fix #22

pom.xml

@@ -77,7 +77,6 @@
           <source>1.5</source>
           <target>1.5</target>
           <excludes>
-            <exclude>**/client/**/*.java</exclude>
             <exclude>**/emul/**/*.java</exclude>
           </excludes>
         </configuration>

src/main/java/com/googlecode/gwtx/java/util/emul/Emulation.gwt.xml

@@ -1,3 +1,4 @@
 <module>
+   <inherits name="com.googlecode.gwtx.java.util.impl.Util"/>
    <super-source/>
 </module>

src/main/java/com/googlecode/gwtx/java/util/emul/java/util/regex/Pattern.java

@@ -23,194 +23,87 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.regex.Matcher;
 
 import com.google.gwt.core.client.JavaScriptObject;
+import com.googlecode.gwtx.java.util.impl.client.PatternImpl;
 
-/**
- * Implementation of the {@link java.util.regex.Pattern} class with a wrapper
- * aroung the Javascript <a href="http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Guide:Regular_Expressions"
- * >RegExp</a> object. As most of the methods delegate to the JavaScript RegExp
- * object, certain differences in the declaration and behaviour of regular
- * expressions must be expected. </p>
- * <p>
- * Please note that neither the {@link java.util.regex.Pattern#compile(String)}
- * method nor {@link Matcher} instances are supported. For the later, consider
- * using {@link Pattern#match(String)}.
- * </p>
- *
- * @author George Georgovassilis
- * @author Robert Hanson <iamroberthanson AT gmail.com>
- */
-public class Pattern {
-
-  /**
-   * Declares that regular expressions should be matched across line borders.
-   */
-  public final static int MULTILINE = 1;
-
-  /**
-   * Declares that characters are matched reglardless of case.
-   */
-  public final static int CASE_INSENSITIVE = 2;
-
-  private static native JavaScriptObject _createExpression(String pattern,
-      String flags)
-  /*-{
-    return new RegExp(pattern, flags);
-  }-*/;
+public class Pattern
+    extends PatternImpl
+{
 
-  public static Pattern compile(String pattern) {
-    return new Pattern(pattern);
-  }
+    /**
+     * Declares that regular expressions should be matched across line borders.
+     */
+    public final static int MULTILINE = PatternImpl.MULTILINE;
 
-  public static Pattern compile(String pattern, int flags) {
-    return new Pattern(pattern, flags);
-  }
+    /**
+     * Declares that characters are matched reglardless of case.
+     */
+    public final static int CASE_INSENSITIVE = PatternImpl.CASE_INSENSITIVE;
 
-  private static JavaScriptObject createExpression(String pattern, int flags) {
-    String sFlags = "";
-    if ((flags & MULTILINE) != 0)
-      sFlags += "m";
-    if ((flags & CASE_INSENSITIVE) != 0)
-      sFlags += "i";
-    return _createExpression(pattern, sFlags);
-  }
-
-  /**
-   * Determines wether the specified regular expression is validated by the
-   * provided input.
-   *
-   * @param regex Regular expression
-   * @param input String to validate
-   * @return <code>true</code> if matched.
-   */
-  public static boolean matches(String regex, String input) {
-    return new Pattern(regex).matches(input);
-  }
-
-  /**
-   * Escape a provided string so that it will be interpreted as a literal in
-   * regular expressions. The current implementation does escape each character
-   * even if not neccessary, generating verbose literals.
-   *
-   * @param input
-   * @return
-   */
-  public static String quote(String input) {
-    String output = "";
-    for (int i = 0; i < input.length(); i++) {
-      output += "\\" + input.charAt(i);
+    public static Pattern compile( String pattern )
+    {
+        return new Pattern( pattern );
     }
-    return output;
-  }
-
-  private JavaScriptObject regExp;
-
-  /**
-   * Class constructor
-   *
-   * @param pattern Regular expression
-   */
-  public Pattern(String pattern) {
-    this(pattern, 0);
-  }
 
-  /**
-   * Class constructor
-   *
-   * @param pattern Regular expression
-   * @param flags
-   */
-  public Pattern(String pattern, int flags) {
-    regExp = createExpression(pattern, flags);
-  }
-
-  /**
-   * Create a matcher for this pattern and a given input character sequence
-   *
-   * @param cs The input character sequence
-   * @return A new matcher
-   */
-  public Matcher matcher(CharSequence cs) {
-    return new Matcher(this, cs);
-  }
-
-  private native void _match(String text, List matches)
-  /*-{
-    var regExp = this.@com.googlecode.gwtx.java.util.emul.java.util.regex.Pattern::regExp;
-    var result = text.match(regExp);
-    if (result == null) return;
-    for (var i=0;i<result.length;i++)
-    matches.@java.util.ArrayList::add(Ljava/lang/Object;)(result[i]);
-  }-*/;
+    public static Pattern compile( String pattern, int flags )
+    {
+        return new Pattern( pattern, flags );
+    }
 
-  private native void _split(String input, List results)
-  /*-{
-    var regExp = this.@com.googlecode.gwtx.java.util.emul.java.util.regex.Pattern::regExp;
-    var parts = input.split(regExp);
-    for (var i=0;i<parts.length;i++)
-    results.@java.util.ArrayList::add(Ljava/lang/Object;)(parts[i] );
-  }-*/;
+    public static boolean matches( String regex, String input )
+    {
+        return new Pattern( regex ).matches( input );
+    }
 
-  /**
-   * This method is borrowed from the JavaScript RegExp object. It parses a
-   * string and returns as an array any assignments to parenthesis groups in the
-   * pattern's regular expression
-   *
-   * @param text
-   * @return Array of strings following java's Pattern convention for groups:
-   *         Group 0 is the entire input string and the remaining groups are the
-   *         matched parenthesis. In case nothing was matched an empty array is
-   *         returned.
-   */
-  public String[] match(String text) {
-    List matches = new ArrayList();
-    _match(text, matches);
-    String arr[] = new String[matches.size()];
-    for (int i = 0; i < matches.size(); i++)
-      arr[i] = matches.get(i).toString();
-    return arr;
-  }
+    /**
+     * Escape a provided string so that it will be interpreted as a literal in regular expressions. The current
+     * implementation does escape each character even if not neccessary, generating verbose literals.
+     *
+     * @param input
+     * @return
+     */
+    public static String quote( String input )
+    {
+        String output = "";
+        for ( int i = 0; i < input.length(); i++ )
+        {
+            output += "\\" + input.charAt( i );
+        }
+        return output;
+    }
 
-  /**
-   * Determines wether a provided text matches the regular expression
-   *
-   * @param text
-   * @return
-   */
-  public native boolean matches(String text)
-  /*-{
-    var regExp = this.@com.googlecode.gwtx.java.util.emul.java.util.regex.Pattern::regExp;
-    return regExp.test(text);
-  }-*/;
+    /**
+     * Class constructor
+     *
+     * @param pattern Regular expression
+     */
+    public Pattern( String pattern )
+    {
+        this( pattern, 0 );
+    }
 
-  /**
-   * Returns the regular expression for this pattern
-   *
-   * @return
-   */
-  public native String pattern()
-  /*-{
-    var regExp = this.@com.googlecode.gwtx.java.util.emul.java.util.regex.Pattern::regExp;
-    return regExp.source;
-  }-*/;
+    /**
+     * Class constructor
+     *
+     * @param pattern Regular expression
+     * @param flags
+     */
+    public Pattern( String pattern, int flags )
+    {
+        super( pattern, flags );
+    }
 
-  /**
-   * Split an input string by the pattern's regular expression
-   *
-   * @param input
-   * @return Array of strings
-   */
-  public String[] split(String input) {
-    List results = new ArrayList();
-    _split(input, results);
-    String[] parts = new String[results.size()];
-    for (int i = 0; i < results.size(); i++)
-      parts[i] = (String) results.get(i);
-    return parts;
-  }
+    /**
+     * Create a matcher for this pattern and a given input character sequence
+     *
+     * @param cs The input character sequence
+     * @return A new matcher
+     */
+    public Matcher matcher( CharSequence cs )
+    {
+        return new Matcher( this, cs );
+    }
 
-  public String toString() {
-    return regExp.toString();
-  }
 }

src/main/java/com/googlecode/gwtx/java/util/impl/Util.gwt.xml

@@ -0,0 +1,19 @@
+<!--
+ *  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.
+ -->
+<module>
+    <source path="client"/>
+</module>