struts-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From lukaszlen...@apache.org
Subject [35/57] [partial] struts git commit: Merges xwork packages into struts
Date Wed, 17 Jun 2015 21:09:35 GMT
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/util/PropertiesReader.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/util/PropertiesReader.java b/core/src/main/java/com/opensymphony/xwork2/util/PropertiesReader.java
new file mode 100644
index 0000000..a25a679
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/util/PropertiesReader.java
@@ -0,0 +1,546 @@
+/*
+ * 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 com.opensymphony.xwork2.util;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This class is used to read properties lines. These lines do
+ * not terminate with new-line chars but rather when there is no
+ * backslash sign a the end of the line.  This is used to
+ * concatenate multiple lines for readability.
+ * <p/>
+ * This class was pulled out of Jakarta Commons Configuration and
+ * Jakarta Commons Lang trunk revision 476093
+ */
+public class PropertiesReader extends LineNumberReader {
+    /**
+     * Stores the comment lines for the currently processed property.
+     */
+    private List<String> commentLines;
+
+    /**
+     * Stores the name of the last read property.
+     */
+    private String propertyName;
+
+    /**
+     * Stores the value of the last read property.
+     */
+    private String propertyValue;
+
+    /**
+     * Stores the list delimiter character.
+     */
+    private char delimiter;
+
+    /**
+     * Constant for the supported comment characters.
+     */
+    static final String COMMENT_CHARS = "#!";
+
+    /**
+     * Constant for the radix of hex numbers.
+     */
+    private static final int HEX_RADIX = 16;
+
+    /**
+     * Constant for the length of a unicode literal.
+     */
+    private static final int UNICODE_LEN = 4;
+
+    /**
+     * The list of possible key/value separators
+     */
+    private static final char[] SEPARATORS = new char[]{'=', ':'};
+
+    /**
+     * The white space characters used as key/value separators.
+     */
+    private static final char[] WHITE_SPACE = new char[]{' ', '\t', '\f'};
+
+    /**
+     * Constructor.
+     *
+     * @param reader A Reader.
+     */
+    public PropertiesReader(Reader reader) {
+        this(reader, ',');
+    }
+
+    /**
+     * Creates a new instance of <code>PropertiesReader</code> and sets
+     * the underlaying reader and the list delimiter.
+     *
+     * @param reader        the reader
+     * @param listDelimiter the list delimiter character
+     * @since 1.3
+     */
+    public PropertiesReader(Reader reader, char listDelimiter) {
+        super(reader);
+        commentLines = new ArrayList<String>();
+        delimiter = listDelimiter;
+    }
+
+    /**
+     * Tests whether a line is a comment, i.e. whether it starts with a comment
+     * character.
+     *
+     * @param line the line
+     * @return a flag if this is a comment line
+     * @since 1.3
+     */
+    boolean isCommentLine(String line) {
+        String s = line.trim();
+        // blanc lines are also treated as comment lines
+        return s.length() < 1 || COMMENT_CHARS.indexOf(s.charAt(0)) >= 0;
+    }
+
+    /**
+     * Reads a property line. Returns null if Stream is
+     * at EOF. Concatenates lines ending with "\".
+     * Skips lines beginning with "#" or "!" and empty lines.
+     * The return value is a property definition (<code>&lt;name&gt;</code>
+     * = <code>&lt;value&gt;</code>)
+     *
+     * @return A string containing a property value or null
+     * @throws IOException in case of an I/O error
+     */
+    public String readProperty() throws IOException {
+        commentLines.clear();
+        StringBuilder buffer = new StringBuilder();
+
+        while (true) {
+            String line = readLine();
+            if (line == null) {
+                // EOF
+                return null;
+            }
+
+            if (isCommentLine(line)) {
+                commentLines.add(line);
+                continue;
+            }
+
+            line = line.trim();
+
+            if (checkCombineLines(line)) {
+                line = line.substring(0, line.length() - 1);
+                buffer.append(line);
+            } else {
+                buffer.append(line);
+                break;
+            }
+        }
+        return buffer.toString();
+    }
+
+    /**
+     * Parses the next property from the input stream and stores the found
+     * name and value in internal fields. These fields can be obtained using
+     * the provided getter methods. The return value indicates whether EOF
+     * was reached (<b>false</b>) or whether further properties are
+     * available (<b>true</b>).
+     *
+     * @return a flag if further properties are available
+     * @throws IOException if an error occurs
+     * @since 1.3
+     */
+    public boolean nextProperty() throws IOException {
+        String line = readProperty();
+
+        if (line == null) {
+            return false; // EOF
+        }
+
+        // parse the line
+        String[] property = parseProperty(line);
+        propertyName = unescapeJava(property[0]);
+        propertyValue = unescapeJava(property[1], delimiter);
+        return true;
+    }
+
+    /**
+     * Returns the comment lines that have been read for the last property.
+     *
+     * @return the comment lines for the last property returned by
+     * <code>readProperty()</code>
+     * @since 1.3
+     */
+    public List<String> getCommentLines() {
+        return commentLines;
+    }
+
+    /**
+     * Returns the name of the last read property. This method can be called
+     * after <code>{@link #nextProperty()}</code> was invoked and its
+     * return value was <b>true</b>.
+     *
+     * @return the name of the last read property
+     * @since 1.3
+     */
+    public String getPropertyName() {
+        return propertyName;
+    }
+
+    /**
+     * Returns the value of the last read property. This method can be
+     * called after <code>{@link #nextProperty()}</code> was invoked and
+     * its return value was <b>true</b>.
+     *
+     * @return the value of the last read property
+     * @since 1.3
+     */
+    public String getPropertyValue() {
+        return propertyValue;
+    }
+
+    /**
+     * Checks if the passed in line should be combined with the following.
+     * This is true, if the line ends with an odd number of backslashes.
+     *
+     * @param line the line
+     * @return a flag if the lines should be combined
+     */
+    private boolean checkCombineLines(String line) {
+        int bsCount = 0;
+        for (int idx = line.length() - 1; idx >= 0 && line.charAt(idx) == '\\'; idx--) {
+            bsCount++;
+        }
+
+        return bsCount % 2 == 1;
+    }
+
+    /**
+     * Parse a property line and return the key and the value in an array.
+     *
+     * @param line the line to parse
+     * @return an array with the property's key and value
+     * @since 1.2
+     */
+    private String[] parseProperty(String line) {
+        // sorry for this spaghetti code, please replace it as soon as
+        // possible with a regexp when the Java 1.3 requirement is dropped
+
+        String[] result = new String[2];
+        StringBuilder key = new StringBuilder();
+        StringBuilder value = new StringBuilder();
+
+        // state of the automaton:
+        // 0: key parsing
+        // 1: antislash found while parsing the key
+        // 2: separator crossing
+        // 3: value parsing
+        int state = 0;
+
+        for (int pos = 0; pos < line.length(); pos++) {
+            char c = line.charAt(pos);
+
+            switch (state) {
+                case 0:
+                    if (c == '\\') {
+                        state = 1;
+                    } else if (contains(WHITE_SPACE, c)) {
+                        // switch to the separator crossing state
+                        state = 2;
+                    } else if (contains(SEPARATORS, c)) {
+                        // switch to the value parsing state
+                        state = 3;
+                    } else {
+                        key.append(c);
+                    }
+
+                    break;
+
+                case 1:
+                    if (contains(SEPARATORS, c) || contains(WHITE_SPACE, c)) {
+                        // this is an escaped separator or white space
+                        key.append(c);
+                    } else {
+                        // another escaped character, the '\' is preserved
+                        key.append('\\');
+                        key.append(c);
+                    }
+
+                    // return to the key parsing state
+                    state = 0;
+
+                    break;
+
+                case 2:
+                    if (contains(WHITE_SPACE, c)) {
+                        // do nothing, eat all white spaces
+                        state = 2;
+                    } else if (contains(SEPARATORS, c)) {
+                        // switch to the value parsing state
+                        state = 3;
+                    } else {
+                        // any other character indicates we encoutered the beginning of the value
+                        value.append(c);
+
+                        // switch to the value parsing state
+                        state = 3;
+                    }
+
+                    break;
+
+                case 3:
+                    value.append(c);
+                    break;
+            }
+        }
+
+        result[0] = key.toString().trim();
+        result[1] = value.toString().trim();
+
+        return result;
+    }
+
+    /**
+     * <p>Unescapes any Java literals found in the <code>String</code> to a
+     * <code>Writer</code>.</p> This is a slightly modified version of the
+     * StringEscapeUtils.unescapeJava() function in commons-lang that doesn't
+     * drop escaped separators (i.e '\,').
+     *
+     * @param str       the <code>String</code> to unescape, may be null
+     * @param delimiter the delimiter for multi-valued properties
+     * @return the processed string
+     * @throws IllegalArgumentException if the Writer is <code>null</code>
+     */
+    protected static String unescapeJava(String str, char delimiter) {
+        if (str == null) {
+            return null;
+        }
+        int sz = str.length();
+        StringBuilder out = new StringBuilder(sz);
+        StringBuffer unicode = new StringBuffer(UNICODE_LEN);
+        boolean hadSlash = false;
+        boolean inUnicode = false;
+        for (int i = 0; i < sz; i++) {
+            char ch = str.charAt(i);
+            if (inUnicode) {
+                // if in unicode, then we're reading unicode
+                // values in somehow
+                unicode.append(ch);
+                if (unicode.length() == UNICODE_LEN) {
+                    // unicode now contains the four hex digits
+                    // which represents our unicode character
+                    try {
+                        int value = Integer.parseInt(unicode.toString(), HEX_RADIX);
+                        out.append((char) value);
+                        unicode.setLength(0);
+                        inUnicode = false;
+                        hadSlash = false;
+                    } catch (NumberFormatException nfe) {
+                        throw new RuntimeException("Unable to parse unicode value: " + unicode, nfe);
+                    }
+                }
+                continue;
+            }
+
+            if (hadSlash) {
+                // handle an escaped value
+                hadSlash = false;
+
+                if (ch == '\\') {
+                    out.append('\\');
+                } else if (ch == '\'') {
+                    out.append('\'');
+                } else if (ch == '\"') {
+                    out.append('"');
+                } else if (ch == 'r') {
+                    out.append('\r');
+                } else if (ch == 'f') {
+                    out.append('\f');
+                } else if (ch == 't') {
+                    out.append('\t');
+                } else if (ch == 'n') {
+                    out.append('\n');
+                } else if (ch == 'b') {
+                    out.append('\b');
+                } else if (ch == delimiter) {
+                    out.append('\\');
+                    out.append(delimiter);
+                } else if (ch == 'u') {
+                    // uh-oh, we're in unicode country....
+                    inUnicode = true;
+                } else {
+                    out.append(ch);
+                }
+
+                continue;
+            } else if (ch == '\\') {
+                hadSlash = true;
+                continue;
+            }
+            out.append(ch);
+        }
+
+        if (hadSlash) {
+            // then we're in the weird case of a \ at the end of the
+            // string, let's output it anyway.
+            out.append('\\');
+        }
+
+        return out.toString();
+    }
+
+    /**
+     * <p>Checks if the object is in the given array.</p>
+     * <p/>
+     * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
+     *
+     * @param array        the array to search through
+     * @param objectToFind the object to find
+     * @return <code>true</code> if the array contains the object
+     */
+    public boolean contains(char[] array, char objectToFind) {
+        if (array == null) {
+            return false;
+        }
+        for (char anArray : array) {
+            if (objectToFind == anArray) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * <p>Unescapes any Java literals found in the <code>String</code>.
+     * For example, it will turn a sequence of <code>'\'</code> and
+     * <code>'n'</code> into a newline character, unless the <code>'\'</code>
+     * is preceded by another <code>'\'</code>.</p>
+     *
+     * @param str the <code>String</code> to unescape, may be null
+     * @return a new unescaped <code>String</code>, <code>null</code> if null string input
+     */
+    public static String unescapeJava(String str) {
+        if (str == null) {
+            return null;
+        }
+        try {
+            StringWriter writer = new StringWriter(str.length());
+            unescapeJava(writer, str);
+            return writer.toString();
+        } catch (IOException ioe) {
+            // this should never ever happen while writing to a StringWriter
+            ioe.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * <p>Unescapes any Java literals found in the <code>String</code> to a
+     * <code>Writer</code>.</p>
+     * <p/>
+     * <p>For example, it will turn a sequence of <code>'\'</code> and
+     * <code>'n'</code> into a newline character, unless the <code>'\'</code>
+     * is preceded by another <code>'\'</code>.</p>
+     * <p/>
+     * <p>A <code>null</code> string input has no effect.</p>
+     *
+     * @param out the <code>Writer</code> used to output unescaped characters
+     * @param str the <code>String</code> to unescape, may be null
+     * @throws IllegalArgumentException if the Writer is <code>null</code>
+     * @throws IOException              if error occurs on underlying Writer
+     */
+    public static void unescapeJava(Writer out, String str) throws IOException {
+        if (out == null) {
+            throw new IllegalArgumentException("The Writer must not be null");
+        }
+        if (str == null) {
+            return;
+        }
+        int sz = str.length();
+        StringBuffer unicode = new StringBuffer(4);
+        boolean hadSlash = false;
+        boolean inUnicode = false;
+        for (int i = 0; i < sz; i++) {
+            char ch = str.charAt(i);
+            if (inUnicode) {
+                // if in unicode, then we're reading unicode
+                // values in somehow
+                unicode.append(ch);
+                if (unicode.length() == 4) {
+                    // unicode now contains the four hex digits
+                    // which represents our unicode character
+                    try {
+                        int value = Integer.parseInt(unicode.toString(), 16);
+                        out.write((char) value);
+                        unicode.setLength(0);
+                        inUnicode = false;
+                        hadSlash = false;
+                    } catch (NumberFormatException nfe) {
+                        throw new RuntimeException("Unable to parse unicode value: " + unicode, nfe);
+                    }
+                }
+                continue;
+            }
+            if (hadSlash) {
+                // handle an escaped value
+                hadSlash = false;
+                switch (ch) {
+                    case '\\':
+                        out.write('\\');
+                        break;
+                    case '\'':
+                        out.write('\'');
+                        break;
+                    case '\"':
+                        out.write('"');
+                        break;
+                    case 'r':
+                        out.write('\r');
+                        break;
+                    case 'f':
+                        out.write('\f');
+                        break;
+                    case 't':
+                        out.write('\t');
+                        break;
+                    case 'n':
+                        out.write('\n');
+                        break;
+                    case 'b':
+                        out.write('\b');
+                        break;
+                    case 'u': {
+                        // uh-oh, we're in unicode country....
+                        inUnicode = true;
+                        break;
+                    }
+                    default:
+                        out.write(ch);
+                        break;
+                }
+                continue;
+            } else if (ch == '\\') {
+                hadSlash = true;
+                continue;
+            }
+            out.write(ch);
+        }
+        if (hadSlash) {
+            // then we're in the weird case of a \ at the end of the
+            // string, let's output it anyway.
+            out.write('\\');
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/util/ResolverUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/util/ResolverUtil.java b/core/src/main/java/com/opensymphony/xwork2/util/ResolverUtil.java
new file mode 100644
index 0000000..e7222cd
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/util/ResolverUtil.java
@@ -0,0 +1,466 @@
+/* Copyright 2005-2006 Tim Fennell
+ *
+ * Licensed 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 com.opensymphony.xwork2.util;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.jar.JarEntry;
+import java.util.jar.JarInputStream;
+
+/**
+ * <p>ResolverUtil is used to locate classes that are available in the/a class path and meet
+ * arbitrary conditions. The two most common conditions are that a class implements/extends
+ * another class, or that is it annotated with a specific annotation. However, through the use
+ * of the {@link Test} class it is possible to search using arbitrary conditions.</p>
+ *
+ * <p>A ClassLoader is used to locate all locations (directories and jar files) in the class
+ * path that contain classes within certain packages, and then to load those classes and
+ * check them. By default the ClassLoader returned by
+ *  {@code Thread.currentThread().getContextClassLoader()} is used, but this can be overridden
+ * by calling {@link #setClassLoader(ClassLoader)} prior to invoking any of the {@code find()}
+ * methods.</p>
+ *
+ * <p>General searches are initiated by calling the
+ * {@link #find(com.opensymphony.xwork2.util.ResolverUtil.Test, String...)} ()} method and supplying
+ * a package name and a Test instance. This will cause the named package <b>and all sub-packages</b>
+ * to be scanned for classes that meet the test. There are also utility methods for the common
+ * use cases of scanning multiple packages for extensions of particular classes, or classes
+ * annotated with a specific annotation.</p>
+ *
+ * <p>The standard usage pattern for the ResolverUtil class is as follows:</p>
+ *
+ *<pre>
+ *ResolverUtil&lt;ActionBean&gt; resolver = new ResolverUtil&lt;ActionBean&gt;();
+ *resolver.findImplementation(ActionBean.class, pkg1, pkg2);
+ *resolver.find(new CustomTest(), pkg1);
+ *resolver.find(new CustomTest(), pkg2);
+ *Collection&lt;ActionBean&gt; beans = resolver.getClasses();
+ *</pre> 
+ *
+ * <p>This class was copied from Stripes - http://stripes.mc4j.org/confluence/display/stripes/Home
+ * </p>
+ * 
+ * @author Tim Fennell
+ */
+public class ResolverUtil<T> {
+    /** An instance of Log to use for logging in this class. */
+    private static final Logger LOG = LogManager.getLogger(ResolverUtil.class);
+
+    /**
+     * A simple interface that specifies how to test classes to determine if they
+     * are to be included in the results produced by the ResolverUtil.
+     */
+    public static interface Test {
+        /**
+         * Will be called repeatedly with candidate classes. Must return True if a class
+         * is to be included in the results, false otherwise.
+         */
+        boolean matches(Class type);
+        
+        boolean matches(URL resource);
+
+        boolean doesMatchClass();
+        boolean doesMatchResource();
+    }
+    
+    public static abstract class ClassTest implements Test {
+        public boolean matches(URL resource) {
+            throw new UnsupportedOperationException();
+        }
+
+        public boolean doesMatchClass() {
+            return true;
+        }
+        public boolean doesMatchResource() {
+            return false;
+        }
+    }
+    
+    public static abstract class ResourceTest implements Test {
+        public boolean matches(Class cls) {
+            throw new UnsupportedOperationException();
+        }
+
+        public boolean doesMatchClass() {
+            return false;
+        }
+        public boolean doesMatchResource() {
+            return true;
+        }
+    }
+
+    /**
+     * A Test that checks to see if each class is assignable to the provided class. Note
+     * that this test will match the parent type itself if it is presented for matching.
+     */
+    public static class IsA extends ClassTest {
+        private Class parent;
+
+        /** Constructs an IsA test using the supplied Class as the parent class/interface. */
+        public IsA(Class parentType) { this.parent = parentType; }
+
+        /** Returns true if type is assignable to the parent type supplied in the constructor. */
+        public boolean matches(Class type) {
+            return type != null && parent.isAssignableFrom(type);
+        }
+
+        @Override public String toString() {
+            return "is assignable to " + parent.getSimpleName();
+        }
+    }
+    
+    /**
+     * A Test that checks to see if each class name ends with the provided suffix.
+     */
+    public static class NameEndsWith extends ClassTest {
+        private String suffix;
+
+        /** Constructs a NameEndsWith test using the supplied suffix. */
+        public NameEndsWith(String suffix) { this.suffix = suffix; }
+
+        /** Returns true if type name ends with the suffix supplied in the constructor. */
+        public boolean matches(Class type) {
+            return type != null && type.getName().endsWith(suffix);
+        }
+
+        @Override public String toString() {
+            return "ends with the suffix " + suffix;
+        }
+    }
+
+    /**
+     * A Test that checks to see if each class is annotated with a specific annotation. If it
+     * is, then the test returns true, otherwise false.
+     */
+    public static class AnnotatedWith extends ClassTest {
+        private Class<? extends Annotation> annotation;
+
+        /** Construts an AnnotatedWith test for the specified annotation type. */
+        public AnnotatedWith(Class<? extends Annotation> annotation) { this.annotation = annotation; }
+
+        /** Returns true if the type is annotated with the class provided to the constructor. */
+        public boolean matches(Class type) {
+            return type != null && type.isAnnotationPresent(annotation);
+        }
+
+        @Override public String toString() {
+            return "annotated with @" + annotation.getSimpleName();
+        }
+    }
+    
+    public static class NameIs extends ResourceTest {
+        private String name;
+        
+        public NameIs(String name) { this.name = "/" + name; }
+        
+        public boolean matches(URL resource) {
+            return (resource.getPath().endsWith(name));
+        }
+        
+        @Override public String toString() {
+            return "named " + name;
+        }
+    }
+
+    /** The set of matches being accumulated. */
+    private Set<Class<? extends T>> classMatches = new HashSet<Class<?extends T>>();
+    
+    /** The set of matches being accumulated. */
+    private Set<URL> resourceMatches = new HashSet<URL>();
+
+    /**
+     * The ClassLoader to use when looking for classes. If null then the ClassLoader returned
+     * by Thread.currentThread().getContextClassLoader() will be used.
+     */
+    private ClassLoader classloader;
+
+    /**
+     * Provides access to the classes discovered so far. If no calls have been made to
+     * any of the {@code find()} methods, this set will be empty.
+     *
+     * @return the set of classes that have been discovered.
+     */
+    public Set<Class<? extends T>> getClasses() {
+        return classMatches;
+    }
+    
+    public Set<URL> getResources() {
+        return resourceMatches;
+    }
+    
+
+    /**
+     * Returns the classloader that will be used for scanning for classes. If no explicit
+     * ClassLoader has been set by the calling, the context class loader will be used.
+     *
+     * @return the ClassLoader that will be used to scan for classes
+     */
+    public ClassLoader getClassLoader() {
+        return classloader == null ? Thread.currentThread().getContextClassLoader() : classloader;
+    }
+
+    /**
+     * Sets an explicit ClassLoader that should be used when scanning for classes. If none
+     * is set then the context classloader will be used.
+     *
+     * @param classloader a ClassLoader to use when scanning for classes
+     */
+    public void setClassLoader(ClassLoader classloader) { this.classloader = classloader; }
+
+    /**
+     * Attempts to discover classes that are assignable to the type provided. In the case
+     * that an interface is provided this method will collect implementations. In the case
+     * of a non-interface class, subclasses will be collected.  Accumulated classes can be
+     * accessed by calling {@link #getClasses()}.
+     *
+     * @param parent the class of interface to find subclasses or implementations of
+     * @param packageNames one or more package names to scan (including subpackages) for classes
+     */
+    public void findImplementations(Class parent, String... packageNames) {
+        if (packageNames == null) return;
+
+        Test test = new IsA(parent);
+        for (String pkg : packageNames) {
+            findInPackage(test, pkg);
+        }
+    }
+    
+    /**
+     * Attempts to discover classes who's name ends with the provided suffix. Accumulated classes can be
+     * accessed by calling {@link #getClasses()}.
+     *
+     * @param suffix The class name suffix to match
+     * @param packageNames one or more package names to scan (including subpackages) for classes
+     */
+    public void findSuffix(String suffix, String... packageNames) {
+        if (packageNames == null) return;
+
+        Test test = new NameEndsWith(suffix);
+        for (String pkg : packageNames) {
+            findInPackage(test, pkg);
+        }
+    }
+
+    /**
+     * Attempts to discover classes that are annotated with to the annotation. Accumulated
+     * classes can be accessed by calling {@link #getClasses()}.
+     *
+     * @param annotation the annotation that should be present on matching classes
+     * @param packageNames one or more package names to scan (including subpackages) for classes
+     */
+    public void findAnnotated(Class<? extends Annotation> annotation, String... packageNames) {
+        if (packageNames == null) return;
+
+        Test test = new AnnotatedWith(annotation);
+        for (String pkg : packageNames) {
+            findInPackage(test, pkg);
+        }
+    }
+    
+    public void findNamedResource(String name, String... pathNames) {
+        if (pathNames == null) return;
+        
+        Test test = new NameIs(name);
+        for (String pkg : pathNames) {
+            findInPackage(test, pkg);
+        }
+    }
+    
+    /**
+     * Attempts to discover classes that pass the test. Accumulated
+     * classes can be accessed by calling {@link #getClasses()}.
+     *
+     * @param test the test to determine matching classes
+     * @param packageNames one or more package names to scan (including subpackages) for classes
+     */
+    public void find(Test test, String... packageNames) {
+        if (packageNames == null) return;
+
+        for (String pkg : packageNames) {
+            findInPackage(test, pkg);
+        }
+    }
+
+    /**
+     * Scans for classes starting at the package provided and descending into subpackages.
+     * Each class is offered up to the Test as it is discovered, and if the Test returns
+     * true the class is retained.  Accumulated classes can be fetched by calling
+     * {@link #getClasses()}.
+     *
+     * @param test an instance of {@link Test} that will be used to filter classes
+     * @param packageName the name of the package from which to start scanning for
+     *        classes, e.g. {@code net.sourceforge.stripes}
+     */
+    public void findInPackage(Test test, String packageName) {
+        packageName = packageName.replace('.', '/');
+        ClassLoader loader = getClassLoader();
+        Enumeration<URL> urls;
+
+        try {
+            urls = loader.getResources(packageName);
+        }
+        catch (IOException ioe) {
+            if (LOG.isWarnEnabled()) {
+        	LOG.warn("Could not read package: " + packageName, ioe);
+            }
+            return;
+        }
+
+        while (urls.hasMoreElements()) {
+            try {
+                String urlPath = urls.nextElement().getFile();
+                urlPath = URLDecoder.decode(urlPath, "UTF-8");
+
+                // If it's a file in a directory, trim the stupid file: spec
+                if ( urlPath.startsWith("file:") ) {
+                    urlPath = urlPath.substring(5);
+                }
+
+                // Else it's in a JAR, grab the path to the jar
+                if (urlPath.indexOf('!') > 0) {
+                    urlPath = urlPath.substring(0, urlPath.indexOf('!'));
+                }
+
+                if (LOG.isInfoEnabled()) {
+                    LOG.info("Scanning for classes in [" + urlPath + "] matching criteria: " + test);
+                }
+                File file = new File(urlPath);
+                if ( file.isDirectory() ) {
+                    loadImplementationsInDirectory(test, packageName, file);
+                }
+                else {
+                    loadImplementationsInJar(test, packageName, file);
+                }
+            }
+            catch (IOException ioe) {
+                if (LOG.isWarnEnabled()) {
+                    LOG.warn("could not read entries", ioe);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * Finds matches in a physical directory on a filesystem.  Examines all
+     * files within a directory - if the File object is not a directory, and ends with <i>.class</i>
+     * the file is loaded and tested to see if it is acceptable according to the Test.  Operates
+     * recursively to find classes within a folder structure matching the package structure.
+     *
+     * @param test a Test used to filter the classes that are discovered
+     * @param parent the package name up to this directory in the package hierarchy.  E.g. if
+     *        /classes is in the classpath and we wish to examine files in /classes/org/apache then
+     *        the values of <i>parent</i> would be <i>org/apache</i>
+     * @param location a File object representing a directory
+     */
+    private void loadImplementationsInDirectory(Test test, String parent, File location) {
+        File[] files = location.listFiles();
+        StringBuilder builder = null;
+
+        for (File file : files) {
+            builder = new StringBuilder(100);
+            builder.append(parent).append("/").append(file.getName());
+            String packageOrClass = ( parent == null ? file.getName() : builder.toString() );
+
+            if (file.isDirectory()) {
+                loadImplementationsInDirectory(test, packageOrClass, file);
+            }
+            else if (isTestApplicable(test, file.getName())) {
+                addIfMatching(test, packageOrClass);
+            }
+        }
+    }
+
+    private boolean isTestApplicable(Test test, String path) {
+        return test.doesMatchResource() || path.endsWith(".class") && test.doesMatchClass();
+    }
+
+    /**
+     * Finds matching classes within a jar files that contains a folder structure
+     * matching the package structure.  If the File is not a JarFile or does not exist a warning
+     * will be logged, but no error will be raised.
+     *
+     * @param test a Test used to filter the classes that are discovered
+     * @param parent the parent package under which classes must be in order to be considered
+     * @param jarfile the jar file to be examined for classes
+     */
+    private void loadImplementationsInJar(Test test, String parent, File jarfile) {
+
+        try {
+            JarEntry entry;
+            JarInputStream jarStream = new JarInputStream(new FileInputStream(jarfile));
+
+            while ( (entry = jarStream.getNextJarEntry() ) != null) {
+                String name = entry.getName();
+                if (!entry.isDirectory() && name.startsWith(parent) && isTestApplicable(test, name)) {
+                    addIfMatching(test, name);
+                }
+            }
+        }
+        catch (IOException ioe) {
+            LOG.error("Could not search jar file '" + jarfile + "' for classes matching criteria: " +
+                      test + " due to an IOException", ioe);
+        }
+    }
+
+    /**
+     * Add the class designated by the fully qualified class name provided to the set of
+     * resolved classes if and only if it is approved by the Test supplied.
+     *
+     * @param test the test used to determine if the class matches
+     * @param fqn the fully qualified name of a class
+     */
+    protected void addIfMatching(Test test, String fqn) {
+        try {
+            ClassLoader loader = getClassLoader();
+            if (test.doesMatchClass()) {
+                String externalName = fqn.substring(0, fqn.indexOf('.')).replace('/', '.');
+                if (LOG.isDebugEnabled()) {
+                    LOG.debug("Checking to see if class " + externalName + " matches criteria [" + test + "]");
+                }
+    
+                Class type = loader.loadClass(externalName);
+                if (test.matches(type) ) {
+                    classMatches.add( (Class<T>) type);
+                }
+            }
+            if (test.doesMatchResource()) {
+                URL url = loader.getResource(fqn);
+                if (url == null) {
+                    url = loader.getResource(fqn.substring(1));
+                }
+                if (url != null && test.matches(url)) {
+                    resourceMatches.add(url);
+                }
+            }
+        }
+        catch (Throwable t) {
+            if (LOG.isWarnEnabled()) {
+        	LOG.warn("Could not examine class '" + fqn + "' due to a " +
+                     t.getClass().getName() + " with message: " + t.getMessage());
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/util/TextParseUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/util/TextParseUtil.java b/core/src/main/java/com/opensymphony/xwork2/util/TextParseUtil.java
new file mode 100644
index 0000000..db1af6d
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/util/TextParseUtil.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ * 
+ * Licensed 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 com.opensymphony.xwork2.util;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.conversion.impl.XWorkConverter;
+import com.opensymphony.xwork2.inject.Container;
+
+import java.util.*;
+
+
+/**
+ * Utility class for text parsing.
+ *
+ * @author Jason Carreira
+ * @author Rainer Hermanns
+ * @author tm_jee
+ *
+ * @version $Date$ $Id$
+ */
+public class TextParseUtil {
+
+    private static final int MAX_RECURSION = 1;
+
+    /**
+     * Converts all instances of ${...}, and %{...} in <code>expression</code> to the value returned
+     * by a call to {@link ValueStack#findValue(java.lang.String)}. If an item cannot
+     * be found on the stack (null is returned), then the entire variable ${...} is not
+     * displayed, just as if the item was on the stack but returned an empty string.
+     *
+     * @param expression an expression that hasn't yet been translated
+     * @return the parsed expression
+     */
+    public static String translateVariables(String expression, ValueStack stack) {
+        return translateVariables(new char[]{'$', '%'}, expression, stack, String.class, null).toString();
+    }
+
+
+    /**
+     * Function similarly as {@link #translateVariables(char, String, ValueStack)}
+     * except for the introduction of an additional <code>evaluator</code> that allows
+     * the parsed value to be evaluated by the <code>evaluator</code>. The <code>evaluator</code>
+     * could be null, if it is it will just be skipped as if it is just calling
+     * {@link #translateVariables(char, String, ValueStack)}.
+     *
+     * <p/>
+     *
+     * A typical use-case would be when we need to URL Encode the parsed value. To do so
+     * we could just supply a URLEncodingEvaluator for example.
+     *
+     * @param expression
+     * @param stack
+     * @param evaluator The parsed Value evaluator (could be null).
+     * @return the parsed (and possibly evaluated) variable String.
+     */
+    public static String translateVariables(String expression, ValueStack stack, ParsedValueEvaluator evaluator) {
+    	return translateVariables(new char[]{'$', '%'}, expression, stack, String.class, evaluator).toString();
+    }
+
+    /**
+     * Converts all instances of ${...} in <code>expression</code> to the value returned
+     * by a call to {@link ValueStack#findValue(java.lang.String)}. If an item cannot
+     * be found on the stack (null is returned), then the entire variable ${...} is not
+     * displayed, just as if the item was on the stack but returned an empty string.
+     *
+     * @param open
+     * @param expression
+     * @param stack
+     * @return Translated variable String
+     */
+    public static String translateVariables(char open, String expression, ValueStack stack) {
+        return translateVariables(open, expression, stack, String.class, null).toString();
+    }
+
+    /**
+     * Converted object from variable translation.
+     *
+     * @param open
+     * @param expression
+     * @param stack
+     * @param asType
+     * @return Converted object from variable translation.
+     */
+    public static Object translateVariables(char open, String expression, ValueStack stack, Class asType) {
+    	return translateVariables(open, expression, stack, asType, null);
+    }
+
+    /**
+     * Converted object from variable translation.
+     *
+     * @param open
+     * @param expression
+     * @param stack
+     * @param asType
+     * @param evaluator
+     * @return Converted object from variable translation.
+     */
+    public static Object translateVariables(char open, String expression, ValueStack stack, Class asType, ParsedValueEvaluator evaluator) {
+        return translateVariables(new char[]{open} , expression, stack, asType, evaluator, MAX_RECURSION);
+    }
+
+    /**
+     * Converted object from variable translation.
+     *
+     * @param openChars
+     * @param expression
+     * @param stack
+     * @param asType
+     * @param evaluator
+     * @return Converted object from variable translation.
+     */
+    public static Object translateVariables(char[] openChars, String expression, ValueStack stack, Class asType, ParsedValueEvaluator evaluator) {
+        return translateVariables(openChars, expression, stack, asType, evaluator, MAX_RECURSION);
+    }
+
+    /**
+     * Converted object from variable translation.
+     *
+     * @param open
+     * @param expression
+     * @param stack
+     * @param asType
+     * @param evaluator
+     * @return Converted object from variable translation.
+     */
+    public static Object translateVariables(char open, String expression, ValueStack stack, Class asType, ParsedValueEvaluator evaluator, int maxLoopCount) {
+        return translateVariables(new char[]{open}, expression, stack, asType, evaluator, maxLoopCount);
+    }
+
+    /**
+     * Converted object from variable translation.
+     *
+     * @param openChars
+     * @param expression
+     * @param stack
+     * @param asType
+     * @param evaluator
+     * @return Converted object from variable translation.
+     */
+    public static Object translateVariables(char[] openChars, String expression, final ValueStack stack, final Class asType, final ParsedValueEvaluator evaluator, int maxLoopCount) {
+
+        ParsedValueEvaluator ognlEval = new ParsedValueEvaluator() {
+            public Object evaluate(String parsedValue) {
+                Object o = stack.findValue(parsedValue, asType);
+                if (evaluator != null && o != null) {
+                    o = evaluator.evaluate(o.toString());
+                }
+                return o;
+            }
+        };
+
+        TextParser parser = ((Container)stack.getContext().get(ActionContext.CONTAINER)).getInstance(TextParser.class);
+
+        return parser.evaluate(openChars, expression, ognlEval, maxLoopCount);
+    }
+
+    /**
+     * @see #translateVariablesCollection(char[], String, ValueStack, boolean, ParsedValueEvaluator, int)
+     *
+     * @param expression
+     * @param stack
+     * @param excludeEmptyElements
+     * @param evaluator
+     * @return
+     */
+    public static Collection<String>  translateVariablesCollection(String expression, ValueStack stack, boolean excludeEmptyElements, ParsedValueEvaluator evaluator) {
+        return translateVariablesCollection(new char[]{'$', '%'}, expression, stack, excludeEmptyElements, evaluator, MAX_RECURSION);
+    }
+
+    /**
+     * Resolves given expression on given ValueStack. If found element is a
+     * collection each element will be converted to String. If just a single
+     * object is found it is converted to String and wrapped in a collection.
+     * 
+     * @param openChars
+     * @param expression
+     * @param stack
+     * @param excludeEmptyElements
+     * @param evaluator
+     * @param maxLoopCount
+     * @return
+     */
+    public static Collection<String> translateVariablesCollection(
+            char[] openChars, String expression, final ValueStack stack, boolean excludeEmptyElements,
+            final ParsedValueEvaluator evaluator, int maxLoopCount) {
+
+        ParsedValueEvaluator ognlEval = new ParsedValueEvaluator() {
+            public Object evaluate(String parsedValue) {
+                return stack.findValue(parsedValue); // no asType !!!
+            }
+        };
+
+        Map<String, Object> context = stack.getContext();
+        TextParser parser = ((Container)context.get(ActionContext.CONTAINER)).getInstance(TextParser.class);
+
+        Object result = parser.evaluate(openChars, expression, ognlEval, maxLoopCount);
+
+        Collection<String> resultCol;
+        if (result instanceof Collection) {
+            @SuppressWarnings("unchecked")
+            Collection<Object> casted = (Collection<Object>)result;
+            resultCol = new ArrayList<>();
+
+            XWorkConverter conv = ((Container)context.get(ActionContext.CONTAINER)).getInstance(XWorkConverter.class);
+
+            for (Object element : casted) {
+                String stringElement = (String)conv.convertValue(context, element, String.class);
+                if (shallBeIncluded(stringElement, excludeEmptyElements)) {
+                    if (evaluator != null) {
+                        stringElement = evaluator.evaluate(stringElement).toString();
+                    }
+                    resultCol.add(stringElement);
+                }
+            }
+        } else {
+            resultCol = new ArrayList<>();
+            String resultStr = translateVariables(expression, stack, evaluator);
+            if (shallBeIncluded(resultStr, excludeEmptyElements)) {
+                resultCol.add(resultStr);
+            }
+        }
+
+        return resultCol;
+    }
+
+    /**
+     * Tests if given string is not null and not empty when excluding of empty
+     * elements is requested.
+     * 
+     * @param str String to check.
+     * @param excludeEmptyElements Whether empty elements shall be excluded.
+     * @return True if given string can be included in collection.
+     */
+    private static boolean shallBeIncluded(String str, boolean excludeEmptyElements) {
+        return !excludeEmptyElements || ((str != null) && (str.length() > 0));
+    }
+
+    /**
+     * Returns a set from comma delimted Strings.
+     * @param s The String to parse.
+     * @return A set from comma delimted Strings.
+     */
+    public static Set<String> commaDelimitedStringToSet(String s) {
+        Set<String> set = new HashSet<>();
+        String[] split = s.split(",");
+        for (String aSplit : split) {
+            String trimmed = aSplit.trim();
+            if (trimmed.length() > 0)
+                set.add(trimmed);
+        }
+        return set;
+    }
+
+
+    /**
+     * A parsed value evaluator for {@link TextParseUtil}. It could be supplied by
+     * calling {@link TextParseUtil#translateVariables(char, String, ValueStack, Class, ParsedValueEvaluator)}.
+     *
+     * <p/>
+     *
+     * By supplying this <code>ParsedValueEvaluator</code>, the parsed value
+     * (parsed against the value stack) value will be
+     * given to <code>ParsedValueEvaluator</code> to be evaluated before the
+     * translateVariable process goes on.
+     *
+     * <p/>
+     *
+     * A typical use-case would be to have a custom <code>ParseValueEvaluator</code>
+     * to URL Encode the parsed value.
+     *
+     * @author tm_jee
+     *
+     * @version $Date$ $Id$
+     */
+    public static interface ParsedValueEvaluator {
+
+    	/**
+    	 * Evaluated the value parsed by Ognl value stack.
+    	 *
+    	 * @param parsedValue - value parsed by ognl value stack
+    	 * @return return the evaluted value.
+    	 */
+    	Object evaluate(String parsedValue);
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/util/TextParser.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/util/TextParser.java b/core/src/main/java/com/opensymphony/xwork2/util/TextParser.java
new file mode 100644
index 0000000..54b18ef
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/util/TextParser.java
@@ -0,0 +1,11 @@
+package com.opensymphony.xwork2.util;
+
+/**
+ * Used to parse expressions like ${foo.bar} or %{bar.foo} but it is up tp the TextParser's
+ * implementation what kind of opening char to use (#, $, %, etc)
+ */
+public interface TextParser {
+
+    Object evaluate(char[] openChars, String expression, TextParseUtil.ParsedValueEvaluator evaluator, int maxLoopCount);
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/util/URLUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/util/URLUtil.java b/core/src/main/java/com/opensymphony/xwork2/util/URLUtil.java
new file mode 100644
index 0000000..006fd5e
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/util/URLUtil.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2002-2003,2009 The Apache Software Foundation.
+ * 
+ * Licensed 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 com.opensymphony.xwork2.util;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+/**
+ * Helper class to extract file paths from different urls
+ */
+public class URLUtil {
+
+    private static final Logger LOG = LogManager.getLogger(URLUtil.class);
+
+    /**
+     * Verify That the given String is in valid URL format.
+     * @param url The url string to verify.
+     * @return a boolean indicating whether the URL seems to be incorrect.
+     */
+    @Deprecated
+    public static boolean verifyUrl(String url) {
+        LOG.debug("Checking if url [{}] is valid", url);
+        if (url == null) {
+            return false;
+        }
+
+        if (url.startsWith("https://")) {
+            // URL doesn't understand the https protocol, hack it
+            url = "http://" + url.substring(8);
+        }
+
+        try {
+            URL u = new URL(url);
+            URI uri = u.toURI(); // perform a additional url syntax check
+            if (uri.getHost() == null) {
+                LOG.debug("Url [{}] does not contains a valid host: {}", url, uri);
+                return false;
+            }
+            return true;
+        } catch (MalformedURLException | URISyntaxException e) {
+            LOG.debug("Url [{}] is invalid: {}", url, e.getMessage(), e);
+            return false;
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/util/ValueStack.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/util/ValueStack.java b/core/src/main/java/com/opensymphony/xwork2/util/ValueStack.java
new file mode 100644
index 0000000..b59bcee
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/util/ValueStack.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2002-2007,2009 The Apache Software Foundation.
+ * 
+ * Licensed 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 com.opensymphony.xwork2.util;
+
+import java.util.Map;
+
+/**
+ * ValueStack allows multiple beans to be pushed in and dynamic EL expressions to be evaluated against it. When
+ * evaluating an expression, the stack will be searched down the stack, from the latest objects pushed in to the
+ * earliest, looking for a bean with a getter or setter for the given property or a method of the given name (depending
+ * on the expression being evaluated).
+ */
+public interface ValueStack {
+
+    public static final String VALUE_STACK = "com.opensymphony.xwork2.util.ValueStack.ValueStack";
+
+    public static final String REPORT_ERRORS_ON_NO_PROP = "com.opensymphony.xwork2.util.ValueStack.ReportErrorsOnNoProp";
+
+    /**
+     * Gets the context for this value stack. The context holds all the information in the value stack and it's surroundings.
+     *
+     * @return  the context.
+     */
+    public abstract Map<String, Object> getContext();
+
+    /**
+     * Sets the default type to convert to if no type is provided when getting a value.
+     *
+     * @param defaultType the new default type
+     */
+    public abstract void setDefaultType(Class defaultType);
+
+    /**
+     * Set a override map containing <code>key -> values</code> that takes precedent when doing find operations on the ValueStack.
+     * <p/>
+     * See the unit test for ValueStackTest for examples.
+     *
+     * @param overrides  overrides map.
+     */
+    public abstract void setExprOverrides(Map<Object, Object> overrides);
+
+    /**
+     * Gets the override map if anyone exists.
+     *
+     * @return the override map, <tt>null</tt> if not set.
+     */
+    public abstract Map<Object, Object> getExprOverrides();
+
+    /**
+     * Get the CompoundRoot which holds the objects pushed onto the stack
+     *
+     * @return the root
+     */
+    public abstract CompoundRoot getRoot();
+
+    /**
+     * Attempts to set a property on a bean in the stack with the given expression using the default search order.
+     *
+     * @param expr  the expression defining the path to the property to be set.
+     * @param value the value to be set into the named property
+     */
+    public abstract void setValue(String expr, Object value);
+
+    /**
+     * Attempts to set a property on a bean in the stack with the given expression using the default search order.
+     * N.B.: unlike #setValue(String,Object) it doesn't allow eval expression.
+     * @param expr  the expression defining the path to the property to be set.
+     * @param value the value to be set into the named property
+     */
+    void setParameter(String expr, Object value);
+
+    /**
+     * Attempts to set a property on a bean in the stack with the given expression using the default search order.
+     *
+     * @param expr                    the expression defining the path to the property to be set.
+     * @param value                   the value to be set into the named property
+     * @param throwExceptionOnFailure a flag to tell whether an exception should be thrown if there is no property with
+     *                                the given name.
+     */
+    public abstract void setValue(String expr, Object value, boolean throwExceptionOnFailure);
+
+    public abstract String findString(String expr);
+    public abstract String findString(String expr, boolean throwExceptionOnFailure);
+
+    /**
+     * Find a value by evaluating the given expression against the stack in the default search order.
+     *
+     * @param expr the expression giving the path of properties to navigate to find the property value to return
+     * @return the result of evaluating the expression
+     */
+    public abstract Object findValue(String expr);
+
+    public abstract Object findValue(String expr, boolean throwExceptionOnFailure);
+
+    /**
+     * Find a value by evaluating the given expression against the stack in the default search order.
+     *
+     * @param expr   the expression giving the path of properties to navigate to find the property value to return
+     * @param asType the type to convert the return value to
+     * @return the result of evaluating the expression
+     */
+    public abstract Object findValue(String expr, Class asType);
+    public abstract Object findValue(String expr, Class asType,  boolean throwExceptionOnFailure);
+
+    /**
+     * Get the object on the top of the stack <b>without</b> changing the stack.
+     *
+     * @return the object on the top.
+     * @see CompoundRoot#peek()
+     */
+    public abstract Object peek();
+
+    /**
+     * Get the object on the top of the stack and <b>remove</b> it from the stack.
+     *
+     * @return the object on the top of the stack
+     * @see CompoundRoot#pop()
+     */
+    public abstract Object pop();
+
+    /**
+     * Put this object onto the top of the stack
+     *
+     * @param o the object to be pushed onto the stack
+     * @see CompoundRoot#push(Object)
+     */
+    public abstract void push(Object o);
+
+    /**
+     * Sets an object on the stack with the given key
+     * so it is retrievable by {@link #findValue(String)}, {@link #findValue(String, Class)}
+     *
+     * @param key  the key
+     * @param o    the object
+     */
+    public abstract void set(String key, Object o);
+
+    /**
+     * Get the number of objects in the stack
+     *
+     * @return the number of objects in the stack
+     */
+    public abstract int size();
+
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/util/ValueStackFactory.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/util/ValueStackFactory.java b/core/src/main/java/com/opensymphony/xwork2/util/ValueStackFactory.java
new file mode 100644
index 0000000..aa8256d
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/util/ValueStackFactory.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2002-2007,2009 The Apache Software Foundation.
+ * 
+ * Licensed 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 com.opensymphony.xwork2.util;
+
+/**
+ * Factory that creates a value stack, defaulting to the OgnlValueStackFactory
+ */
+public interface ValueStackFactory {
+
+    /**
+     * Get a new instance of {@link com.opensymphony.xwork2.util.ValueStack}
+     *
+     * @return  a new {@link com.opensymphony.xwork2.util.ValueStack}.
+     */
+    ValueStack createValueStack();
+    
+    /**
+     * Get a new instance of {@link com.opensymphony.xwork2.util.ValueStack}
+     *
+     * @param stack an existing stack to include.
+     * @return  a new {@link com.opensymphony.xwork2.util.ValueStack}.
+     */
+    ValueStack createValueStack(ValueStack stack);
+    
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/util/WildcardHelper.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/util/WildcardHelper.java b/core/src/main/java/com/opensymphony/xwork2/util/WildcardHelper.java
new file mode 100644
index 0000000..86a3b9a
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/util/WildcardHelper.java
@@ -0,0 +1,463 @@
+/*
+ * $Id$
+ *
+ * Copyright 2003-2004 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.util;
+
+import java.util.Map;
+
+/**
+ * This class is an utility class that perform wilcard-patterns matching and
+ * isolation taken from Apache Cocoon.
+ *
+ * @version $Rev$ $Date: 2005-05-07 12:11:38 -0400 (Sat, 07 May 2005)
+ *          $
+ */
+public class WildcardHelper implements PatternMatcher<int[]> {
+    /**
+     * The int representing '*' in the pattern <code>int []</code>.
+     */
+    protected static final int MATCH_FILE = -1;
+
+    /**
+     * The int representing '**' in the pattern <code>int []</code>.
+     */
+    protected static final int MATCH_PATH = -2;
+
+    /**
+     * The int representing begin in the pattern <code>int []</code>.
+     */
+    protected static final int MATCH_BEGIN = -4;
+
+    /**
+     * The int representing end in pattern <code>int []</code>.
+     */
+    protected static final int MATCH_THEEND = -5;
+
+    /**
+     * The int value that terminates the pattern <code>int []</code>.
+     */
+    protected static final int MATCH_END = -3;
+
+    /**
+     * Determines if the pattern contains any * characters
+     *
+     * @param pattern The pattern
+     * @return True if no wildcards are found
+     */
+    public boolean isLiteral(String pattern) {
+        return (pattern == null || pattern.indexOf('*') == -1);
+    }
+
+    /**
+     * <p> Translate the given <code>String</code> into a <code>int []</code>
+     * representing the pattern matchable by this class. <br> This function
+     * translates a <code>String</code> into an int array converting the
+     * special '*' and '\' characters. <br> Here is how the conversion
+     * algorithm works:</p>
+     *
+     * <ul>
+     *
+     * <li>The '*' character is converted to MATCH_FILE, meaning that zero or
+     * more characters (excluding the path separator '/') are to be
+     * matched.</li>
+     *
+     * <li>The '**' sequence is converted to MATCH_PATH, meaning that zero or
+     * more characters (including the path separator '/') are to be
+     * matched.</li>
+     *
+     * <li>The '\' character is used as an escape sequence ('\*' is translated
+     * in '*', not in MATCH_FILE). If an exact '\' character is to be matched
+     * the source string must contain a '\\'. sequence.</li>
+     *
+     * </ul>
+     *
+     * <p>When more than two '*' characters, not separated by another
+     * character, are found their value is considered as '**' (MATCH_PATH).
+     * <br> The array is always terminated by a special value (MATCH_END).
+     * <br> All MATCH* values are less than zero, while normal characters are
+     * equal or greater.</p>
+     *
+     * @param data The string to translate.
+     * @return The encoded string as an int array, terminated by the MATCH_END
+     *         value (don't consider the array length).
+     * @throws NullPointerException If data is null.
+     */
+    public int[] compilePattern(String data) {
+        // Prepare the arrays
+        int[] expr = new int[data.length() + 2];
+        char[] buff = data.toCharArray();
+
+        // Prepare variables for the translation loop
+        int y = 0;
+        boolean slash = false;
+
+        // Must start from beginning
+        expr[y++] = MATCH_BEGIN;
+
+        if (buff.length > 0) {
+            if (buff[0] == '\\') {
+                slash = true;
+            } else if (buff[0] == '*') {
+                expr[y++] = MATCH_FILE;
+            } else {
+                expr[y++] = buff[0];
+            }
+
+            // Main translation loop
+            for (int x = 1; x < buff.length; x++) {
+                // If the previous char was '\' simply copy this char.
+                if (slash) {
+                    expr[y++] = buff[x];
+                    slash = false;
+
+                    // If the previous char was not '\' we have to do a bunch of
+                    // checks
+                } else {
+                    // If this char is '\' declare that and continue
+                    if (buff[x] == '\\') {
+                        slash = true;
+
+                        // If this char is '*' check the previous one
+                    } else if (buff[x] == '*') {
+                        // If the previous character als was '*' match a path
+                        if (expr[y - 1] <= MATCH_FILE) {
+                            expr[y - 1] = MATCH_PATH;
+                        } else {
+                            expr[y++] = MATCH_FILE;
+                        }
+                    } else {
+                        expr[y++] = buff[x];
+                    }
+                }
+            }
+        }
+
+        // Must match end at the end
+        expr[y] = MATCH_THEEND;
+
+        return expr;
+    }
+
+    /**
+     * Match a pattern agains a string and isolates wildcard replacement into
+     * a <code>Stack</code>.
+     *
+     * @param map  The map to store matched values
+     * @param data The string to match
+     * @param expr The compiled wildcard expression
+     * @return True if a match
+     * @throws NullPointerException If any parameters are null
+     */
+    public boolean match(Map<String, String> map, String data, int[] expr) {
+        if (map == null) {
+            throw new NullPointerException("No map provided");
+        }
+
+        if (data == null) {
+            throw new NullPointerException("No data provided");
+        }
+
+        if (expr == null) {
+            throw new NullPointerException("No pattern expression provided");
+        }
+
+        char[] buff = data.toCharArray();
+
+        // Allocate the result buffer
+        char[] rslt = new char[expr.length + buff.length];
+
+        // The previous and current position of the expression character
+        // (MATCH_*)
+        int charpos = 0;
+
+        // The position in the expression, input, translation and result arrays
+        int exprpos = 0;
+        int buffpos = 0;
+        int rsltpos = 0;
+        int offset = -1;
+
+        // The matching count
+        int mcount = 0;
+
+        // We want the complete data be in {0}
+        map.put(Integer.toString(mcount), data);
+
+        // First check for MATCH_BEGIN
+        boolean matchBegin = false;
+
+        if (expr[charpos] == MATCH_BEGIN) {
+            matchBegin = true;
+            exprpos = ++charpos;
+        }
+
+        // Search the fist expression character (except MATCH_BEGIN - already
+        // skipped)
+        while (expr[charpos] >= 0) {
+            charpos++;
+        }
+
+        // The expression charater (MATCH_*)
+        int exprchr = expr[charpos];
+
+        while (true) {
+            // Check if the data in the expression array before the current
+            // expression character matches the data in the input buffer
+            if (matchBegin) {
+                if (!matchArray(expr, exprpos, charpos, buff, buffpos)) {
+                    return (false);
+                }
+
+                matchBegin = false;
+            } else {
+                offset = indexOfArray(expr, exprpos, charpos, buff, buffpos);
+
+                if (offset < 0) {
+                    return (false);
+                }
+            }
+
+            // Check for MATCH_BEGIN
+            if (matchBegin) {
+                if (offset != 0) {
+                    return (false);
+                }
+
+                matchBegin = false;
+            }
+
+            // Advance buffpos
+            buffpos += (charpos - exprpos);
+
+            // Check for END's
+            if (exprchr == MATCH_END) {
+                if (rsltpos > 0) {
+                    map.put(Integer.toString(++mcount),
+                        new String(rslt, 0, rsltpos));
+                }
+
+                // Don't care about rest of input buffer
+                return (true);
+            } else if (exprchr == MATCH_THEEND) {
+                if (rsltpos > 0) {
+                    map.put(Integer.toString(++mcount),
+                        new String(rslt, 0, rsltpos));
+                }
+
+                // Check that we reach buffer's end
+                return (buffpos == buff.length);
+            }
+
+            // Search the next expression character
+            exprpos = ++charpos;
+
+            while (expr[charpos] >= 0) {
+                charpos++;
+            }
+
+            int prevchr = exprchr;
+
+            exprchr = expr[charpos];
+
+            // We have here prevchr == * or **.
+            offset =
+                (prevchr == MATCH_FILE)
+                ? indexOfArray(expr, exprpos, charpos, buff, buffpos)
+                : lastIndexOfArray(expr, exprpos, charpos, buff, buffpos);
+
+            if (offset < 0) {
+                return (false);
+            }
+
+            // Copy the data from the source buffer into the result buffer
+            // to substitute the expression character
+            if (prevchr == MATCH_PATH) {
+                while (buffpos < offset) {
+                    rslt[rsltpos++] = buff[buffpos++];
+                }
+            } else {
+                // Matching file, don't copy '/'
+                while (buffpos < offset) {
+                    if (buff[buffpos] == '/') {
+                        return (false);
+                    }
+
+                    rslt[rsltpos++] = buff[buffpos++];
+                }
+            }
+
+            map.put(Integer.toString(++mcount), new String(rslt, 0, rsltpos));
+            rsltpos = 0;
+        }
+    }
+
+    /**
+     * Get the offset of a part of an int array within a char array. <br> This
+     * method return the index in d of the first occurrence after dpos of that
+     * part of array specified by r, starting at rpos and terminating at
+     * rend.
+     *
+     * @param r    The array containing the data that need to be matched in
+     *             d.
+     * @param rpos The index of the first character in r to look for.
+     * @param rend The index of the last character in r to look for plus 1.
+     * @param d    The array of char that should contain a part of r.
+     * @param dpos The starting offset in d for the matching.
+     * @return The offset in d of the part of r matched in d or -1 if that was
+     *         not found.
+     */
+    protected int indexOfArray(int[] r, int rpos, int rend, char[] d, int dpos) {
+        // Check if pos and len are legal
+        if (rend < rpos) {
+            throw new IllegalArgumentException("rend < rpos");
+        }
+
+        // If we need to match a zero length string return current dpos
+        if (rend == rpos) {
+            return (d.length); //?? dpos?
+        }
+
+        // If we need to match a 1 char length string do it simply
+        if ((rend - rpos) == 1) {
+            // Search for the specified character
+            for (int x = dpos; x < d.length; x++) {
+                if (r[rpos] == d[x]) {
+                    return (x);
+                }
+            }
+        }
+
+        // Main string matching loop. It gets executed if the characters to
+        // match are less then the characters left in the d buffer
+        while (((dpos + rend) - rpos) <= d.length) {
+            // Set current startpoint in d
+            int y = dpos;
+
+            // Check every character in d for equity. If the string is matched
+            // return dpos
+            for (int x = rpos; x <= rend; x++) {
+                if (x == rend) {
+                    return (dpos);
+                }
+
+                if (r[x] != d[y++]) {
+                    break;
+                }
+            }
+
+            // Increase dpos to search for the same string at next offset
+            dpos++;
+        }
+
+        // The remaining chars in d buffer were not enough or the string
+        // wasn't matched
+        return (-1);
+    }
+
+    /**
+     * Get the offset of a last occurance of an int array within a char array.
+     * <br> This method return the index in d of the last occurrence after
+     * dpos of that part of array specified by r, starting at rpos and
+     * terminating at rend.
+     *
+     * @param r    The array containing the data that need to be matched in
+     *             d.
+     * @param rpos The index of the first character in r to look for.
+     * @param rend The index of the last character in r to look for plus 1.
+     * @param d    The array of char that should contain a part of r.
+     * @param dpos The starting offset in d for the matching.
+     * @return The offset in d of the last part of r matched in d or -1 if
+     *         that was not found.
+     */
+    protected int lastIndexOfArray(int[] r, int rpos, int rend, char[] d,
+        int dpos) {
+        // Check if pos and len are legal
+        if (rend < rpos) {
+            throw new IllegalArgumentException("rend < rpos");
+        }
+
+        // If we need to match a zero length string return current dpos
+        if (rend == rpos) {
+            return (d.length); //?? dpos?
+        }
+
+        // If we need to match a 1 char length string do it simply
+        if ((rend - rpos) == 1) {
+            // Search for the specified character
+            for (int x = d.length - 1; x > dpos; x--) {
+                if (r[rpos] == d[x]) {
+                    return (x);
+                }
+            }
+        }
+
+        // Main string matching loop. It gets executed if the characters to
+        // match are less then the characters left in the d buffer
+        int l = d.length - (rend - rpos);
+
+        while (l >= dpos) {
+            // Set current startpoint in d
+            int y = l;
+
+            // Check every character in d for equity. If the string is matched
+            // return dpos
+            for (int x = rpos; x <= rend; x++) {
+                if (x == rend) {
+                    return (l);
+                }
+
+                if (r[x] != d[y++]) {
+                    break;
+                }
+            }
+
+            // Decrease l to search for the same string at next offset
+            l--;
+        }
+
+        // The remaining chars in d buffer were not enough or the string
+        // wasn't matched
+        return (-1);
+    }
+
+    /**
+     * Matches elements of array r from rpos to rend with array d, starting
+     * from dpos. <br> This method return true if elements of array r from
+     * rpos to rend equals elements of array d starting from dpos to
+     * dpos+(rend-rpos).
+     *
+     * @param r    The array containing the data that need to be matched in
+     *             d.
+     * @param rpos The index of the first character in r to look for.
+     * @param rend The index of the last character in r to look for.
+     * @param d    The array of char that should start from a part of r.
+     * @param dpos The starting offset in d for the matching.
+     * @return true if array d starts from portion of array r.
+     */
+    protected boolean matchArray(int[] r, int rpos, int rend, char[] d, int dpos) {
+        if ((d.length - dpos) < (rend - rpos)) {
+            return (false);
+        }
+
+        for (int i = rpos; i < rend; i++) {
+            if (r[i] != d[dpos++]) {
+                return (false);
+            }
+        }
+
+        return (true);
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/util/WildcardUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/util/WildcardUtil.java b/core/src/main/java/com/opensymphony/xwork2/util/WildcardUtil.java
new file mode 100644
index 0000000..8e6a573
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/util/WildcardUtil.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010 Yahoo, Inc.  All rights reserved.
+ *
+ * Licensed 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 com.opensymphony.xwork2.util;
+
+import java.util.regex.Pattern;
+
+/**
+ * Helper class to convert wildcard expression to regular expression
+ */
+public class WildcardUtil {
+
+    /**
+     * Convert wildcard pattern to Pattern
+     * @param pattern String containing wildcard pattern
+     * @return compiled regular expression as a Pattern
+     */
+    public static Pattern compileWildcardPattern(String pattern) {
+        StringBuilder buf = new StringBuilder(pattern);
+
+        for (int i=buf.length()-1; i>=0; i--)
+        {
+            char c = buf.charAt(i);
+            if (c == '*' && (i == 0 || buf.charAt(i-1) != '\\'))
+            {
+                buf.insert(i+1, '?');
+                buf.insert(i, '.');
+            }
+            else if (c == '*')
+            {
+                i--;	// skip backslash, too
+            }
+            else if (needsBackslashToBeLiteralInRegex(c))
+            {
+                buf.insert(i, '\\');
+            }
+        }
+
+        return Pattern.compile(buf.toString());
+    }
+
+    /**
+     * @param c character to test
+     * @return true if the given character must be escaped to be a literal
+     * inside a regular expression.
+     */
+
+    private static final String theSpecialRegexCharList = ".[]\\?*+{}|()^$";
+
+    public static boolean needsBackslashToBeLiteralInRegex(
+        char c)
+    {
+        return (theSpecialRegexCharList.indexOf(c) >= 0);
+    }
+
+}


Mime
View raw message