src/main/java/org/apache/maven/shared/filtering/InterpolatorFilterReaderLineEnding.java - maven-filtering - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.maven.shared.filtering;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.Reader;

 import org.codehaus.plexus.interpolation.InterpolationException;
 import org.codehaus.plexus.interpolation.Interpolator;
 import org.codehaus.plexus.interpolation.RecursionInterceptor;
 import org.codehaus.plexus.interpolation.SimpleRecursionInterceptor;

 /**
  * A FilterReader implementation, that works with Interpolator interface instead of it's own interpolation
  * implementation. This implementation is heavily based on org.codehaus.plexus.util.InterpolationFilterReader.
  *
  * @author cstamas
  * @author Olivier Lamy
  * @since 1.0
  */
 public class InterpolatorFilterReaderLineEnding extends AbstractFilterReaderLineEnding {

     /**
      * Interpolator used to interpolate
      */
     private Interpolator interpolator;

     private RecursionInterceptor recursionInterceptor;

     /**
      * replacement text from a token
      */
     private String replaceData = null;

     /**
      * Index into replacement data
      */
     private int replaceIndex = 0;

     /**
      * Default begin token.
      */
     public static final String DEFAULT_BEGIN_TOKEN = "${";

     /**
      * Default end token.
      */
     public static final String DEFAULT_END_TOKEN = "}";

     private String beginToken;

     private String endToken;

     /**
      * true by default to preserve backward comp
      */
     private boolean interpolateWithPrefixPattern = true;

     private boolean supportMultiLineFiltering;

     private boolean eof = false;

     /**
      * @param in reader to use
      * @param interpolator interpolator instance to use
      * @param beginToken start token to use
      * @param endToken end token to use
      * @param supportMultiLineFiltering If multi line filtering is allowed
      */
     public InterpolatorFilterReaderLineEnding(
             Reader in,
             Interpolator interpolator,
             String beginToken,
             String endToken,
             boolean supportMultiLineFiltering) {
         this(in, interpolator, beginToken, endToken, new SimpleRecursionInterceptor(), supportMultiLineFiltering);
     }

     /**
      * @param in reader to use
      * @param interpolator interpolator instance to use
      * @param beginToken start token to use
      * @param endToken end token to use
      * @param ri The {@link RecursionInterceptor} to use to prevent recursive expressions.
      * @param supportMultiLineFiltering If multi line filtering is allowed
      */
     private InterpolatorFilterReaderLineEnding(
             Reader in,
             Interpolator interpolator,
             String beginToken,
             String endToken,
             RecursionInterceptor ri,
             boolean supportMultiLineFiltering) {
         // wrap our own buffer, so we can use mark/reset safely.
         super(new BufferedReader(in));

         this.interpolator = interpolator;

         this.beginToken = beginToken;

         this.endToken = endToken;

         recursionInterceptor = ri;

         this.supportMultiLineFiltering = supportMultiLineFiltering;

         calculateMarkLength();
     }

     /**
      * Skips characters. This method will block until some characters are available, an I/O error occurs, or the end of
      * the stream is reached.
      *
      * @param n The number of characters to skip
      * @return the number of characters actually skipped
      * @throws IOException If an I/O error occurs
      */
     @Override
     public long skip(long n) throws IOException {
         if (n < 0L) {
             throw new IllegalArgumentException("skip value is negative");
         }

         for (long i = 0; i < n; i++) {
             if (read() == -1) {
                 return i;
             }
         }
         return n;
     }

     /**
      * Reads characters into a portion of an array. This method will block until some input is available, an I/O error
      * occurs, or the end of the stream is reached.
      *
      * @param cbuf Destination buffer to write characters to. Must not be <code>null</code>.
      * @param off Offset at which to start storing characters.
      * @param len Maximum number of characters to read.
      * @return the number of characters read, or -1 if the end of the stream has been reached
      * @throws IOException If an I/O error occurs
      */
     @Override
     public int read(char[] cbuf, int off, int len) throws IOException {
         for (int i = 0; i < len; i++) {
             int ch = read();
             if (ch == -1) {
                 if (i == 0) {
                     return -1;
                 } else {
                     return i;
                 }
             }
             cbuf[off + i] = (char) ch;
         }
         return len;
     }

     /**
      * Returns the next character in the filtered stream, replacing tokens from the original stream.
      *
      * @return the next character in the resulting stream, or -1 if the end of the resulting stream has been reached
      * @throws IOException if the underlying stream throws an IOException during reading
      */
     @Override
     public int read() throws IOException {
         if (replaceIndex > 0) {
             return replaceData.charAt(replaceData.length() - (replaceIndex--));
         }
         if (eof) {
             return -1;
         }

         in.mark(markLength);

         int ch = in.read();
         if (ch == -1 || (ch == '\n' && !supportMultiLineFiltering)) {
             return ch;
         }

         boolean inEscape = useEscape && ch == getEscapeString().charAt(0);

         StringBuilder key = new StringBuilder();

         // have we found an escape string?
         if (inEscape) {
             for (int i = 0; i < getEscapeString().length(); i++) {
                 key.append((char) ch);

                 if (ch != getEscapeString().charAt(i) || ch == -1 || (ch == '\n' && !supportMultiLineFiltering)) {
                     // mismatch, EOF or EOL, no escape string here
                     in.reset();
                     inEscape = false;
                     key.setLength(0);
                     break;
                 }

                 ch = in.read();
             }
         }

         // have we found a delimiter?
         boolean foundToken = false;
         for (int i = 0; i < beginToken.length(); i++) {
             if (ch != beginToken.charAt(i) || ch == -1 || (ch == '\n' && !supportMultiLineFiltering)) {
                 // mismatch, EOF or EOL, no match
                 break;
             }

             if (i == beginToken.length() - 1) {

                 foundToken = true;
             }

             ch = in.read();
         }

         in.reset();
         in.skip(key.length());
         ch = in.read();

         // escape means no luck, prevent parsing of the escaped character, and return
         if (inEscape) {

             if (beginToken != null) {
                 if (!isPreserveEscapeString()) {
                     key.setLength(0);
                 }
             }

             key.append((char) ch);

             replaceData = key.toString();
             replaceIndex = key.length();

             return read();
         }

         // no match means no luck, reset and return
         if (!foundToken) {

             in.reset();
             return in.read();
         }

         // we're committed, find the end token, EOL or EOF

         key.append(beginToken);
         in.reset();
         in.skip(beginToken.length());
         ch = in.read();

         int endTokenSize = endToken.length();
         int end = endTokenSize;
         do {
             if (ch == -1) {
                 break;
             } else if (ch == '\n' && !supportMultiLineFiltering) {
                 // EOL
                 key.append((char) ch);
                 break;
             }

             key.append((char) ch);

             if (ch == this.endToken.charAt(endTokenSize - end)) {
                 end--;
                 if (end == 0) {
                     break;
                 }
             } else {
                 end = endTokenSize;
             }

             ch = in.read();
         } while (true);

         // found endtoken? interpolate our key resolved above
         String value = null;
         if (end == 0) {
             try {
                 if (interpolateWithPrefixPattern) {
                     value = interpolator.interpolate(key.toString(), "", recursionInterceptor);
                 } else {
                     value = interpolator.interpolate(key.toString(), recursionInterceptor);
                 }
             } catch (InterpolationException e) {
                 throw new IllegalArgumentException(e.getMessage(), e);
             }
         }

         // write away the value if present, otherwise the key unmodified
         if (value != null) {
             replaceData = value;
             replaceIndex = value.length();
         } else {
             replaceData = key.toString();
             replaceIndex = key.length();
         }

         if (ch == -1) {
             eof = true;
         }
         return read();
     }

     /**
      * @return current state of interpolate with prefix pattern.
      */
     public boolean isInterpolateWithPrefixPattern() {
         return interpolateWithPrefixPattern;
     }

     /**
      * @param interpolateWithPrefixPattern interpolate with prefix pattern.
      */
     public void setInterpolateWithPrefixPattern(boolean interpolateWithPrefixPattern) {
         this.interpolateWithPrefixPattern = interpolateWithPrefixPattern;
     }

     /**
      * @return {@link #recursionInterceptor}
      */
     public RecursionInterceptor getRecursionInterceptor() {
         return recursionInterceptor;
     }

     /**
      * @param theRecursionInterceptor {@link RecursionInterceptor}
      * @return {@link InterpolatorFilterReaderLineEnding}
      */
     public InterpolatorFilterReaderLineEnding setRecursionInterceptor(RecursionInterceptor theRecursionInterceptor) {
         this.recursionInterceptor = theRecursionInterceptor;
         return this;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.maven.shared.filtering;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.Reader;

	import org.codehaus.plexus.interpolation.InterpolationException;
	import org.codehaus.plexus.interpolation.Interpolator;
	import org.codehaus.plexus.interpolation.RecursionInterceptor;
	import org.codehaus.plexus.interpolation.SimpleRecursionInterceptor;

	/**
	* A FilterReader implementation, that works with Interpolator interface instead of it's own interpolation
	* implementation. This implementation is heavily based on org.codehaus.plexus.util.InterpolationFilterReader.
	*
	* @author cstamas
	* @author Olivier Lamy
	* @since 1.0
	*/
	public class InterpolatorFilterReaderLineEnding extends AbstractFilterReaderLineEnding {

	/**
	* Interpolator used to interpolate
	*/
	private Interpolator interpolator;

	private RecursionInterceptor recursionInterceptor;

	/**
	* replacement text from a token
	*/
	private String replaceData = null;

	/**
	* Index into replacement data
	*/
	private int replaceIndex = 0;

	/**
	* Default begin token.
	*/
	public static final String DEFAULT_BEGIN_TOKEN = "${";

	/**
	* Default end token.
	*/
	public static final String DEFAULT_END_TOKEN = "}";

	private String beginToken;

	private String endToken;

	/**
	* true by default to preserve backward comp
	*/
	private boolean interpolateWithPrefixPattern = true;

	private boolean supportMultiLineFiltering;

	private boolean eof = false;

	/**
	* @param in reader to use
	* @param interpolator interpolator instance to use
	* @param beginToken start token to use
	* @param endToken end token to use
	* @param supportMultiLineFiltering If multi line filtering is allowed
	*/
	public InterpolatorFilterReaderLineEnding(
	Reader in,
	Interpolator interpolator,
	String beginToken,
	String endToken,
	boolean supportMultiLineFiltering) {
	this(in, interpolator, beginToken, endToken, new SimpleRecursionInterceptor(), supportMultiLineFiltering);
	}

	/**
	* @param in reader to use
	* @param interpolator interpolator instance to use
	* @param beginToken start token to use
	* @param endToken end token to use
	* @param ri The {@link RecursionInterceptor} to use to prevent recursive expressions.
	* @param supportMultiLineFiltering If multi line filtering is allowed
	*/
	private InterpolatorFilterReaderLineEnding(
	Reader in,
	Interpolator interpolator,
	String beginToken,
	String endToken,
	RecursionInterceptor ri,
	boolean supportMultiLineFiltering) {
	// wrap our own buffer, so we can use mark/reset safely.
	super(new BufferedReader(in));

	this.interpolator = interpolator;

	this.beginToken = beginToken;

	this.endToken = endToken;

	recursionInterceptor = ri;

	this.supportMultiLineFiltering = supportMultiLineFiltering;

	calculateMarkLength();
	}

	/**
	* Skips characters. This method will block until some characters are available, an I/O error occurs, or the end of
	* the stream is reached.
	*
	* @param n The number of characters to skip
	* @return the number of characters actually skipped
	* @throws IOException If an I/O error occurs
	*/
	@Override
	public long skip(long n) throws IOException {
	if (n < 0L) {
	throw new IllegalArgumentException("skip value is negative");
	}

	for (long i = 0; i < n; i++) {
	if (read() == -1) {
	return i;
	}
	}
	return n;
	}

	/**
	* Reads characters into a portion of an array. This method will block until some input is available, an I/O error
	* occurs, or the end of the stream is reached.
	*
	* @param cbuf Destination buffer to write characters to. Must not be <code>null</code>.
	* @param off Offset at which to start storing characters.
	* @param len Maximum number of characters to read.
	* @return the number of characters read, or -1 if the end of the stream has been reached
	* @throws IOException If an I/O error occurs
	*/
	@Override
	public int read(char[] cbuf, int off, int len) throws IOException {
	for (int i = 0; i < len; i++) {
	int ch = read();
	if (ch == -1) {
	if (i == 0) {
	return -1;
	} else {
	return i;
	}
	}
	cbuf[off + i] = (char) ch;
	}
	return len;
	}

	/**
	* Returns the next character in the filtered stream, replacing tokens from the original stream.
	*
	* @return the next character in the resulting stream, or -1 if the end of the resulting stream has been reached
	* @throws IOException if the underlying stream throws an IOException during reading
	*/
	@Override
	public int read() throws IOException {
	if (replaceIndex > 0) {
	return replaceData.charAt(replaceData.length() - (replaceIndex--));
	}
	if (eof) {
	return -1;
	}

	in.mark(markLength);

	int ch = in.read();
	if (ch == -1 \|\| (ch == '\n' && !supportMultiLineFiltering)) {
	return ch;
	}

	boolean inEscape = useEscape && ch == getEscapeString().charAt(0);

	StringBuilder key = new StringBuilder();

	// have we found an escape string?
	if (inEscape) {
	for (int i = 0; i < getEscapeString().length(); i++) {
	key.append((char) ch);

	if (ch != getEscapeString().charAt(i) \|\| ch == -1 \|\| (ch == '\n' && !supportMultiLineFiltering)) {
	// mismatch, EOF or EOL, no escape string here
	in.reset();
	inEscape = false;
	key.setLength(0);
	break;
	}

	ch = in.read();
	}
	}

	// have we found a delimiter?
	boolean foundToken = false;
	for (int i = 0; i < beginToken.length(); i++) {
	if (ch != beginToken.charAt(i) \|\| ch == -1 \|\| (ch == '\n' && !supportMultiLineFiltering)) {
	// mismatch, EOF or EOL, no match
	break;
	}

	if (i == beginToken.length() - 1) {

	foundToken = true;
	}

	ch = in.read();
	}

	in.reset();
	in.skip(key.length());
	ch = in.read();

	// escape means no luck, prevent parsing of the escaped character, and return
	if (inEscape) {

	if (beginToken != null) {
	if (!isPreserveEscapeString()) {
	key.setLength(0);
	}
	}

	key.append((char) ch);

	replaceData = key.toString();
	replaceIndex = key.length();

	return read();
	}

	// no match means no luck, reset and return
	if (!foundToken) {

	in.reset();
	return in.read();
	}

	// we're committed, find the end token, EOL or EOF

	key.append(beginToken);
	in.reset();
	in.skip(beginToken.length());
	ch = in.read();

	int endTokenSize = endToken.length();
	int end = endTokenSize;
	do {
	if (ch == -1) {
	break;
	} else if (ch == '\n' && !supportMultiLineFiltering) {
	// EOL
	key.append((char) ch);
	break;
	}

	key.append((char) ch);

	if (ch == this.endToken.charAt(endTokenSize - end)) {
	end--;
	if (end == 0) {
	break;
	}
	} else {
	end = endTokenSize;
	}

	ch = in.read();
	} while (true);

	// found endtoken? interpolate our key resolved above
	String value = null;
	if (end == 0) {
	try {
	if (interpolateWithPrefixPattern) {
	value = interpolator.interpolate(key.toString(), "", recursionInterceptor);
	} else {
	value = interpolator.interpolate(key.toString(), recursionInterceptor);
	}
	} catch (InterpolationException e) {
	throw new IllegalArgumentException(e.getMessage(), e);
	}
	}

	// write away the value if present, otherwise the key unmodified
	if (value != null) {
	replaceData = value;
	replaceIndex = value.length();
	} else {
	replaceData = key.toString();
	replaceIndex = key.length();
	}

	if (ch == -1) {
	eof = true;
	}
	return read();
	}

	/**
	* @return current state of interpolate with prefix pattern.
	*/
	public boolean isInterpolateWithPrefixPattern() {
	return interpolateWithPrefixPattern;
	}

	/**
	* @param interpolateWithPrefixPattern interpolate with prefix pattern.
	*/
	public void setInterpolateWithPrefixPattern(boolean interpolateWithPrefixPattern) {
	this.interpolateWithPrefixPattern = interpolateWithPrefixPattern;
	}

	/**
	* @return {@link #recursionInterceptor}
	*/
	public RecursionInterceptor getRecursionInterceptor() {
	return recursionInterceptor;
	}

	/**
	* @param theRecursionInterceptor {@link RecursionInterceptor}
	* @return {@link InterpolatorFilterReaderLineEnding}
	*/
	public InterpolatorFilterReaderLineEnding setRecursionInterceptor(RecursionInterceptor theRecursionInterceptor) {
	this.recursionInterceptor = theRecursionInterceptor;
	return this;
	}
	}