Merge branch 'master' of https://github.com/rubin55/commons-cli

Author: chtompki

.gitignore

@@ -1,5 +1,4 @@
-### https://raw.github.com/github/gitignore/f2ce448f2ba7a092da05482ceca99209127c0884/maven.gitignore
-
+# maven
 target/
 pom.xml.tag
 pom.xml.releaseBackup
@@ -9,9 +8,14 @@ release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
 .mvn/timing.properties
-
-# Exclude maven wrapper
 !/.mvn/wrapper/maven-wrapper.jar
 
-site-content
+# vscode/eclipse/idea
+*.iml
+.idea/
+.classpath
+.project
+.settings/
 
+# other
+site-content

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

@@ -53,7 +53,24 @@ public class DefaultParser implements CommandLineParser
 
     /** The required options and groups expected to be found when parsing the command line. */
     protected List expectedOpts;
- 
+
+    /** Flag indicating if partial matching of long options is supported. */
+    private  boolean allowPartialMatching;
+
+    /** Creates a new DefaultParser instance with partial matching enabled. */
+    public DefaultParser() {
+        this.allowPartialMatching = true;
+    }
+
+    /**
+     * Create a new DefaultParser instance with the specified partial matching policy.
+     *
+     * @param allowPartialMatching if partial matching of long options shall be enabled
+     */
+    public DefaultParser(final boolean allowPartialMatching) {
+        this.allowPartialMatching = allowPartialMatching;
+    }
+
     public CommandLine parse(final Options options, final String[] arguments) throws ParseException
     {
         return parse(options, arguments, null);
@@ -329,7 +346,7 @@ private boolean isLongOption(final String token)
         final int pos = token.indexOf("=");
         final String t = pos == -1 ? token : token.substring(0, pos);
 
-        if (!options.getMatchingOptions(t).isEmpty())
+        if (!getMatchingLongOptions(t).isEmpty())
         {
             // long or partial long options (--L, -L, --L=V, -L=V, --l, --l=V)
             return true;
@@ -400,18 +417,19 @@ private void handleLongOption(final String token) throws ParseException
      */
     private void handleLongOptionWithoutEqual(final String token) throws ParseException
     {
-        final List<String> matchingOpts = options.getMatchingOptions(token);
+        final List<String> matchingOpts = getMatchingLongOptions(token);
         if (matchingOpts.isEmpty())
         {
             handleUnknownToken(currentToken);
         }
-        else if (matchingOpts.size() > 1)
+        else if (matchingOpts.size() > 1 && !options.hasLongOption(token))
         {
             throw new AmbiguousOptionException(token, matchingOpts);
         }
         else
         {
-            handleOption(options.getOption(matchingOpts.get(0)));
+            final String key = options.hasLongOption(token) ? token : matchingOpts.get(0);
+            handleOption(options.getOption(key));
         }
     }
 
@@ -433,18 +451,19 @@ private void handleLongOptionWithEqual(final String token) throws ParseException
 
         final String opt = token.substring(0, pos);
 
-        final List<String> matchingOpts = options.getMatchingOptions(opt);
+        final List<String> matchingOpts = getMatchingLongOptions(opt);
         if (matchingOpts.isEmpty())
         {
             handleUnknownToken(currentToken);
         }
-        else if (matchingOpts.size() > 1)
+        else if (matchingOpts.size() > 1 && !options.hasLongOption(opt))
         {
             throw new AmbiguousOptionException(opt, matchingOpts);
         }
         else
         {
-            final Option option = options.getOption(matchingOpts.get(0));
+            final String key = options.hasLongOption(opt) ? opt : matchingOpts.get(0);
+            final Option option = options.getOption(key);
 
             if (option.acceptsArg())
             {
@@ -503,7 +522,7 @@ else if (pos == -1)
             {
                 handleOption(options.getOption(t));
             }
-            else if (!options.getMatchingOptions(t).isEmpty())
+            else if (!getMatchingLongOptions(t).isEmpty())
             {
                 // -L or -l
                 handleLongOptionWithoutEqual(token);
@@ -652,6 +671,32 @@ private void updateRequiredOptions(final Option option) throws AlreadySelectedEx
         }
     }
 
+    /**
+     * Returns a list of matching option strings for the given token, depending
+     * on the selected partial matching policy.
+     *
+     * @param token the token (may contain leading dashes)
+     * @return the list of matching option strings or an empty list if no matching option could be found
+     */
+    private List<String> getMatchingLongOptions(final String token)
+    {
+        if (allowPartialMatching)
+        {
+            return options.getMatchingOptions(token);
+        }
+        else
+        {
+            List<String> matches = new ArrayList<String>(1);
+            if (options.hasLongOption(token))
+            {
+                Option option = options.getOption(token);
+                matches.add(option.getLongOpt());
+            }
+
+            return matches;
+        }
+    }
+
     /**
      * Breaks <code>token</code> into its constituent parts
      * using the following algorithm.

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

@@ -0,0 +1,63 @@
+/**
+ * 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;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class DisablePartialMatchingTest
+{
+    @Test
+    public void testDisablePartialMatching() throws Exception
+    {
+        CommandLineParser parser = new DefaultParser(false);
+
+        final Options options = new Options();
+
+        options.addOption(new Option("d", "debug", false, "Turn on debug."));
+        options.addOption(new Option("e", "extract", false, "Turn on extract."));
+        options.addOption(new Option("o", "option", true, "Turn on option with argument."));
+
+        CommandLine line = parser.parse(options, new String[]{"-de", "--option=foobar"});
+
+        assertTrue("There should be an option debug in any case...", line.hasOption("debug"));
+        assertTrue("There should be an extract option because partial matching is off", line.hasOption("extract"));
+        assertTrue("There should be an option option with a argument value", line.hasOption("option"));
+    }
+
+    @Test
+    public void testRegularPartialMatching() throws Exception
+    {
+        CommandLineParser parser = new DefaultParser();
+
+        final Options options = new Options();
+
+        options.addOption(new Option("d", "debug", false, "Turn on debug."));
+        options.addOption(new Option("e", "extract", false, "Turn on extract."));
+        options.addOption(new Option("o", "option", true, "Turn on option with argument."));
+
+
+        CommandLine line = parser.parse(options, new String[]{"-de", "--option=foobar"});
+
+        assertTrue("There should be an option debug in any case...", line.hasOption("debug"));
+        assertFalse("There should not be an extract option because partial matching only selects debug", line.hasOption("extract"));
+        assertTrue("There should be an option option with a argument value", line.hasOption("option"));
+    }
+}