New unified parser (CLI-181, also fixes CLI-160, CLI-161, CLI-167, CLI-184)

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/cli/trunk@780264 13f79535-47bb-0310-9956-ffa450edef68

Author: ebourg

src/java/org/apache/commons/cli/DefaultParser.java

@@ -465,7 +465,7 @@ private void processValue(String value)
      */
     private void add(String value)
     {
-        if ((numberOfArgs > 0) && (values.size() > (numberOfArgs - 1)))
+        if (!acceptsArg())
         {
             throw new RuntimeException("Cannot add value, list full.");
         }
@@ -671,4 +671,36 @@ public boolean addValue(String value)
                 + "Subclasses should use the addValueForProcessing method instead. ");
     }
 
+    /**
+     * Tells if the option can accept more arguments.
+     * 
+     * @return false if the maximum number of arguments is reached
+     * @since 1.3
+     */
+    boolean acceptsArg()
+    {
+        return (hasArg() || hasArgs() || hasOptionalArg()) && (numberOfArgs <= 0 || values.size() < numberOfArgs);
+    }
+
+    /**
+     * Tells if the option requires more arguments to be valid.
+     * 
+     * @return false if the option doesn't require more arguments
+     * @since 1.3
+     */
+    boolean requiresArg()
+    {
+        if (optionalArg)
+        {
+            return false;
+        }
+        if (numberOfArgs == UNLIMITED_VALUES)
+        {
+            return values.size() < 1;
+        }
+        else
+        {
+            return acceptsArg();
+        }
+    }
 }

src/java/org/apache/commons/cli/Option.java

@@ -243,8 +243,7 @@ public List getMatchingOptions(String opt)
      * Returns whether the named {@link Option} is a member of this {@link Options}.
      *
      * @param opt short or long name of the {@link Option}
-     * @return true if the named {@link Option} is a member
-     * of this {@link Options}
+     * @return true if the named {@link Option} is a member of this {@link Options}
      */
     public boolean hasOption(String opt)
     {
@@ -253,6 +252,34 @@ public boolean hasOption(String opt)
         return shortOpts.containsKey(opt) || longOpts.containsKey(opt);
     }
 
+    /**
+     * Returns whether the named {@link Option} is a member of this {@link Options}.
+     *
+     * @param opt long name of the {@link Option}
+     * @return true if the named {@link Option} is a member of this {@link Options}
+     * @since 1.3
+     */
+    public boolean hasLongOption(String opt)
+    {
+        opt = Util.stripLeadingHyphens(opt);
+
+        return longOpts.containsKey(opt);
+    }
+
+    /**
+     * Returns whether the named {@link Option} is a member of this {@link Options}.
+     *
+     * @param opt short name of the {@link Option}
+     * @return true if the named {@link Option} is a member of this {@link Options}
+     * @since 1.3
+     */
+    public boolean hasShortOption(String opt)
+    {
+        opt = Util.stripLeadingHyphens(opt);
+
+        return shortOpts.containsKey(opt);
+    }
+
     /**
      * Returns the OptionGroup the <code>opt</code> belongs to.
      * @param opt the option whose OptionGroup is being queried.

src/java/org/apache/commons/cli/Options.java

@@ -29,6 +29,26 @@ public void setUp()
         parser = new BasicParser();
     }
 
+    public void testDoubleDash2() throws Exception
+    {
+        // not supported by the BasicParser
+    }
+
+    public void testLongWithoutEqualSingleDash() throws Exception
+    {
+        // not supported by the BasicParser
+    }
+    
+    public void testAmbiguousLongWithoutEqualSingleDash() throws Exception
+    {
+        // not supported by the basicParser
+    }
+    
+    public void testNegativeOption() throws Exception
+    {
+        // not supported by the BasicParser (CLI-184)
+    }
+
     public void testPropertiesOption1() throws Exception
     {
         // not supported by the BasicParser

src/test/org/apache/commons/cli/BasicParserTest.java

@@ -0,0 +1,30 @@
+/**
+ * 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.commons.cli;
+
+/**
+ * @author Emmanuel Bourg
+ * @version $Revision$, $Date$
+ */
+public class DefaultParserTest extends ParserTestCase {
+
+    public void setUp() {
+        super.setUp();
+        parser = new DefaultParser();
+    }
+}

src/test/org/apache/commons/cli/DefaultParserTest.java

@@ -25,6 +25,41 @@ public void setUp()
         parser = new GnuParser();
     }
 
+    public void testDoubleDash2() throws Exception
+    {
+        // not supported by the GnuParser
+    }
+    
+    public void testLongWithoutEqualSingleDash() throws Exception
+    {
+        // not supported by the GnuParser
+    }
+
+    public void testAmbiguousLongWithoutEqualSingleDash() throws Exception
+    {
+        // not supported by the GnuParser
+    }
+
+    public void testNegativeOption() throws Exception
+    {
+        // not supported by the GnuParser (CLI-184)
+    }
+
+    public void testLongWithUnexpectedArgument1() throws Exception 
+    {
+        // not supported by the GnuParser
+    }
+
+    public void testLongWithUnexpectedArgument2() throws Exception 
+    {
+        // not supported by the GnuParser
+    }
+
+    public void testShortWithUnexpectedArgument() throws Exception 
+    {
+        // not supported by the GnuParser
+    }
+
     public void testUnambiguousPartialLongOption1() throws Exception
     {
         // not supported by the GnuParser

src/test/org/apache/commons/cli/GnuParserTest.java

@@ -157,6 +157,24 @@ public void testDoubleDash1() throws Exception
         assertTrue("Confirm 2 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 2);
     }
 
+    public void testDoubleDash2() throws Exception
+    {
+        Options options = new Options();
+        options.addOption(OptionBuilder.hasArg().create('n'));
+        options.addOption(OptionBuilder.create('m'));
+
+        try
+        {
+            parser.parse(options, new String[]{"-n", "--", "-m"});
+            fail("MissingArgumentException not thrown for option -n");
+        }
+        catch (MissingArgumentException e)
+        {
+            assertNotNull("option null", e.getOption());
+            assertEquals("n", e.getOption().getOpt());
+        }
+    }
+    
     public void testSingleDash() throws Exception
     {
         String[] args = new String[] { "--copt",
@@ -228,6 +246,16 @@ public void testNegativeArgument() throws Exception
         assertEquals("-1", cl.getOptionValue("b"));
     }
 
+    public void testNegativeOption() throws Exception
+    {
+        String[] args = new String[] { "-b", "-1"} ;
+        
+        options.addOption("1", false, null);
+
+        CommandLine cl = parser.parse(options, args);
+        assertEquals("-1", cl.getOptionValue("b"));
+    }
+    
     public void testArgumentStartingWithHyphen() throws Exception
     {
         String[] args = new String[]{"-b", "-foo"};
@@ -284,6 +312,105 @@ public void testLongWithEqualSingleDash() throws Exception
         assertEquals("bar", cl.getOptionValue("foo"));
     }
 
+    public void testLongWithoutEqualSingleDash() throws Exception
+    {
+        String[] args = new String[] { "-foobar" };
+
+        Options options = new Options();
+        options.addOption(OptionBuilder.withLongOpt("foo").hasArg().create('f'));
+
+        CommandLine cl = parser.parse(options, args);
+
+        assertEquals("bar", cl.getOptionValue("foo"));
+    }
+    
+    public void testAmbiguousLongWithoutEqualSingleDash() throws Exception
+    {
+        String[] args = new String[] { "-b", "-foobar" };
+
+        Options options = new Options();
+        options.addOption(OptionBuilder.withLongOpt("foo").hasOptionalArg().create('f'));
+        options.addOption(OptionBuilder.withLongOpt("bar").hasOptionalArg().create('b'));
+
+        CommandLine cl = parser.parse(options, args);
+
+        assertTrue(cl.hasOption("b"));
+        assertTrue(cl.hasOption("f"));
+        assertEquals("bar", cl.getOptionValue("foo"));
+    }
+
+    public void testLongWithoutEqualDoubleDash() throws Exception
+    {
+        String[] args = new String[] { "--foobar" };
+
+        Options options = new Options();
+        options.addOption(OptionBuilder.withLongOpt("foo").hasArg().create('f'));
+
+        CommandLine cl = parser.parse(options, args, true);
+
+        assertFalse(cl.hasOption("foo")); // foo isn't expected to be recognized with a double dash
+    }
+
+    public void testLongWithUnexpectedArgument1() throws Exception
+    {
+        String[] args = new String[] { "--foo=bar" };
+
+        Options options = new Options();
+        options.addOption(OptionBuilder.withLongOpt("foo").create('f'));
+
+        try
+        {
+            parser.parse(options, args);
+        }
+        catch (UnrecognizedOptionException e)
+        {
+            assertEquals("--foo=bar", e.getOption());
+            return;
+        }
+
+        fail("UnrecognizedOptionException not thrown");
+    }
+
+    public void testLongWithUnexpectedArgument2() throws Exception
+    {
+        String[] args = new String[] { "-foobar" };
+
+        Options options = new Options();
+        options.addOption(OptionBuilder.withLongOpt("foo").create('f'));
+
+        try
+        {
+            parser.parse(options, args);
+        }
+        catch (UnrecognizedOptionException e)
+        {
+            assertEquals("-foobar", e.getOption());
+            return;
+        }
+
+        fail("UnrecognizedOptionException not thrown");
+    }
+
+    public void testShortWithUnexpectedArgument() throws Exception
+    {
+        String[] args = new String[] { "-f=bar" };
+
+        Options options = new Options();
+        options.addOption(OptionBuilder.withLongOpt("foo").create('f'));
+
+        try
+        {
+            parser.parse(options, args);
+        }
+        catch (UnrecognizedOptionException e)
+        {
+            assertEquals("-f=bar", e.getOption());
+            return;
+        }
+
+        fail("UnrecognizedOptionException not thrown");
+    }
+    
     public void testPropertiesOption1() throws Exception
     {
         String[] args = new String[] { "-Jsource=1.5", "-J", "target", "1.5", "foo" };
@@ -726,4 +853,20 @@ public void testStopBursting2() throws Exception
         assertTrue("Confirm  1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
         assertTrue("Confirm  value of extra arg: " + cl.getArgList().get(0), cl.getArgList().get(0).equals("foobar"));
     }
+
+    public void testUnlimitedArgs() throws Exception
+    {
+        String[] args = new String[]{"-e", "one", "two", "-f", "alpha"};
+
+        Options options = new Options();
+        options.addOption(OptionBuilder.hasArgs().create("e"));
+        options.addOption(OptionBuilder.hasArgs().create("f"));
+
+        CommandLine cl = parser.parse(options, args);
+
+        assertTrue("Confirm -e is set", cl.hasOption("e"));
+        assertEquals("number of arg for -e", 2, cl.getOptionValues("e").length);
+        assertTrue("Confirm -f is set", cl.hasOption("f"));
+        assertEquals("number of arg for -f", 1, cl.getOptionValues("f").length);
+    }
 }

src/test/org/apache/commons/cli/ParserTestCase.java

@@ -30,6 +30,31 @@ public void setUp()
         parser = new PosixParser();
     }
 
+    public void testDoubleDash2() throws Exception
+    {
+        // not supported by the PosixParser
+    }
+    
+    public void testLongWithoutEqualSingleDash() throws Exception
+    {
+        // not supported by the PosixParser
+    }
+
+    public void testAmbiguousLongWithoutEqualSingleDash() throws Exception
+    {
+        // not supported by the PosixParser
+    }
+    
+    public void testNegativeOption() throws Exception
+    {
+        // not supported by the PosixParser (CLI-184)
+    }
+
+    public void testLongWithUnexpectedArgument1() throws Exception
+    {
+        // not supported by the PosixParser
+    }
+
     public void testLongWithEqualSingleDash() throws Exception
     {
         // not supported by the PosixParser