+ * Both allowPartialMatching and stripLeadingAndTrailingQuotes are true by default, mimicking the argument-less constructor. + *

* By "partial matching" we mean that given the following code: + *

-         * {
-         *     @code
-         *     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."));
-         * }
-         * 

{@code
+         * 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."));
+         * }

+ * If "partial matching" is turned on, {@code -de} only matches the {@code "debug"} option. However, with "partial matching" disabled, {@code -de} would + * enable both {@code debug} as well as {@code extract} + *

+ * If "stripping of balanced leading and trailing double quotes from option arguments" is true, the outermost balanced double quotes of option arguments + * values will be removed. For example, {@code -o '"x"'} getValue() will return {@code x}, instead of {@code "x"} + *

+ * If "stripping of balanced leading and trailing double quotes from option arguments" is null, then quotes will be stripped from option values + * separated by space from the option, but kept in other cases, which is the historic behavior. + *

+ * If you want to serialize this field, use a serialization proxy. + *

* By "partial matching" we mean that given the following code: + *

-     * {
-     *     @code
-     *     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."));
+     * 
{@code
+     * 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."));
      * }
      * 
      *
@@ -182,32 +269,33 @@ public static Builder builder() {
     public DefaultParser() {
         this.allowPartialMatching = true;
         this.stripLeadingAndTrailingQuotes = null;
+        this.deprecatedHandler = CommandLine.Builder.DEPRECATED_HANDLER;
     }
 
     /**
      * Create a new DefaultParser instance with the specified partial matching policy.
-     *
+     * 

      * By "partial matching" we mean that given the following code:
-     *
-     * 
-     * {
-     *     @code
+     * 

+     * 
{@code
      *     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."));
      * }
      * 
-     *
+     * 

      * with "partial matching" turned on, {@code -de} only matches the {@code "debug"} option. However, with
      * "partial matching" disabled, {@code -de} would enable both {@code debug} as well as {@code extract}
      * options.
+     * 
      *
      * @param allowPartialMatching if partial matching of long options shall be enabled
      */
     public DefaultParser(final boolean allowPartialMatching) {
         this.allowPartialMatching = allowPartialMatching;
         this.stripLeadingAndTrailingQuotes = null;
+        this.deprecatedHandler = CommandLine.Builder.DEPRECATED_HANDLER;
     }
 
     /**
@@ -217,10 +305,20 @@ public DefaultParser(final boolean allowPartialMatching) {
      * @param allowPartialMatching if partial matching of long options shall be enabled
      * @param stripLeadingAndTrailingQuotes if balanced outer double quoutes should be stripped
      */
-    private DefaultParser(final boolean allowPartialMatching,
-            final Boolean stripLeadingAndTrailingQuotes) {
+    private DefaultParser(final boolean allowPartialMatching, final Boolean stripLeadingAndTrailingQuotes, final Consumer deprecatedHandler) {
         this.allowPartialMatching = allowPartialMatching;
         this.stripLeadingAndTrailingQuotes = stripLeadingAndTrailingQuotes;
+        this.deprecatedHandler = deprecatedHandler;
+    }
+
+    /**
+     * Adds token to command line {@link CommandLine#addArg(String)}.
+     *
+     * @param token the unrecognized option/argument.
+     * @since 1.10.0
+     */
+    protected void addArg(final String token) {
+        cmd.addArg(token);
     }
 
     /**
@@ -228,6 +326,9 @@ private DefaultParser(final boolean allowPartialMatching,
      */
     private void checkRequiredArgs() throws ParseException {
         if (currentOption != null && currentOption.requiresArg()) {
+            if (isJavaProperty(currentOption.getKey()) && currentOption.getValuesList().size() == 1) {
+                return;
+            }
             throw new MissingArgumentException(currentOption);
         }
     }
@@ -245,13 +346,12 @@ protected void checkRequiredOptions() throws MissingOptionException {
     }
 
     /**
-     * Searches for a prefix that is the long name of an option (-Xmx512m)
+     * Searches for a prefix that is the long name of an option (-Xmx512m).
      *
      * @param token
      */
     private String getLongPrefix(final String token) {
         final String t = Util.stripLeadingHyphens(token);
-
         int i;
         String opt = null;
         for (i = t.length() - 2; i > 1; i--) {
@@ -261,15 +361,14 @@ private String getLongPrefix(final String token) {
                 break;
             }
         }
-
         return opt;
     }
 
     /**
      * Gets 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
+     * @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 getMatchingLongOptions(final String token) {
         if (allowPartialMatching) {
@@ -277,10 +376,8 @@ private List getMatchingLongOptions(final String token) {
         }
         final List matches = new ArrayList<>(1);
         if (options.hasLongOption(token)) {
-            final Option option = options.getOption(token);
-            matches.add(option.getLongOpt());
+            matches.add(options.getOption(token).getLongOpt());
         }
-
         return matches;
     }
 
@@ -288,35 +385,33 @@ private List getMatchingLongOptions(final String token) {
      * Breaks {@code token} into its constituent parts using the following algorithm.
      *
      * 

-     * 
ignore the first character ("-")
+     * 
ignore the first character ("-")
      * 
for each remaining character check if an {@link Option} exists with that id.
-     * 
if an {@link Option} does exist then add that character prepended with "-" to the list of processed
+     * 
if an {@link Option} does exist then add that character prepended with "-" to the list of processed
      * tokens.
      * 
if the {@link Option} can have an argument value and there are remaining characters in the token then add the
      * remaining characters as a token to the list of processed tokens.
-     * 
if an {@link Option} does NOT exist AND {@code stopAtNonOption} IS set then add the
-     * special token "--" followed by the remaining characters and also the remaining tokens directly to the
+     * 
if an {@link Option} does NOT exist AND {@code stopAtNonOption} IS set then add the
+     * special token "--" followed by the remaining characters and also the remaining tokens directly to the
      * processed tokens list.
-     * 
if an {@link Option} does NOT exist AND {@code stopAtNonOption} IS NOT set then add
-     * that character prepended with "-".
+     * 
if an {@link Option} does NOT exist AND {@code stopAtNonOption} IS NOT set then add
+     * that character prepended with "-".
      * 
      *
-     * @param token The current token to be burst at the first non-Option encountered.
+     * @param token The current token to be burst at the first non-Option encountered.
      * @throws ParseException if there are any problems encountered while parsing the command line token.
      */
     protected void handleConcatenatedOptions(final String token) throws ParseException {
         for (int i = 1; i < token.length(); i++) {
             final String ch = String.valueOf(token.charAt(i));
-
             if (!options.hasOption(ch)) {
-                handleUnknownToken(stopAtNonOption && i > 1 ? token.substring(i) : token);
+                handleUnknownToken(nonOptionAction == NonOptionAction.STOP && i > 1 ? token.substring(i) : token);
                 break;
             }
             handleOption(options.getOption(ch));
-
             if (currentOption != null && token.length() != i + 1) {
                 // add the trail as an argument of the option
-                currentOption.addValueForProcessing(stripLeadingAndTrailingQuotesDefaultOff(token.substring(i + 1)));
+                currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOff(token.substring(i + 1)));
                 break;
             }
         }
@@ -324,13 +419,14 @@ protected void handleConcatenatedOptions(final String token) throws ParseExcepti
 
     /**
      * Handles the following tokens:
-     *
+     * 
      * --L --L=V --L V --l
+     * 
      *
-     * @param token the command line token to handle
+     * @param token the command line token to handle.
      */
     private void handleLongOption(final String token) throws ParseException {
-        if (token.indexOf('=') == -1) {
+        if (indexOfEqual(token) == -1) {
             handleLongOptionWithoutEqual(token);
         } else {
             handleLongOptionWithEqual(token);
@@ -339,18 +435,16 @@ private void handleLongOption(final String token) throws ParseException {
 
     /**
      * Handles the following tokens:
-     *
+     * 
      * --L=V -L=V --l=V -l=V
+     * 
      *
-     * @param token the command line token to handle
+     * @param token the command line token to handle.
      */
     private void handleLongOptionWithEqual(final String token) throws ParseException {
-        final int pos = token.indexOf('=');
-
+        final int pos = indexOfEqual(token);
         final String value = token.substring(pos + 1);
-
         final String opt = token.substring(0, pos);
-
         final List matchingOpts = getMatchingLongOptions(opt);
         if (matchingOpts.isEmpty()) {
             handleUnknownToken(currentToken);
@@ -359,10 +453,9 @@ private void handleLongOptionWithEqual(final String token) throws ParseException
         } else {
             final String key = options.hasLongOption(opt) ? opt : matchingOpts.get(0);
             final Option option = options.getOption(key);
-
             if (option.acceptsArg()) {
                 handleOption(option);
-                currentOption.addValueForProcessing(stripLeadingAndTrailingQuotesDefaultOff(value));
+                currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOff(value));
                 currentOption = null;
             } else {
                 handleUnknownToken(currentToken);
@@ -373,9 +466,11 @@ private void handleLongOptionWithEqual(final String token) throws ParseException
     /**
      * Handles the following tokens:
      *
+     * 
      * --L -L --l -l
+     * 
      *
-     * @param token the command line token to handle
+     * @param token the command line token to handle.
      */
     private void handleLongOptionWithoutEqual(final String token) throws ParseException {
         final List matchingOpts = getMatchingLongOptions(token);
@@ -389,21 +484,13 @@ private void handleLongOptionWithoutEqual(final String token) throws ParseExcept
         }
     }
 
-    private void handleOption(Option option) throws ParseException {
+    private void handleOption(final Option option) throws ParseException {
         // check the previous option before handling the next one
         checkRequiredArgs();
-
-        option = (Option) option.clone();
-
-        updateRequiredOptions(option);
-
-        cmd.addOption(option);
-
-        if (option.hasArg()) {
-            currentOption = option;
-        } else {
-            currentOption = null;
-        }
+        final Option copy = (Option) option.clone();
+        updateRequiredOptions(copy);
+        cmd.addOption(copy);
+        currentOption = copy.hasArg() ? copy : null;
     }
 
     /**
@@ -415,32 +502,27 @@ private void handleProperties(final Properties properties) throws ParseException
         if (properties == null) {
             return;
         }
-
         for (final Enumeration e = properties.propertyNames(); e.hasMoreElements();) {
             final String option = e.nextElement().toString();
-
             final Option opt = options.getOption(option);
             if (opt == null) {
                 throw new UnrecognizedOptionException("Default option wasn't defined", option);
             }
-
             // if the option is part of a group, check if another option of the group has been selected
-            final OptionGroup group = options.getOptionGroup(opt);
-            final boolean selected = group != null && group.getSelected() != null;
-
+            final OptionGroup optionGroup = options.getOptionGroup(opt);
+            final boolean selected = optionGroup != null && optionGroup.isSelected();
             if (!cmd.hasOption(option) && !selected) {
                 // get the value from the properties
                 final String value = properties.getProperty(option);
 
                 if (opt.hasArg()) {
-                    if (opt.getValues() == null || opt.getValues().length == 0) {
-                        opt.addValueForProcessing(stripLeadingAndTrailingQuotesDefaultOff(value));
+                    if (opt.isValuesEmpty()) {
+                        opt.processValue(stripLeadingAndTrailingQuotesDefaultOff(value));
                     }
                 } else if (!("yes".equalsIgnoreCase(value) || "true".equalsIgnoreCase(value) || "1".equalsIgnoreCase(value))) {
                     // if the value is not yes, true or 1 then don't add the option to the CommandLine
                     continue;
                 }
-
                 handleOption(opt);
                 currentOption = null;
             }
@@ -449,74 +531,73 @@ private void handleProperties(final Properties properties) throws ParseException
 
     /**
      * Handles the following tokens:
-     *
+     * 
      * -S -SV -S V -S=V -S1S2 -S1S2 V -SV1=V2
      *
      * -L -LV -L V -L=V -l
+     * 
      *
-     * @param token the command line token to handle
+     * @param hyphenToken the command line token to handle.
      */
-    private void handleShortAndLongOption(final String token) throws ParseException {
-        final String t = Util.stripLeadingHyphens(token);
-
-        final int pos = t.indexOf('=');
-
-        if (t.length() == 1) {
+    private void handleShortAndLongOption(final String hyphenToken) throws ParseException {
+        final String token = Util.stripLeadingHyphens(hyphenToken);
+        final int pos = indexOfEqual(token);
+        if (token.length() == 1) {
             // -S
-            if (options.hasShortOption(t)) {
-                handleOption(options.getOption(t));
+            if (options.hasShortOption(token)) {
+                handleOption(options.getOption(token));
             } else {
-                handleUnknownToken(token);
+                handleUnknownToken(hyphenToken);
             }
         } else if (pos == -1) {
             // no equal sign found (-xxx)
-            if (options.hasShortOption(t)) {
-                handleOption(options.getOption(t));
-            } else if (!getMatchingLongOptions(t).isEmpty()) {
+            if (options.hasShortOption(token)) {
+                handleOption(options.getOption(token));
+            } else if (!getMatchingLongOptions(token).isEmpty()) {
                 // -L or -l
-                handleLongOptionWithoutEqual(token);
+                handleLongOptionWithoutEqual(hyphenToken);
             } else {
                 // look for a long prefix (-Xmx512m)
-                final String opt = getLongPrefix(t);
+                final String opt = getLongPrefix(token);
 
                 if (opt != null && options.getOption(opt).acceptsArg()) {
                     handleOption(options.getOption(opt));
-                    currentOption.addValueForProcessing(stripLeadingAndTrailingQuotesDefaultOff(t.substring(opt.length())));
+                    currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOff(token.substring(opt.length())));
                     currentOption = null;
-                } else if (isJavaProperty(t)) {
+                } else if (isJavaProperty(token)) {
                     // -SV1 (-Dflag)
-                    handleOption(options.getOption(t.substring(0, 1)));
-                    currentOption.addValueForProcessing(stripLeadingAndTrailingQuotesDefaultOff(t.substring(1)));
+                    handleOption(options.getOption(token.substring(0, 1)));
+                    currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOff(token.substring(1)));
                     currentOption = null;
                 } else {
                     // -S1S2S3 or -S1S2V
-                    handleConcatenatedOptions(token);
+                    handleConcatenatedOptions(hyphenToken);
                 }
             }
         } else {
             // equal sign found (-xxx=yyy)
-            final String opt = t.substring(0, pos);
-            final String value = t.substring(pos + 1);
+            final String opt = token.substring(0, pos);
+            final String value = token.substring(pos + 1);
 
             if (opt.length() == 1) {
                 // -S=V
                 final Option option = options.getOption(opt);
                 if (option != null && option.acceptsArg()) {
                     handleOption(option);
-                    currentOption.addValueForProcessing(value);
+                    currentOption.processValue(value);
                     currentOption = null;
                 } else {
-                    handleUnknownToken(token);
+                    handleUnknownToken(hyphenToken);
                 }
             } else if (isJavaProperty(opt)) {
                 // -SV1=V2 (-Dkey=value)
                 handleOption(options.getOption(opt.substring(0, 1)));
-                currentOption.addValueForProcessing(opt.substring(1));
-                currentOption.addValueForProcessing(value);
+                currentOption.processValue(opt.substring(1));
+                currentOption.processValue(value);
                 currentOption = null;
             } else {
                 // -L=V or -l=V
-                handleLongOptionWithEqual(token);
+                handleLongOptionWithEqual(hyphenToken);
             }
         }
     }
@@ -524,28 +605,28 @@ private void handleShortAndLongOption(final String token) throws ParseException
     /**
      * Handles any command line token.
      *
-     * @param token the command line token to handle
+     * @param token the command line token to handle.
      * @throws ParseException
      */
     private void handleToken(final String token) throws ParseException {
-        currentToken = token;
-
-        if (skipParsing) {
-            cmd.addArg(token);
-        } else if ("--".equals(token)) {
-            skipParsing = true;
-        } else if (currentOption != null && currentOption.acceptsArg() && isArgument(token)) {
-            currentOption.addValueForProcessing(stripLeadingAndTrailingQuotesDefaultOn(token));
-        } else if (token.startsWith("--")) {
-            handleLongOption(token);
-        } else if (token.startsWith("-") && !"-".equals(token)) {
-            handleShortAndLongOption(token);
-        } else {
-            handleUnknownToken(token);
-        }
-
-        if (currentOption != null && !currentOption.acceptsArg()) {
-            currentOption = null;
+        if (token != null) {
+            currentToken = token;
+            if (skipParsing) {
+                addArg(token);
+            } else if (OptionFormatter.DEFAULT_LONG_OPT_PREFIX.equals(token)) {
+                skipParsing = true;
+            } else if (currentOption != null && currentOption.acceptsArg() && isArgument(token)) {
+                currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOn(token));
+            } else if (token.startsWith(OptionFormatter.DEFAULT_LONG_OPT_PREFIX)) {
+                handleLongOption(token);
+            } else if (token.startsWith(OptionFormatter.DEFAULT_OPT_PREFIX) && !OptionFormatter.DEFAULT_OPT_PREFIX.equals(token)) {
+                handleShortAndLongOption(token);
+            } else {
+                handleUnknownToken(token);
+            }
+            if (currentOption != null && !currentOption.acceptsArg()) {
+                currentOption = null;
+            }
         }
     }
 
@@ -554,15 +635,19 @@ private void handleToken(final String token) throws ParseException {
      * token is added to the arguments of the command line. If the stopAtNonOption flag is set, this stops the parsing and
      * the remaining tokens are added as-is in the arguments of the command line.
      *
-     * @param token the command line token to handle
+     * @param token the command line token to handle.
+     * @throws ParseException if parsing should fail.
+     * @since 1.10.0
      */
-    private void handleUnknownToken(final String token) throws ParseException {
-        if (token.startsWith("-") && token.length() > 1 && !stopAtNonOption) {
+    protected void handleUnknownToken(final String token) throws ParseException {
+        if (token.startsWith(OptionFormatter.DEFAULT_OPT_PREFIX) && token.length() > 1 && nonOptionAction == NonOptionAction.THROW) {
             throw new UnrecognizedOptionException("Unrecognized option: " + token, token);
         }
-
-        cmd.addArg(token);
-        if (stopAtNonOption) {
+        if (!token.startsWith(OptionFormatter.DEFAULT_OPT_PREFIX) || token.equals(OptionFormatter.DEFAULT_OPT_PREFIX)
+                || token.length() > 1 && nonOptionAction != NonOptionAction.IGNORE) {
+            addArg(token);
+        }
+        if (nonOptionAction == NonOptionAction.STOP) {
             skipParsing = true;
         }
     }
@@ -580,9 +665,8 @@ private boolean isArgument(final String token) {
      * Tests if the specified token is a Java-like property (-Dkey=value).
      */
     private boolean isJavaProperty(final String token) {
-        final String opt = token.substring(0, 1);
+        final String opt = token.isEmpty() ? null : token.substring(0, 1);
         final Option option = options.getOption(opt);
-
         return option != null && (option.getArgs() >= 2 || option.getArgs() == Option.UNLIMITED_VALUES);
     }
 
@@ -592,22 +676,19 @@ private boolean isJavaProperty(final String token) {
      * @param token
      */
     private boolean isLongOption(final String token) {
-        if (token == null || !token.startsWith("-") || token.length() == 1) {
+        if (token == null || !token.startsWith(OptionFormatter.DEFAULT_OPT_PREFIX) || token.length() == 1) {
             return false;
         }
-
-        final int pos = token.indexOf("=");
+        final int pos = indexOfEqual(token);
         final String t = pos == -1 ? token : token.substring(0, pos);
-
         if (!getMatchingLongOptions(t).isEmpty()) {
             // long or partial long options (--L, -L, --L=V, -L=V, --l, --l=V)
             return true;
         }
-        if (getLongPrefix(token) != null && !token.startsWith("--")) {
+        if (getLongPrefix(token) != null && !token.startsWith(OptionFormatter.DEFAULT_LONG_OPT_PREFIX)) {
             // -LV
             return true;
         }
-
         return false;
     }
 
@@ -641,12 +722,11 @@ private boolean isOption(final String token) {
      */
     private boolean isShortOption(final String token) {
         // short options (-S, -SV, -S=V, -SV1=V2, -S1S2)
-        if (token == null || !token.startsWith("-") || token.length() == 1) {
+        if (token == null || !token.startsWith(OptionFormatter.DEFAULT_OPT_PREFIX) || token.length() == 1) {
             return false;
         }
-
         // remove leading "-" and "=value"
-        final int pos = token.indexOf("=");
+        final int pos = indexOfEqual(token);
         final String optName = pos == -1 ? token.substring(1) : token.substring(1, pos);
         if (options.hasShortOption(optName)) {
             return true;
@@ -655,11 +735,51 @@ private boolean isShortOption(final String token) {
         return !optName.isEmpty() && options.hasShortOption(String.valueOf(optName.charAt(0)));
     }
 
+    /**
+     * Parses the arguments according to the specified options and properties.
+     *
+     * @param options the specified Options
+     * @param properties command line option name-value pairs
+     * @param nonOptionAction see {@link NonOptionAction}.
+     * @param arguments the command line arguments
+     *
+     * @return the list of atomic option and value tokens.
+     * @throws ParseException if there are any problems encountered while parsing the command line tokens.
+     * @since 1.10.0
+     */
+    public CommandLine parse(final Options options, final Properties properties, final NonOptionAction nonOptionAction, final String... arguments)
+            throws ParseException {
+        this.options = Objects.requireNonNull(options, "options");
+        this.nonOptionAction = nonOptionAction;
+        skipParsing = false;
+        currentOption = null;
+        expectedOpts = new ArrayList<>(options.getRequiredOptions());
+        // clear the data from the groups
+        for (final OptionGroup optionGroup : options.getOptionGroups()) {
+            optionGroup.setSelected(null);
+        }
+        cmd = CommandLine.builder().setDeprecatedHandler(deprecatedHandler).get();
+        if (arguments != null) {
+            for (final String argument : arguments) {
+                handleToken(argument);
+            }
+        }
+        // check the arguments of the last option
+        checkRequiredArgs();
+        // add the default options
+        handleProperties(properties);
+        checkRequiredOptions();
+        return cmd;
+    }
+
     @Override
     public CommandLine parse(final Options options, final String[] arguments) throws ParseException {
         return parse(options, arguments, null);
     }
 
+    /**
+     * @see #parse(Options, Properties, NonOptionAction, String[])
+     */
     @Override
     public CommandLine parse(final Options options, final String[] arguments, final boolean stopAtNonOption) throws ParseException {
         return parse(options, arguments, null, stopAtNonOption);
@@ -668,11 +788,10 @@ public CommandLine parse(final Options options, final String[] arguments, final
     /**
      * Parses the arguments according to the specified options and properties.
      *
-     * @param options the specified Options
-     * @param arguments the command line arguments
-     * @param properties command line option name-value pairs
-     * @return the list of atomic option and value tokens
-     *
+     * @param options the specified Options.
+     * @param arguments the command line arguments.
+     * @param properties command line option name-value pairs.
+     * @return the list of atomic option and value tokens.
      * @throws ParseException if there are any problems encountered while parsing the command line tokens.
      */
     public CommandLine parse(final Options options, final String[] arguments, final Properties properties) throws ParseException {
@@ -682,54 +801,27 @@ public CommandLine parse(final Options options, final String[] arguments, final
     /**
      * Parses the arguments according to the specified options and properties.
      *
-     * @param options the specified Options
-     * @param arguments the command line arguments
-     * @param properties command line option name-value pairs
+     * @param options the specified Options.
+     * @param arguments the command line arguments.
+     * @param properties command line option name-value pairs.
      * @param stopAtNonOption if {@code true} an unrecognized argument stops the parsing and the remaining arguments
      *        are added to the {@link CommandLine}s args list. If {@code false} an unrecognized argument triggers a
      *        ParseException.
-     *
-     * @return the list of atomic option and value tokens
+     * @return the list of atomic option and value tokens.
      * @throws ParseException if there are any problems encountered while parsing the command line tokens.
+     * @see #parse(Options, Properties, NonOptionAction, String[])
      */
     public CommandLine parse(final Options options, final String[] arguments, final Properties properties, final boolean stopAtNonOption)
         throws ParseException {
-        this.options = options;
-        this.stopAtNonOption = stopAtNonOption;
-        skipParsing = false;
-        currentOption = null;
-        expectedOpts = new ArrayList<>(options.getRequiredOptions());
-
-        // clear the data from the groups
-        for (final OptionGroup group : options.getOptionGroups()) {
-            group.setSelected(null);
-        }
-
-        cmd = new CommandLine();
-
-        if (arguments != null) {
-            for (final String argument : arguments) {
-                handleToken(argument);
-            }
-        }
-
-        // check the arguments of the last option
-        checkRequiredArgs();
-
-        // add the default options
-        handleProperties(properties);
-
-        checkRequiredOptions();
-
-        return cmd;
+        return parse(options, properties, stopAtNonOption ? NonOptionAction.STOP : NonOptionAction.THROW, arguments);
     }
 
     /**
      * Strips balanced leading and trailing quotes if the stripLeadingAndTrailingQuotes is set
      * If stripLeadingAndTrailingQuotes is null, then do not strip
      *
-     * @param token a string
-     * @return token with the quotes stripped (if set)
+     * @param token a string.
+     * @return token with the quotes stripped (if set).
      */
     private String stripLeadingAndTrailingQuotesDefaultOff(final String token) {
         if (stripLeadingAndTrailingQuotes != null && stripLeadingAndTrailingQuotes) {
@@ -742,8 +834,8 @@ private String stripLeadingAndTrailingQuotesDefaultOff(final String token) {
      * Strips balanced leading and trailing quotes if the stripLeadingAndTrailingQuotes is set
      * If stripLeadingAndTrailingQuotes is null, then do not strip
      *
-     * @param token a string
-     * @return token with the quotes stripped (if set)
+     * @param token a string.
+     * @return token with the quotes stripped (if set).
      */
     private String stripLeadingAndTrailingQuotesDefaultOn(final String token) {
         if (stripLeadingAndTrailingQuotes == null || stripLeadingAndTrailingQuotes) {
@@ -761,16 +853,13 @@ private void updateRequiredOptions(final Option option) throws AlreadySelectedEx
         if (option.isRequired()) {
             expectedOpts.remove(option.getKey());
         }
-
         // if the option is in an OptionGroup make that option the selected option of the group
         if (options.getOptionGroup(option) != null) {
-            final OptionGroup group = options.getOptionGroup(option);
-
-            if (group.isRequired()) {
-                expectedOpts.remove(group);
+            final OptionGroup optionGroup = options.getOptionGroup(option);
+            if (optionGroup.isRequired()) {
+                expectedOpts.remove(optionGroup);
             }
-
-            group.setSelected(option);
+            optionGroup.setSelected(option);
         }
     }
 }
diff --git a/src/main/java/org/apache/commons/cli/DeprecatedAttributes.java b/src/main/java/org/apache/commons/cli/DeprecatedAttributes.java
new file mode 100644
index 000000000..b4ec5f35a
--- /dev/null
+++ b/src/main/java/org/apache/commons/cli/DeprecatedAttributes.java
@@ -0,0 +1,196 @@
+/*
+  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
+
+      https://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 java.util.function.Supplier;
+
+/**
+ * Deprecated attributes.
+ * 

+ * Note: This class isn't called "Deprecated" to avoid clashing with "java.lang.Deprecated".
+ * 
+ * 

+ * If you want to serialize this class, use a serialization proxy.
+ * 
+ *
+ * @since 1.7.0
+ * @see Deprecated
+ */
+public final class DeprecatedAttributes {
+
+    /**
+     * Builds {@link DeprecatedAttributes}.
+     */
+    public static class Builder implements Supplier {
+
+        /** The description. */
+        private String description;
+
+        /**
+         * Whether this option is subject to removal in a future version.
+         *
+         * @see Deprecated.forRemoval
+         */
+        private boolean forRemoval;
+
+        /**
+         * The version in which the option became deprecated.
+         *
+         * @see Deprecated.since
+         */
+        private String since;
+
+        /**
+         * Constructs a new instance.
+         *
+         * @deprecated Use {@link #builder()}.
+         */
+        @Deprecated
+        public Builder() {
+            // empty
+        }
+
+        @Override
+        public DeprecatedAttributes get() {
+            return new DeprecatedAttributes(description, since, forRemoval);
+        }
+
+        /**
+         * Sets the description.
+         *
+         * @param description the description.
+         * @return {@code this} instance.
+         */
+        public Builder setDescription(final String description) {
+            this.description = description;
+            return this;
+        }
+
+        /**
+         * Sets whether this option is subject to removal in a future version.
+         *
+         * @param forRemoval whether this is subject to removal in a future version.
+         * @return {@code this} instance.
+         * @see Deprecated.forRemoval
+         */
+        public Builder setForRemoval(final boolean forRemoval) {
+            this.forRemoval = forRemoval;
+            return this;
+        }
+
+        /**
+         * Sets the version in which the option became deprecated.
+         *
+         * @param since the version in which the option became deprecated.
+         * @return {@code this} instance.
+         */
+        public Builder setSince(final String since) {
+            this.since = since;
+            return this;
+        }
+    }
+
+    /**
+     * The default value for a DeprecatedAttributes.
+     */
+    static final DeprecatedAttributes DEFAULT = new DeprecatedAttributes("", "", false);
+
+    /**
+     * The empty string.
+     */
+    private static final String EMPTY_STRING = "";
+
+    /**
+     * Creates a new builder.
+     *
+     * @return a new builder.
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /** The description. */
+    private final String description;
+
+    /** Whether this option will be removed. */
+    private final boolean forRemoval;
+
+    /** The version label for removal. */
+    private final String since;
+
+    /**
+     * Constructs a new instance.
+     *
+     * @param description The description.
+     * @param since       The version label for removal.
+     * @param forRemoval  Whether this option will be removed.
+     */
+    private DeprecatedAttributes(final String description, final String since, final boolean forRemoval) {
+        this.description = toEmpty(description);
+        this.since = toEmpty(since);
+        this.forRemoval = forRemoval;
+    }
+
+    /**
+     * Gets the descriptions.
+     *
+     * @return the descriptions.
+     */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * Gets version in which the option became deprecated.
+     *
+     * @return the version in which the option became deprecated.
+     */
+    public String getSince() {
+        return since;
+    }
+
+    /**
+     * Tests whether this option is subject to removal in a future version.
+     *
+     * @return whether this option is subject to removal in a future version.
+     */
+    public boolean isForRemoval() {
+        return forRemoval;
+    }
+
+    private String toEmpty(final String since) {
+        return since != null ? since : EMPTY_STRING;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder("Deprecated");
+        if (forRemoval) {
+            builder.append(" for removal");
+        }
+        if (!since.isEmpty()) {
+            builder.append(" since ");
+            builder.append(since);
+        }
+        if (!description.isEmpty()) {
+            builder.append(": ");
+            builder.append(description);
+        }
+        return builder.toString();
+    }
+}
diff --git a/src/main/java/org/apache/commons/cli/GnuParser.java b/src/main/java/org/apache/commons/cli/GnuParser.java
index 8369c8051..6d2b8715e 100644
--- a/src/main/java/org/apache/commons/cli/GnuParser.java
+++ b/src/main/java/org/apache/commons/cli/GnuParser.java
@@ -6,7 +6,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
   (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
+      https://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,
@@ -20,70 +20,79 @@ Licensed to the Apache Software Foundation (ASF) under one or more
 import java.util.ArrayList;
 import java.util.List;
 
+import org.apache.commons.cli.help.OptionFormatter;
+
 /**
  * The class GnuParser provides an implementation of the {@link Parser#flatten(Options, String[], boolean) flatten}
  * method.
  *
- * @deprecated since 1.3, use the {@link DefaultParser} instead
+ * @deprecated Since 1.3, use the {@link DefaultParser} instead.
  */
 @Deprecated
 public class GnuParser extends Parser {
+
+    /**
+     * Constructs a new instance.
+     */
+    public GnuParser() {
+        // empty
+    }
+
     /**
      * This flatten method does so using the following rules:
      * 

-     * 
If an {@link Option} exists for the first character of the {@code arguments} entry AND an
+     * 
If an {@link Option} exists for the first character of the {@code arguments} entry AND an
      * {@link Option} does not exist for the whole {@code argument} then add the first character as an option to the
-     * processed tokens list e.g. "-D" and add the rest of the entry to the also.
+     * processed tokens list for example "-D" and add the rest of the entry to the also.
      * 
Otherwise just add the token to the processed tokens list.
      * 
      *
      * @param options The Options to parse the arguments by.
      * @param arguments The arguments that have to be flattened.
-     * @param stopAtNonOption specifies whether to stop flattening when a non option has been encountered
-     * @return a String array of the flattened arguments
+     * @param stopAtNonOption specifies whether to stop flattening when a non option has been encountered.
+     * @return a String array of the flattened arguments.
      */
     @Override
     protected String[] flatten(final Options options, final String[] arguments, final boolean stopAtNonOption) {
         final List tokens = new ArrayList<>();
-
         boolean eatTheRest = false;
-
         for (int i = 0; i < arguments.length; i++) {
             final String arg = arguments[i];
-
-            if ("--".equals(arg)) {
-                eatTheRest = true;
-                tokens.add("--");
-            } else if ("-".equals(arg)) {
-                tokens.add("-");
-            } else if (arg.startsWith("-")) {
-                final String opt = Util.stripLeadingHyphens(arg);
-
-                if (options.hasOption(opt)) {
-                    tokens.add(arg);
-                } else if (opt.indexOf('=') != -1 && options.hasOption(opt.substring(0, opt.indexOf('=')))) {
-                    // the format is --foo=value or -foo=value
-                    tokens.add(arg.substring(0, arg.indexOf('='))); // --foo
-                    tokens.add(arg.substring(arg.indexOf('=') + 1)); // value
-                } else if (options.hasOption(arg.substring(0, 2))) {
-                    // the format is a special properties option (-Dproperty=value)
-                    tokens.add(arg.substring(0, 2)); // -D
-                    tokens.add(arg.substring(2)); // property=value
+            if (arg != null) {
+                if (OptionFormatter.DEFAULT_LONG_OPT_PREFIX.equals(arg)) {
+                    eatTheRest = true;
+                    tokens.add(OptionFormatter.DEFAULT_LONG_OPT_PREFIX);
+                } else if (OptionFormatter.DEFAULT_OPT_PREFIX.equals(arg)) {
+                    tokens.add(OptionFormatter.DEFAULT_OPT_PREFIX);
+                } else if (arg.startsWith(OptionFormatter.DEFAULT_OPT_PREFIX)) {
+                    final String opt = Util.stripLeadingHyphens(arg);
+                    if (options.hasOption(opt)) {
+                        tokens.add(arg);
+                    } else {
+                        final int equalPos = DefaultParser.indexOfEqual(opt);
+                        if (equalPos != -1 && options.hasOption(opt.substring(0, equalPos))) {
+                            // the format is --foo=value or -foo=value
+                            tokens.add(arg.substring(0, arg.indexOf(Char.EQUAL))); // --foo
+                            tokens.add(arg.substring(arg.indexOf(Char.EQUAL) + 1)); // value
+                        } else if (options.hasOption(arg.substring(0, 2))) {
+                            // the format is a special properties option (-Dproperty=value)
+                            tokens.add(arg.substring(0, 2)); // -D
+                            tokens.add(arg.substring(2)); // property=value
+                        } else {
+                            eatTheRest = stopAtNonOption;
+                            tokens.add(arg);
+                        }
+                    }
                 } else {
-                    eatTheRest = stopAtNonOption;
                     tokens.add(arg);
                 }
-            } else {
-                tokens.add(arg);
-            }
-
-            if (eatTheRest) {
-                for (i++; i < arguments.length; i++) { // NOPMD
-                    tokens.add(arguments[i]);
+                if (eatTheRest) {
+                    for (i++; i < arguments.length; i++) { // NOPMD
+                        tokens.add(arguments[i]);
+                    }
                 }
             }
         }
-
         return tokens.toArray(Util.EMPTY_STRING_ARRAY);
     }
 }
diff --git a/src/main/java/org/apache/commons/cli/HelpFormatter.java b/src/main/java/org/apache/commons/cli/HelpFormatter.java
index 911e3f877..fb9da62e9 100644
--- a/src/main/java/org/apache/commons/cli/HelpFormatter.java
+++ b/src/main/java/org/apache/commons/cli/HelpFormatter.java
@@ -6,7 +6,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
   (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
+      https://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,
@@ -22,6 +22,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
 import java.io.PrintWriter;
 import java.io.Serializable;
 import java.io.StringReader;
+import java.io.UncheckedIOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -29,14 +30,18 @@ Licensed to the Apache Software Foundation (ASF) under one or more
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import org.apache.commons.cli.help.AbstractHelpFormatter;
+import org.apache.commons.cli.help.OptionFormatter;
 
 /**
  * A formatter of help messages for command line options.
- *
  * 

  * Example:
  * 
- *
  * 
  * Options options = new Options();
  * options.addOption(OptionBuilder.withLongOpt("file").withDescription("The file to be processed").hasArg().withArgName("FILE").isRequired().create('f'));
@@ -44,31 +49,118 @@ Licensed to the Apache Software Foundation (ASF) under one or more
  * options.addOption(OptionBuilder.withLongOpt("help").create('h'));
  *
  * String header = "Do something useful with an input file\n\n";
- * String footer = "\nPlease report issues at http://example.com/issues";
+ * String footer = "\nPlease report issues at https://example.com/issues";
  *
  * HelpFormatter formatter = new HelpFormatter();
  * formatter.printHelp("myapp", header, options, footer, true);
  * 
- *
+ * 

  * This produces the following output:
- *
- * 
- * usage: myapp -f <FILE> [-h] [-v]
+ * 

+ * 
{@code
+ * usage: myapp -f  [-h] [-v]
  * Do something useful with an input file
  *
- *  -f,--file <FILE>   The file to be processed
+ *  -f,--file    The file to be processed
  *  -h,--help
  *  -v,--version       Print the version of the application
  *
- * Please report issues at http://example.com/issues
- * 
+ * Please report issues at https://example.com/issues
+ * }
+ * @deprecated Use {@link org.apache.commons.cli.help.HelpFormatter}.
  */
+@Deprecated
 public class HelpFormatter {
 
+    /**
+     * Builds {@link HelpFormatter}.
+     *
+     * @since 1.7.0
+     */
+    public static class Builder implements Supplier {
+        // TODO All other instance HelpFormatter instance variables.
+        // Make HelpFormatter immutable for 2.0
+
+        /**
+         * A function to convert a description (not null) and a deprecated Option (not null) to help description
+         */
+        private static final Function DEFAULT_DEPRECATED_FORMAT = o -> "[Deprecated] " + getDescription(o);
+
+        /**
+         * Formatter for deprecated options.
+         */
+        private Function deprecatedFormatFunction = DEFAULT_DEPRECATED_FORMAT;
+
+        /**
+         * The output PrintWriter, defaults to wrapping {@link System#out}.
+         */
+        private PrintWriter printStream = createDefaultPrintWriter();
+
+        /** The flag to determine if the since values should be dispalyed */
+        private boolean showSince;
+
+        /**
+         * Constructs a new instance.
+         */
+        public Builder() {
+            // empty
+        }
+
+        @Override
+        public HelpFormatter get() {
+            return new HelpFormatter(deprecatedFormatFunction, printStream, showSince);
+        }
+
+        /**
+         * Sets the output PrintWriter, defaults to wrapping {@link System#out}.
+         *
+         * @param printWriter the output PrintWriter, not null.
+         * @return {@code this} instance.
+         */
+        public Builder setPrintWriter(final PrintWriter printWriter) {
+            this.printStream = Objects.requireNonNull(printWriter, "printWriter");
+            return this;
+        }
+
+        /**
+         * Sets whether to show deprecated options.
+         *
+         * @param useDefaultFormat if {@code true} use the default format, otherwise clear the formatter.
+         * @return {@code this} instance.
+         */
+        public Builder setShowDeprecated(final boolean useDefaultFormat) {
+            return setShowDeprecated(useDefaultFormat ? DEFAULT_DEPRECATED_FORMAT : null);
+        }
+
+        /**
+         * Sets whether to show deprecated options.
+         *
+         * @param deprecatedFormatFunction Specify the format for the deprecated options.
+         * @return {@code this} instance.
+         * @since 1.8.0
+         */
+        public Builder setShowDeprecated(final Function deprecatedFormatFunction) {
+            this.deprecatedFormatFunction = deprecatedFormatFunction;
+            return this;
+        }
+
+        /**
+         * Sets whether to show the date the option was first added.
+         * @param showSince if @{code true} the date the options was first added will be shown.
+         * @return this builder.
+         * @since 1.9.0
+         */
+        public Builder setShowSince(final boolean showSince) {
+            this.showSince = showSince;
+            return this;
+        }
+    }
+
     /**
      * This class implements the {@code Comparator} interface for comparing Options.
      */
-    private static class OptionComparator implements Comparator, Serializable {
+    private static final class OptionComparator implements Comparator, Serializable {
+
         /** The serial version UID. */
         private static final long serialVersionUID = 5305467873966684014L;
 
@@ -87,36 +179,70 @@ public int compare(final Option opt1, final Option opt2) {
         }
     }
 
+    /** "Options" text for options header */
+    private static final String HEADER_OPTIONS = "Options";
+
+    /** "Since" text for options header */
+    private static final String HEADER_SINCE = "Since";
+
+    /** "Description" test for options header */
+    private static final String HEADER_DESCRIPTION = "Description";
+
     /** Default number of characters per line */
     public static final int DEFAULT_WIDTH = 74;
 
     /** Default padding to the left of each line */
     public static final int DEFAULT_LEFT_PAD = 1;
 
-    /** number of space characters to be prefixed to each description line */
+    /** Number of space characters to be prefixed to each description line */
     public static final int DEFAULT_DESC_PAD = 3;
 
     /** The string to display at the beginning of the usage statement */
     public static final String DEFAULT_SYNTAX_PREFIX = "usage: ";
 
     /** Default prefix for shortOpts */
-    public static final String DEFAULT_OPT_PREFIX = "-";
+    public static final String DEFAULT_OPT_PREFIX = OptionFormatter.DEFAULT_OPT_PREFIX;
 
     /** Default prefix for long Option */
-    public static final String DEFAULT_LONG_OPT_PREFIX = "--";
+    public static final String DEFAULT_LONG_OPT_PREFIX = OptionFormatter.DEFAULT_LONG_OPT_PREFIX;
 
     /**
-     * default separator displayed between a long Option and its value
+     * Default separator displayed between a long Option and its value
      *
      * @since 1.3
-     **/
+     */
     public static final String DEFAULT_LONG_OPT_SEPARATOR = " ";
 
     /** Default name for an argument */
     public static final String DEFAULT_ARG_NAME = "arg";
 
     /**
-     * number of characters per line
+     * Creates a new builder.
+     *
+     * @return a new builder.
+     * @since 1.7.0
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    private static PrintWriter createDefaultPrintWriter() {
+        return new PrintWriter(System.out);
+    }
+
+    /**
+     * Gets the option description or an empty string if the description is {@code null}.
+     * @param option The option to get the description from.
+     * @return the option description or an empty string if the description is {@code null}.
+     * @since 1.8.0
+     */
+    public static String getDescription(final Option option) {
+        final String desc = option.getDescription();
+        return desc == null ? "" : desc;
+    }
+
+    /**
+     * Number of characters per line
      *
      * @deprecated Scope will be made private for next major version - use get/setWidth methods instead.
      */
@@ -124,7 +250,7 @@ public int compare(final Option opt1, final Option opt2) {
     public int defaultWidth = DEFAULT_WIDTH;
 
     /**
-     * amount of padding to the left of each line
+     * Amount of padding to the left of each line
      *
      * @deprecated Scope will be made private for next major version - use get/setLeftPadding methods instead.
      */
@@ -132,7 +258,7 @@ public int compare(final Option opt1, final Option opt2) {
     public int defaultLeftPad = DEFAULT_LEFT_PAD;
 
     /**
-     * the number of characters of padding to be prefixed to each description line
+     * The number of characters of padding to be prefixed to each description line
      *
      * @deprecated Scope will be made private for next major version - use get/setDescPadding methods instead.
      */
@@ -140,7 +266,7 @@ public int compare(final Option opt1, final Option opt2) {
     public int defaultDescPad = DEFAULT_DESC_PAD;
 
     /**
-     * the string to display at the beginning of the usage statement
+     * The string to display at the beginning of the usage statement
      *
      * @deprecated Scope will be made private for next major version - use get/setSyntaxPrefix methods instead.
      */
@@ -148,15 +274,15 @@ public int compare(final Option opt1, final Option opt2) {
     public String defaultSyntaxPrefix = DEFAULT_SYNTAX_PREFIX;
 
     /**
-     * the new line string
+     * The new line string
      *
      * @deprecated Scope will be made private for next major version - use get/setNewLine methods instead.
      */
     @Deprecated
-    public String defaultNewLine = System.getProperty("line.separator");
+    public String defaultNewLine = System.lineSeparator();
 
     /**
-     * the shortOpt prefix
+     * The shortOpt prefix
      *
      * @deprecated Scope will be made private for next major version - use get/setOptPrefix methods instead.
      */
@@ -164,7 +290,7 @@ public int compare(final Option opt1, final Option opt2) {
     public String defaultOptPrefix = DEFAULT_OPT_PREFIX;
 
     /**
-     * the long Opt prefix
+     * The long Opt prefix
      *
      * @deprecated Scope will be made private for next major version - use get/setLongOptPrefix methods instead.
      */
@@ -172,7 +298,7 @@ public int compare(final Option opt1, final Option opt2) {
     public String defaultLongOptPrefix = DEFAULT_LONG_OPT_PREFIX;
 
     /**
-     * the name of the argument
+     * The name of the argument
      *
      * @deprecated Scope will be made private for next major version - use get/setArgName methods instead.
      */
@@ -186,9 +312,43 @@ public int compare(final Option opt1, final Option opt2) {
      */
     protected Comparator optionComparator = new OptionComparator();
 
-    /** The separator displayed between the long option and its value. */
+    /**
+     * Function to format the description for a deprecated option.
+     */
+    private final Function deprecatedFormatFunction;
+
+    /**
+     * Where to print help.
+     */
+    private final PrintWriter printWriter;
+
+    /** Flag to determine if since field should be displayed */
+    private final boolean showSince;
+
+    /**
+     * The separator displayed between the long option and its value.
+     */
     private String longOptSeparator = DEFAULT_LONG_OPT_SEPARATOR;
 
+    /**
+     * Constructs a new instance.
+     */
+    public HelpFormatter() {
+        this(null, createDefaultPrintWriter(), false);
+    }
+
+    /**
+     * Constructs a new instance.
+     * @param printWriter TODO
+     */
+    private HelpFormatter(final Function deprecatedFormatFunction, final PrintWriter printWriter, final boolean showSince) {
+        // TODO All other instance HelpFormatter instance variables.
+        // Make HelpFormatter immutable for 2.0
+        this.deprecatedFormatFunction = deprecatedFormatFunction;
+        this.printWriter = printWriter;
+        this.showSince = showSince;
+    }
+
     /**
      * Appends the usage clause for an Option to a StringBuffer.
      *
@@ -196,23 +356,20 @@ public int compare(final Option opt1, final Option opt2) {
      * @param option the Option to append
      * @param required whether the Option is required or not
      */
-    private void appendOption(final StringBuffer buff, final Option option, final boolean required) {
+    private void appendOption(final StringBuilder buff, final Option option, final boolean required) {
         if (!required) {
             buff.append("[");
         }
-
         if (option.getOpt() != null) {
-            buff.append("-").append(option.getOpt());
+            buff.append(OptionFormatter.DEFAULT_OPT_PREFIX).append(option.getOpt());
         } else {
-            buff.append("--").append(option.getLongOpt());
+            buff.append(OptionFormatter.DEFAULT_LONG_OPT_PREFIX).append(option.getLongOpt());
         }
-
         // if the Option has a value and a non blank argname
         if (option.hasArg() && (option.getArgName() == null || !option.getArgName().isEmpty())) {
             buff.append(option.getOpt() == null ? longOptSeparator : " ");
             buff.append("<").append(option.getArgName() != null ? option.getArgName() : getArgName()).append(">");
         }
-
         // if the Option is not a required option
         if (!required) {
             buff.append("]");
@@ -223,16 +380,15 @@ private void appendOption(final StringBuffer buff, final Option option, final bo
      * Appends the usage clause for an OptionGroup to a StringBuffer. The clause is wrapped in square brackets if the group
      * is required. The display of the options is handled by appendOption
      *
-     * @param buff the StringBuffer to append to
-     * @param group the group to append
-     * @see #appendOption(StringBuffer,Option,boolean)
+     * @param buff the StringBuilder to append to
+     * @param optionGroup the group to append
+     * @see #appendOption(StringBuilder,Option,boolean)
      */
-    private void appendOptionGroup(final StringBuffer buff, final OptionGroup group) {
-        if (!group.isRequired()) {
+    private void appendOptionGroup(final StringBuilder buff, final OptionGroup optionGroup) {
+        if (!optionGroup.isRequired()) {
             buff.append("[");
         }
-
-        final List optList = new ArrayList<>(group.getOptions());
+        final List optList = new ArrayList<>(optionGroup.getOptions());
         if (getOptionComparator() != null) {
             Collections.sort(optList, getOptionComparator());
         }
@@ -240,31 +396,160 @@ private void appendOptionGroup(final StringBuffer buff, final OptionGroup group)
         for (final Iterator it = optList.iterator(); it.hasNext();) {
             // whether the option is required or not is handled at group level
             appendOption(buff, it.next(), true);
+            if (it.hasNext()) {
+                buff.append(AbstractHelpFormatter.DEFAULT_OPTION_GROUP_SEPARATOR);
+            }
+        }
+        if (!optionGroup.isRequired()) {
+            buff.append("]");
+        }
+    }
+
+    /**
+     * Renders the specified Options and return the rendered Options in a StringBuffer.
+     *
+     * @param sb The StringBuffer to place the rendered Options into.
+     * @param width The number of characters to display per line
+     * @param options The command line Options
+     * @param leftPad the number of characters of padding to be prefixed to each line
+     * @param descPad the number of characters of padding to be prefixed to each description line
+     * @return the StringBuffer with the rendered Options contents.
+     * @throws IOException if an I/O error occurs.
+     */
+     A appendOptions(final A sb, final int width, final Options options, final int leftPad, final int descPad) throws IOException {
+        final String lpad = createPadding(leftPad);
+        final String dpad = createPadding(descPad);
+        // first create list containing only -a,--aaa where
+        // -a is opt and --aaa is long opt; in parallel look for
+        // the longest opt string this list will be then used to
+        // sort options ascending
+        int max = 0;
+        final int maxSince = showSince ? determineMaxSinceLength(options) + leftPad : 0;
+        final List prefixList = new ArrayList<>();
+        final List optList = options.helpOptions();
+        if (getOptionComparator() != null) {
+            Collections.sort(optList, getOptionComparator());
+        }
+        for (final Option option : optList) {
+            final StringBuilder optBuf = new StringBuilder();
+            if (option.getOpt() == null) {
+                optBuf.append(lpad).append("   ").append(getLongOptPrefix()).append(option.getLongOpt());
+            } else {
+                optBuf.append(lpad).append(getOptPrefix()).append(option.getOpt());
+                if (option.hasLongOpt()) {
+                    optBuf.append(',').append(getLongOptPrefix()).append(option.getLongOpt());
+                }
+            }
+            if (option.hasArg()) {
+                final String argName = option.getArgName();
+                if (argName != null && argName.isEmpty()) {
+                    // if the option has a blank argname
+                    optBuf.append(' ');
+                } else {
+                    optBuf.append(option.hasLongOpt() ? longOptSeparator : " ");
+                    optBuf.append("<").append(argName != null ? option.getArgName() : getArgName()).append(">");
+                }
+            }
+
+            prefixList.add(optBuf);
+            max = Math.max(optBuf.length() + maxSince, max);
+        }
+        final int nextLineTabStop = max + descPad;
+        if (showSince) {
+            final StringBuilder optHeader = new StringBuilder(HEADER_OPTIONS).append(createPadding(max - maxSince - HEADER_OPTIONS.length() + leftPad))
+                    .append(HEADER_SINCE);
+            optHeader.append(createPadding(max - optHeader.length())).append(lpad).append(HEADER_DESCRIPTION);
+            appendWrappedText(sb, width, nextLineTabStop, optHeader.toString());
+            sb.append(getNewLine());
+        }
+
+        int x = 0;
+        for (final Iterator it = optList.iterator(); it.hasNext();) {
+            final Option option = it.next();
+            final StringBuilder optBuf = new StringBuilder(prefixList.get(x++).toString());
+            if (optBuf.length() < max) {
+                optBuf.append(createPadding(max - maxSince - optBuf.length()));
+                if (showSince) {
+                    optBuf.append(lpad).append(option.getSince() == null ? OptionFormatter.DEFAULT_OPT_PREFIX : option.getSince());
+                }
+                optBuf.append(createPadding(max - optBuf.length()));
+            }
+            optBuf.append(dpad);
 
+            if (deprecatedFormatFunction != null && option.isDeprecated()) {
+                optBuf.append(deprecatedFormatFunction.apply(option).trim());
+            } else if (option.getDescription() != null) {
+                optBuf.append(option.getDescription());
+            }
+            appendWrappedText(sb, width, nextLineTabStop, optBuf.toString());
             if (it.hasNext()) {
-                buff.append(" | ");
+                sb.append(getNewLine());
             }
         }
+        return sb;
+    }
 
-        if (!group.isRequired()) {
-            buff.append("]");
+    /**
+     * Renders the specified text and return the rendered Options in a StringBuffer.
+     *
+     * @param  The Appendable implementation.
+     * @param appendable The StringBuffer to place the rendered text into.
+     * @param width The number of characters to display per line
+     * @param nextLineTabStop The position on the next line for the first tab.
+     * @param text The text to be rendered.
+     * @return the StringBuffer with the rendered Options contents.
+     * @throws IOException if an I/O error occurs.
+     */
+     A appendWrappedText(final A appendable, final int width, final int nextLineTabStop, final String text) throws IOException {
+        if (width <= 0) {
+            return appendable;
+        }
+        String render = text;
+        int nextLineTabStopPos = nextLineTabStop;
+        int pos = findWrapPos(render, width, 0);
+        if (pos == -1) {
+            appendable.append(rtrim(render));
+            return appendable;
+        }
+        appendable.append(rtrim(render.substring(0, pos))).append(getNewLine());
+        if (nextLineTabStopPos >= width) {
+            // stops infinite loop happening
+            nextLineTabStopPos = 1;
+        }
+        // all following lines must be padded with nextLineTabStop space characters
+        final String padding = createPadding(nextLineTabStopPos);
+        while (true) {
+            render = padding + render.substring(pos).trim();
+            pos = findWrapPos(render, width, 0);
+            if (pos == -1) {
+                appendable.append(render);
+                return appendable;
+            }
+            if (render.length() > width && pos == nextLineTabStopPos - 1) {
+                pos = width;
+            }
+            appendable.append(rtrim(render.substring(0, pos))).append(getNewLine());
         }
     }
 
     /**
-     * Return a String of padding of length {@code len}.
+     * Creates a String of padding of length {@code len}.
      *
      * @param len The length of the String of padding to create.
-     *
      * @return The String of padding
      */
     protected String createPadding(final int len) {
         final char[] padding = new char[len];
         Arrays.fill(padding, ' ');
-
         return new String(padding);
     }
 
+    private int determineMaxSinceLength(final Options options) {
+        final int minLen = HEADER_SINCE.length();
+        final int len = options.getOptions().stream().map(o -> o.getSince() == null ? minLen : o.getSince().length()).max(Integer::compareTo).orElse(minLen);
+        return len < minLen ? minLen : len;
+    }
+
     /**
      * Finds the next text wrap position after {@code startPos} for the text in {@code text} with the column width
      * {@code width}. The wrap point is the last position before startPos+width having a whitespace character (space,
@@ -277,36 +562,30 @@ protected String createPadding(final int len) {
      */
     protected int findWrapPos(final String text, final int width, final int startPos) {
         // the line ends before the max wrap pos or a new line char found
-        int pos = text.indexOf('\n', startPos);
+        int pos = text.indexOf(Char.LF, startPos);
         if (pos != -1 && pos <= width) {
             return pos + 1;
         }
-
-        pos = text.indexOf('\t', startPos);
+        pos = text.indexOf(Char.TAB, startPos);
         if (pos != -1 && pos <= width) {
             return pos + 1;
         }
-
         if (startPos + width >= text.length()) {
             return -1;
         }
-
         // look for the last whitespace character before startPos+width
         for (pos = startPos + width; pos >= startPos; --pos) {
             final char c = text.charAt(pos);
-            if (c == ' ' || c == '\n' || c == '\r') {
+            if (c == Char.SP || c == Char.LF || c == Char.CR) {
                 break;
             }
         }
-
         // if we found it - just return
         if (pos > startPos) {
             return pos;
         }
-
         // if we didn't find one, simply chop at startPos+width
         pos = startPos + width;
-
         return pos == text.length() ? -1 : pos;
     }
 
@@ -404,8 +683,8 @@ public int getWidth() {
     }
 
     /**
-     * Print the help for {@code options} with the specified command line syntax. This method prints help information
-     * to System.out.
+     * Prints the help for {@code options} with the specified command line syntax. This method prints help information
+     * to  {@link System#out}  by default.
      *
      * @param width the number of characters to be displayed on each line
      * @param cmdLineSyntax the syntax for this application
@@ -418,8 +697,8 @@ public void printHelp(final int width, final String cmdLineSyntax, final String
     }
 
     /**
-     * Print the help for {@code options} with the specified command line syntax. This method prints help information
-     * to System.out.
+     * Prints the help for {@code options} with the specified command line syntax. This method prints help information
+     * to {@link System#out} by default.
      *
      * @param width the number of characters to be displayed on each line
      * @param cmdLineSyntax the syntax for this application
@@ -430,14 +709,13 @@ public void printHelp(final int width, final String cmdLineSyntax, final String
      */
     public void printHelp(final int width, final String cmdLineSyntax, final String header, final Options options, final String footer,
         final boolean autoUsage) {
-        final PrintWriter pw = new PrintWriter(System.out);
-
+        final PrintWriter pw = new PrintWriter(printWriter);
         printHelp(pw, width, cmdLineSyntax, header, options, getLeftPadding(), getDescPadding(), footer, autoUsage);
         pw.flush();
     }
 
     /**
-     * Print the help for {@code options} with the specified command line syntax.
+     * Prints the help for {@code options} with the specified command line syntax.
      *
      * @param pw the writer to which the help will be written
      * @param width the number of characters to be displayed on each line
@@ -447,7 +725,6 @@ public void printHelp(final int width, final String cmdLineSyntax, final String
      * @param leftPad the number of characters of padding to be prefixed to each line
      * @param descPad the number of characters of padding to be prefixed to each description line
      * @param footer the banner to display at the end of the help
-     *
      * @throws IllegalStateException if there is no room to print a line
      */
     public void printHelp(final PrintWriter pw, final int width, final String cmdLineSyntax, final String header, final Options options, final int leftPad,
@@ -456,7 +733,7 @@ public void printHelp(final PrintWriter pw, final int width, final String cmdLin
     }
 
     /**
-     * Print the help for {@code options} with the specified command line syntax.
+     * Prints the help for {@code options} with the specified command line syntax.
      *
      * @param pw the writer to which the help will be written
      * @param width the number of characters to be displayed on each line
@@ -467,35 +744,30 @@ public void printHelp(final PrintWriter pw, final int width, final String cmdLin
      * @param descPad the number of characters of padding to be prefixed to each description line
      * @param footer the banner to display at the end of the help
      * @param autoUsage whether to print an automatically generated usage statement
-     *
      * @throws IllegalStateException if there is no room to print a line
      */
     public void printHelp(final PrintWriter pw, final int width, final String cmdLineSyntax, final String header, final Options options, final int leftPad,
         final int descPad, final String footer, final boolean autoUsage) {
-        if (cmdLineSyntax == null || cmdLineSyntax.isEmpty()) {
+        if (Util.isEmpty(cmdLineSyntax)) {
             throw new IllegalArgumentException("cmdLineSyntax not provided");
         }
-
         if (autoUsage) {
             printUsage(pw, width, cmdLineSyntax, options);
         } else {
             printUsage(pw, width, cmdLineSyntax);
         }
-
         if (header != null && !header.isEmpty()) {
             printWrapped(pw, width, header);
         }
-
         printOptions(pw, width, options, leftPad, descPad);
-
         if (footer != null && !footer.isEmpty()) {
             printWrapped(pw, width, footer);
         }
     }
 
     /**
-     * Print the help for {@code options} with the specified command line syntax. This method prints help information
-     * to System.out.
+     * Prints the help for {@code options} with the specified command line syntax. This method prints help information
+     * to {@link System#out} by default.
      *
      * @param cmdLineSyntax the syntax for this application
      * @param options the Options instance
@@ -505,8 +777,8 @@ public void printHelp(final String cmdLineSyntax, final Options options) {
     }
 
     /**
-     * Print the help for {@code options} with the specified command line syntax. This method prints help information
-     * to System.out.
+     * Prints the help for {@code options} with the specified command line syntax. This method prints help information
+     * to {@link System#out} by default.
      *
      * @param cmdLineSyntax the syntax for this application
      * @param options the Options instance
@@ -517,8 +789,8 @@ public void printHelp(final String cmdLineSyntax, final Options options, final b
     }
 
     /**
-     * Print the help for {@code options} with the specified command line syntax. This method prints help information
-     * to System.out.
+     * Prints the help for {@code options} with the specified command line syntax. This method prints help information
+     * to {@link System#out} by default.
      *
      * @param cmdLineSyntax the syntax for this application
      * @param header the banner to display at the beginning of the help
@@ -530,8 +802,8 @@ public void printHelp(final String cmdLineSyntax, final String header, final Opt
     }
 
     /**
-     * Print the help for {@code options} with the specified command line syntax. This method prints help information
-     * to System.out.
+     * Prints the help for {@code options} with the specified command line syntax. This method prints help information
+     * to {@link System#out} by default.
      *
      * @param cmdLineSyntax the syntax for this application
      * @param header the banner to display at the beginning of the help
@@ -544,7 +816,7 @@ public void printHelp(final String cmdLineSyntax, final String header, final Opt
     }
 
     /**
-     * Print the help for the specified Options to the specified writer, using the specified width, left padding and
+     * Prints the help for the specified Options to the specified writer, using the specified width, left padding and
      * description padding.
      *
      * @param pw The printWriter to write the help to
@@ -554,14 +826,16 @@ public void printHelp(final String cmdLineSyntax, final String header, final Opt
      * @param descPad the number of characters of padding to be prefixed to each description line
      */
     public void printOptions(final PrintWriter pw, final int width, final Options options, final int leftPad, final int descPad) {
-        final StringBuffer sb = new StringBuffer();
-
-        renderOptions(sb, width, options, leftPad, descPad);
-        pw.println(sb.toString());
+        try {
+            pw.println(appendOptions(new StringBuilder(), width, options, leftPad, descPad));
+        } catch (final IOException e) {
+            // Cannot happen
+            throw new UncheckedIOException(e);
+        }
     }
 
     /**
-     * Print the cmdLineSyntax to the specified writer, using the specified width.
+     * Prints the cmdLineSyntax to the specified writer, using the specified width.
      *
      * @param pw The printWriter to write the help to
      * @param width The number of characters per line for the usage statement.
@@ -569,7 +843,6 @@ public void printOptions(final PrintWriter pw, final int width, final Options op
      */
     public void printUsage(final PrintWriter pw, final int width, final String cmdLineSyntax) {
         final int argPos = cmdLineSyntax.indexOf(' ') + 1;
-
         printWrapped(pw, width, getSyntaxPrefix().length() + argPos, getSyntaxPrefix() + cmdLineSyntax);
     }
 
@@ -583,11 +856,9 @@ public void printUsage(final PrintWriter pw, final int width, final String cmdLi
      */
     public void printUsage(final PrintWriter pw, final int width, final String app, final Options options) {
         // initialize the string buffer
-        final StringBuffer buff = new StringBuffer(getSyntaxPrefix()).append(app).append(" ");
-
+        final StringBuilder buff = new StringBuilder(getSyntaxPrefix()).append(app).append(Char.SP);
         // create a list for processed option groups
         final Collection processedGroups = new ArrayList<>();
-
         final List optList = new ArrayList<>(options.getOptions());
         if (getOptionComparator() != null) {
             Collections.sort(optList, getOptionComparator());
@@ -596,32 +867,26 @@ public void printUsage(final PrintWriter pw, final int width, final String app,
         for (final Iterator it = optList.iterator(); it.hasNext();) {
             // get the next Option
             final Option option = it.next();
-
             // check if the option is part of an OptionGroup
             final OptionGroup group = options.getOptionGroup(option);
-
             // if the option is part of a group
             if (group != null) {
                 // and if the group has not already been processed
                 if (!processedGroups.contains(group)) {
                     // add the group to the processed list
                     processedGroups.add(group);
-
                     // add the usage clause
                     appendOptionGroup(buff, group);
                 }
-
                 // otherwise the option was displayed in the group
                 // previously so ignore it.
             }
-
             // if the Option is not part of an OptionGroup
             else {
                 appendOption(buff, option, option.isRequired());
             }
-
             if (it.hasNext()) {
-                buff.append(" ");
+                buff.append(Char.SP);
             }
         }
 
@@ -630,7 +895,7 @@ public void printUsage(final PrintWriter pw, final int width, final String app,
     }
 
     /**
-     * Print the specified text to the specified PrintWriter.
+     * Prints the specified text to the specified PrintWriter.
      *
      * @param pw The printWriter to write the help to
      * @param width The number of characters to display per line
@@ -638,14 +903,11 @@ public void printUsage(final PrintWriter pw, final int width, final String app,
      * @param text The text to be written to the PrintWriter
      */
     public void printWrapped(final PrintWriter pw, final int width, final int nextLineTabStop, final String text) {
-        final StringBuffer sb = new StringBuffer(text.length());
-
-        renderWrappedTextBlock(sb, width, nextLineTabStop, text);
-        pw.println(sb.toString());
+        pw.println(renderWrappedTextBlock(new StringBuilder(text.length()), width, nextLineTabStop, text));
     }
 
     /**
-     * Print the specified text to the specified PrintWriter.
+     * Prints the specified text to the specified PrintWriter.
      *
      * @param pw The printWriter to write the help to
      * @param width The number of characters to display per line
@@ -656,182 +918,84 @@ public void printWrapped(final PrintWriter pw, final int width, final String tex
     }
 
     /**
-     * Render the specified Options and return the rendered Options in a StringBuffer.
+     * Renders the specified Options and return the rendered Options in a StringBuffer.
      *
      * @param sb The StringBuffer to place the rendered Options into.
      * @param width The number of characters to display per line
      * @param options The command line Options
      * @param leftPad the number of characters of padding to be prefixed to each line
      * @param descPad the number of characters of padding to be prefixed to each description line
-     *
      * @return the StringBuffer with the rendered Options contents.
      */
     protected StringBuffer renderOptions(final StringBuffer sb, final int width, final Options options, final int leftPad, final int descPad) {
-        final String lpad = createPadding(leftPad);
-        final String dpad = createPadding(descPad);
-
-        // first create list containing only -a,--aaa where
-        // -a is opt and --aaa is long opt; in parallel look for
-        // the longest opt string this list will be then used to
-        // sort options ascending
-        int max = 0;
-        final List prefixList = new ArrayList<>();
-
-        final List optList = options.helpOptions();
-
-        if (getOptionComparator() != null) {
-            Collections.sort(optList, getOptionComparator());
-        }
-
-        for (final Option option : optList) {
-            final StringBuffer optBuf = new StringBuffer();
-
-            if (option.getOpt() == null) {
-                optBuf.append(lpad).append("   ").append(getLongOptPrefix()).append(option.getLongOpt());
-            } else {
-                optBuf.append(lpad).append(getOptPrefix()).append(option.getOpt());
-
-                if (option.hasLongOpt()) {
-                    optBuf.append(',').append(getLongOptPrefix()).append(option.getLongOpt());
-                }
-            }
-
-            if (option.hasArg()) {
-                final String argName = option.getArgName();
-                if (argName != null && argName.isEmpty()) {
-                    // if the option has a blank argname
-                    optBuf.append(' ');
-                } else {
-                    optBuf.append(option.hasLongOpt() ? longOptSeparator : " ");
-                    optBuf.append("<").append(argName != null ? option.getArgName() : getArgName()).append(">");
-                }
-            }
-
-            prefixList.add(optBuf);
-            max = optBuf.length() > max ? optBuf.length() : max;
-        }
-
-        int x = 0;
-
-        for (final Iterator it = optList.iterator(); it.hasNext();) {
-            final Option option = it.next();
-            final StringBuilder optBuf = new StringBuilder(prefixList.get(x++).toString());
-
-            if (optBuf.length() < max) {
-                optBuf.append(createPadding(max - optBuf.length()));
-            }
-
-            optBuf.append(dpad);
-
-            final int nextLineTabStop = max + descPad;
-
-            if (option.getDescription() != null) {
-                optBuf.append(option.getDescription());
-            }
-
-            renderWrappedText(sb, width, nextLineTabStop, optBuf.toString());
-
-            if (it.hasNext()) {
-                sb.append(getNewLine());
-            }
+        try {
+            return appendOptions(sb, width, options, leftPad, descPad);
+        } catch (final IOException e) {
+            // Cannot happen
+            throw new UncheckedIOException(e);
         }
-
-        return sb;
     }
 
     /**
-     * Render the specified text and return the rendered Options in a StringBuffer.
+     * Renders the specified text and return the rendered Options in a StringBuffer.
      *
      * @param sb The StringBuffer to place the rendered text into.
      * @param width The number of characters to display per line
      * @param nextLineTabStop The position on the next line for the first tab.
      * @param text The text to be rendered.
-     *
      * @return the StringBuffer with the rendered Options contents.
      */
-    protected StringBuffer renderWrappedText(final StringBuffer sb, final int width, int nextLineTabStop, String text) {
-        int pos = findWrapPos(text, width, 0);
-
-        if (pos == -1) {
-            sb.append(rtrim(text));
-
-            return sb;
-        }
-        sb.append(rtrim(text.substring(0, pos))).append(getNewLine());
-
-        if (nextLineTabStop >= width) {
-            // stops infinite loop happening
-            nextLineTabStop = 1;
-        }
-
-        // all following lines must be padded with nextLineTabStop space characters
-        final String padding = createPadding(nextLineTabStop);
-
-        while (true) {
-            text = padding + text.substring(pos).trim();
-            pos = findWrapPos(text, width, 0);
-
-            if (pos == -1) {
-                sb.append(text);
-
-                return sb;
-            }
-
-            if (text.length() > width && pos == nextLineTabStop - 1) {
-                pos = width;
-            }
-
-            sb.append(rtrim(text.substring(0, pos))).append(getNewLine());
+    protected StringBuffer renderWrappedText(final StringBuffer sb, final int width, final int nextLineTabStop, final String text) {
+        try {
+            return appendWrappedText(sb, width, nextLineTabStop, text);
+        } catch (final IOException e) {
+            // Cannot happen.
+            throw new UncheckedIOException(e);
         }
     }
 
     /**
-     * Render the specified text width a maximum width. This method differs from renderWrappedText by not removing leading
+     * Renders the specified text width a maximum width. This method differs from renderWrappedText by not removing leading
      * spaces after a new line.
      *
-     * @param sb The StringBuffer to place the rendered text into.
+     * @param appendable The StringBuffer to place the rendered text into.
      * @param width The number of characters to display per line
      * @param nextLineTabStop The position on the next line for the first tab.
      * @param text The text to be rendered.
      */
-    private Appendable renderWrappedTextBlock(final StringBuffer sb, final int width, final int nextLineTabStop, final String text) {
+    private  A renderWrappedTextBlock(final A appendable, final int width, final int nextLineTabStop, final String text) {
         try {
             final BufferedReader in = new BufferedReader(new StringReader(text));
             String line;
             boolean firstLine = true;
             while ((line = in.readLine()) != null) {
                 if (!firstLine) {
-                    sb.append(getNewLine());
+                    appendable.append(getNewLine());
                 } else {
                     firstLine = false;
                 }
-                renderWrappedText(sb, width, nextLineTabStop, line);
+                appendWrappedText(appendable, width, nextLineTabStop, line);
             }
         } catch (final IOException e) { // NOPMD
             // cannot happen
         }
-
-        return sb;
+        return appendable;
     }
 
     /**
-     * Remove the trailing whitespace from the specified String.
+     * Removes the trailing whitespace from the specified String.
      *
      * @param s The String to remove the trailing padding from.
-     *
      * @return The String of without the trailing padding
      */
     protected String rtrim(final String s) {
-        if (s == null || s.isEmpty()) {
+        if (Util.isEmpty(s)) {
             return s;
         }
-
         int pos = s.length();
-
         while (pos > 0 && Character.isWhitespace(s.charAt(pos - 1))) {
             --pos;
         }
-
         return s.substring(0, pos);
     }
 
@@ -872,7 +1036,7 @@ public void setLongOptPrefix(final String prefix) {
     }
 
     /**
-     * Set the separator displayed between a long option and its value. Ensure that the separator specified is supported by
+     * Sets the separator displayed between a long option and its value. Ensure that the separator specified is supported by
      * the parser used, typically ' ' or '='.
      *
      * @param longOptSeparator the separator, typically ' ' or '='.
@@ -892,7 +1056,7 @@ public void setNewLine(final String newline) {
     }
 
     /**
-     * Set the comparator used to sort the options when they output in help text. Passing in a null comparator will keep the
+     * Sets the comparator used to sort the options when they output in help text. Passing in a null comparator will keep the
      * options in the order they were declared.
      *
      * @param comparator the {@link Comparator} to use for sorting the options
diff --git a/src/main/java/org/apache/commons/cli/MissingArgumentException.java b/src/main/java/org/apache/commons/cli/MissingArgumentException.java
index 87609d8d0..5deffa672 100644
--- a/src/main/java/org/apache/commons/cli/MissingArgumentException.java
+++ b/src/main/java/org/apache/commons/cli/MissingArgumentException.java
@@ -6,7 +6,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
   (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
+      https://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,
@@ -30,7 +30,7 @@ public class MissingArgumentException extends ParseException {
     private Option option;
 
     /**
-     * Construct a new {@code MissingArgumentException} with the specified detail message.
+     * Constructs a new {@code MissingArgumentException} with the specified detail message.
      *
      * @param option the option requiring an argument
      * @since 1.2
@@ -41,7 +41,7 @@ public MissingArgumentException(final Option option) {
     }
 
     /**
-     * Construct a new {@code MissingArgumentException} with the specified detail message.
+     * Constructs a new {@code MissingArgumentException} with the specified detail message.
      *
      * @param message the detail message
      */
@@ -50,7 +50,7 @@ public MissingArgumentException(final String message) {
     }
 
     /**
-     * Return the option requiring an argument that wasn't provided on the command line.
+     * Gets the option requiring an argument that wasn't provided on the command line.
      *
      * @return the related option
      * @since 1.2
diff --git a/src/main/java/org/apache/commons/cli/MissingOptionException.java b/src/main/java/org/apache/commons/cli/MissingOptionException.java
index 521cf2e71..7ab196564 100644
--- a/src/main/java/org/apache/commons/cli/MissingOptionException.java
+++ b/src/main/java/org/apache/commons/cli/MissingOptionException.java
@@ -6,7 +6,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
   (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
+      https://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,
@@ -17,13 +17,13 @@ Licensed to the Apache Software Foundation (ASF) under one or more
 
 package org.apache.commons.cli;
 
-import java.util.Iterator;
 import java.util.List;
 
 /**
  * Thrown when a required option has not been provided.
  */
 public class MissingOptionException extends ParseException {
+
     /** This exception {@code serialVersionUID}. */
     private static final long serialVersionUID = 8161889051578563249L;
 
@@ -31,22 +31,12 @@ public class MissingOptionException extends ParseException {
      * Build the exception message from the specified list of options.
      *
      * @param missingOptions the list of missing options and groups
-     * @since 1.2
      */
     private static String createMessage(final List missingOptions) {
         final StringBuilder buf = new StringBuilder("Missing required option");
-        buf.append(missingOptions.size() == 1 ? "" : "s");
-        buf.append(": ");
-
-        final Iterator it = missingOptions.iterator();
-        while (it.hasNext()) {
-            buf.append(it.next());
-            if (it.hasNext()) {
-                buf.append(", ");
-            }
-        }
-
-        return buf.toString();
+        buf.append(missingOptions.size() == 1 ? "" : "s").append(": ");
+        final String string = missingOptions.toString();
+        return buf.append(string.substring(1, string.length() - 1)).toString();
     }
 
     /** The list of missing options and groups */
@@ -64,7 +54,7 @@ public MissingOptionException(final List missingOptions) {
     }
 
     /**
-     * Construct a new {@code MissingSelectedException} with the specified detail message.
+     * Constructs a new {@code MissingSelectedException} with the specified detail message.
      *
      * @param message the detail message
      */
diff --git a/src/main/java/org/apache/commons/cli/Option.java b/src/main/java/org/apache/commons/cli/Option.java
index a1c2e4ee7..3f16186ab 100644
--- a/src/main/java/org/apache/commons/cli/Option.java
+++ b/src/main/java/org/apache/commons/cli/Option.java
@@ -6,7 +6,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
   (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
+      https://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,
@@ -17,22 +17,22 @@ Licensed to the Apache Software Foundation (ASF) under one or more
 
 package org.apache.commons.cli;
 
+import static org.apache.commons.cli.Util.EMPTY_STRING_ARRAY;
+
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Supplier;
 
 /**
- * Describes a single command-line option. It maintains information regarding the short-name of the option, the
- * long-name, if any exists, a flag indicating if an argument is required for this option, and a self-documenting
- * description of the option.
+ * Describes a single command-line option. It maintains information regarding the short-name of the option, the long-name, if any exists, a flag indicating if
+ * an argument is required for this option, and a self-documenting description of the option.
  * 

- * An Option is not created independently, but is created through an instance of {@link Options}. An Option is required
- * to have at least a short or a long-name.
+ * An Option is not created independently, but is created through an instance of {@link Options}. An Option is required to have at least a short or a long-name.
  * 
  * 

- * Note: once an {@link Option} has been added to an instance of {@link Options}, its required flag cannot be
- * changed.
+ * Note: once an {@link Option} has been added to an instance of {@link Options}, its required flag cannot be changed.
  * 
  *
  * @see org.apache.commons.cli.Options
@@ -41,7 +41,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
 public class Option implements Cloneable, Serializable {
 
     /**
-     * A nested builder class to create {@code Option} instances using descriptive methods.
+     * Builds {@code Option} instances using descriptive methods.
      * 

      * Example usage:
      * 
@@ -52,40 +52,62 @@ public class Option implements Cloneable, Serializable {
      *
      * @since 1.3
      */
-    public static final class Builder {
+    public static final class Builder implements Supplier {
 
-        /** The name of the option */
-        private String option;
+        /** The default type. */
+        private static final Class DEFAULT_TYPE = String.class;
 
-        /** description of the option */
-        private String description;
+        /**
+         * Returns the input Class or the default type (String) if null.
+         *
+         * @param type the candidate Class.
+         * @return the input Class or the default type (String) if null.
+         */
+        private static Class toType(final Class type) {
+            return type != null ? type : DEFAULT_TYPE;
+        }
 
-        /** The long representation of the option */
-        private String longOption;
+        /** The number of argument values this option can have. */
+        private int argCount = UNINITIALIZED;
 
-        /** The name of the argument for this option */
+        /** The name of the argument for this option. */
         private String argName;
 
-        /** specifies whether this option is required to be present */
-        private boolean required;
+        /** The converter to convert to type. **/
+        private Converter converter;
+
+        /** Specifies whether this option is deprecated. */
+        private DeprecatedAttributes deprecated;
 
-        /** specifies whether the argument value of this Option is optional */
+        /** Description of the option. */
+        private String description;
+
+        /** The long representation of the option. */
+        private String longOption;
+
+        /** The name of the option. */
+        private String option;
+
+        /** Specifies whether the argument value of this Option is optional. */
         private boolean optionalArg;
 
-        /** The number of argument values this option can have */
-        private int argCount = UNINITIALIZED;
+        /** Specifies whether this option is required to be present. */
+        private boolean required;
+
+        /** Specifies the version when this option was added.  May be null */
+        private String since;
 
-        /** The type of this Option */
-        private Class type = String.class;
+        /** The type of this Option. */
+        private Class type = DEFAULT_TYPE;
 
-        /** The character that is the value separator */
+        /** The character that is the value separator. */
         private char valueSeparator;
 
         /**
          * Constructs a new {@code Builder} with the minimum required parameters for an {@code Option} instance.
          *
-         * @param option short representation of the option
-         * @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}
+         * @param option short representation of the option.
+         * @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}.
          */
         private Builder(final String option) throws IllegalArgumentException {
             option(option);
@@ -95,7 +117,7 @@ private Builder(final String option) throws IllegalArgumentException {
          * Sets the display name for the argument value.
          *
          * @param argName the display name for the argument value.
-         * @return this builder, to allow method chaining
+         * @return {@code this} instance..
          */
         public Builder argName(final String argName) {
             this.argName = argName;
@@ -105,21 +127,57 @@ public Builder argName(final String argName) {
         /**
          * Constructs an Option with the values declared by this {@link Builder}.
          *
-         * @return the new {@link Option}
-         * @throws IllegalArgumentException if neither {@code opt} or {@code longOpt} has been set
+         * @return the new {@link Option}.
+         * @throws IllegalArgumentException if neither {@code opt} or {@code longOpt} has been set.
+         * @deprecated Use {@link #get()}.
          */
+        @Deprecated
         public Option build() {
-            if (option == null && longOption == null) {
-                throw new IllegalArgumentException("Either opt or longOpt must be specified");
-            }
-            return new Option(this);
+            return get();
+        }
+
+        /**
+         * Sets the converter for the option.
+         * 

+         * Note: See {@link TypeHandler} for serialization discussion.
+         * 
+         *
+         * @param converter the Converter to use.
+         * @return {@code this} instance..
+         * @since 1.7.0
+         */
+        public Builder converter(final Converter converter) {
+            this.converter = converter;
+            return this;
+        }
+
+        /**
+         * Marks this Option as deprecated.
+         *
+         * @return this builder.
+         * @since 1.7.0
+         */
+        public Builder deprecated() {
+            return deprecated(DeprecatedAttributes.DEFAULT);
+        }
+
+        /**
+         * Sets whether the Option is deprecated.
+         *
+         * @param deprecated specifies whether the Option is deprecated.
+         * @return this builder.
+         * @since 1.7.0
+         */
+        public Builder deprecated(final DeprecatedAttributes deprecated) {
+            this.deprecated = deprecated;
+            return this;
         }
 
         /**
          * Sets the description for this option.
          *
          * @param description the description of the option.
-         * @return this builder, to allow method chaining
+         * @return {@code this} instance..
          */
         public Builder desc(final String description) {
             this.description = description;
@@ -127,64 +185,75 @@ public Builder desc(final String description) {
         }
 
         /**
-         * Indicates that the Option will require an argument.
+         * Constructs an Option with the values declared by this {@link Builder}.
+         *
+         * @return the new {@link Option}.
+         * @throws IllegalStateException if neither {@code opt} or {@code longOpt} has been set.
+         */
+        @Override
+        public Option get() {
+            return new Option(this);
+        }
+
+        /**
+         * Tests whether the Option will require an argument.
          *
-         * @return this builder, to allow method chaining
+         * @return {@code this} instance..
          */
         public Builder hasArg() {
             return hasArg(true);
         }
 
         /**
-         * Indicates if the Option has an argument or not.
+         * Tests whether the Option has an argument or not.
          *
-         * @param hasArg specifies whether the Option takes an argument or not
-         * @return this builder, to allow method chaining
+         * @param hasArg specifies whether the Option takes an argument or not.
+         * @return {@code this} instance..
          */
         public Builder hasArg(final boolean hasArg) {
             // set to UNINITIALIZED when no arg is specified to be compatible with OptionBuilder
-            argCount = hasArg ? 1 : Option.UNINITIALIZED;
+            argCount = hasArg ? 1 : UNINITIALIZED;
             return this;
         }
 
         /**
-         * Indicates that the Option can have unlimited argument values.
+         * Tests whether the Option can have unlimited argument values.
          *
-         * @return this builder, to allow method chaining
+         * @return this builder.
          */
         public Builder hasArgs() {
-            argCount = Option.UNLIMITED_VALUES;
+            argCount = UNLIMITED_VALUES;
             return this;
         }
 
         /**
          * Sets the long name of the Option.
          *
-         * @param longOpt the long name of the Option
-         * @return this builder, to allow method chaining
+         * @param longOption the long name of the Option
+         * @return this builder.
          */
-        public Builder longOpt(final String longOpt) {
-            this.longOption = longOpt;
+        public Builder longOpt(final String longOption) {
+            this.longOption = longOption;
             return this;
         }
 
         /**
          * Sets the number of argument values the Option can take.
          *
-         * @param numberOfArgs the number of argument values
-         * @return this builder, to allow method chaining
+         * @param argCount the number of argument values
+         * @return this builder.
          */
-        public Builder numberOfArgs(final int numberOfArgs) {
-            this.argCount = numberOfArgs;
+        public Builder numberOfArgs(final int argCount) {
+            this.argCount = argCount;
             return this;
         }
 
         /**
          * Sets the name of the Option.
          *
-         * @param option the name of the Option
-         * @return this builder, to allow method chaining
-         * @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}
+         * @param option the name of the Option.
+         * @return this builder.
+         * @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}.
          * @since 1.5.0
          */
         public Builder option(final String option) throws IllegalArgumentException {
@@ -195,93 +264,110 @@ public Builder option(final String option) throws IllegalArgumentException {
         /**
          * Sets whether the Option can have an optional argument.
          *
-         * @param isOptional specifies whether the Option can have an optional argument.
-         * @return this builder, to allow method chaining
+         * @param optionalArg specifies whether the Option can have an optional argument.
+         * @return this builder.
          */
-        public Builder optionalArg(final boolean isOptional) {
-            this.optionalArg = isOptional;
+        public Builder optionalArg(final boolean optionalArg) {
+            if (optionalArg && argCount == UNINITIALIZED) {
+                argCount = 1;
+            }
+            this.optionalArg = optionalArg;
             return this;
         }
 
         /**
          * Marks this Option as required.
          *
-         * @return this builder, to allow method chaining
+         * @return this builder.
          */
         public Builder required() {
             return required(true);
         }
 
         /**
-         * Sets whether the Option is mandatory.
+         * Sets whether the Option is required.
          *
-         * @param required specifies whether the Option is mandatory
-         * @return this builder, to allow method chaining
+         * @param required specifies whether the Option is required.
+         * @return this builder.
          */
         public Builder required(final boolean required) {
             this.required = required;
             return this;
         }
 
+        /** Sets the version number when this option was first defined."
+         *
+         * @param since the version number when this option was first defined.
+         * @return this builder.
+         */
+        public Builder since(final String since) {
+            this.since = since;
+            return this;
+        }
+
         /**
          * Sets the type of the Option.
          *
-         * @param type the type of the Option
-         * @return this builder, to allow method chaining
+         * @param type the type of the Option.
+         * @return this builder.
          */
         public Builder type(final Class type) {
-            this.type = type;
+            this.type = toType(type);
             return this;
         }
 
         /**
          * The Option will use '=' as a means to separate argument value.
          *
-         * @return this builder, to allow method chaining
+         * @return this builder.
          */
         public Builder valueSeparator() {
-            return valueSeparator('=');
+            return valueSeparator(Char.EQUAL);
         }
 
         /**
          * The Option will use {@code sep} as a means to separate argument values.
          * 

-         * Example:
+         * Example:
          * 
          *
          * 
          * Option opt = Option.builder("D").hasArgs().valueSeparator('=').build();
          * Options options = new Options();
          * options.addOption(opt);
-         * String[] args = {"-Dkey=value"};
+         * String[] args = { "-Dkey=value" };
          * CommandLineParser parser = new DefaultParser();
          * CommandLine line = parser.parse(options, args);
          * String propertyName = line.getOptionValues("D")[0]; // will be "key"
          * String propertyValue = line.getOptionValues("D")[1]; // will be "value"
          * 
          *
-         * @param sep The value separator.
-         * @return this builder, to allow method chaining
+         * @param valueSeparator The value separator.
+         * @return this builder.
          */
-        public Builder valueSeparator(final char sep) {
-            valueSeparator = sep;
+        public Builder valueSeparator(final char valueSeparator) {
+            this.valueSeparator = valueSeparator;
             return this;
         }
-    }
 
-    /** Specifies the number of argument values has not been specified */
-    public static final int UNINITIALIZED = -1;
+    }
 
-    /** Specifies the number of argument values is infinite */
-    public static final int UNLIMITED_VALUES = -2;
+    /** Empty array. */
+    static final Option[] EMPTY_ARRAY = {};
 
     /** The serial version UID. */
     private static final long serialVersionUID = 1L;
 
+    /** Specifies the number of argument values has not been specified. */
+    public static final int UNINITIALIZED = -1;
+
+    /** Specifies the number of argument values is infinite. */
+    public static final int UNLIMITED_VALUES = -2;
+
     /**
      * Returns a {@link Builder} to create an {@link Option} using descriptive methods.
      *
-     * @return a new {@link Builder} instance
+     * @return a new {@link Builder} instance.
      * @since 1.3
      */
     public static Builder builder() {
@@ -291,35 +377,49 @@ public static Builder builder() {
     /**
      * Returns a {@link Builder} to create an {@link Option} using descriptive methods.
      *
-     * @param option short representation of the option
-     * @return a new {@link Builder} instance
-     * @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}
+     * @param option short representation of the option.
+     * @return a new {@link Builder} instance.
+     * @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}.
      * @since 1.3
      */
     public static Builder builder(final String option) {
         return new Builder(option);
     }
 
-    /** The name of the option. */
-    private final String option;
-
-    /** The long representation of the option. */
-    private String longOption;
+    /** The number of argument values this option can have. */
+    private int argCount = UNINITIALIZED;
 
     /** The name of the argument for this option. */
     private String argName;
 
+    /** The explicit converter for this option. May be null. */
+    private transient Converter converter;
+
+    /**
+     * Specifies whether this option is deprecated, may be null.
+     * 

+     * If you want to serialize this field, use a serialization proxy.
+     * 
+     */
+    private final transient DeprecatedAttributes deprecated;
+
     /** Description of the option. */
     private String description;
 
-    /** Specifies whether this option is required to be present. */
-    private boolean required;
+    /** The long representation of the option. */
+    private String longOption;
+
+    /** The name of the option. */
+    private final String option;
 
     /** Specifies whether the argument value of this Option is optional. */
     private boolean optionalArg;
 
-    /** The number of argument values this option can have. */
-    private int argCount = UNINITIALIZED;
+    /** Specifies whether this option is required to be present. */
+    private boolean required;
+
+    /** Specifies the version when this option was added.  May be null */
+    private String since;
 
     /** The type of this Option. */
     private Class type = String.class;
@@ -328,32 +428,38 @@ public static Builder builder(final String option) {
     private List values = new ArrayList<>();
 
     /** The character that is the value separator. */
-    private char valuesep;
+    private char valueSeparator;
 
     /**
      * Private constructor used by the nested Builder class.
      *
-     * @param builder builder used to create this option
+     * @param builder builder used to create this option.
+     * @throws IllegalStateException if neither {@code opt} or {@code longOpt} has been set.
      */
     private Option(final Builder builder) {
+        if (builder.option == null && builder.longOption == null) {
+            throw new IllegalStateException("Either opt or longOpt must be specified");
+        }
         this.argName = builder.argName;
         this.description = builder.description;
         this.longOption = builder.longOption;
         this.argCount = builder.argCount;
         this.option = builder.option;
         this.optionalArg = builder.optionalArg;
+        this.deprecated = builder.deprecated;
         this.required = builder.required;
+        this.since = builder.since;
         this.type = builder.type;
-        this.valuesep = builder.valueSeparator;
+        this.valueSeparator = builder.valueSeparator;
+        this.converter = builder.converter;
     }
 
     /**
      * Creates an Option using the specified parameters.
      *
-     * @param option short representation of the option
-     * @param hasArg specifies whether the Option takes an argument or not
-     * @param description describes the function of the option
-     *
+     * @param option      short representation of the option.
+     * @param hasArg      specifies whether the Option takes an argument or not.
+     * @param description describes the function of the option.
      * @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}.
      */
     public Option(final String option, final boolean hasArg, final String description) throws IllegalArgumentException {
@@ -363,9 +469,8 @@ public Option(final String option, final boolean hasArg, final String descriptio
     /**
      * Creates an Option using the specified parameters. The option does not take an argument.
      *
-     * @param option short representation of the option
-     * @param description describes the function of the option
-     *
+     * @param option      short representation of the option.
+     * @param description describes the function of the option.
      * @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}.
      */
     public Option(final String option, final String description) throws IllegalArgumentException {
@@ -375,30 +480,28 @@ public Option(final String option, final String description) throws IllegalArgum
     /**
      * Creates an Option using the specified parameters.
      *
-     * @param option short representation of the option
-     * @param longOption the long representation of the option
-     * @param hasArg specifies whether the Option takes an argument or not
-     * @param description describes the function of the option
-     *
+     * @param option      short representation of the option.
+     * @param longOption  the long representation of the option.
+     * @param hasArg      specifies whether the Option takes an argument or not.
+     * @param description describes the function of the option.
      * @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}.
      */
     public Option(final String option, final String longOption, final boolean hasArg, final String description) throws IllegalArgumentException {
         // ensure that the option is valid
+        this.deprecated = null;
         this.option = OptionValidator.validate(option);
         this.longOption = longOption;
-
         // if hasArg is set then the number of arguments is 1
         if (hasArg) {
             this.argCount = 1;
         }
-
         this.description = description;
     }
 
     /**
-     * Tells if the option can accept more arguments.
+     * Tests whether the option can accept more arguments.
      *
-     * @return false if the maximum number of arguments is reached
+     * @return false if the maximum number of arguments is reached.
      * @since 1.3
      */
     boolean acceptsArg() {
@@ -406,52 +509,34 @@ boolean acceptsArg() {
     }
 
     /**
-     * Add the value to this Option. If the number of arguments is greater than zero and there is enough space in the list
-     * then add the value. Otherwise, throw a runtime exception.
-     *
-     * @param value The value to be added to this Option
+     * Adds the value to this Option. If the number of arguments is greater than zero and there is enough space in the list then add the value. Otherwise, throw
+     * a runtime exception.
      *
-     * @since 1.0.1
+     * @param value The value to be added to this Option.
      */
     private void add(final String value) {
         if (!acceptsArg()) {
-            throw new RuntimeException("Cannot add value, list full.");
+            throw new IllegalArgumentException("Cannot add value, list full.");
         }
-
         // store value
         values.add(value);
     }
 
     /**
-     * This method is not intended to be used. It was a piece of internal API that was made public in 1.0. It currently
-     * throws an UnsupportedOperationException.
+     * This method is not intended to be used. It was a piece of internal API that was made public in 1.0. It currently throws an UnsupportedOperationException.
      *
-     * @param value the value to add
-     * @return always throws an {@link UnsupportedOperationException}
-     * @throws UnsupportedOperationException always
+     * @param value the value to add.
+     * @return always throws an {@link UnsupportedOperationException}.
+     * @throws UnsupportedOperationException always.
      * @deprecated Unused.
      */
     @Deprecated
     public boolean addValue(final String value) {
-        throw new UnsupportedOperationException(
-            "The addValue method is not intended for client use. " + "Subclasses should use the addValueForProcessing method instead. ");
-    }
-
-    /**
-     * Adds the specified value to this Option.
-     *
-     * @param value is a/the value of this Option
-     */
-    void addValueForProcessing(final String value) {
-        if (argCount == UNINITIALIZED) {
-            throw new RuntimeException("NO_ARGS_ALLOWED");
-        }
-        processValue(value);
+        throw new UnsupportedOperationException("The addValue method is not intended for client use. Subclasses should use the processValue method instead.");
     }
 
     /**
-     * Clear the Option values. After a parse is complete, these are left with data in them and they need clearing if
-     * another parse is done.
+     * Clears the Option values. After a parse is complete, these are left with data in them and they need clearing if another parse is done.
      *
      * See: CLI-71
      */
@@ -460,13 +545,13 @@ void clearValues() {
     }
 
     /**
-     * A rather odd clone method - due to incorrect code in 1.0 it is public and in 1.1 rather than throwing a
-     * CloneNotSupportedException it throws a RuntimeException so as to maintain backwards compat at the API level.
+     * A rather odd clone method - due to incorrect code in 1.0 it is public and in 1.1 rather than throwing a CloneNotSupportedException it throws a
+     * RuntimeException so as to maintain backwards compatible at the API level.
      *
      * After calling this method, it is very likely you will want to call clearValues().
      *
-     * @return a clone of this Option instance
-     * @throws RuntimeException if a {@link CloneNotSupportedException} has been thrown by {@code super.clone()}
+     * @return a clone of this Option instance.
+     * @throws RuntimeException if a {@link CloneNotSupportedException} has been thrown by {@code super.clone()}.
      */
     @Override
     public Object clone() {
@@ -474,8 +559,8 @@ public Object clone() {
             final Option option = (Option) super.clone();
             option.values = new ArrayList<>(values);
             return option;
-        } catch (final CloneNotSupportedException cnse) {
-            throw new RuntimeException("A CloneNotSupportedException was thrown: " + cnse.getMessage());
+        } catch (final CloneNotSupportedException e) {
+            throw new UnsupportedOperationException(e.getMessage(), e);
         }
     }
 
@@ -504,12 +589,11 @@ public String getArgName() {
      * Gets the number of argument values this Option can take.
      *
      * 

-     * A value equal to the constant {@link #UNINITIALIZED} (= -1) indicates the number of arguments has not been specified.
-     * A value equal to the constant {@link #UNLIMITED_VALUES} (= -2) indicates that this options takes an unlimited amount
-     * of values.
+     * A value equal to the constant {@link #UNINITIALIZED} (= -1) indicates the number of arguments has not been specified. A value equal to the constant
+     * {@link #UNLIMITED_VALUES} (= -2) indicates that this options takes an unlimited amount of values.
      * 
      *
-     * @return num the number of argument values
+     * @return num the number of argument values.
      * @see #UNINITIALIZED
      * @see #UNLIMITED_VALUES
      */
@@ -518,30 +602,50 @@ public int getArgs() {
     }
 
     /**
-     * Gets the self-documenting description of this Option
+     * Gets the value to type converter.
+     *
+     * @return the value to type converter.
+     * @since 1.7.0
+     */
+    public Converter getConverter() {
+        return converter == null ? TypeHandler.getDefault().getConverter(type) : converter;
+    }
+
+    /**
+     * Gets deprecated attributes if any.
      *
-     * @return The string description of this option
+     * @return boolean deprecated attributes or null.
+     * @since 1.7.0
+     */
+    public DeprecatedAttributes getDeprecated() {
+        return deprecated;
+    }
+
+    /**
+     * Gets the self-documenting description of this Option.
+     *
+     * @return The string description of this option.
      */
     public String getDescription() {
         return description;
     }
 
     /**
-     * Gets the id of this Option. This is only set when the Option shortOpt is a single character. This is used for
-     * switch statements.
+     * Gets the id of this Option. This is only set when the Option shortOpt is a single character. This is used for switch statements.
      *
-     * @return the id of this Option
+     * @return the id of this Option.
      */
     public int getId() {
         return getKey().charAt(0);
     }
 
     /**
-     * Gets the 'unique' Option identifier.
+     * Gets the 'unique' Option identifier. This is the option value if set or the long value if the options value is not set.
      *
-     * @return the 'unique' Option identifier
+     * @return the 'unique' Option identifier.
+     * @since 1.7.0
      */
-    String getKey() {
+    public String getKey() {
         // if 'opt' is null, then it is a 'long' option
         return option == null ? longOption : option;
     }
@@ -549,7 +653,7 @@ String getKey() {
     /**
      * Gets the long name of this Option.
      *
-     * @return Long name of this option, or null, if there is no long name
+     * @return Long name of this option, or null, if there is no long name.
      */
     public String getLongOpt() {
         return longOption;
@@ -558,19 +662,27 @@ public String getLongOpt() {
     /**
      * Gets the name of this Option.
      *
-     * It is this String which can be used with {@link CommandLine#hasOption(String opt)} and
-     * {@link CommandLine#getOptionValue(String opt)} to check for existence and argument.
+     * It is this String which can be used with {@link CommandLine#hasOption(String opt)} and {@link CommandLine#getOptionValue(String opt)} to check for
+     * existence and argument.
      *
-     * @return The name of this option
+     * @return The name of this option.
      */
     public String getOpt() {
         return option;
     }
 
+    /**
+     * Gets the version when this option was added.
+     * @return the version when this option was added, or {@code null} if not set.
+     */
+    public String getSince() {
+        return since;
+    }
+
     /**
      * Gets the type of this Option.
      *
-     * @return The type of this option
+     * @return The type of this option.
      */
     public Object getType() {
         return type;
@@ -582,42 +694,38 @@ public Object getType() {
      * @return the value/first value of this Option or {@code null} if there is no value.
      */
     public String getValue() {
-        return hasNoValues() ? null : values.get(0);
+        return isValuesEmpty() ? null : values.get(0);
     }
 
     /**
      * Gets the specified value of this Option or {@code null} if there is no value.
      *
      * @param index The index of the value to be returned.
-     *
      * @return the specified value of this Option or {@code null} if there is no value.
-     *
      * @throws IndexOutOfBoundsException if index is less than 1 or greater than the number of the values for this Option.
      */
     public String getValue(final int index) throws IndexOutOfBoundsException {
-        return hasNoValues() ? null : values.get(index);
+        return isValuesEmpty() ? null : values.get(index);
     }
 
     /**
      * Gets the value/first value of this Option or the {@code defaultValue} if there is no value.
      *
      * @param defaultValue The value to be returned if there is no value.
-     *
      * @return the value/first value of this Option or the {@code defaultValue} if there are no values.
      */
     public String getValue(final String defaultValue) {
         final String value = getValue();
-
         return value != null ? value : defaultValue;
     }
 
     /**
-     * Gets the values of this Option as a String array or null if there are no values
+     * Gets the values of this Option as a String array or an empty array if there are no values.
      *
-     * @return the values of this Option as a String array or null if there are no values
+     * @return the values of this Option as a String array or an empty array if there are no values.
      */
     public String[] getValues() {
-        return hasNoValues() ? null : values.toArray(new String[values.size()]);
+        return isValuesEmpty() ? null : values.toArray(EMPTY_STRING_ARRAY);
     }
 
     /**
@@ -626,29 +734,29 @@ public String[] getValues() {
      * @return the value separator character.
      */
     public char getValueSeparator() {
-        return valuesep;
+        return valueSeparator;
     }
 
     /**
-     * Gets the values of this Option as a List or null if there are no values.
+     * Gets the values of this Option as a List.  Will return an empty list if there are no values.
      *
-     * @return the values of this Option as a List or null if there are no values
+     * @return the values of this Option as a List or an empty List if there are no values.
      */
     public List getValuesList() {
         return values;
     }
 
     /**
-     * Query to see if this Option requires an argument
+     * Tests whether this Option requires an argument.
      *
-     * @return boolean flag indicating if an argument is required
+     * @return boolean flag indicating if an argument is required.
      */
     public boolean hasArg() {
         return argCount > 0 || argCount == UNLIMITED_VALUES;
     }
 
     /**
-     * Returns whether the display name for the argument value has been set.
+     * Tests whether the display name for the argument value has been set.
      *
      * @return if the display name for the argument value has been set.
      */
@@ -657,9 +765,9 @@ public boolean hasArgName() {
     }
 
     /**
-     * Query to see if this Option can take many values.
+     * Tests whether this Option can take many values.
      *
-     * @return boolean flag indicating if multiple values are allowed
+     * @return boolean flag indicating if multiple values are allowed.
      */
     public boolean hasArgs() {
         return argCount > 1 || argCount == UNLIMITED_VALUES;
@@ -671,103 +779,106 @@ public int hashCode() {
     }
 
     /**
-     * Query to see if this Option has a long name
+     * Tests whether this Option has a long name.
      *
-     * @return boolean flag indicating existence of a long name
+     * @return boolean flag indicating existence of a long name.
      */
     public boolean hasLongOpt() {
         return longOption != null;
     }
 
     /**
-     * Returns whether this Option has any values.
+     * Tests whether this Option can have an optional argument.
      *
-     * @return whether this Option has any values.
-     */
-    private boolean hasNoValues() {
-        return values.isEmpty();
-    }
-
-    /**
-     * @return whether this Option can have an optional argument
+     * @return whether this Option can have an optional argument.
      */
     public boolean hasOptionalArg() {
         return optionalArg;
     }
 
     /**
-     * Return whether this Option has specified a value separator.
+     * Tests whether this Option has specified a value separator.
      *
      * @return whether this Option has specified a value separator.
      * @since 1.1
      */
     public boolean hasValueSeparator() {
-        return valuesep > 0;
+        return valueSeparator > 0;
+    }
+
+    /**
+     * Tests whether this Option is deprecated.
+     *
+     * @return boolean flag indicating whether this Option is deprecated.
+     * @since 1.7.0
+     */
+    public boolean isDeprecated() {
+        return deprecated != null;
     }
 
     /**
-     * Query to see if this Option is mandatory
+     * Tests whether this Option is required.
      *
-     * @return boolean flag indicating whether this Option is mandatory
+     * @return boolean flag indicating whether this Option is required.
      */
     public boolean isRequired() {
         return required;
     }
 
     /**
-     * Processes the value. If this Option has a value separator the value will have to be parsed into individual tokens.
-     * When n-1 tokens have been processed and there are more value separators in the value, parsing is ceased and the
-     * remaining characters are added as a single token.
+     * Tests whether this Option has any values.
      *
-     * @param value The String to be processed.
+     * @return whether this Option has any values.
+     */
+    boolean isValuesEmpty() {
+        return values.isEmpty();
+    }
+
+    /**
+     * Processes the value. If this Option has a value separator the value will have to be parsed into individual tokens. When n-1 tokens have been processed
+     * and there are more value separators in the value, parsing is ceased and the remaining characters are added as a single token.
      *
-     * @since 1.0.1
+     * @param value The String to be processed.
      */
-    private void processValue(String value) {
+    void processValue(final String value) {
+        if (argCount == UNINITIALIZED) {
+            throw new IllegalStateException("NO_ARGS_ALLOWED");
+        }
+        String add = Objects.requireNonNull(value, "value");
         // this Option has a separator character
         if (hasValueSeparator()) {
             // get the separator character
             final char sep = getValueSeparator();
-
             // store the index for the value separator
-            int index = value.indexOf(sep);
-
+            int index = add.indexOf(sep);
             // while there are more value separators
             while (index != -1) {
                 // next value to be added
                 if (values.size() == argCount - 1) {
                     break;
                 }
-
                 // store
-                add(value.substring(0, index));
-
+                add(add.substring(0, index));
                 // parse
-                value = value.substring(index + 1);
-
+                add = add.substring(index + 1);
                 // get new index
-                index = value.indexOf(sep);
+                index = add.indexOf(sep);
             }
         }
-
         // store the actual value or the last value that has been parsed
-        add(value);
+        add(add);
     }
 
     /**
-     * Tells if the option requires more arguments to be valid.
+     * Tests whether the option requires more arguments to be valid.
      *
-     * @return false if the option doesn't require more arguments
-     * @since 1.3
+     * @return false if the option doesn't require more arguments.
      */
     boolean requiresArg() {
         if (optionalArg) {
             return false;
         }
-        if (argCount == UNLIMITED_VALUES) {
-            return values.isEmpty();
-        }
-        return acceptsArg();
+        return argCount == UNLIMITED_VALUES ? values.isEmpty() : acceptsArg();
     }
 
     /**
@@ -782,16 +893,26 @@ public void setArgName(final String argName) {
     /**
      * Sets the number of argument values this Option can take.
      *
-     * @param num the number of argument values
+     * @param num the number of argument values.
      */
     public void setArgs(final int num) {
         this.argCount = num;
     }
 
     /**
-     * Sets the self-documenting description of this Option
+     * Sets the value to type converter.
      *
-     * @param description The description of this option
+     * @param converter The converter to convert the string value to the type.
+     * @since 1.7.0
+     */
+    public void setConverter(final Converter converter) {
+        this.converter = converter;
+    }
+
+    /**
+     * Sets the self-documenting description of this Option.
+     *
+     * @param description The description of this option.
      * @since 1.1
      */
     public void setDescription(final String description) {
@@ -801,7 +922,7 @@ public void setDescription(final String description) {
     /**
      * Sets the long name of this Option.
      *
-     * @param longOpt the long name of this Option
+     * @param longOpt the long name of this Option.
      */
     public void setLongOpt(final String longOpt) {
         this.longOption = longOpt;
@@ -819,7 +940,7 @@ public void setOptionalArg(final boolean optionalArg) {
     /**
      * Sets whether this Option is mandatory.
      *
-     * @param required specifies whether this Option is mandatory
+     * @param required specifies whether this Option is mandatory.
      */
     public void setRequired(final boolean required) {
         this.required = required;
@@ -828,22 +949,21 @@ public void setRequired(final boolean required) {
     /**
      * Sets the type of this Option.
      *
-     * @param type the type of this Option
+     * @param type the type of this Option.
      * @since 1.3
      */
     public void setType(final Class type) {
-        this.type = type;
+        this.type = Builder.toType(type);
     }
 
     /**
      * Sets the type of this Option.
      * 

-     * Note: this method is kept for binary compatibility and the input type is supposed to be a {@link Class}
-     * object.
+     * Note: this method is kept for binary compatibility and the input type is supposed to be a {@link Class} object.
      * 
      *
-     * @param type the type of this Option
-     * @deprecated since 1.3, use {@link #setType(Class)} instead
+     * @param type the type of this Option.
+     * @deprecated Since 1.3, use {@link #setType(Class)} instead.
      */
     @Deprecated
     public void setType(final Object type) {
@@ -853,43 +973,58 @@ public void setType(final Object type) {
     /**
      * Sets the value separator. For example if the argument value was a Java property, the value separator would be '='.
      *
-     * @param sep The value separator.
+     * @param valueSeparator The value separator.
      */
-    public void setValueSeparator(final char sep) {
-        this.valuesep = sep;
+    public void setValueSeparator(final char valueSeparator) {
+        this.valueSeparator = valueSeparator;
+    }
+
+    String toDeprecatedString() {
+        if (!isDeprecated()) {
+            return "";
+        }
+        // @formatter:off
+        final StringBuilder buf = new StringBuilder()
+                .append("Option '")
+                .append(option)
+                .append(Char.APOS);
+        // @formatter:on
+        if (longOption != null) {
+            buf.append(Char.APOS).append(longOption).append(Char.APOS);
+        }
+        buf.append(": ").append(deprecated);
+        return buf.toString();
     }
 
     /**
-     * Dump state, suitable for debugging.
+     * Creates a String suitable for debugging.
      *
-     * @return Stringified form of this object
+     * @return a String suitable for debugging.
      */
     @Override
     public String toString() {
-        final StringBuilder buf = new StringBuilder().append("[ option: ");
-
+        final StringBuilder buf = new StringBuilder().append("[ ");
+        buf.append("Option ");
         buf.append(option);
-
         if (longOption != null) {
-            buf.append(" ").append(longOption);
+            buf.append(Char.SP).append(longOption);
+        }
+        if (isDeprecated()) {
+            buf.append(Char.SP);
+            buf.append(deprecated.toString());
         }
-
-        buf.append(" ");
-
         if (hasArgs()) {
             buf.append("[ARG...]");
         } else if (hasArg()) {
             buf.append(" [ARG]");
         }
-
-        buf.append(" :: ").append(description);
-
-        if (type != null) {
-            buf.append(" :: ").append(type);
-        }
-
-        buf.append(" ]");
-
-        return buf.toString();
+        // @formatter:off
+        return buf.append(" :: ")
+            .append(description)
+            .append(" :: ")
+            .append(type)
+            .append(" ]")
+            .toString();
+        // @formatter:on
     }
 }
diff --git a/src/main/java/org/apache/commons/cli/OptionBuilder.java b/src/main/java/org/apache/commons/cli/OptionBuilder.java
index 8461ad22d..8b6ff0a9a 100644
--- a/src/main/java/org/apache/commons/cli/OptionBuilder.java
+++ b/src/main/java/org/apache/commons/cli/OptionBuilder.java
@@ -6,7 +6,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
   (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
+      https://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,
@@ -21,68 +21,67 @@ Licensed to the Apache Software Foundation (ASF) under one or more
  * OptionBuilder allows the user to create Options using descriptive methods.
  * 

  * Details on the Builder pattern can be found at
- * http://c2.com/cgi-bin/wiki?BuilderPattern.
+ * https://c2.com/cgi-bin/wiki?BuilderPattern.
  * 

  * This class is NOT thread safe. See CLI-209
  *
  * @since 1.0
- * @deprecated since 1.3, use {@link Option#builder(String)} instead
+ * @deprecated Since 1.3, use {@link Option#builder(String)} instead.
  */
 @Deprecated
 public final class OptionBuilder {
 
-    /** Long option */
+    /** Long option. */
     private static String longOption;
 
-    /** Option description */
+    /** Option description. */
     private static String description;
 
-    /** Argument name */
+    /** Argument name. */
     private static String argName;
 
-    /** Is required? */
+    /** Required test. */
     private static boolean required;
 
-    /** The number of arguments */
+    /** The number of arguments. */
     private static int argCount = Option.UNINITIALIZED;
 
-    /** Option type */
+    /** Option type. */
     private static Class type;
 
-    /** Option can have an optional argument value */
+    /** Option can have an optional argument value. */
     private static boolean optionalArg;
 
-    /** Value separator for argument value */
+    /** Value separator for argument value. */
     private static char valueSeparator;
 
-    /** Option builder instance */
+    /** Option builder instance. */
     private static final OptionBuilder INSTANCE = new OptionBuilder();
 
     static {
-        // ensure the consistency of the initial values
+        // ensure the consistency of the initial values.
         reset();
     }
 
     /**
-     * Creates an Option using the current settings
+     * Creates an Option using the current settings.
      *
-     * @return the Option instance
+     * @return the Option instance.
      * @throws IllegalArgumentException if {@code longOpt} has not been set.
      */
     public static Option create() throws IllegalArgumentException {
         if (longOption == null) {
-            OptionBuilder.reset();
-            throw new IllegalArgumentException("must specify longopt");
+            reset();
+            throw new IllegalStateException("longopt missing");
         }
-
         return create(null);
     }
 
     /**
      * Creates an Option using the current settings and with the specified Option {@code char}.
      *
-     * @param opt the character representation of the Option
-     * @return the Option instance
+     * @param opt the character representation of the Option.
+     * @return the Option instance.
      * @throws IllegalArgumentException if {@code opt} is not a valid character. See Option.
      */
     public static Option create(final char opt) throws IllegalArgumentException {
@@ -92,29 +91,28 @@ public static Option create(final char opt) throws IllegalArgumentException {
     /**
      * Creates an Option using the current settings and with the specified Option {@code char}.
      *
-     * @param opt the {@code java.lang.String} representation of the Option
-     * @return the Option instance
+     * @param opt the {@code String} representation of the Option.
+     * @return the Option instance.
      * @throws IllegalArgumentException if {@code opt} is not a valid character. See Option.
      */
     public static Option create(final String opt) throws IllegalArgumentException {
-        Option option = null;
+        Option option;
         try {
             // create the option
             option = new Option(opt, description);
-
             // set the option properties
             option.setLongOpt(longOption);
             option.setRequired(required);
             option.setOptionalArg(optionalArg);
             option.setArgs(argCount);
             option.setType(type);
+            option.setConverter(TypeHandler.getDefault().getConverter(type));
             option.setValueSeparator(valueSeparator);
             option.setArgName(argName);
         } finally {
             // reset the OptionBuilder properties
-            OptionBuilder.reset();
+            reset();
         }
-
         // return the Option instance
         return option;
     }
@@ -125,103 +123,94 @@ public static Option create(final String opt) throws IllegalArgumentException {
      * @return the OptionBuilder instance
      */
     public static OptionBuilder hasArg() {
-        OptionBuilder.argCount = 1;
-
+        argCount = 1;
         return INSTANCE;
     }
 
     /**
      * The next Option created will require an argument value if {@code hasArg} is true.
      *
-     * @param hasArg if true then the Option has an argument value
-     * @return the OptionBuilder instance
+     * @param hasArg if true then the Option has an argument value.
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder hasArg(final boolean hasArg) {
-        OptionBuilder.argCount = hasArg ? 1 : Option.UNINITIALIZED;
-
+        argCount = hasArg ? 1 : Option.UNINITIALIZED;
         return INSTANCE;
     }
 
     /**
      * The next Option created can have unlimited argument values.
      *
-     * @return the OptionBuilder instance
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder hasArgs() {
-        OptionBuilder.argCount = Option.UNLIMITED_VALUES;
-
+        argCount = Option.UNLIMITED_VALUES;
         return INSTANCE;
     }
 
     /**
      * The next Option created can have {@code num} argument values.
      *
-     * @param num the number of args that the option can have
-     * @return the OptionBuilder instance
+     * @param num the number of args that the option can have.
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder hasArgs(final int num) {
-        OptionBuilder.argCount = num;
-
+        argCount = num;
         return INSTANCE;
     }
 
     /**
      * The next Option can have an optional argument.
      *
-     * @return the OptionBuilder instance
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder hasOptionalArg() {
-        OptionBuilder.argCount = 1;
-        OptionBuilder.optionalArg = true;
-
+        argCount = 1;
+        optionalArg = true;
         return INSTANCE;
     }
 
     /**
      * The next Option can have an unlimited number of optional arguments.
      *
-     * @return the OptionBuilder instance
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder hasOptionalArgs() {
-        OptionBuilder.argCount = Option.UNLIMITED_VALUES;
-        OptionBuilder.optionalArg = true;
-
+        argCount = Option.UNLIMITED_VALUES;
+        optionalArg = true;
         return INSTANCE;
     }
 
     /**
      * The next Option can have the specified number of optional arguments.
      *
-     * @param numArgs - the maximum number of optional arguments the next Option created can have.
-     * @return the OptionBuilder instance
+     * @param numArgs   the maximum number of optional arguments the next Option created can have.
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder hasOptionalArgs(final int numArgs) {
-        OptionBuilder.argCount = numArgs;
-        OptionBuilder.optionalArg = true;
-
+        argCount = numArgs;
+        optionalArg = true;
         return INSTANCE;
     }
 
     /**
      * The next Option created will be required.
      *
-     * @return the OptionBuilder instance
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder isRequired() {
-        OptionBuilder.required = true;
-
+        required = true;
         return INSTANCE;
     }
 
     /**
      * The next Option created will be required if {@code required} is true.
      *
-     * @param newRequired if true then the Option is required
-     * @return the OptionBuilder instance
+     * @param newRequired if true then the Option is required.
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder isRequired(final boolean newRequired) {
-        OptionBuilder.required = newRequired;
-
+        required = newRequired;
         return INSTANCE;
     }
 
@@ -242,61 +231,57 @@ private static void reset() {
     /**
      * The next Option created will have the specified argument value name.
      *
-     * @param name the name for the argument value
-     * @return the OptionBuilder instance
+     * @param name the name for the argument value.
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder withArgName(final String name) {
-        OptionBuilder.argName = name;
-
+        argName = name;
         return INSTANCE;
     }
 
     /**
      * The next Option created will have the specified description
      *
-     * @param newDescription a description of the Option's purpose
-     * @return the OptionBuilder instance
+     * @param newDescription a description of the Option's purpose.
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder withDescription(final String newDescription) {
-        OptionBuilder.description = newDescription;
-
+        description = newDescription;
         return INSTANCE;
     }
 
     /**
      * The next Option created will have the following long option value.
      *
-     * @param newLongopt the long option value
-     * @return the OptionBuilder instance
+     * @param newLongopt the long option value.
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder withLongOpt(final String newLongopt) {
-        OptionBuilder.longOption = newLongopt;
-
+        longOption = newLongopt;
         return INSTANCE;
     }
 
     /**
      * The next Option created will have a value that will be an instance of {@code type}.
      *
-     * @param newType the type of the Options argument value
-     * @return the OptionBuilder instance
+     * @param newType the type of the Options argument value.
+     * @return the OptionBuilder instance.
      * @since 1.3
      */
     public static OptionBuilder withType(final Class newType) {
-        OptionBuilder.type = newType;
-
+        type = newType;
         return INSTANCE;
     }
 
     /**
      * The next Option created will have a value that will be an instance of {@code type}.
      * 

-     * Note: this method is kept for binary compatibility and the input type is supposed to be a {@link Class}
+     * Note: this method is kept for binary compatibility and the input type is supposed to be a {@link Class}
      * object.
      *
-     * @param newType the type of the Options argument value
-     * @return the OptionBuilder instance
-     * @deprecated since 1.3, use {@link #withType(Class)} instead
+     * @param newType the type of the Options argument value.
+     * @return the OptionBuilder instance.
+     * @deprecated Since 1.3, use {@link #withType(Class)} instead.
      */
     @Deprecated
     public static OptionBuilder withType(final Object newType) {
@@ -306,28 +291,27 @@ public static OptionBuilder withType(final Object newType) {
     /**
      * The next Option created uses '{@code =}' as a means to separate argument values.
      *
-     * Example:
+     * Example:
      *
      * 
-     * Option opt = OptionBuilder.withValueSeparator().create('D');
+     * Option opt = withValueSeparator().create('D');
      *
      * CommandLine line = parser.parse(args);
      * String propertyName = opt.getValue(0);
      * String propertyValue = opt.getValue(1);
      * 
      *
-     * @return the OptionBuilder instance
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder withValueSeparator() {
-        OptionBuilder.valueSeparator = '=';
-
+        valueSeparator = Char.EQUAL;
         return INSTANCE;
     }
 
     /**
      * The next Option created uses {@code sep} as a means to separate argument values.
      * 

-     * Example:
+     * Example:
      *
      * 
      * Option opt = OptionBuilder.withValueSeparator('=').create('D');
@@ -339,17 +323,15 @@ public static OptionBuilder withValueSeparator() {
      * 
      *
      * @param sep The value separator to be used for the argument values.
-     *
-     * @return the OptionBuilder instance
+     * @return the OptionBuilder instance.
      */
     public static OptionBuilder withValueSeparator(final char sep) {
-        OptionBuilder.valueSeparator = sep;
-
+        valueSeparator = sep;
         return INSTANCE;
     }
 
     /**
-     * private constructor to prevent instances being created
+     * private constructor to prevent instances being created.
      */
     private OptionBuilder() {
         // hide the constructor
diff --git a/src/main/java/org/apache/commons/cli/OptionGroup.java b/src/main/java/org/apache/commons/cli/OptionGroup.java
index c4c7be47b..ed574dc10 100644
--- a/src/main/java/org/apache/commons/cli/OptionGroup.java
+++ b/src/main/java/org/apache/commons/cli/OptionGroup.java
@@ -6,7 +6,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
   (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
+      https://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,
@@ -23,38 +23,49 @@ Licensed to the Apache Software Foundation (ASF) under one or more
 import java.util.LinkedHashMap;
 import java.util.Map;
 
+import org.apache.commons.cli.help.OptionFormatter;
+
 /**
  * A group of mutually exclusive options.
  */
 public class OptionGroup implements Serializable {
+
     /** The serial version UID. */
     private static final long serialVersionUID = 1L;
 
-    /** hold the options */
+    /**
+     * Maps options where keys are option name and values are the options.
+     */
     private final Map optionMap = new LinkedHashMap<>();
 
-    /** The name of the selected option */
+    /** The name of the selected option. */
     private String selected;
 
-    /** specified whether this group is required */
+    /** Specified whether this group is required. */
     private boolean required;
 
     /**
-     * Add the specified {@code Option} to this group.
+     * Constructs a new instance.
+     */
+    public OptionGroup() {
+        // empty
+    }
+
+    /**
+     * Adds the given {@code Option} to this group.
      *
-     * @param option the option to add to this group
-     * @return this option group with the option added
+     * @param option the option to add to this group.
+     * @return this option group with the option added.
      */
     public OptionGroup addOption(final Option option) {
-        // key - option name
-        // value - the option
         optionMap.put(option.getKey(), option);
-
         return this;
     }
 
     /**
-     * @return the names of the options in this group as a {@code Collection}
+     * Gets the names of the options in this group as a {@code Collection}.
+     *
+     * @return the names of the options in this group as a {@code Collection}.
      */
     public Collection getNames() {
         // the key set is the collection of names
@@ -62,7 +73,9 @@ public Collection getNames() {
     }
 
     /**
-     * @return the options in this group as a {@code Collection}
+     * Gets the options in this group as a {@code Collection}.
+     *
+     * @return the options in this group as a {@code Collection}.
      */
     public Collection getOptions() {
         // the values are the collection of options
@@ -70,7 +83,10 @@ public Collection getOptions() {
     }
 
     /**
-     * @return the selected option name
+     * Gets the selected option name.
+     *
+     * If the selected option is deprecated no warning is logged.
+     * @return the selected option name.
      */
     public String getSelected() {
         return selected;
@@ -79,23 +95,37 @@ public String getSelected() {
     /**
      * Tests whether this option group is required.
      *
-     * @return whether this option group is required
+     * @return whether this option group is required.
      */
     public boolean isRequired() {
         return required;
     }
 
     /**
-     * @param required specifies if this group is required
+     * Tests whether an option is selected.
+     *
+     *  If an option is selected and is deprecated no warning is logged.
+     * @return whether whether an option is selected.
+     * @since 1.9.0
+     */
+    public boolean isSelected() {
+        return selected != null;
+    }
+
+    /**
+     * Sets whether this group is required.
+     *
+     * @param required whether this group is required.
      */
     public void setRequired(final boolean required) {
         this.required = required;
     }
 
     /**
-     * Set the selected option of this group to {@code name}.
+     * Sets the selected option of this group to {@code name}.
      *
-     * @param option the option that is selected
+     * If the selected option is deprecated no warning is logged.
+     * @param option the option that is selected.
      * @throws AlreadySelectedException if an option from this group has already been selected.
      */
     public void setSelected(final Option option) throws AlreadySelectedException {
@@ -104,7 +134,6 @@ public void setSelected(final Option option) throws AlreadySelectedException {
             selected = null;
             return;
         }
-
         // if no option has already been selected or the
         // same option is being reselected then set the
         // selected member variable
@@ -117,39 +146,31 @@ public void setSelected(final Option option) throws AlreadySelectedException {
     /**
      * Returns the stringified version of this OptionGroup.
      *
-     * @return the stringified representation of this group
+     * @return the stringified representation of this group.
      */
     @Override
     public String toString() {
         final StringBuilder buff = new StringBuilder();
-
         final Iterator iter = getOptions().iterator();
-
         buff.append("[");
-
         while (iter.hasNext()) {
             final Option option = iter.next();
-
             if (option.getOpt() != null) {
-                buff.append("-");
+                buff.append(OptionFormatter.DEFAULT_OPT_PREFIX);
                 buff.append(option.getOpt());
             } else {
-                buff.append("--");
+                buff.append(OptionFormatter.DEFAULT_LONG_OPT_PREFIX);
                 buff.append(option.getLongOpt());
             }
-
             if (option.getDescription() != null) {
-                buff.append(" ");
+                buff.append(Char.SP);
                 buff.append(option.getDescription());
             }
-
             if (iter.hasNext()) {
                 buff.append(", ");
             }
         }
-
         buff.append("]");
-
         return buff.toString();
     }
 }
diff --git a/src/main/java/org/apache/commons/cli/OptionValidator.java b/src/main/java/org/apache/commons/cli/OptionValidator.java
index 01848819b..56852f20c 100644
--- a/src/main/java/org/apache/commons/cli/OptionValidator.java
+++ b/src/main/java/org/apache/commons/cli/OptionValidator.java
@@ -6,7 +6,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
   (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
+      https://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,
@@ -19,28 +19,69 @@ Licensed to the Apache Software Foundation (ASF) under one or more
 
 /**
  * Validates an Option string.
- *
- * @since 1.1
  */
 final class OptionValidator {
+    /* package private for testing access */
+    /** The array of additional characters allowed as the first character in the option but not in the rest of the option */
+    static final char[] ADDITIONAL_OPTION_CHARS = {'?', '@'};
+    /** The array of additional characters allowed in the rest of the option but not in the first position */
+    static final char[] ADDITIONAL_LONG_CHARS = {'-'};
+
     /**
      * Returns whether the specified character is a valid character.
-     *
+     * A character is valid if any of the following conditions are true:
+     * 

+     * 
it is a letter
+     * 
it is a currency symbol (such as '$')
+     * 
it is a connecting punctuation character (such as '_')
+     * 
it is a digit
+     * 
it is a numeric letter (such as a Roman numeral character)
+     * 
it is a combining mark
+     * 
it is a non-spacing mark
+     * 
isIdentifierIgnorable returns true for the character
+     * 
it is a hyphen/dash ('-')
+     * 
      * @param c the character to validate
-     * @return true if {@code c} is a letter.
+     * @return true if {@code c} is a valid character letter.
      */
     private static boolean isValidChar(final char c) {
-        return Character.isJavaIdentifierPart(c);
+        return Character.isJavaIdentifierPart(c) || search(ADDITIONAL_LONG_CHARS, c);
     }
 
     /**
      * Returns whether the specified character is a valid Option.
-     *
+     * A character is valid if any of the following conditions are true:
+     * 

+     * 
it is a letter
+     * 
it is a currency symbol (such as '$')
+     * 
it is a connecting punctuation character (such as '_')
+     * 
it is a digit
+     * 
it is a numeric letter (such as a Roman numeral character)
+     * 
it is a combining mark
+     * 
it is a non-spacing mark
+     * 
isIdentifierIgnorable returns true for the character
+     * 
it is a question mark or 'at' sign ('?' or '@')
+     * 
      * @param c the option to validate
      * @return true if {@code c} is a letter, '?' or '@', otherwise false.
      */
     private static boolean isValidOpt(final char c) {
-        return isValidChar(c) || c == '?' || c == '@';
+        return Character.isJavaIdentifierPart(c) || search(ADDITIONAL_OPTION_CHARS, c);
+    }
+
+    /**
+     * Checks the char array for a matching char.
+     * @param chars the char array to search
+     * @param c the char to look for.
+     * @return {@code true} if {@code c} was in {@code ary}, {@code false} otherwise.
+     */
+    private static boolean search(final char[] chars, final char c) {
+        for (final char a : chars) {
+            if (a == c) {
+                return true;
+            }
+        }
+        return false;
     }
 
     /**
@@ -48,33 +89,47 @@ private static boolean isValidOpt(final char c) {
      * is valid are:
      *
      * 

-     * 
a single character {@code opt} that is either ' '(special case), '?', '@' or a letter
-     * 
a multi character {@code opt} that only contains letters.
+     * 
a single character {@code opt} that is either Chars.SP(special case), '?', '@' or a letter
+     * 
a multi character {@code opt} that only contains valid characters
+     * 
+     * 

+     * A character is valid if any of the following conditions are true:
+     * 

+     * 
it is a letter
+     * 
it is a currency symbol (such as '$')
+     * 
it is a connecting punctuation character (such as '_')
+     * 
it is a digit
+     * 
it is a numeric letter (such as a Roman numeral character)
+     * 
it is a combining mark
+     * 
it is a non-spacing mark
+     * 
isIdentifierIgnorable returns true for the character
+     * 
it is a hyphen/dash ('-')
      * 
-     * 

+     * 

      * In case {@code opt} is {@code null} no further validation is performed.
      *
-     * @param option The option string to validate, may be null
+     * @param option The option string to validate, may be null.
      * @throws IllegalArgumentException if the Option is not valid.
      */
     static String validate(final String option) throws IllegalArgumentException {
-        // if opt is NULL do not check further
+        // if opt is null do not check further.
         if (option == null) {
             return null;
         }
-
-        // handle the single character opt
-        if (option.length() == 1) {
-            final char ch = option.charAt(0);
-
-            if (!isValidOpt(ch)) {
-                throw new IllegalArgumentException("Illegal option name '" + ch + "'");
-            }
-        } else {
-            // handle the multi character opt
-            for (final char ch : option.toCharArray()) {
+        if (option.isEmpty()) {
+            throw new IllegalArgumentException("Empty option name.");
+        }
+        final char[] chars = option.toCharArray();
+        final char ch0 = chars[0];
+        if (!isValidOpt(ch0)) {
+            throw new IllegalArgumentException(String.format("Illegal option name '%s'.", ch0));
+        }
+        // handle the multi-character opt
+        if (option.length() > 1) {
+            for (int i = 1; i < chars.length; i++) {
+                final char ch = chars[i];
                 if (!isValidChar(ch)) {
-                    throw new IllegalArgumentException("The option '" + option + "' contains an illegal " + "character : '" + ch + "'");
+                    throw new IllegalArgumentException(String.format("The option '%s' contains an illegal character : '%s'.", option, ch));
                 }
             }
         }
diff --git a/src/main/java/org/apache/commons/cli/Options.java b/src/main/java/org/apache/commons/cli/Options.java
index 6905f8f4b..7f0cda159 100644
--- a/src/main/java/org/apache/commons/cli/Options.java
+++ b/src/main/java/org/apache/commons/cli/Options.java
@@ -6,7 +6,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
   (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
+      https://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,
@@ -30,44 +30,52 @@ Licensed to the Apache Software Foundation (ASF) under one or more
  * Main entry-point into the library.
  * 

  * Options represents a collection of {@link Option} objects, which describe the possible options for a command-line.
+ * 
  * 

  * It may flexibly parse long and short options, with or without values. Additionally, it may parse only a portion of a
- * commandline, allowing for flexible multi-stage parsing.
+ * command-line, allowing for flexible multi-stage parsing.
+ * 
  *
  * @see org.apache.commons.cli.CommandLine
  */
 public class Options implements Serializable {
+
     /** The serial version UID. */
     private static final long serialVersionUID = 1L;
 
-    /** a map of the options with the character key */
+    /** A map of the options with the character key */
     private final Map shortOpts = new LinkedHashMap<>();
 
-    /** a map of the options with the long key */
+    /** A map of the options with the long key */
     private final Map longOpts = new LinkedHashMap<>();
 
-    /** a map of the required options */
-    // N.B. This can contain either a String (addOption) or an OptionGroup (addOptionGroup)
+    /** A map of the required options */
+    // This can contain either a String (addOption) or an OptionGroup (addOptionGroup)
     // TODO this seems wrong
     private final List