From eb1a00d1e5de801bdc9fd26a7682101d212bbdd1 Mon Sep 17 00:00:00 2001
From: Robin Garner <robin.garner@scu.edu.au>
Date: Tue, 3 Jan 2017 15:07:19 +1100
Subject: [PATCH 1/3] Negatable Boolean Options

Option Handler that implements boolean options that are switched on using
--<option> and switched off using --no<option>.  Requires that you add
the "--no<option>" as an alias.
---
 .../spi/NegatableBooleanOptionHandler.java    | 76 +++++++++++++++++++
 .../NegatableBooleanOptionHandlerTest.java    | 52 +++++++++++++
 2 files changed, 128 insertions(+)
 create mode 100644 args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java
 create mode 100644 args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java

diff --git a/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java b/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java
new file mode 100644
index 00000000..b42230f5
--- /dev/null
+++ b/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java
@@ -0,0 +1,76 @@
+package org.kohsuke.args4j.spi;
+
+import org.kohsuke.args4j.CmdLineException;
+import org.kohsuke.args4j.CmdLineParser;
+import org.kohsuke.args4j.IllegalAnnotationError;
+import org.kohsuke.args4j.NamedOptionDef;
+import org.kohsuke.args4j.OptionDef;
+import org.kohsuke.args4j.spi.OptionHandler;
+import org.kohsuke.args4j.spi.Parameters;
+import org.kohsuke.args4j.spi.Setter;
+
+/**
+ * Boolean {@link OptionHandler} that allows values to be specified as
+ * --<option> and negated with --no<option>.
+ *
+ * Requires the caller to explicitly add the --no version to the alternative
+ * names in the option definition, e.g.
+ *   <code>
+ *     name = "--option", aliases = { "--nooption" },
+ *   </code>
+ * If the negated option isn't present, the constructor will throw an IllegalAnnotationError.
+ *
+ * @Author Robin Garner
+ */
+public class NegatableBooleanOptionHandler extends OptionHandler<Boolean> {
+
+  private final String negatedName;
+
+  public NegatableBooleanOptionHandler(CmdLineParser parser,
+      OptionDef option, Setter<? super Boolean> setter) {
+    super(parser, option, setter);
+
+    if (!(option instanceof NamedOptionDef)) {
+      throw new IllegalAnnotationError("NegatableBooleanOptionHandler can only be used for named options.");
+    }
+
+    NamedOptionDef namedOption = (NamedOptionDef) option;
+    this.negatedName = namedOption.name().replaceFirst("(-*)", "$1no");
+
+    if (!find(negatedName, namedOption.aliases())) {
+      throw new IllegalAnnotationError("There is no negated version of "+namedOption.name()+" in the option aliases.");
+    }
+  }
+
+  @Override
+  public int parseArguments(Parameters params) throws CmdLineException {
+    if (params.getParameter(-1).equals(negatedName)) {
+      setter.addValue(false);
+    } else {
+      setter.addValue(true);
+    }
+    return 0;
+  }
+
+  @Override
+  public String getDefaultMetaVariable() {
+    return null;
+  }
+
+  /**
+   * Look for a string in an array of strings
+   * @param str String to look for
+   * @param strings Array of strings to search
+   * @return {@code true} if {@code str} is present in {@code strings}
+   */
+  private static boolean find(String str, String[] strings) {
+    for (String alias : strings) {
+      if (alias.equals(str)) {
+        return true;
+      }
+      System.err.println(alias + " != " + str);
+    }
+    return false;
+  }
+
+}
diff --git a/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java b/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java
new file mode 100644
index 00000000..c653e403
--- /dev/null
+++ b/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java
@@ -0,0 +1,52 @@
+package org.kohsuke.args4j.spi;
+
+import org.kohsuke.args4j.CmdLineParser;
+import org.kohsuke.args4j.Option;
+
+import junit.framework.TestCase;
+
+public class NegatableBooleanOptionHandlerTest extends TestCase {
+
+  private static class SimpleTestBean {
+    @Option(name = "--option", aliases = { "--nooption" },
+        handler=NegatableBooleanOptionHandler.class,
+        usage = "Standard option")
+    private boolean option;
+  }
+
+  private static class NoNoTestBean {
+    @Option(name = "--notify", aliases = { "--nonotify" },
+        handler=NegatableBooleanOptionHandler.class,
+        usage = "Option that naturally starts with --no")
+    private boolean option = true;
+  }
+
+
+  public void testSimpleOptionPresent() throws Exception {
+    SimpleTestBean args = new SimpleTestBean();
+    CmdLineParser parser = new CmdLineParser(args);
+    parser.parseArgument("--option");
+    assertEquals(true, args.option);
+  }
+
+  public void testSimpleOptionNegated() throws Exception {
+    SimpleTestBean args = new SimpleTestBean();
+    CmdLineParser parser = new CmdLineParser(args);
+    parser.parseArgument("--nooption");
+    assertEquals(false, args.option);
+  }
+
+  public void testNoOptionPresent() throws Exception {
+    NoNoTestBean args = new NoNoTestBean();
+    CmdLineParser parser = new CmdLineParser(args);
+    parser.parseArgument("--notify");
+    assertEquals(true, args.option);
+  }
+
+  public void testNoOptionNegated() throws Exception {
+    NoNoTestBean args = new NoNoTestBean();
+    CmdLineParser parser = new CmdLineParser(args);
+    parser.parseArgument("--nonotify");
+    assertEquals(false, args.option);
+  }
+}

From 2f84156624eeccd0549695c5ce89825ff7b8d633 Mon Sep 17 00:00:00 2001
From: Robin Garner <robin.garner@scu.edu.au>
Date: Tue, 3 Jan 2017 15:12:53 +1100
Subject: [PATCH 2/3] Fix code style.

---
 .../spi/NegatableBooleanOptionHandler.java    | 76 ++++++++--------
 .../NegatableBooleanOptionHandlerTest.java    | 87 ++++++++++---------
 2 files changed, 83 insertions(+), 80 deletions(-)

diff --git a/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java b/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java
index b42230f5..76bc97df 100644
--- a/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java
+++ b/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java
@@ -24,53 +24,53 @@
  */
 public class NegatableBooleanOptionHandler extends OptionHandler<Boolean> {
 
-  private final String negatedName;
+    private final String negatedName;
 
-  public NegatableBooleanOptionHandler(CmdLineParser parser,
-      OptionDef option, Setter<? super Boolean> setter) {
-    super(parser, option, setter);
+    public NegatableBooleanOptionHandler(CmdLineParser parser,
+	    OptionDef option, Setter<? super Boolean> setter) {
+	super(parser, option, setter);
 
-    if (!(option instanceof NamedOptionDef)) {
-      throw new IllegalAnnotationError("NegatableBooleanOptionHandler can only be used for named options.");
-    }
+	if (!(option instanceof NamedOptionDef)) {
+	    throw new IllegalAnnotationError("NegatableBooleanOptionHandler can only be used for named options.");
+	}
 
-    NamedOptionDef namedOption = (NamedOptionDef) option;
-    this.negatedName = namedOption.name().replaceFirst("(-*)", "$1no");
+	NamedOptionDef namedOption = (NamedOptionDef) option;
+	this.negatedName = namedOption.name().replaceFirst("(-*)", "$1no");
 
-    if (!find(negatedName, namedOption.aliases())) {
-      throw new IllegalAnnotationError("There is no negated version of "+namedOption.name()+" in the option aliases.");
+	if (!find(negatedName, namedOption.aliases())) {
+	    throw new IllegalAnnotationError("There is no negated version of "+namedOption.name()+" in the option aliases.");
+	}
     }
-  }
 
-  @Override
-  public int parseArguments(Parameters params) throws CmdLineException {
-    if (params.getParameter(-1).equals(negatedName)) {
-      setter.addValue(false);
-    } else {
-      setter.addValue(true);
+    @Override
+    public int parseArguments(Parameters params) throws CmdLineException {
+	if (params.getParameter(-1).equals(negatedName)) {
+	    setter.addValue(false);
+	} else {
+	    setter.addValue(true);
+	}
+	return 0;
     }
-    return 0;
-  }
 
-  @Override
-  public String getDefaultMetaVariable() {
-    return null;
-  }
+    @Override
+    public String getDefaultMetaVariable() {
+	return null;
+    }
 
-  /**
-   * Look for a string in an array of strings
-   * @param str String to look for
-   * @param strings Array of strings to search
-   * @return {@code true} if {@code str} is present in {@code strings}
-   */
-  private static boolean find(String str, String[] strings) {
-    for (String alias : strings) {
-      if (alias.equals(str)) {
-        return true;
-      }
-      System.err.println(alias + " != " + str);
+    /**
+     * Look for a string in an array of strings
+     * @param str String to look for
+     * @param strings Array of strings to search
+     * @return {@code true} if {@code str} is present in {@code strings}
+     */
+    private static boolean find(String str, String[] strings) {
+	for (String alias : strings) {
+	    if (alias.equals(str)) {
+		return true;
+	    }
+	    System.err.println(alias + " != " + str);
+	}
+	return false;
     }
-    return false;
-  }
 
 }
diff --git a/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java b/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java
index c653e403..f3dfeef4 100644
--- a/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java
+++ b/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java
@@ -5,48 +5,51 @@
 
 import junit.framework.TestCase;
 
+/** Simple test for the {@link NegatableBooleanOptionHandler}.
+ * @author Robin Garner
+ */
 public class NegatableBooleanOptionHandlerTest extends TestCase {
 
-  private static class SimpleTestBean {
-    @Option(name = "--option", aliases = { "--nooption" },
-        handler=NegatableBooleanOptionHandler.class,
-        usage = "Standard option")
-    private boolean option;
-  }
-
-  private static class NoNoTestBean {
-    @Option(name = "--notify", aliases = { "--nonotify" },
-        handler=NegatableBooleanOptionHandler.class,
-        usage = "Option that naturally starts with --no")
-    private boolean option = true;
-  }
-
-
-  public void testSimpleOptionPresent() throws Exception {
-    SimpleTestBean args = new SimpleTestBean();
-    CmdLineParser parser = new CmdLineParser(args);
-    parser.parseArgument("--option");
-    assertEquals(true, args.option);
-  }
-
-  public void testSimpleOptionNegated() throws Exception {
-    SimpleTestBean args = new SimpleTestBean();
-    CmdLineParser parser = new CmdLineParser(args);
-    parser.parseArgument("--nooption");
-    assertEquals(false, args.option);
-  }
-
-  public void testNoOptionPresent() throws Exception {
-    NoNoTestBean args = new NoNoTestBean();
-    CmdLineParser parser = new CmdLineParser(args);
-    parser.parseArgument("--notify");
-    assertEquals(true, args.option);
-  }
-
-  public void testNoOptionNegated() throws Exception {
-    NoNoTestBean args = new NoNoTestBean();
-    CmdLineParser parser = new CmdLineParser(args);
-    parser.parseArgument("--nonotify");
-    assertEquals(false, args.option);
-  }
+    private static class SimpleTestBean {
+	@Option(name = "--option", aliases = { "--nooption" },
+		handler=NegatableBooleanOptionHandler.class,
+		usage = "Standard option")
+	private boolean option;
+    }
+
+    private static class NoNoTestBean {
+	@Option(name = "--notify", aliases = { "--nonotify" },
+		handler=NegatableBooleanOptionHandler.class,
+		usage = "Option that naturally starts with --no")
+	private boolean option = true;
+    }
+
+
+    public void testSimpleOptionPresent() throws Exception {
+	SimpleTestBean args = new SimpleTestBean();
+	CmdLineParser parser = new CmdLineParser(args);
+	parser.parseArgument("--option");
+	assertEquals(true, args.option);
+    }
+
+    public void testSimpleOptionNegated() throws Exception {
+	SimpleTestBean args = new SimpleTestBean();
+	CmdLineParser parser = new CmdLineParser(args);
+	parser.parseArgument("--nooption");
+	assertEquals(false, args.option);
+    }
+
+    public void testNoOptionPresent() throws Exception {
+	NoNoTestBean args = new NoNoTestBean();
+	CmdLineParser parser = new CmdLineParser(args);
+	parser.parseArgument("--notify");
+	assertEquals(true, args.option);
+    }
+
+    public void testNoOptionNegated() throws Exception {
+	NoNoTestBean args = new NoNoTestBean();
+	CmdLineParser parser = new CmdLineParser(args);
+	parser.parseArgument("--nonotify");
+	assertEquals(false, args.option);
+    }
 }

From acd997cb985713a982c071e71053f98c99e79aa4 Mon Sep 17 00:00:00 2001
From: Robin Garner <robin.garner@scu.edu.au>
Date: Thu, 5 Jan 2017 11:42:14 +1100
Subject: [PATCH 3/3] Remove the requirement that the user needs to add the
 "--no" version of the option.  If the negated version isn't present as an
 alias it will be added implicitly.

---
 .../org/kohsuke/args4j/NamedOptionDef.java    | 29 +++++++---
 .../spi/NegatableBooleanOptionHandler.java    | 58 +++++++++++++------
 .../NegatableBooleanOptionHandlerTest.java    | 23 +++++++-
 3 files changed, 84 insertions(+), 26 deletions(-)

diff --git a/args4j/src/org/kohsuke/args4j/NamedOptionDef.java b/args4j/src/org/kohsuke/args4j/NamedOptionDef.java
index 1ed2dd16..939448fe 100644
--- a/args4j/src/org/kohsuke/args4j/NamedOptionDef.java
+++ b/args4j/src/org/kohsuke/args4j/NamedOptionDef.java
@@ -5,12 +5,12 @@
 /**
  * Immutable run-time copy of {@link Option} annotation.
  */
-public final class NamedOptionDef extends OptionDef {
+public class NamedOptionDef extends OptionDef {
     private final String name;
 	private final String[] aliases;
     private final String[] depends;
     private final String[] forbids;
-    
+
     /**
      * @deprecated
      *      multi-valuedness as option definition does not make sense. It's driven by the setter.
@@ -27,7 +27,20 @@ public NamedOptionDef(Option o) {
         this.depends = createZeroSizedArrayIfNull(o.depends());
         this.forbids = createZeroSizedArrayIfNull(o.forbids());
     }
-    
+
+    /**
+     * Create a copy of another NamedOptionDef
+     * @param o The original option
+     */
+    public NamedOptionDef(NamedOptionDef o) {
+    	super(o.usage(),o.metaVar(),o.required(),o.help(),o.hidden(),o.handler(),false);
+
+    	this.name = o.name();
+    	this.aliases = o.aliases();
+        this.depends = o.depends();
+        this.forbids = o.forbids();
+    }
+
     private static String[] createZeroSizedArrayIfNull(String in[]) {
         if (in == null) {
             return new String[0];
@@ -39,7 +52,7 @@ private static String[] createZeroSizedArrayIfNull(String in[]) {
     public String name() {
     	return name;
     }
-    
+
     public String[] aliases() {
     	return Arrays.copyOf(aliases, aliases.length);
     }
@@ -51,12 +64,12 @@ public String[] depends() {
     public String[] forbids() {
         return Arrays.copyOf(forbids, forbids.length);
     }
-    
+
     @Override
     public String toString() {
-    	if (aliases.length > 0) {
+    	if (aliases().length > 0) {
     		String str = "";
-    		for (String alias : aliases) {
+    		for (String alias : aliases()) {
     			if (str.length() > 0) {
     				str += ", ";
     			}
@@ -66,7 +79,7 @@ public String toString() {
     	}
     	return name();
     }
-    
+
     @Override
     public boolean isArgument() {
     	return false;
diff --git a/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java b/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java
index 76bc97df..9fba0b6c 100644
--- a/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java
+++ b/args4j/src/org/kohsuke/args4j/spi/NegatableBooleanOptionHandler.java
@@ -1,5 +1,7 @@
 package org.kohsuke.args4j.spi;
 
+import java.util.Arrays;
+
 import org.kohsuke.args4j.CmdLineException;
 import org.kohsuke.args4j.CmdLineParser;
 import org.kohsuke.args4j.IllegalAnnotationError;
@@ -13,12 +15,8 @@
  * Boolean {@link OptionHandler} that allows values to be specified as
  * --<option> and negated with --no<option>.
  *
- * Requires the caller to explicitly add the --no version to the alternative
- * names in the option definition, e.g.
- *   <code>
- *     name = "--option", aliases = { "--nooption" },
- *   </code>
- * If the negated option isn't present, the constructor will throw an IllegalAnnotationError.
+ * Implicitly adds the negated version of the option to the list of aliases
+ * unless the user has already specified it.
  *
  * @Author Robin Garner
  */
@@ -28,18 +26,9 @@ public class NegatableBooleanOptionHandler extends OptionHandler<Boolean> {
 
     public NegatableBooleanOptionHandler(CmdLineParser parser,
 	    OptionDef option, Setter<? super Boolean> setter) {
-	super(parser, option, setter);
-
-	if (!(option instanceof NamedOptionDef)) {
-	    throw new IllegalAnnotationError("NegatableBooleanOptionHandler can only be used for named options.");
-	}
-
-	NamedOptionDef namedOption = (NamedOptionDef) option;
-	this.negatedName = namedOption.name().replaceFirst("(-*)", "$1no");
+	super(parser, addNegatedName(option), setter);
 
-	if (!find(negatedName, namedOption.aliases())) {
-	    throw new IllegalAnnotationError("There is no negated version of "+namedOption.name()+" in the option aliases.");
-	}
+	this.negatedName = negatedOption(((NamedOptionDef) option).name());
     }
 
     @Override
@@ -57,6 +46,41 @@ public String getDefaultMetaVariable() {
 	return null;
     }
 
+    /**
+     * Return a new OptionDef that includes the negated name of the option in its
+     * aliases.  If the user has already done this, return the original untouched.
+     * @param option Original option
+     * @return The option, with the negated name guaranteed to be in the aliases.
+     * @throws IllegalAnnotationError if option is not a NanedOptionDef
+     */
+    private static OptionDef addNegatedName(final OptionDef option) {
+	if (!(option instanceof NamedOptionDef)) {
+	    throw new IllegalAnnotationError("NegatableBooleanOptionHandler can only be used for named options.");
+	}
+	if (hasNegatedAlias((NamedOptionDef)option)) {
+	    return option;
+	}
+	return new NamedOptionDef((NamedOptionDef)option) {
+
+	    @Override
+	    public String[] aliases() {
+		String[] aliases = super.aliases();
+		String[] result = Arrays.copyOf(aliases, aliases.length+1);
+		result[aliases.length] = negatedOption(name());
+		return result;
+	    }
+
+	};
+    }
+
+    private static String negatedOption(String name) {
+	return name.replaceFirst("(-*)", "$1no");
+    }
+
+    private static boolean hasNegatedAlias(NamedOptionDef option) {
+	return find(negatedOption(option.name()), option.aliases());
+    }
+
     /**
      * Look for a string in an array of strings
      * @param str String to look for
diff --git a/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java b/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java
index f3dfeef4..82d4df39 100644
--- a/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java
+++ b/args4j/test/org/kohsuke/args4j/spi/NegatableBooleanOptionHandlerTest.java
@@ -11,6 +11,13 @@
 public class NegatableBooleanOptionHandlerTest extends TestCase {
 
     private static class SimpleTestBean {
+	@Option(name = "--option",
+		handler=NegatableBooleanOptionHandler.class,
+		usage = "Standard option")
+	private boolean option;
+    }
+
+    private static class ExistingAliasBean {
 	@Option(name = "--option", aliases = { "--nooption" },
 		handler=NegatableBooleanOptionHandler.class,
 		usage = "Standard option")
@@ -18,7 +25,7 @@ private static class SimpleTestBean {
     }
 
     private static class NoNoTestBean {
-	@Option(name = "--notify", aliases = { "--nonotify" },
+	@Option(name = "--notify",
 		handler=NegatableBooleanOptionHandler.class,
 		usage = "Option that naturally starts with --no")
 	private boolean option = true;
@@ -39,6 +46,20 @@ public void testSimpleOptionNegated() throws Exception {
 	assertEquals(false, args.option);
     }
 
+    public void testExistingAliasPresent() throws Exception {
+	ExistingAliasBean args = new ExistingAliasBean();
+	CmdLineParser parser = new CmdLineParser(args);
+	parser.parseArgument("--option");
+	assertEquals(true, args.option);
+    }
+
+    public void testExistingAliasNegated() throws Exception {
+	ExistingAliasBean args = new ExistingAliasBean();
+	CmdLineParser parser = new CmdLineParser(args);
+	parser.parseArgument("--nooption");
+	assertEquals(false, args.option);
+    }
+
     public void testNoOptionPresent() throws Exception {
 	NoNoTestBean args = new NoNoTestBean();
 	CmdLineParser parser = new CmdLineParser(args);