RELEASE_2_1_13/src/java/org/apache/cocoon/util/WildcardMatcherHelper.java - cocoon - 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.cocoon.util;

 import org.apache.regexp.RE;
 import org.apache.regexp.RECompiler;
 import org.apache.regexp.REProgram;

 import java.util.HashMap;
 import java.util.Map;


 /**
  * This class is an utility class that perform wildcard-patterns matching and isolation.
  *
  * @version $Id$
  */
 public class WildcardMatcherHelper {
     //~ Static fields/initializers -----------------------------------------------------------------

     /** Default path separator: "/" */
     public static final char ESC = '\\';

     /** Default path separator: "/" */
     public static final char PATHSEP = '/';

     /** Default path separator: "/" */
     public static final char STAR = '*';

     //~ Methods ------------------------------------------------------------------------------------

     /**
      * Match a pattern agains a string and isolates wildcard replacement into a <code>Map</code>.
      * <br>
      * Here is how the matching algorithm works:
      *
      * <ul>
      *   <li>
      *     The '*' character, meaning that zero or more characters (excluding the path separator '/')
      *     are to be matched.
      *   </li>
      *   <li>
      *     The '**' sequence, meaning that zero or more characters (including the path separator '/')
      *     are to be matched.
      *   </li>
      *   <li>
      *     The '\*' sequence is honored as a litteral '*' character, not a wildcard
      *   </li>
      * </ul>
      * <br>
      * When more than two '*' characters, not separated by another character, are found their value is
      * considered as '**' and immediate succeeding '*' are skipped.
      * <br>
      * The '**' wildcard is greedy and thus the following sample matches as {"foo/bar","baz","bug"}:
      * <dl>
      *   <dt>pattern</dt>
      *   <dd>STAR,STAR,PATHSEP,STAR,PATHSEP,STAR,STAR (why can't I express it litterally?)</dt>
      *   <dt>string</dt>
      *   <dd>foo/bar/baz/bug</dt>
      * </dl>
      * The first '**' in the pattern will suck up as much as possible without making the match fail.
      *
      * @param pat The pattern string.
      * @param str The string to math agains the pattern
      *
      * @return a <code>Map</code> containing the representation of the extracted pattern. The extracted patterns are
      *         keys in the <code>Map</code> from left to right beginning with "1" for te left most, "2" for the next,
      *         a.s.o. The key "0" is the string itself. If the return value is null, string does not match to the
      *         pattern .
      */
     public static Map match(final String pat,
                             final String str) {
         Matcher matcher;
         synchronized (cache) {
             matcher = (Matcher) cache.get(pat);
             if ( matcher == null ) {
                 matcher = new Matcher(pat);
                 cache.put(pat, matcher);
             }
         }

         String[] list = matcher.getMatches(str);
         if ( list == null )
             return null;

         int n = list.length;
         Map map = new HashMap(n * 2 + 1);
         for ( int i = 0; i < n; i++ ) {
             map.put(String.valueOf(i), list[i]);
         }

         return map;
     }

     /** Cache for compiled pattern matchers */
     private static final Map cache = new HashMap();

     //~ Inner Classes ------------------------------------------------------------------------------

     /**
      * The private matcher class
      */
     private static class Matcher {

         /** Regexp to split constant parts from front and back leaving wildcards in the middle. */
         private static final REProgram splitter;

         static {
             final String fixedRE = "([^*\\\\]*)";
             final String wcardRE = "(.*[*\\\\])";
             final String splitRE = "^" + fixedRE + wcardRE + fixedRE + "$";
             splitter = new RECompiler().compile(splitRE);
         }

         /** Wildcard types to short-cut simple '*' and "**' matches. */
         private static final int WC_CONST = 0;
         private static final int WC_STAR = 1;
         private static final int WC_STARSTAR = 2;
         private static final int WC_REGEXP = 3;

         //~ Instance fields ------------------------------------------------------------------------

         // All fields declared final to emphasize requirement to be thread-safe.

         /** Fixed text at start of pattern. */
         private final String prefix;

         /** Fixed text at end of pattern. */
         private final String suffix;

         /** Length of prefix and suffix. */
         private final int fixlen;

         /** Wildcard type of pattern. */
         private final int wctype;

         /** Compiled regexp equivalent to wildcard pattern between prefix and suffix. */
         private final REProgram regexp;

         //~ Constructors ---------------------------------------------------------------------------

         /**
          * Creates a new Matcher object.
          *
          * @param pat The pattern
          * @param str The string
          */
         Matcher(final String pat) {
             RE re = new RE(splitter);

             if ( re.match(pat) ) {

                 // Split pattern into (foo/)(*)(/bar).

                 prefix = re.getParen(1);
                 String wildcard = re.getParen(2);
                 String tail = re.getParen(3);

                 // If wildcard ends with \ then add the first char of postfix to wildcard.
                 if ( tail.length() != 0 && wildcard.charAt(wildcard.length() - 1) == ESC ) {
                     wildcard = wildcard + tail.substring(0, 1);
                     suffix = tail.substring(1);
                 }
                 else {
                     suffix = tail;
                 }

                 // Use short-cuts for single * or ** wildcards

                 if ( wildcard.equals("*") ) {
                     wctype = WC_STAR;
                     regexp = null;
                 }
                 else if ( wildcard.equals("**") ) {
                     wctype = WC_STARSTAR;
                     regexp = null;
                 }
                 else {
                     wctype = WC_REGEXP;
                     regexp = compileRegexp(wildcard);
                 }
             }
             else {
                 // Pattern is a constant without '*' or '\'.
                 prefix = pat;
                 suffix = "";
                 wctype = WC_CONST;
                 regexp = null;
             }

             fixlen = prefix.length() + suffix.length();
         }

         //~ Methods --------------------------------------------------------------------------------

         /**
          * Match string against pattern.
          *
          * @param str The string
          * @return list of wildcard matches, null if match failed
          */
         String[] getMatches(final String str) {

             // Protect against 'foo' matching 'foo*foo'.
             if ( str.length() < fixlen )
                 return null;

             if ( !str.startsWith(prefix) )
                 return null;

             if ( !str.endsWith(suffix) )
                 return null;

             String infix = str.substring(prefix.length(), str.length() - suffix.length());

             if ( wctype == WC_REGEXP ) {
                 RE re = new RE(regexp);
                 if ( !re.match(infix) )
                     return null;

                 int n = re.getParenCount();
                 String[] list = new String[n];
                 list[0] = str;
                 for ( int i = 1; i < n; i++ )
                     list[i] = re.getParen(i);
                 return list;
             }

             if ( wctype == WC_CONST ) {
                 if ( infix.length() != 0 )
                     return null;
                 return new String[] {
                     str
                 };
             }

             if ( wctype == WC_STAR ) {
                 if ( infix.indexOf(PATHSEP) != -1 )
                     return null;
             }

             return new String[] {
                 str, infix
             };
         }
     }

     /**
      * Compile wildcard pattern into regexp pattern.
      *
      * @param pat The wildcard pattern
      * @return compiled regexp program.
      */
     private static REProgram compileRegexp(String pat) {
         StringBuffer repat = new StringBuffer(pat.length() * 6);
         repat.append('^');

         // Add an extra character to allow unchecked wcpat[i+1] accesses.
         // Unterminated ESC sequences are silently handled as '\\'.
         char[] wcpat = (pat + ESC).toCharArray();
         for ( int i = 0, n = pat.length(); i < n; i++ ) {
             char ch = wcpat[i];

             if ( ch == STAR ) {
                 if ( wcpat[i + 1] != STAR ) {
                     repat.append("([^/]*)");
                     continue;
                 }

                 // Handle two and more '*' as single '**'.
                 while ( wcpat[i + 1] == STAR )
                     i++;
                 repat.append("(.*)");
                 continue;
             }

             // Match ESC+ESC and ESC+STAR as literal ESC and STAR which needs to be escaped
             // in regexp. Match ESC+other as two characters ESC+other where other may also
             // need to be escaped in regexp.
             if ( ch == ESC ) {
                 ch = wcpat[++i];
                 if ( ch != ESC && ch != STAR )
                     repat.append("\\\\");
             }

             if ( ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' || ch >= '0' && ch <= '9'
                  || ch == '/' ) {
                 repat.append(ch);
                 continue;
             }

             repat.append('\\');
             repat.append(ch);
         }
         repat.append('$');

         return new RECompiler().compile(repat.toString());
     }
 }
	/*
	* 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.cocoon.util;

	import org.apache.regexp.RE;
	import org.apache.regexp.RECompiler;
	import org.apache.regexp.REProgram;

	import java.util.HashMap;
	import java.util.Map;


	/**
	* This class is an utility class that perform wildcard-patterns matching and isolation.
	*
	* @version $Id$
	*/
	public class WildcardMatcherHelper {
	//~ Static fields/initializers -----------------------------------------------------------------

	/** Default path separator: "/" */
	public static final char ESC = '\\';

	/** Default path separator: "/" */
	public static final char PATHSEP = '/';

	/** Default path separator: "/" */
	public static final char STAR = '*';

	//~ Methods ------------------------------------------------------------------------------------

	/**
	* Match a pattern agains a string and isolates wildcard replacement into a <code>Map</code>.
	* <br>
	* Here is how the matching algorithm works:
	*
	* <ul>
	* <li>
	* The '*' character, meaning that zero or more characters (excluding the path separator '/')
	* are to be matched.
	* </li>
	* <li>
	* The '**' sequence, meaning that zero or more characters (including the path separator '/')
	* are to be matched.
	* </li>
	* <li>
	* The '\' sequence is honored as a litteral '' character, not a wildcard
	* </li>
	* </ul>
	* <br>
	* When more than two '*' characters, not separated by another character, are found their value is
	* considered as '*' and immediate succeeding '' are skipped.
	* <br>
	* The '**' wildcard is greedy and thus the following sample matches as {"foo/bar","baz","bug"}:
	* <dl>
	* <dt>pattern</dt>
	* <dd>STAR,STAR,PATHSEP,STAR,PATHSEP,STAR,STAR (why can't I express it litterally?)</dt>
	* <dt>string</dt>
	* <dd>foo/bar/baz/bug</dt>
	* </dl>
	* The first '**' in the pattern will suck up as much as possible without making the match fail.
	*
	* @param pat The pattern string.
	* @param str The string to math agains the pattern
	*
	* @return a <code>Map</code> containing the representation of the extracted pattern. The extracted patterns are
	* keys in the <code>Map</code> from left to right beginning with "1" for te left most, "2" for the next,
	* a.s.o. The key "0" is the string itself. If the return value is null, string does not match to the
	* pattern .
	*/
	public static Map match(final String pat,
	final String str) {
	Matcher matcher;
	synchronized (cache) {
	matcher = (Matcher) cache.get(pat);
	if ( matcher == null ) {
	matcher = new Matcher(pat);
	cache.put(pat, matcher);
	}
	}

	String[] list = matcher.getMatches(str);
	if ( list == null )
	return null;

	int n = list.length;
	Map map = new HashMap(n * 2 + 1);
	for ( int i = 0; i < n; i++ ) {
	map.put(String.valueOf(i), list[i]);
	}

	return map;
	}

	/** Cache for compiled pattern matchers */
	private static final Map cache = new HashMap();

	//~ Inner Classes ------------------------------------------------------------------------------

	/**
	* The private matcher class
	*/
	private static class Matcher {

	/** Regexp to split constant parts from front and back leaving wildcards in the middle. */
	private static final REProgram splitter;

	static {
	final String fixedRE = "([^\\\\])";
	final String wcardRE = "(.[\\\\])";
	final String splitRE = "^" + fixedRE + wcardRE + fixedRE + "$";
	splitter = new RECompiler().compile(splitRE);
	}

	/** Wildcard types to short-cut simple '' and "' matches. /
	private static final int WC_CONST = 0;
	private static final int WC_STAR = 1;
	private static final int WC_STARSTAR = 2;
	private static final int WC_REGEXP = 3;

	//~ Instance fields ------------------------------------------------------------------------

	// All fields declared final to emphasize requirement to be thread-safe.

	/** Fixed text at start of pattern. */
	private final String prefix;

	/** Fixed text at end of pattern. */
	private final String suffix;

	/** Length of prefix and suffix. */
	private final int fixlen;

	/** Wildcard type of pattern. */
	private final int wctype;

	/** Compiled regexp equivalent to wildcard pattern between prefix and suffix. */
	private final REProgram regexp;

	//~ Constructors ---------------------------------------------------------------------------

	/**
	* Creates a new Matcher object.
	*
	* @param pat The pattern
	* @param str The string
	*/
	Matcher(final String pat) {
	RE re = new RE(splitter);

	if ( re.match(pat) ) {

	// Split pattern into (foo/)(*)(/bar).

	prefix = re.getParen(1);
	String wildcard = re.getParen(2);
	String tail = re.getParen(3);

	// If wildcard ends with \ then add the first char of postfix to wildcard.
	if ( tail.length() != 0 && wildcard.charAt(wildcard.length() - 1) == ESC ) {
	wildcard = wildcard + tail.substring(0, 1);
	suffix = tail.substring(1);
	}
	else {
	suffix = tail;
	}

	// Use short-cuts for single * or ** wildcards

	if ( wildcard.equals("*") ) {
	wctype = WC_STAR;
	regexp = null;
	}
	else if ( wildcard.equals("**") ) {
	wctype = WC_STARSTAR;
	regexp = null;
	}
	else {
	wctype = WC_REGEXP;
	regexp = compileRegexp(wildcard);
	}
	}
	else {
	// Pattern is a constant without '*' or '\'.
	prefix = pat;
	suffix = "";
	wctype = WC_CONST;
	regexp = null;
	}

	fixlen = prefix.length() + suffix.length();
	}

	//~ Methods --------------------------------------------------------------------------------

	/**
	* Match string against pattern.
	*
	* @param str The string
	* @return list of wildcard matches, null if match failed
	*/
	String[] getMatches(final String str) {

	// Protect against 'foo' matching 'foo*foo'.
	if ( str.length() < fixlen )
	return null;

	if ( !str.startsWith(prefix) )
	return null;

	if ( !str.endsWith(suffix) )
	return null;

	String infix = str.substring(prefix.length(), str.length() - suffix.length());

	if ( wctype == WC_REGEXP ) {
	RE re = new RE(regexp);
	if ( !re.match(infix) )
	return null;

	int n = re.getParenCount();
	String[] list = new String[n];
	list[0] = str;
	for ( int i = 1; i < n; i++ )
	list[i] = re.getParen(i);
	return list;
	}

	if ( wctype == WC_CONST ) {
	if ( infix.length() != 0 )
	return null;
	return new String[] {
	str
	};
	}

	if ( wctype == WC_STAR ) {
	if ( infix.indexOf(PATHSEP) != -1 )
	return null;
	}

	return new String[] {
	str, infix
	};
	}
	}

	/**
	* Compile wildcard pattern into regexp pattern.
	*
	* @param pat The wildcard pattern
	* @return compiled regexp program.
	*/
	private static REProgram compileRegexp(String pat) {
	StringBuffer repat = new StringBuffer(pat.length() * 6);
	repat.append('^');

	// Add an extra character to allow unchecked wcpat[i+1] accesses.
	// Unterminated ESC sequences are silently handled as '\\'.
	char[] wcpat = (pat + ESC).toCharArray();
	for ( int i = 0, n = pat.length(); i < n; i++ ) {
	char ch = wcpat[i];

	if ( ch == STAR ) {
	if ( wcpat[i + 1] != STAR ) {
	repat.append("([^/]*)");
	continue;
	}

	// Handle two and more '' as single '*'.
	while ( wcpat[i + 1] == STAR )
	i++;
	repat.append("(.*)");
	continue;
	}

	// Match ESC+ESC and ESC+STAR as literal ESC and STAR which needs to be escaped
	// in regexp. Match ESC+other as two characters ESC+other where other may also
	// need to be escaped in regexp.
	if ( ch == ESC ) {
	ch = wcpat[++i];
	if ( ch != ESC && ch != STAR )
	repat.append("\\\\");
	}

	if ( ch >= 'a' && ch <= 'z' \|\| ch >= 'A' && ch <= 'Z' \|\| ch >= '0' && ch <= '9'
	\|\| ch == '/' ) {
	repat.append(ch);
	continue;
	}

	repat.append('\\');
	repat.append(ch);
	}
	repat.append('$');

	return new RECompiler().compile(repat.toString());
	}
	}