From 9f2da7561af1f1ad4f69aa3056b19b27c8c0c7f0 Mon Sep 17 00:00:00 2001
From: Jiaqi Guo <jiaqi.guo@gmail.com>
Date: Wed, 7 Feb 2018 15:11:31 -0800
Subject: [PATCH] Format with Google style

---
 .../jcli/ArgumentProcessorFactory.java        |  48 ++--
 .../cyclopsgroup/jcli/AutoCompletable.java    |  33 ++-
 .../cyclopsgroup/jcli/ValidationResult.java   | 157 +++++------
 .../jcli/annotation/Argument.java             |  27 +-
 .../org/cyclopsgroup/jcli/annotation/Cli.java |  39 ++-
 .../jcli/annotation/MultiValue.java           |  39 ++-
 .../cyclopsgroup/jcli/annotation/Option.java  |  55 ++--
 .../jcli/annotation/package-info.java         |   2 +-
 .../jcli/example/UserControlAction.java       |  35 ++-
 .../jcli/impl/DefaultBeanProcessor.java       |  98 +++----
 .../jcli/impl/DefaultHelpPrinter.java         |  60 ++---
 .../jcli/impl/MultiValueReference.java        |  66 ++---
 .../cyclopsgroup/jcli/impl/OptionHelp.java    |  81 +++---
 .../jcli/impl/ParsingContextBuilder.java      | 160 ++++++------
 .../jcli/impl/SingleValueReference.java       |  31 +--
 .../jcli/jline/ArgumentsInspector.java        | 217 +++++++--------
 .../jcli/jline/ArgumentsInspectorState.java   |  43 ++-
 .../cyclopsgroup/jcli/jline/package-info.java |   2 +-
 .../org/cyclopsgroup/jcli/package-info.java   |   2 +-
 .../org/cyclopsgroup/jcli/spi/Argument.java   |  19 +-
 .../java/org/cyclopsgroup/jcli/spi/Cli.java   |  27 +-
 .../jcli/spi/CommandLineBuilder.java          | 145 +++++-----
 .../jcli/spi/CommandLineParser.java           |  15 +-
 .../org/cyclopsgroup/jcli/spi/Option.java     |  81 +++---
 .../cyclopsgroup/jcli/spi/ParsingContext.java |  47 ++--
 .../cyclopsgroup/jcli/spi/package-info.java   |   2 +-
 .../org/cyclopsgroup/jcli/GnuParserTest.java  | 229 ++++++++--------
 .../cyclopsgroup/jcli/MultiActionTest.java    |  26 +-
 .../jcli/WithMultiValueOption.java            |  37 ++-
 .../cyclopsgroup/jcli/WithSimpleArgument.java |  35 ++-
 .../org/cyclopsgroup/jcli/WithoutCli.java     |  37 ++-
 .../jcli/example/UserControlTest.java         |  27 +-
 .../impl/DefaultArgumentProcessorTest.java    |  72 +++--
 .../jcli/jline/ArgumentsInspectorTest.java    |  56 ++--
 .../jcli/jline/CliCompletorTest.java          | 247 ++++++++----------
 35 files changed, 1065 insertions(+), 1232 deletions(-)

diff --git a/src/main/java/org/cyclopsgroup/jcli/ArgumentProcessorFactory.java b/src/main/java/org/cyclopsgroup/jcli/ArgumentProcessorFactory.java
index 3fc713c..58e6b09 100644
--- a/src/main/java/org/cyclopsgroup/jcli/ArgumentProcessorFactory.java
+++ b/src/main/java/org/cyclopsgroup/jcli/ArgumentProcessorFactory.java
@@ -10,30 +10,30 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public abstract class ArgumentProcessorFactory
-{
-    /**
-     * @return Instance of ArgumentProcessorFactory. The implementation is determined by {@link ServiceLoader}
-     */
-    static ArgumentProcessorFactory getInstance()
-    {
-        Iterator<ArgumentProcessorFactory> factories = ServiceLoader.load( ArgumentProcessorFactory.class ).iterator();
-        if ( factories.hasNext() )
-        {
-            return factories.next();
-        }
-        throw new AssertionError( "Can't find an implementation of " + ArgumentProcessorFactory.class.getName()
-            + " from service loader" );
+public abstract class ArgumentProcessorFactory {
+  /**
+   * @return Instance of ArgumentProcessorFactory. The implementation is determined by
+   *         {@link ServiceLoader}
+   */
+  static ArgumentProcessorFactory getInstance() {
+    Iterator<ArgumentProcessorFactory> factories =
+        ServiceLoader.load(ArgumentProcessorFactory.class).iterator();
+    if (factories.hasNext()) {
+      return factories.next();
     }
+    throw new AssertionError("Can't find an implementation of "
+        + ArgumentProcessorFactory.class.getName() + " from service loader");
+  }
 
-    /**
-     * Create new instance of {@link ArgumentProcessor}. The implementation of factory needs to implement this method to
-     * create customized argument processor
-     *
-     * @param <T> Type of bean to process
-     * @param beanType Type of bean to process
-     * @param parser Command line parser that is aware of command line syntax
-     * @return Instance of argument processor implementation
-     */
-    protected abstract <T> ArgumentProcessor<T> newProcessor( Class<? extends T> beanType, CommandLineParser parser );
+  /**
+   * Create new instance of {@link ArgumentProcessor}. The implementation of factory needs to
+   * implement this method to create customized argument processor
+   *
+   * @param <T> Type of bean to process
+   * @param beanType Type of bean to process
+   * @param parser Command line parser that is aware of command line syntax
+   * @return Instance of argument processor implementation
+   */
+  protected abstract <T> ArgumentProcessor<T> newProcessor(Class<? extends T> beanType,
+      CommandLineParser parser);
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/AutoCompletable.java b/src/main/java/org/cyclopsgroup/jcli/AutoCompletable.java
index 9cfad7c..8cf7023 100644
--- a/src/main/java/org/cyclopsgroup/jcli/AutoCompletable.java
+++ b/src/main/java/org/cyclopsgroup/jcli/AutoCompletable.java
@@ -7,22 +7,21 @@
  * 
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
-public interface AutoCompletable
-{
-    /**
-     * Suggest candidates for an option with given partial input
-     * 
-     * @param optionName Name of option
-     * @param partialOption Given partial input
-     * @return List of candidates or NULL if it can't figure out
-     */
-    List<String> suggestOption( String optionName, String partialOption );
+public interface AutoCompletable {
+  /**
+   * Suggest candidates for an option with given partial input
+   * 
+   * @param optionName Name of option
+   * @param partialOption Given partial input
+   * @return List of candidates or NULL if it can't figure out
+   */
+  List<String> suggestOption(String optionName, String partialOption);
 
-    /**
-     * Suggest candidates for argument with given partial input
-     * 
-     * @param partialArgument Partial argument input
-     * @return List of candidates or NULL if it can't figure out
-     */
-    List<String> suggestArgument( String partialArgument );
+  /**
+   * Suggest candidates for argument with given partial input
+   * 
+   * @param partialArgument Partial argument input
+   * @return List of candidates or NULL if it can't figure out
+   */
+  List<String> suggestArgument(String partialArgument);
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/ValidationResult.java b/src/main/java/org/cyclopsgroup/jcli/ValidationResult.java
index 576bbd4..a49f5ad 100644
--- a/src/main/java/org/cyclopsgroup/jcli/ValidationResult.java
+++ b/src/main/java/org/cyclopsgroup/jcli/ValidationResult.java
@@ -9,111 +9,94 @@
 /**
  * Argument validation result coming from {@link ArgumentProcessor#validate(String[])}
  */
-public final class ValidationResult
-{
-    /**
-     * A violation indicating required argument is missing
-     */
-    public static final class ArgumentMissing
-        extends Violation
-    {
-    }
-
-    /**
-     * Type of violation where a required option is missing
-     */
-    public static final class OptionMissing
-        extends Violation
-    {
-        private final String optionName;
+public final class ValidationResult {
+  /**
+   * A violation indicating required argument is missing
+   */
+  public static final class ArgumentMissing extends Violation {
+  }
 
-        /**
-         * @param optionName Name of missing option
-         */
-        public OptionMissing( String optionName )
-        {
-            Validate.notNull( optionName, "Name of missing option can't be NULL" );
-            this.optionName = optionName;
-        }
-
-        /**
-         * Get name of missing option
-         *
-         * @return optionName Name of option missed
-         */
-        public String getOptionName()
-        {
-            return optionName;
-        }
-    }
+  /**
+   * Type of violation where a required option is missing
+   */
+  public static final class OptionMissing extends Violation {
+    private final String optionName;
 
     /**
-     * Violation where an unexpected option value is found
+     * @param optionName Name of missing option
      */
-    public static final class UnexpectedOption
-        extends Violation
-    {
-        private final String optionName;
-
-        /**
-         * @param optionName Name of unexpected option
-         */
-        public UnexpectedOption( String optionName )
-        {
-            Validate.notNull( optionName, "Name of missing option can't be NULL" );
-            this.optionName = optionName;
-        }
-
-        /**
-         * Get name of missing option
-         *
-         * @return optionName Name of option missed
-         */
-        public String getOptionName()
-        {
-            return optionName;
-        }
+    public OptionMissing(String optionName) {
+      Validate.notNull(optionName, "Name of missing option can't be NULL");
+      this.optionName = optionName;
     }
 
     /**
-     * A validation violation
+     * Get name of missing option
+     *
+     * @return optionName Name of option missed
      */
-    public static abstract class Violation
-    {
-        Violation()
-        {
-        }
+    public String getOptionName() {
+      return optionName;
     }
+  }
 
-    private final List<Violation> violations = new ArrayList<Violation>();
+  /**
+   * Violation where an unexpected option value is found
+   */
+  public static final class UnexpectedOption extends Violation {
+    private final String optionName;
 
     /**
-     * Add a new violation to validation result
-     *
-     * @param <T> Type of validation violation
-     * @param violation Violation
+     * @param optionName Name of unexpected option
      */
-    public <T extends Violation> void addViolation( T violation )
-    {
-        violations.add( violation );
+    public UnexpectedOption(String optionName) {
+      Validate.notNull(optionName, "Name of missing option can't be NULL");
+      this.optionName = optionName;
     }
 
     /**
-     * Get list of violations in result
+     * Get name of missing option
      *
-     * @return List of violations in result
+     * @return optionName Name of option missed
      */
-    public List<Violation> getViolations()
-    {
-        return Collections.unmodifiableList( violations );
-
+    public String getOptionName() {
+      return optionName;
     }
+  }
 
-    /**
-     * @return True if there is not violation
-     */
-    public boolean isValid()
-    {
-        return violations.isEmpty();
-    }
+  /**
+   * A validation violation
+   */
+  public static abstract class Violation {
+    Violation() {}
+  }
+
+  private final List<Violation> violations = new ArrayList<Violation>();
+
+  /**
+   * Add a new violation to validation result
+   *
+   * @param <T> Type of validation violation
+   * @param violation Violation
+   */
+  public <T extends Violation> void addViolation(T violation) {
+    violations.add(violation);
+  }
+
+  /**
+   * Get list of violations in result
+   *
+   * @return List of violations in result
+   */
+  public List<Violation> getViolations() {
+    return Collections.unmodifiableList(violations);
+
+  }
+
+  /**
+   * @return True if there is not violation
+   */
+  public boolean isValid() {
+    return violations.isEmpty();
+  }
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/annotation/Argument.java b/src/main/java/org/cyclopsgroup/jcli/annotation/Argument.java
index 758ce8d..dc67ebc 100644
--- a/src/main/java/org/cyclopsgroup/jcli/annotation/Argument.java
+++ b/src/main/java/org/cyclopsgroup/jcli/annotation/Argument.java
@@ -7,23 +7,22 @@
 import java.lang.annotation.Target;
 
 /**
- * This annotation marks a property as non-option argument or arguments. Type of this property can be array, List or
- * single value.
+ * This annotation marks a property as non-option argument or arguments. Type of this property can
+ * be array, List or single value.
  *
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
 @Documented
-@Target( { ElementType.METHOD, ElementType.FIELD } )
-@Retention( RetentionPolicy.RUNTIME )
-public @interface Argument
-{
-    /**
-     * @return String description of argument which will be displayed in usage
-     */
-    String description() default "";
+@Target({ElementType.METHOD, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Argument {
+  /**
+   * @return String description of argument which will be displayed in usage
+   */
+  String description() default "";
 
-    /**
-     * @return Name of argument displayed in usage
-     */
-    String displayName() default "arg";
+  /**
+   * @return Name of argument displayed in usage
+   */
+  String displayName() default "arg";
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/annotation/Cli.java b/src/main/java/org/cyclopsgroup/jcli/annotation/Cli.java
index c183a84..9a892e7 100644
--- a/src/main/java/org/cyclopsgroup/jcli/annotation/Cli.java
+++ b/src/main/java/org/cyclopsgroup/jcli/annotation/Cli.java
@@ -12,27 +12,26 @@
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
 @Documented
-@Target( ElementType.TYPE )
-@Retention( RetentionPolicy.RUNTIME )
-public @interface Cli
-{
-    /**
-     * @return String description of command
-     */
-    String description() default "";
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Cli {
+  /**
+   * @return String description of command
+   */
+  String description() default "";
 
-    /**
-     * @return Name of command
-     */
-    String name();
+  /**
+   * @return Name of command
+   */
+  String name();
 
-    /**
-     * @return Note displayed as footer
-     */
-    String note() default "";
+  /**
+   * @return Note displayed as footer
+   */
+  String note() default "";
 
-    /**
-     * @return True if unexpected option or argument is expected to cause error
-     */
-    boolean restrict() default true;
+  /**
+   * @return True if unexpected option or argument is expected to cause error
+   */
+  boolean restrict() default true;
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/annotation/MultiValue.java b/src/main/java/org/cyclopsgroup/jcli/annotation/MultiValue.java
index 1874a86..58b0403 100644
--- a/src/main/java/org/cyclopsgroup/jcli/annotation/MultiValue.java
+++ b/src/main/java/org/cyclopsgroup/jcli/annotation/MultiValue.java
@@ -13,27 +13,26 @@
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
 @Documented
-@Target( { ElementType.METHOD, ElementType.FIELD } )
-@Retention( RetentionPolicy.RUNTIME )
-public @interface MultiValue
-{
-    /**
-     * @return Type of list that contains values
-     */
-    Class<?> listType() default ArrayList.class;
+@Target({ElementType.METHOD, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MultiValue {
+  /**
+   * @return Type of list that contains values
+   */
+  Class<?> listType() default ArrayList.class;
 
-    /**
-     * @return Max number of values in list. By default it's -1 that means unlimited
-     */
-    int maxValues() default -1;
+  /**
+   * @return Max number of values in list. By default it's -1 that means unlimited
+   */
+  int maxValues() default -1;
 
-    /**
-     * @return Minimal number of values in list. By default it's 0
-     */
-    int minValues() default 0;
+  /**
+   * @return Minimal number of values in list. By default it's 0
+   */
+  int minValues() default 0;
 
-    /**
-     * @return Type of value in list
-     */
-    Class<?> valueType() default String.class;
+  /**
+   * @return Type of value in list
+   */
+  Class<?> valueType() default String.class;
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/annotation/Option.java b/src/main/java/org/cyclopsgroup/jcli/annotation/Option.java
index abcaed6..fc9f6b3 100644
--- a/src/main/java/org/cyclopsgroup/jcli/annotation/Option.java
+++ b/src/main/java/org/cyclopsgroup/jcli/annotation/Option.java
@@ -12,37 +12,36 @@
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
 @Documented
-@Target( { ElementType.METHOD, ElementType.FIELD } )
-@Retention( RetentionPolicy.RUNTIME )
-public @interface Option
-{
-    /**
-     * @return Default value of option
-     */
-    String defaultValue() default "";
+@Target({ElementType.METHOD, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Option {
+  /**
+   * @return Default value of option
+   */
+  String defaultValue() default "";
 
-    /**
-     * @return String description of option which is displayed in usage
-     */
-    String description() default "";
+  /**
+   * @return String description of option which is displayed in usage
+   */
+  String description() default "";
 
-    /**
-     * @return Display name of option
-     */
-    String displayName() default "value";
+  /**
+   * @return Display name of option
+   */
+  String displayName() default "value";
 
-    /**
-     * @return Long option name specified with double dash
-     */
-    String longName() default "";
+  /**
+   * @return Long option name specified with double dash
+   */
+  String longName() default "";
 
-    /**
-     * @return Short option name specified with single dash
-     */
-    String name();
+  /**
+   * @return Short option name specified with single dash
+   */
+  String name();
 
-    /**
-     * @return True if option has to be specified explicitly
-     */
-    boolean required() default false;
+  /**
+   * @return True if option has to be specified explicitly
+   */
+  boolean required() default false;
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/annotation/package-info.java b/src/main/java/org/cyclopsgroup/jcli/annotation/package-info.java
index 3f87a05..8ab84d4 100644
--- a/src/main/java/org/cyclopsgroup/jcli/annotation/package-info.java
+++ b/src/main/java/org/cyclopsgroup/jcli/annotation/package-info.java
@@ -1,4 +1,4 @@
 /**
  * Annotations that defines command line syntax
  */
-package org.cyclopsgroup.jcli.annotation;
\ No newline at end of file
+package org.cyclopsgroup.jcli.annotation;
diff --git a/src/main/java/org/cyclopsgroup/jcli/example/UserControlAction.java b/src/main/java/org/cyclopsgroup/jcli/example/UserControlAction.java
index 5d286e4..65440a3 100644
--- a/src/main/java/org/cyclopsgroup/jcli/example/UserControlAction.java
+++ b/src/main/java/org/cyclopsgroup/jcli/example/UserControlAction.java
@@ -5,22 +5,21 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public enum UserControlAction
-{
-    /**
-     * Add something
-     */
-    ADD,
-    /**
-     * Delete something
-     */
-    DELETE,
-    /**
-     * Change something
-     */
-    EDIT,
-    /**
-     * Display something
-     */
-    DISPLAY;
+public enum UserControlAction {
+  /**
+   * Add something
+   */
+  ADD,
+  /**
+   * Delete something
+   */
+  DELETE,
+  /**
+   * Change something
+   */
+  EDIT,
+  /**
+   * Display something
+   */
+  DISPLAY;
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/impl/DefaultBeanProcessor.java b/src/main/java/org/cyclopsgroup/jcli/impl/DefaultBeanProcessor.java
index 2a0b927..5d8dc60 100644
--- a/src/main/java/org/cyclopsgroup/jcli/impl/DefaultBeanProcessor.java
+++ b/src/main/java/org/cyclopsgroup/jcli/impl/DefaultBeanProcessor.java
@@ -8,60 +8,48 @@
 import org.cyclopsgroup.jcli.spi.CommandLine;
 import org.cyclopsgroup.jcli.spi.CommandLineParser;
 
-class DefaultBeanProcessor
-{
-    static <T> void process( AnnotationParsingContext<T> context, List<String> arguments, T bean,
-                             CommandLineParser parser )
-    {
-        CommandLine cli = parser.parse( arguments, context );
-        Map<String, List<String>> multiValues = new HashMap<String, List<String>>();
-        for ( CommandLine.OptionValue ov : cli.getOptionValues() )
-        {
-            Reference<T> ref = context.lookupReference( ov.name, !ov.shortName );
-            if ( ref == null )
-            {
-                throw new AssertionError( "Option " + ov.name + " doesn't exist" );
-            }
-            if ( ref instanceof SingleValueReference<?> )
-            {
-                ( (SingleValueReference<T>) ref ).setValue( bean, ov.value );
-                continue;
-            }
-            String optionName;
-            if ( ov.shortName )
-            {
-                optionName = ov.name;
-            }
-            else
-            {
-                optionName = context.optionWithLongName( ov.name ).getName();
-            }
-            List<String> values = multiValues.get( optionName );
-            if ( values == null )
-            {
-                values = new ArrayList<String>();
-                multiValues.put( optionName, values );
-            }
-            values.add( ov.value );
-        }
-        for ( Map.Entry<String, List<String>> entry : multiValues.entrySet() )
-        {
-            MultiValueReference<T> ref = (MultiValueReference<T>) context.lookupReference( entry.getKey(), false );
-            ref.setValues( bean, entry.getValue() );
-        }
-        Reference<T> ref = context.lookupReference( DefaultArgumentProcessor.ARGUMENT_REFERNCE_NAME, false );
-        if ( ref == null )
-        {
-            return;
-        }
-        if ( ref instanceof MultiValueReference<?> )
-        {
-            ( (MultiValueReference<T>) ref ).setValues( bean, cli.getArguments() );
-        }
-        else
-        {
-            String value = cli.getArguments().isEmpty() ? null : cli.getArguments().get( 0 );
-            ( (SingleValueReference<T>) ref ).setValue( bean, value );
-        }
+class DefaultBeanProcessor {
+  static <T> void process(AnnotationParsingContext<T> context, List<String> arguments, T bean,
+      CommandLineParser parser) {
+    CommandLine cli = parser.parse(arguments, context);
+    Map<String, List<String>> multiValues = new HashMap<String, List<String>>();
+    for (CommandLine.OptionValue ov : cli.getOptionValues()) {
+      Reference<T> ref = context.lookupReference(ov.name, !ov.shortName);
+      if (ref == null) {
+        throw new AssertionError("Option " + ov.name + " doesn't exist");
+      }
+      if (ref instanceof SingleValueReference<?>) {
+        ((SingleValueReference<T>) ref).setValue(bean, ov.value);
+        continue;
+      }
+      String optionName;
+      if (ov.shortName) {
+        optionName = ov.name;
+      } else {
+        optionName = context.optionWithLongName(ov.name).getName();
+      }
+      List<String> values = multiValues.get(optionName);
+      if (values == null) {
+        values = new ArrayList<String>();
+        multiValues.put(optionName, values);
+      }
+      values.add(ov.value);
     }
+    for (Map.Entry<String, List<String>> entry : multiValues.entrySet()) {
+      MultiValueReference<T> ref =
+          (MultiValueReference<T>) context.lookupReference(entry.getKey(), false);
+      ref.setValues(bean, entry.getValue());
+    }
+    Reference<T> ref =
+        context.lookupReference(DefaultArgumentProcessor.ARGUMENT_REFERNCE_NAME, false);
+    if (ref == null) {
+      return;
+    }
+    if (ref instanceof MultiValueReference<?>) {
+      ((MultiValueReference<T>) ref).setValues(bean, cli.getArguments());
+    } else {
+      String value = cli.getArguments().isEmpty() ? null : cli.getArguments().get(0);
+      ((SingleValueReference<T>) ref).setValue(bean, value);
+    }
+  }
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/impl/DefaultHelpPrinter.java b/src/main/java/org/cyclopsgroup/jcli/impl/DefaultHelpPrinter.java
index 7e69f4a..e7e02f6 100644
--- a/src/main/java/org/cyclopsgroup/jcli/impl/DefaultHelpPrinter.java
+++ b/src/main/java/org/cyclopsgroup/jcli/impl/DefaultHelpPrinter.java
@@ -8,38 +8,32 @@
 import org.cyclopsgroup.caff.format.Formats;
 import org.cyclopsgroup.jcli.spi.Option;
 
-class DefaultHelpPrinter
-{
-    static <T> void printHelp( AnnotationParsingContext<T> context, PrintWriter out )
-        throws IOException
-    {
-        out.println( "[USAGE]" );
-        out.println( "  " + context.cli().getName() + ( context.options().isEmpty() ? "" : " <OPTIONS>" )
-            + ( context.argument() == null ? "" : " <ARGS>" ) );
-        if ( StringUtils.isNotBlank( context.cli().getDescription() ) )
-        {
-            out.println( "[DESCRIPTION]" );
-            out.println( "  " + context.cli().getDescription() );
-        }
-        if ( !context.options().isEmpty() )
-        {
-            out.println( "[OPTIONS]" );
-            Format<OptionHelp> helpFormat = Formats.newFixLengthFormat( OptionHelp.class );
-            for ( Option option : context.options() )
-            {
-                String line = helpFormat.formatToString( new OptionHelp( option ) ).trim();
-                out.println( "  " + line );
-            }
-        }
-        if ( context.argument() != null )
-        {
-            out.println( "[ARGS]" );
-            out.println( "  <" + context.argument().getDisplayName() + ">... " + context.argument().getDescription() );
-        }
-        if ( !StringUtils.isBlank( context.cli().getNote() ) )
-        {
-            out.println( "[NOTE]" );
-            out.println( "  " + context.cli().getNote() );
-        }
+class DefaultHelpPrinter {
+  static <T> void printHelp(AnnotationParsingContext<T> context, PrintWriter out)
+      throws IOException {
+    out.println("[USAGE]");
+    out.println("  " + context.cli().getName() + (context.options().isEmpty() ? "" : " <OPTIONS>")
+        + (context.argument() == null ? "" : " <ARGS>"));
+    if (StringUtils.isNotBlank(context.cli().getDescription())) {
+      out.println("[DESCRIPTION]");
+      out.println("  " + context.cli().getDescription());
     }
+    if (!context.options().isEmpty()) {
+      out.println("[OPTIONS]");
+      Format<OptionHelp> helpFormat = Formats.newFixLengthFormat(OptionHelp.class);
+      for (Option option : context.options()) {
+        String line = helpFormat.formatToString(new OptionHelp(option)).trim();
+        out.println("  " + line);
+      }
+    }
+    if (context.argument() != null) {
+      out.println("[ARGS]");
+      out.println("  <" + context.argument().getDisplayName() + ">... "
+          + context.argument().getDescription());
+    }
+    if (!StringUtils.isBlank(context.cli().getNote())) {
+      out.println("[NOTE]");
+      out.println("  " + context.cli().getNote());
+    }
+  }
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/impl/MultiValueReference.java b/src/main/java/org/cyclopsgroup/jcli/impl/MultiValueReference.java
index c8defab..a4aec24 100644
--- a/src/main/java/org/cyclopsgroup/jcli/impl/MultiValueReference.java
+++ b/src/main/java/org/cyclopsgroup/jcli/impl/MultiValueReference.java
@@ -6,45 +6,35 @@
 import org.cyclopsgroup.caff.conversion.Converter;
 import org.cyclopsgroup.caff.ref.ValueReference;
 
-class MultiValueReference<T>
-    extends Reference<T>
-{
-    private final Class<?> listType;
+class MultiValueReference<T> extends Reference<T> {
+  private final Class<?> listType;
 
-    MultiValueReference( Class<? extends T> beanType, Converter<?> converter, ValueReference<T> ref, String longName,
-                         Class<?> listType )
-    {
-        super( converter, ref, longName );
-        this.listType = listType;
-    }
+  MultiValueReference(Class<? extends T> beanType, Converter<?> converter, ValueReference<T> ref,
+      String longName, Class<?> listType) {
+    super(converter, ref, longName);
+    this.listType = listType;
+  }
 
-    /**
-     * Write multi value to bean
-     *
-     * @param <P> Type of value to convert
-     * @param bean Bean to set values
-     * @param values List of values to set
-     */
-    @SuppressWarnings( "unchecked" )
-    <P> void setValues( T bean, List<String> values )
-    {
-        Collection<P> col;
-        try
-        {
-            col = (Collection<P>) listType.newInstance();
-        }
-        catch ( InstantiationException e )
-        {
-            throw new RuntimeException( "Can't instantiate " + listType, e );
-        }
-        catch ( IllegalAccessException e )
-        {
-            throw new RuntimeException( "Can't access default constructor of " + listType );
-        }
-        for ( String value : values )
-        {
-            col.add( (P) converter.fromCharacters( value ) );
-        }
-        ref.writeValue( col, bean );
+  /**
+   * Write multi value to bean
+   *
+   * @param <P> Type of value to convert
+   * @param bean Bean to set values
+   * @param values List of values to set
+   */
+  @SuppressWarnings("unchecked")
+  <P> void setValues(T bean, List<String> values) {
+    Collection<P> col;
+    try {
+      col = (Collection<P>) listType.newInstance();
+    } catch (InstantiationException e) {
+      throw new RuntimeException("Can't instantiate " + listType, e);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException("Can't access default constructor of " + listType);
+    }
+    for (String value : values) {
+      col.add((P) converter.fromCharacters(value));
     }
+    ref.writeValue(col, bean);
+  }
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/impl/OptionHelp.java b/src/main/java/org/cyclopsgroup/jcli/impl/OptionHelp.java
index 4715b5e..e3678c6 100644
--- a/src/main/java/org/cyclopsgroup/jcli/impl/OptionHelp.java
+++ b/src/main/java/org/cyclopsgroup/jcli/impl/OptionHelp.java
@@ -10,54 +10,47 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-@FixLengthType( length = 256 )
-public class OptionHelp
-{
-    private final Option option;
+@FixLengthType(length = 256)
+public class OptionHelp {
+  private final Option option;
 
-    OptionHelp( Option option )
-    {
-        this.option = option;
-    }
+  OptionHelp(Option option) {
+    this.option = option;
+  }
 
-    /**
-     * @return Description of option
-     */
-    @FixLengthField( start = 26, length = 228 )
-    public String getDescription()
-    {
-        String desc = option.getDescription();
-        if ( !option.isFlag() && StringUtils.isNotBlank( option.getDefaultValue() ) )
-        {
-            desc += "(Default value is " + option.getDefaultValue() + ")";
-        }
-        return desc;
+  /**
+   * @return Description of option
+   */
+  @FixLengthField(start = 26, length = 228)
+  public String getDescription() {
+    String desc = option.getDescription();
+    if (!option.isFlag() && StringUtils.isNotBlank(option.getDefaultValue())) {
+      desc += "(Default value is " + option.getDefaultValue() + ")";
     }
+    return desc;
+  }
 
-    /**
-     * @return Name of option value
-     */
-    @FixLengthField( start = 15, length = 10 )
-    public String getDisplayName()
-    {
-        return option.isFlag() ? null : "<" + option.getDisplayName() + ">";
-    }
+  /**
+   * @return Name of option value
+   */
+  @FixLengthField(start = 15, length = 10)
+  public String getDisplayName() {
+    return option.isFlag() ? null : "<" + option.getDisplayName() + ">";
+  }
 
-    /**
-     * @return Long name of option
-     */
-    @FixLengthField( start = 4, length = 10 )
-    public String getLongName()
-    {
-        return StringUtils.isBlank( option.getLongName() ) ? null : "--" + option.getLongName();
-    }
+  /**
+   * @return Long name of option
+   */
+  @FixLengthField(start = 4, length = 10)
+  public String getLongName() {
+    return StringUtils.isBlank(option.getLongName()) ? null : "--" + option.getLongName();
+  }
 
-    /**
-     * @return Short name of option
-     */
-    @FixLengthField( start = 1, length = 2 )
-    public String getName()
-    {
-        return "-" + option.getName();
-    }
+  /**
+   * @return Short name of option
+   */
+  @FixLengthField(start = 1, length = 2)
+  public String getName() {
+    return "-" + option.getName();
+  }
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/impl/ParsingContextBuilder.java b/src/main/java/org/cyclopsgroup/jcli/impl/ParsingContextBuilder.java
index f4ef659..d0e88f4 100644
--- a/src/main/java/org/cyclopsgroup/jcli/impl/ParsingContextBuilder.java
+++ b/src/main/java/org/cyclopsgroup/jcli/impl/ParsingContextBuilder.java
@@ -25,99 +25,85 @@
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  * @param <T> Type of bean to parse
  */
-class ParsingContextBuilder<T>
-{
-    @SuppressWarnings( "unchecked" )
-    private static <B, P> Reference<B> createReference( Class<? extends B> beanType, PropertyDescriptor descriptor,
-                                                        String longName )
-    {
-        Class<P> valueType = (Class<P>) descriptor.getPropertyType();
-        MultiValue multiValue = getAnnotation( descriptor, MultiValue.class );
-        if ( multiValue != null )
-        {
-            valueType = (Class<P>) multiValue.valueType();
-        }
+class ParsingContextBuilder<T> {
+  @SuppressWarnings("unchecked")
+  private static <B, P> Reference<B> createReference(Class<? extends B> beanType,
+      PropertyDescriptor descriptor, String longName) {
+    Class<P> valueType = (Class<P>) descriptor.getPropertyType();
+    MultiValue multiValue = getAnnotation(descriptor, MultiValue.class);
+    if (multiValue != null) {
+      valueType = (Class<P>) multiValue.valueType();
+    }
 
-        Converter<P> converter = new AnnotatedConverter<P>( valueType, descriptor );
-        ValueReference<B> reference = ValueReference.instanceOf( descriptor );
-        if ( multiValue != null )
-        {
-            return new MultiValueReference<B>( beanType, converter, reference, longName, multiValue.listType() );
-        }
-        return new SingleValueReference<B>( beanType, converter, reference, longName );
+    Converter<P> converter = new AnnotatedConverter<P>(valueType, descriptor);
+    ValueReference<B> reference = ValueReference.instanceOf(descriptor);
+    if (multiValue != null) {
+      return new MultiValueReference<B>(beanType, converter, reference, longName,
+          multiValue.listType());
     }
+    return new SingleValueReference<B>(beanType, converter, reference, longName);
+  }
 
-    /**
-     * Get annotation from either writer or reader of a Java property
-     *
-     * @param <A> Type of annotation
-     * @param descriptor Field descriptor from which annotation is searched
-     * @param type Type of annotation
-     * @return Annotation or null if it's not found
-     */
-    private static <A extends Annotation> A getAnnotation( PropertyDescriptor descriptor, Class<A> type )
-    {
-        A a = null;
-        if ( descriptor.getWriteMethod() != null )
-        {
-            a = descriptor.getWriteMethod().getAnnotation( type );
-        }
-        if ( a == null && descriptor.getReadMethod() != null )
-        {
-            a = descriptor.getReadMethod().getAnnotation( type );
-        }
-        return a;
+  /**
+   * Get annotation from either writer or reader of a Java property
+   *
+   * @param <A> Type of annotation
+   * @param descriptor Field descriptor from which annotation is searched
+   * @param type Type of annotation
+   * @return Annotation or null if it's not found
+   */
+  private static <A extends Annotation> A getAnnotation(PropertyDescriptor descriptor,
+      Class<A> type) {
+    A a = null;
+    if (descriptor.getWriteMethod() != null) {
+      a = descriptor.getWriteMethod().getAnnotation(type);
+    }
+    if (a == null && descriptor.getReadMethod() != null) {
+      a = descriptor.getReadMethod().getAnnotation(type);
     }
+    return a;
+  }
 
-    private final Class<? extends T> beanType;
+  private final Class<? extends T> beanType;
 
-    ParsingContextBuilder( Class<? extends T> beanType )
-    {
-        this.beanType = beanType;
-    }
+  ParsingContextBuilder(Class<? extends T> beanType) {
+    this.beanType = beanType;
+  }
 
-    AnnotationParsingContext<T> build()
-    {
-        List<AnnotationOption> options = new ArrayList<AnnotationOption>();
-        Map<String, Reference<T>> references = new HashMap<String, Reference<T>>();
-        Cli cliAnnotation = beanType.getAnnotation( Cli.class );
-        BeanInfo beanInfo;
-        try
-        {
-            beanInfo = Introspector.getBeanInfo( beanType );
-        }
-        catch ( IntrospectionException e )
-        {
-            throw new RuntimeException( "Bean " + beanType + " is not correctly defined", e );
-        }
-        Argument argument = null;
-        for ( PropertyDescriptor descriptor : beanInfo.getPropertyDescriptors() )
-        {
-            Method writer = descriptor.getWriteMethod();
-            if ( writer == null )
-            {
-                continue;
-            }
-            Option option = getAnnotation( descriptor, Option.class );
-            if ( option != null )
-            {
-                boolean flag =
-                    ( descriptor.getPropertyType() == Boolean.TYPE || descriptor.getPropertyType() == Boolean.class );
-                boolean multiValue = getAnnotation( descriptor, MultiValue.class ) != null;
-                options.add( new AnnotationOption( option, flag, multiValue ) );
-                references.put( option.name(), createReference( beanType, descriptor, option.longName() ) );
-                continue;
-            }
-            Argument arg = getAnnotation( descriptor, Argument.class );
-            if ( arg != null )
-            {
-                argument = arg;
-                references.put( DefaultArgumentProcessor.ARGUMENT_REFERNCE_NAME,
-                                createReference( beanType, descriptor, DefaultArgumentProcessor.ARGUMENT_REFERNCE_NAME ) );
-                continue;
-            }
-        }
-        return new AnnotationParsingContext<T>( references, options, new AnnotationCli( cliAnnotation ),
-                                                argument == null ? null : new AnnotationArgument( argument ) );
+  AnnotationParsingContext<T> build() {
+    List<AnnotationOption> options = new ArrayList<AnnotationOption>();
+    Map<String, Reference<T>> references = new HashMap<String, Reference<T>>();
+    Cli cliAnnotation = beanType.getAnnotation(Cli.class);
+    BeanInfo beanInfo;
+    try {
+      beanInfo = Introspector.getBeanInfo(beanType);
+    } catch (IntrospectionException e) {
+      throw new RuntimeException("Bean " + beanType + " is not correctly defined", e);
+    }
+    Argument argument = null;
+    for (PropertyDescriptor descriptor : beanInfo.getPropertyDescriptors()) {
+      Method writer = descriptor.getWriteMethod();
+      if (writer == null) {
+        continue;
+      }
+      Option option = getAnnotation(descriptor, Option.class);
+      if (option != null) {
+        boolean flag = (descriptor.getPropertyType() == Boolean.TYPE
+            || descriptor.getPropertyType() == Boolean.class);
+        boolean multiValue = getAnnotation(descriptor, MultiValue.class) != null;
+        options.add(new AnnotationOption(option, flag, multiValue));
+        references.put(option.name(), createReference(beanType, descriptor, option.longName()));
+        continue;
+      }
+      Argument arg = getAnnotation(descriptor, Argument.class);
+      if (arg != null) {
+        argument = arg;
+        references.put(DefaultArgumentProcessor.ARGUMENT_REFERNCE_NAME,
+            createReference(beanType, descriptor, DefaultArgumentProcessor.ARGUMENT_REFERNCE_NAME));
+        continue;
+      }
     }
+    return new AnnotationParsingContext<T>(references, options, new AnnotationCli(cliAnnotation),
+        argument == null ? null : new AnnotationArgument(argument));
+  }
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/impl/SingleValueReference.java b/src/main/java/org/cyclopsgroup/jcli/impl/SingleValueReference.java
index ea0adec..7a4bb05 100644
--- a/src/main/java/org/cyclopsgroup/jcli/impl/SingleValueReference.java
+++ b/src/main/java/org/cyclopsgroup/jcli/impl/SingleValueReference.java
@@ -3,22 +3,19 @@
 import org.cyclopsgroup.caff.conversion.Converter;
 import org.cyclopsgroup.caff.ref.ValueReference;
 
-class SingleValueReference<T>
-    extends Reference<T>
-{
-    SingleValueReference( Class<? extends T> beanType, Converter<?> converter, ValueReference<T> ref, String longName )
-    {
-        super( converter, ref, longName );
-    }
+class SingleValueReference<T> extends Reference<T> {
+  SingleValueReference(Class<? extends T> beanType, Converter<?> converter, ValueReference<T> ref,
+      String longName) {
+    super(converter, ref, longName);
+  }
 
-    /**
-     * Set a string value to bean based on known conversion rule and value reference
-     *
-     * @param bean Bean to set value to
-     * @param value String expression of value to set
-     */
-    void setValue( T bean, String value )
-    {
-        ref.writeValue( converter.fromCharacters( value ), bean );
-    }
+  /**
+   * Set a string value to bean based on known conversion rule and value reference
+   *
+   * @param bean Bean to set value to
+   * @param value String expression of value to set
+   */
+  void setValue(T bean, String value) {
+    ref.writeValue(converter.fromCharacters(value), bean);
+  }
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/jline/ArgumentsInspector.java b/src/main/java/org/cyclopsgroup/jcli/jline/ArgumentsInspector.java
index 1ccc81a..cb3f34d 100644
--- a/src/main/java/org/cyclopsgroup/jcli/jline/ArgumentsInspector.java
+++ b/src/main/java/org/cyclopsgroup/jcli/jline/ArgumentsInspector.java
@@ -12,140 +12,115 @@
  *
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
-class ArgumentsInspector
-{
-    private final ParsingContext context;
+class ArgumentsInspector {
+  private final ParsingContext context;
 
-    private Option currentOption;
+  private Option currentOption;
 
-    private String currentValue;
+  private String currentValue;
 
-    private final Set<Option> remainingOptions;
+  private final Set<Option> remainingOptions;
 
-    private ArgumentsInspectorState state = ArgumentsInspectorState.READY;
+  private ArgumentsInspectorState state = ArgumentsInspectorState.READY;
 
-    /**
-     * @param context Parsing context
-     */
-    ArgumentsInspector( ParsingContext context )
-    {
-        this.context = context;
-        remainingOptions = new HashSet<Option>( context.options() );
+  /**
+   * @param context Parsing context
+   */
+  ArgumentsInspector(ParsingContext context) {
+    this.context = context;
+    remainingOptions = new HashSet<Option>(context.options());
+  }
+
+  /**
+   * @param argument Argument to consume
+   */
+  void consume(String argument) {
+    if (argument.startsWith("--")) {
+      state = ArgumentsInspectorState.LONG_OPTION;
+    } else if (argument.startsWith("-")) {
+      state = ArgumentsInspectorState.OPTION;
+    } else {
+      switch (state) {
+        case READY:
+          state = ArgumentsInspectorState.ARGUMENT;
+          break;
+        case OPTION:
+          currentOption = context.optionWithShortName(currentValue.substring(1));
+        case LONG_OPTION:
+          if (state == ArgumentsInspectorState.LONG_OPTION) {
+            currentOption = context.optionWithLongName(currentValue.substring(2));
+          }
+          if (currentOption != null && !currentOption.isMultiValue()) {
+            remainingOptions.remove(currentOption);
+          }
+          if (currentOption == null || currentOption.isFlag()) {
+            state = ArgumentsInspectorState.ARGUMENT;
+          } else {
+            state = ArgumentsInspectorState.OPTION_VALUE;
+          }
+          break;
+        case OPTION_VALUE:
+        case ARGUMENT:
+          state = ArgumentsInspectorState.ARGUMENT;
+          break;
+        default:
+          throw new IllegalStateException();
+      }
     }
+    currentValue = argument;
+  }
 
-    /**
-     * @param argument Argument to consume
-     */
-    void consume( String argument )
-    {
-        if ( argument.startsWith( "--" ) )
-        {
-            state = ArgumentsInspectorState.LONG_OPTION;
-        }
-        else if ( argument.startsWith( "-" ) )
-        {
-            state = ArgumentsInspectorState.OPTION;
+  /**
+   * End the process
+   */
+  void end() {
+    switch (state) {
+      case OPTION:
+        currentOption = context.optionWithShortName(currentValue.substring(1));
+      case LONG_OPTION:
+        if (state == ArgumentsInspectorState.LONG_OPTION) {
+          currentOption = context.optionWithLongName(currentValue.substring(2));
         }
-        else
-        {
-            switch ( state )
-            {
-                case READY:
-                    state = ArgumentsInspectorState.ARGUMENT;
-                    break;
-                case OPTION:
-                    currentOption = context.optionWithShortName( currentValue.substring( 1 ) );
-                case LONG_OPTION:
-                    if ( state == ArgumentsInspectorState.LONG_OPTION )
-                    {
-                        currentOption = context.optionWithLongName( currentValue.substring( 2 ) );
-                    }
-                    if ( currentOption != null && !currentOption.isMultiValue() )
-                    {
-                        remainingOptions.remove( currentOption );
-                    }
-                    if ( currentOption == null || currentOption.isFlag() )
-                    {
-                        state = ArgumentsInspectorState.ARGUMENT;
-                    }
-                    else
-                    {
-                        state = ArgumentsInspectorState.OPTION_VALUE;
-                    }
-                    break;
-                case OPTION_VALUE:
-                case ARGUMENT:
-                    state = ArgumentsInspectorState.ARGUMENT;
-                    break;
-                default:
-                    throw new IllegalStateException();
-            }
+        if (currentOption != null && !currentOption.isMultiValue()) {
+          remainingOptions.remove(currentOption);
         }
-        currentValue = argument;
-    }
-
-    /**
-     * End the process
-     */
-    void end()
-    {
-        switch ( state )
-        {
-            case OPTION:
-                currentOption = context.optionWithShortName( currentValue.substring( 1 ) );
-            case LONG_OPTION:
-                if ( state == ArgumentsInspectorState.LONG_OPTION )
-                {
-                    currentOption = context.optionWithLongName( currentValue.substring( 2 ) );
-                }
-                if ( currentOption != null && !currentOption.isMultiValue() )
-                {
-                    remainingOptions.remove( currentOption );
-                }
-                if ( currentOption == null || currentOption.isFlag() )
-                {
-                    state = ArgumentsInspectorState.ARGUMENT;
-                }
-                else
-                {
-                    state = ArgumentsInspectorState.OPTION_VALUE;
-                }
-                break;
-            default:
-                state = ArgumentsInspectorState.READY;
+        if (currentOption == null || currentOption.isFlag()) {
+          state = ArgumentsInspectorState.ARGUMENT;
+        } else {
+          state = ArgumentsInspectorState.OPTION_VALUE;
         }
-        currentValue = null;
+        break;
+      default:
+        state = ArgumentsInspectorState.READY;
     }
+    currentValue = null;
+  }
 
-    /**
-     * @return The option being processed currently
-     */
-    Option getCurrentOption()
-    {
-        return currentOption;
-    }
+  /**
+   * @return The option being processed currently
+   */
+  Option getCurrentOption() {
+    return currentOption;
+  }
 
-    /**
-     * @return Current value
-     */
-    String getCurrentValue()
-    {
-        return currentValue;
-    }
+  /**
+   * @return Current value
+   */
+  String getCurrentValue() {
+    return currentValue;
+  }
 
-    /**
-     * @return Set of remaining options
-     */
-    Set<Option> getRemainingOptions()
-    {
-        return Collections.unmodifiableSet( remainingOptions );
-    }
+  /**
+   * @return Set of remaining options
+   */
+  Set<Option> getRemainingOptions() {
+    return Collections.unmodifiableSet(remainingOptions);
+  }
 
-    /**
-     * @return Current parsing state
-     */
-    ArgumentsInspectorState getState()
-    {
-        return state;
-    }
+  /**
+   * @return Current parsing state
+   */
+  ArgumentsInspectorState getState() {
+    return state;
+  }
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/jline/ArgumentsInspectorState.java b/src/main/java/org/cyclopsgroup/jcli/jline/ArgumentsInspectorState.java
index bdbf2e6..9e5bf12 100644
--- a/src/main/java/org/cyclopsgroup/jcli/jline/ArgumentsInspectorState.java
+++ b/src/main/java/org/cyclopsgroup/jcli/jline/ArgumentsInspectorState.java
@@ -5,26 +5,25 @@
  * 
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
-enum ArgumentsInspectorState
-{
-    /**
-     * Ready for new option of argument
-     */
-    READY,
-    /**
-     * Writing short option name
-     */
-    OPTION,
-    /**
-     * Writing long option name
-     */
-    LONG_OPTION,
-    /**
-     * Writing option value
-     */
-    OPTION_VALUE,
-    /**
-     * Writing argument
-     */
-    ARGUMENT;
+enum ArgumentsInspectorState {
+  /**
+   * Ready for new option of argument
+   */
+  READY,
+  /**
+   * Writing short option name
+   */
+  OPTION,
+  /**
+   * Writing long option name
+   */
+  LONG_OPTION,
+  /**
+   * Writing option value
+   */
+  OPTION_VALUE,
+  /**
+   * Writing argument
+   */
+  ARGUMENT;
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/jline/package-info.java b/src/main/java/org/cyclopsgroup/jcli/jline/package-info.java
index de8ad9e..766406c 100644
--- a/src/main/java/org/cyclopsgroup/jcli/jline/package-info.java
+++ b/src/main/java/org/cyclopsgroup/jcli/jline/package-info.java
@@ -1,4 +1,4 @@
 /**
  * Provides classes needed for jline(http://jline.sf.net) integration
  */
-package org.cyclopsgroup.jcli.jline;
\ No newline at end of file
+package org.cyclopsgroup.jcli.jline;
diff --git a/src/main/java/org/cyclopsgroup/jcli/package-info.java b/src/main/java/org/cyclopsgroup/jcli/package-info.java
index 1b5494a..79023ec 100644
--- a/src/main/java/org/cyclopsgroup/jcli/package-info.java
+++ b/src/main/java/org/cyclopsgroup/jcli/package-info.java
@@ -1,4 +1,4 @@
 /**
  * General utilities used by jcli package
  */
-package org.cyclopsgroup.jcli;
\ No newline at end of file
+package org.cyclopsgroup.jcli;
diff --git a/src/main/java/org/cyclopsgroup/jcli/spi/Argument.java b/src/main/java/org/cyclopsgroup/jcli/spi/Argument.java
index 3cea011..5d78b13 100644
--- a/src/main/java/org/cyclopsgroup/jcli/spi/Argument.java
+++ b/src/main/java/org/cyclopsgroup/jcli/spi/Argument.java
@@ -5,15 +5,14 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public interface Argument
-{
-    /**
-     * @return Description of arguments
-     */
-    String getDescription();
+public interface Argument {
+  /**
+   * @return Description of arguments
+   */
+  String getDescription();
 
-    /**
-     * @return Displayable argument name in help page
-     */
-    String getDisplayName();
+  /**
+   * @return Displayable argument name in help page
+   */
+  String getDisplayName();
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/spi/Cli.java b/src/main/java/org/cyclopsgroup/jcli/spi/Cli.java
index 4f94869..59bfdbe 100644
--- a/src/main/java/org/cyclopsgroup/jcli/spi/Cli.java
+++ b/src/main/java/org/cyclopsgroup/jcli/spi/Cli.java
@@ -5,20 +5,19 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public interface Cli
-{
-    /**
-     * @return Description of command line
-     */
-    String getDescription();
+public interface Cli {
+  /**
+   * @return Description of command line
+   */
+  String getDescription();
 
-    /**
-     * @return Name of command line
-     */
-    String getName();
+  /**
+   * @return Name of command line
+   */
+  String getName();
 
-    /**
-     * @return Not of command line in the end
-     */
-    String getNote();
+  /**
+   * @return Not of command line in the end
+   */
+  String getNote();
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/spi/CommandLineBuilder.java b/src/main/java/org/cyclopsgroup/jcli/spi/CommandLineBuilder.java
index 2a2bf9f..60a2468 100644
--- a/src/main/java/org/cyclopsgroup/jcli/spi/CommandLineBuilder.java
+++ b/src/main/java/org/cyclopsgroup/jcli/spi/CommandLineBuilder.java
@@ -7,90 +7,81 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public final class CommandLineBuilder
-{
-    private static final String FLAG_VALUE = Boolean.TRUE.toString();
+public final class CommandLineBuilder {
+  private static final String FLAG_VALUE = Boolean.TRUE.toString();
 
-    private final CommandLine cl = new CommandLine();
+  private final CommandLine cl = new CommandLine();
 
-    /**
-     * @return The command line instance with information that has been added so far
-     */
-    public CommandLine toCommandLine()
-    {
-        return cl;
-    }
+  /**
+   * @return The command line instance with information that has been added so far
+   */
+  public CommandLine toCommandLine() {
+    return cl;
+  }
 
-    /**
-     * @param argument Add an argument expression
-     * @return Builder itself
-     */
-    public CommandLineBuilder withArgument( String argument )
-    {
-        cl.addArgument( argument );
-        return this;
-    }
+  /**
+   * @param argument Add an argument expression
+   * @return Builder itself
+   */
+  public CommandLineBuilder withArgument(String argument) {
+    cl.addArgument(argument);
+    return this;
+  }
 
-    /**
-     * @param arguments Add a list of arguments
-     * @return Builder itself
-     */
-    public CommandLineBuilder withArguments( Collection<String> arguments )
-    {
-        for ( String arg : arguments )
-        {
-            withArgument( arg );
-        }
-        return this;
+  /**
+   * @param arguments Add a list of arguments
+   * @return Builder itself
+   */
+  public CommandLineBuilder withArguments(Collection<String> arguments) {
+    for (String arg : arguments) {
+      withArgument(arg);
     }
+    return this;
+  }
 
-    /**
-     * Add a flag option with its long name
-     *
-     * @param name Long name of the flag option to add
-     * @return Builder itself
-     */
-    public CommandLineBuilder withLongFlag( String name )
-    {
-        withLongOption( name, FLAG_VALUE );
-        return this;
-    }
+  /**
+   * Add a flag option with its long name
+   *
+   * @param name Long name of the flag option to add
+   * @return Builder itself
+   */
+  public CommandLineBuilder withLongFlag(String name) {
+    withLongOption(name, FLAG_VALUE);
+    return this;
+  }
 
-    /**
-     * Add an option with its long name
-     *
-     * @param name Long name of the option to add
-     * @param value Value of the option to add
-     * @return Builder itself
-     */
-    public CommandLineBuilder withLongOption( String name, String value )
-    {
-        cl.addOptionValue( name, value, false );
-        return this;
-    }
+  /**
+   * Add an option with its long name
+   *
+   * @param name Long name of the option to add
+   * @param value Value of the option to add
+   * @return Builder itself
+   */
+  public CommandLineBuilder withLongOption(String name, String value) {
+    cl.addOptionValue(name, value, false);
+    return this;
+  }
 
-    /**
-     * Add a flag option with its short name
-     *
-     * @param name Short name of option to add
-     * @return Builder itself
-     */
-    public CommandLineBuilder withShortFlag( String name )
-    {
-        withShortOption( name, FLAG_VALUE );
-        return this;
-    }
+  /**
+   * Add a flag option with its short name
+   *
+   * @param name Short name of option to add
+   * @return Builder itself
+   */
+  public CommandLineBuilder withShortFlag(String name) {
+    withShortOption(name, FLAG_VALUE);
+    return this;
+  }
 
-    /**
-     * Add an option with its short name
-     *
-     * @param name Short name of the option to add
-     * @param value Value of option to add
-     * @return Builder itself
-     */
-    public CommandLineBuilder withShortOption( String name, String value )
-    {
-        cl.addOptionValue( name, value, true );
-        return this;
-    }
+  /**
+   * Add an option with its short name
+   *
+   * @param name Short name of the option to add
+   * @param value Value of option to add
+   * @return Builder itself
+   */
+  public CommandLineBuilder withShortOption(String name, String value) {
+    cl.addOptionValue(name, value, true);
+    return this;
+  }
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/spi/CommandLineParser.java b/src/main/java/org/cyclopsgroup/jcli/spi/CommandLineParser.java
index 5266bc0..6283c96 100644
--- a/src/main/java/org/cyclopsgroup/jcli/spi/CommandLineParser.java
+++ b/src/main/java/org/cyclopsgroup/jcli/spi/CommandLineParser.java
@@ -7,12 +7,11 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public interface CommandLineParser
-{
-    /**
-     * @param arguments List of arguments
-     * @param context Parsing context
-     * @return Command line with values to pass to bean
-     */
-    CommandLine parse( List<String> arguments, ParsingContext context );
+public interface CommandLineParser {
+  /**
+   * @param arguments List of arguments
+   * @param context Parsing context
+   * @return Command line with values to pass to bean
+   */
+  CommandLine parse(List<String> arguments, ParsingContext context);
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/spi/Option.java b/src/main/java/org/cyclopsgroup/jcli/spi/Option.java
index 03e07c6..ff4e1b6 100644
--- a/src/main/java/org/cyclopsgroup/jcli/spi/Option.java
+++ b/src/main/java/org/cyclopsgroup/jcli/spi/Option.java
@@ -5,45 +5,44 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public interface Option
-{
-    /**
-     * @return Implied value of option, NULL if not specified
-     */
-    String getDefaultValue();
-
-    /**
-     * @return String description of the option
-     */
-    String getDescription();
-
-    /**
-     * @return Display name of option value
-     */
-    String getDisplayName();
-
-    /**
-     * @return Long option name used in command line
-     */
-    String getLongName();
-
-    /**
-     * @return Short option name used in command line
-     */
-    String getName();
-
-    /**
-     * @return True if option doesn't take a value
-     */
-    boolean isFlag();
-
-    /**
-     * @return True if there can be more than one of this option
-     */
-    boolean isMultiValue();
-
-    /**
-     * @return True if option is required
-     */
-    boolean isRequired();
+public interface Option {
+  /**
+   * @return Implied value of option, NULL if not specified
+   */
+  String getDefaultValue();
+
+  /**
+   * @return String description of the option
+   */
+  String getDescription();
+
+  /**
+   * @return Display name of option value
+   */
+  String getDisplayName();
+
+  /**
+   * @return Long option name used in command line
+   */
+  String getLongName();
+
+  /**
+   * @return Short option name used in command line
+   */
+  String getName();
+
+  /**
+   * @return True if option doesn't take a value
+   */
+  boolean isFlag();
+
+  /**
+   * @return True if there can be more than one of this option
+   */
+  boolean isMultiValue();
+
+  /**
+   * @return True if option is required
+   */
+  boolean isRequired();
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/spi/ParsingContext.java b/src/main/java/org/cyclopsgroup/jcli/spi/ParsingContext.java
index 35fb744..69d2fed 100644
--- a/src/main/java/org/cyclopsgroup/jcli/spi/ParsingContext.java
+++ b/src/main/java/org/cyclopsgroup/jcli/spi/ParsingContext.java
@@ -7,32 +7,31 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public interface ParsingContext
-{
-    /**
-     * @return Command line model
-     */
-    Cli cli();
+public interface ParsingContext {
+  /**
+   * @return Command line model
+   */
+  Cli cli();
 
-    /**
-     * @return Argument model
-     */
-    Argument argument();
+  /**
+   * @return Argument model
+   */
+  Argument argument();
 
-    /**
-     * @return List of all options
-     */
-    List<Option> options();
+  /**
+   * @return List of all options
+   */
+  List<Option> options();
 
-    /**
-     * @param longName Long name of option
-     * @return Option model. NULL if it doesn't exist
-     */
-    Option optionWithLongName( String longName );
+  /**
+   * @param longName Long name of option
+   * @return Option model. NULL if it doesn't exist
+   */
+  Option optionWithLongName(String longName);
 
-    /**
-     * @param shortName Name of option
-     * @return Option model. NULL if it doesn't exist
-     */
-    Option optionWithShortName( String shortName );
+  /**
+   * @param shortName Name of option
+   * @return Option model. NULL if it doesn't exist
+   */
+  Option optionWithShortName(String shortName);
 }
diff --git a/src/main/java/org/cyclopsgroup/jcli/spi/package-info.java b/src/main/java/org/cyclopsgroup/jcli/spi/package-info.java
index c1df7ab..809a03c 100644
--- a/src/main/java/org/cyclopsgroup/jcli/spi/package-info.java
+++ b/src/main/java/org/cyclopsgroup/jcli/spi/package-info.java
@@ -1,4 +1,4 @@
 /**
  * Service provider API for implementations
  */
-package org.cyclopsgroup.jcli.spi;
\ No newline at end of file
+package org.cyclopsgroup.jcli.spi;
diff --git a/src/test/java/org/cyclopsgroup/jcli/GnuParserTest.java b/src/test/java/org/cyclopsgroup/jcli/GnuParserTest.java
index 26715a7..dc5d42c 100644
--- a/src/test/java/org/cyclopsgroup/jcli/GnuParserTest.java
+++ b/src/test/java/org/cyclopsgroup/jcli/GnuParserTest.java
@@ -15,134 +15,125 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public class GnuParserTest
-{
-    /**
-     * Verify use cases with all possible types of arguments
-     */
-    @Test
-    public void testCombination()
-    {
-        ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance( Simple.class, new GnuParser() );
-        Simple b = new Simple();
-        p.process( new String[] { "-i", "123", "a", "-f", "abc", "b" }, b );
+public class GnuParserTest {
+  /**
+   * Verify use cases with all possible types of arguments
+   */
+  @Test
+  public void testCombination() {
+    ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance(Simple.class, new GnuParser());
+    Simple b = new Simple();
+    p.process(new String[] {"-i", "123", "a", "-f", "abc", "b"}, b);
 
-        assertEquals( 123, b.getIntField() );
-        assertEquals( "abc", b.getStringField1() );
-        assertEquals( Arrays.asList( "a", "b" ), b.getValues() );
-        assertFalse( b.isBooleanField() );
-    }
+    assertEquals(123, b.getIntField());
+    assertEquals("abc", b.getStringField1());
+    assertEquals(Arrays.asList("a", "b"), b.getValues());
+    assertFalse(b.isBooleanField());
+  }
 
-    /**
-     * Verify that long option name with dash is acceptable
-     */
-    @Test
-    public void testLongOptionWithDash()
-    {
-        ArgumentProcessor<WithoutCli> p = ArgumentProcessor.newInstance( WithoutCli.class, new GnuParser() );
-        WithoutCli b = new WithoutCli();
-        p.process( new String[] { "--with-dash", "x" }, b );
-        assertEquals( "x", b.optionWithDash );
-    }
+  /**
+   * Verify that long option name with dash is acceptable
+   */
+  @Test
+  public void testLongOptionWithDash() {
+    ArgumentProcessor<WithoutCli> p =
+        ArgumentProcessor.newInstance(WithoutCli.class, new GnuParser());
+    WithoutCli b = new WithoutCli();
+    p.process(new String[] {"--with-dash", "x"}, b);
+    assertEquals("x", b.optionWithDash);
+  }
 
-    /**
-     * Verify empty arguments doesn't reset default arguments
-     */
-    @Test
-    public void testNormalBeanWithoutValues()
-    {
-        ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance( Simple.class, new GnuParser() );
-        Simple b = new Simple();
-        p.process( new String[] { "-i", "123", "--field1", "abc" }, b );
+  /**
+   * Verify empty arguments doesn't reset default arguments
+   */
+  @Test
+  public void testNormalBeanWithoutValues() {
+    ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance(Simple.class, new GnuParser());
+    Simple b = new Simple();
+    p.process(new String[] {"-i", "123", "--field1", "abc"}, b);
 
-        assertEquals( 123, b.getIntField() );
-        assertEquals( "abc", b.getStringField1() );
-        assertEquals( new ArrayList<String>(), b.getValues() );
-        assertFalse( b.isBooleanField() );
-    }
+    assertEquals(123, b.getIntField());
+    assertEquals("abc", b.getStringField1());
+    assertEquals(new ArrayList<String>(), b.getValues());
+    assertFalse(b.isBooleanField());
+  }
 
-    /**
-     * Verify simple argument can be handled correctly
-     */
-    @Test
-    public void testSimpleArgumentWithMultiValues()
-    {
-        ArgumentProcessor<WithSimpleArgument> p =
-            ArgumentProcessor.newInstance( WithSimpleArgument.class, new GnuParser() );
-        WithSimpleArgument b = new WithSimpleArgument();
-        p.process( new String[] { "a", "b" }, b );
-        assertEquals( "a", b.getArg() );
-    }
+  /**
+   * Verify simple argument can be handled correctly
+   */
+  @Test
+  public void testSimpleArgumentWithMultiValues() {
+    ArgumentProcessor<WithSimpleArgument> p =
+        ArgumentProcessor.newInstance(WithSimpleArgument.class, new GnuParser());
+    WithSimpleArgument b = new WithSimpleArgument();
+    p.process(new String[] {"a", "b"}, b);
+    assertEquals("a", b.getArg());
+  }
 
-    /**
-     * Verify simple argument without value can be handled correctly
-     */
-    @Test
-    public void testSimpleArgumentWithoutValue()
-    {
-        ArgumentProcessor<WithSimpleArgument> p =
-            ArgumentProcessor.newInstance( WithSimpleArgument.class, new GnuParser() );
-        WithSimpleArgument b = new WithSimpleArgument();
-        p.process( new String[] {}, b );
-        assertNull( b.getArg() );
-    }
+  /**
+   * Verify simple argument without value can be handled correctly
+   */
+  @Test
+  public void testSimpleArgumentWithoutValue() {
+    ArgumentProcessor<WithSimpleArgument> p =
+        ArgumentProcessor.newInstance(WithSimpleArgument.class, new GnuParser());
+    WithSimpleArgument b = new WithSimpleArgument();
+    p.process(new String[] {}, b);
+    assertNull(b.getArg());
+  }
 
-    @Test
-    public void testWithDash()
-    {
-        ArgumentProcessor<Simple> p = ArgumentProcessor.forType( Simple.class );
-        Simple s = new Simple();
-        p.process( new String[] { "-f", "-1" }, s );
-        assertEquals( "-1", s.getStringField1() );
-    }
+  @Test
+  public void testWithDash() {
+    ArgumentProcessor<Simple> p = ArgumentProcessor.forType(Simple.class);
+    Simple s = new Simple();
+    p.process(new String[] {"-f", "-1"}, s);
+    assertEquals("-1", s.getStringField1());
+  }
 
-    /**
-     * Verify boolean is handled correctly
-     */
-    @Test
-    public void testWithFlag()
-    {
-        ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance( Simple.class, new GnuParser() );
-        Simple b = new Simple();
-        p.process( new String[] { "-b", "123" }, b );
-        assertTrue( b.isBooleanField() );
-    }
+  /**
+   * Verify boolean is handled correctly
+   */
+  @Test
+  public void testWithFlag() {
+    ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance(Simple.class, new GnuParser());
+    Simple b = new Simple();
+    p.process(new String[] {"-b", "123"}, b);
+    assertTrue(b.isBooleanField());
+  }
 
-    /**
-     * Verify multi value option is handled correctly
-     */
-    @Test
-    public void testWithMultiValueOption()
-    {
-        ArgumentProcessor<WithMultiValueOption> p =
-            ArgumentProcessor.newInstance( WithMultiValueOption.class, new GnuParser() );
-        WithMultiValueOption b = new WithMultiValueOption();
-        p.process( new String[] { "a", "-o", "b", "-o", "c", "d", "--option", "e" }, b );
-        assertEquals( Arrays.asList( "b", "c", "e" ), b.getOptions() );
-    }
+  /**
+   * Verify multi value option is handled correctly
+   */
+  @Test
+  public void testWithMultiValueOption() {
+    ArgumentProcessor<WithMultiValueOption> p =
+        ArgumentProcessor.newInstance(WithMultiValueOption.class, new GnuParser());
+    WithMultiValueOption b = new WithMultiValueOption();
+    p.process(new String[] {"a", "-o", "b", "-o", "c", "d", "--option", "e"}, b);
+    assertEquals(Arrays.asList("b", "c", "e"), b.getOptions());
+  }
 
-    /**
-     * Verify negative numbers are accepted
-     */
-    @Test
-    public void testWithNegativeNumbers()
-    {
-        ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance( Simple.class, new GnuParser() );
-        Simple b = new Simple();
-        p.process( new String[] { "-1", "--1", "-2", "-3", "-4" }, b );
-        assertEquals( "-3", b.getStringFIeld2() );
-        assertEquals( Arrays.asList( "-1", "--1", "-4" ), b.getValues() );
-    }
+  /**
+   * Verify negative numbers are accepted
+   */
+  @Test
+  public void testWithNegativeNumbers() {
+    ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance(Simple.class, new GnuParser());
+    Simple b = new Simple();
+    p.process(new String[] {"-1", "--1", "-2", "-3", "-4"}, b);
+    assertEquals("-3", b.getStringFIeld2());
+    assertEquals(Arrays.asList("-1", "--1", "-4"), b.getValues());
+  }
 
-    /**
-     * Verify bean without Cli annotation is acceptable
-     */
-    @Test
-    public void testWithoutCli()
-    {
-        ArgumentProcessor<WithoutCli> p = ArgumentProcessor.newInstance( WithoutCli.class, new GnuParser() );
-        WithoutCli b = new WithoutCli();
-        p.process( new String[] { "-a", "aaaaa" }, b );
-        assertEquals( "aaaaa", b.optionA );
-    }
+  /**
+   * Verify bean without Cli annotation is acceptable
+   */
+  @Test
+  public void testWithoutCli() {
+    ArgumentProcessor<WithoutCli> p =
+        ArgumentProcessor.newInstance(WithoutCli.class, new GnuParser());
+    WithoutCli b = new WithoutCli();
+    p.process(new String[] {"-a", "aaaaa"}, b);
+    assertEquals("aaaaa", b.optionA);
+  }
 }
diff --git a/src/test/java/org/cyclopsgroup/jcli/MultiActionTest.java b/src/test/java/org/cyclopsgroup/jcli/MultiActionTest.java
index 2ff9366..81f7703 100644
--- a/src/test/java/org/cyclopsgroup/jcli/MultiActionTest.java
+++ b/src/test/java/org/cyclopsgroup/jcli/MultiActionTest.java
@@ -12,19 +12,17 @@
  * A test to go over multi action use case
  */
 public class MultiActionTest {
-	/**
-	 * Happy case of multi actions.
-	 */
-	@Test
-	public void testMultiAction()
-			throws InstantiationException, IllegalAccessException {
-		Map<String, Class<?>> clis = new HashMap<String, Class<?>>();
-		clis.put("nocli", WithoutCli.class);
-		clis.put("simple", WithSimpleArgument.class);
+  /**
+   * Happy case of multi actions.
+   */
+  @Test
+  public void testMultiAction() throws InstantiationException, IllegalAccessException {
+    Map<String, Class<?>> clis = new HashMap<String, Class<?>>();
+    clis.put("nocli", WithoutCli.class);
+    clis.put("simple", WithSimpleArgument.class);
 
-		WithoutCli nocli = (WithoutCli) clis.get("nocli").newInstance();
-		ArgumentProcessor.forTypeOf(nocli).process(Arrays.asList("-a", "aaaaa"),
-				nocli);
-		assertEquals("aaaaa", nocli.optionA);
-	}
+    WithoutCli nocli = (WithoutCli) clis.get("nocli").newInstance();
+    ArgumentProcessor.forTypeOf(nocli).process(Arrays.asList("-a", "aaaaa"), nocli);
+    assertEquals("aaaaa", nocli.optionA);
+  }
 }
diff --git a/src/test/java/org/cyclopsgroup/jcli/WithMultiValueOption.java b/src/test/java/org/cyclopsgroup/jcli/WithMultiValueOption.java
index 320fce9..a9fd4e2 100644
--- a/src/test/java/org/cyclopsgroup/jcli/WithMultiValueOption.java
+++ b/src/test/java/org/cyclopsgroup/jcli/WithMultiValueOption.java
@@ -12,26 +12,23 @@
  *
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
-@Cli( name = "sample" )
-public class WithMultiValueOption
-{
-    private List<String> options;
+@Cli(name = "sample")
+public class WithMultiValueOption {
+  private List<String> options;
 
-    /**
-     * @return List value of option
-     */
-    public final List<String> getOptions()
-    {
-        return options;
-    }
+  /**
+   * @return List value of option
+   */
+  public final List<String> getOptions() {
+    return options;
+  }
 
-    /**
-     * @param options Option values
-     */
-    @Option( name = "o", longName = "option", description = "Multi value option" )
-    @MultiValue( listType = ArrayList.class )
-    public final void setOptions( List<String> options )
-    {
-        this.options = options;
-    }
+  /**
+   * @param options Option values
+   */
+  @Option(name = "o", longName = "option", description = "Multi value option")
+  @MultiValue(listType = ArrayList.class)
+  public final void setOptions(List<String> options) {
+    this.options = options;
+  }
 }
diff --git a/src/test/java/org/cyclopsgroup/jcli/WithSimpleArgument.java b/src/test/java/org/cyclopsgroup/jcli/WithSimpleArgument.java
index 26db0d4..48fdc70 100644
--- a/src/test/java/org/cyclopsgroup/jcli/WithSimpleArgument.java
+++ b/src/test/java/org/cyclopsgroup/jcli/WithSimpleArgument.java
@@ -8,25 +8,22 @@
  * 
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
-@Cli( name = "sample2" )
-public class WithSimpleArgument
-{
-    private String arg;
+@Cli(name = "sample2")
+public class WithSimpleArgument {
+  private String arg;
 
-    /**
-     * @param arg Argument value
-     */
-    @Argument
-    public final void setArg( String arg )
-    {
-        this.arg = arg;
-    }
+  /**
+   * @param arg Argument value
+   */
+  @Argument
+  public final void setArg(String arg) {
+    this.arg = arg;
+  }
 
-    /**
-     * @return Argument value
-     */
-    public final String getArg()
-    {
-        return arg;
-    }
+  /**
+   * @return Argument value
+   */
+  public final String getArg() {
+    return arg;
+  }
 }
diff --git a/src/test/java/org/cyclopsgroup/jcli/WithoutCli.java b/src/test/java/org/cyclopsgroup/jcli/WithoutCli.java
index d109083..86258d1 100644
--- a/src/test/java/org/cyclopsgroup/jcli/WithoutCli.java
+++ b/src/test/java/org/cyclopsgroup/jcli/WithoutCli.java
@@ -5,27 +5,24 @@
 /**
  * A bean with out cli annotation
  */
-public class WithoutCli
-{
-    String optionA;
+public class WithoutCli {
+  String optionA;
 
-    String optionWithDash;
+  String optionWithDash;
 
-    /**
-     * @param value A string option
-     */
-    @Option( name = "a" )
-    public void setOptionA( String value )
-    {
-        this.optionA = value;
-    }
+  /**
+   * @param value A string option
+   */
+  @Option(name = "a")
+  public void setOptionA(String value) {
+    this.optionA = value;
+  }
 
-    /**
-     * @param value A string option with dash in name
-     */
-    @Option( name = "d", longName = "with-dash" )
-    public void setOptionWithDash( String value )
-    {
-        this.optionWithDash = value;
-    }
+  /**
+   * @param value A string option with dash in name
+   */
+  @Option(name = "d", longName = "with-dash")
+  public void setOptionWithDash(String value) {
+    this.optionWithDash = value;
+  }
 }
diff --git a/src/test/java/org/cyclopsgroup/jcli/example/UserControlTest.java b/src/test/java/org/cyclopsgroup/jcli/example/UserControlTest.java
index 9ed9552..051ffa0 100644
--- a/src/test/java/org/cyclopsgroup/jcli/example/UserControlTest.java
+++ b/src/test/java/org/cyclopsgroup/jcli/example/UserControlTest.java
@@ -13,18 +13,17 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public class UserControlTest
-{
-    /**
-     * Verify user control parsing is correct
-     */
-    @Test
-    public void testWithSingleUser()
-    {
-        ArgumentProcessor<UserControl> p = ArgumentProcessor.newInstance( UserControl.class, new GnuParser() );
-        UserControl c = new UserControl();
-        p.process( Arrays.asList( "-a", "ADD", "john" ), c );
-        assertEquals( UserControlAction.ADD, c.getAction() );
-        assertEquals( Arrays.asList( "john" ), c.getUserNames() );
-    }
+public class UserControlTest {
+  /**
+   * Verify user control parsing is correct
+   */
+  @Test
+  public void testWithSingleUser() {
+    ArgumentProcessor<UserControl> p =
+        ArgumentProcessor.newInstance(UserControl.class, new GnuParser());
+    UserControl c = new UserControl();
+    p.process(Arrays.asList("-a", "ADD", "john"), c);
+    assertEquals(UserControlAction.ADD, c.getAction());
+    assertEquals(Arrays.asList("john"), c.getUserNames());
+  }
 }
diff --git a/src/test/java/org/cyclopsgroup/jcli/impl/DefaultArgumentProcessorTest.java b/src/test/java/org/cyclopsgroup/jcli/impl/DefaultArgumentProcessorTest.java
index f34d685..59cdf54 100644
--- a/src/test/java/org/cyclopsgroup/jcli/impl/DefaultArgumentProcessorTest.java
+++ b/src/test/java/org/cyclopsgroup/jcli/impl/DefaultArgumentProcessorTest.java
@@ -20,46 +20,40 @@
  *
  * @author <a href="mailto:jiaqi@cyclopsgroup.org">Jiaqi Guo</a>
  */
-public class DefaultArgumentProcessorTest
-{
-    /**
-     * Verify {@link ServiceLoader} can find right implementation
-     */
-    @Test
-    public void testAvailability()
-    {
-        ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance( Simple.class, null );
-        assertNotNull( p );
-        assertTrue( p.getClass() == DefaultArgumentProcessor.class );
-    }
+public class DefaultArgumentProcessorTest {
+  /**
+   * Verify {@link ServiceLoader} can find right implementation
+   */
+  @Test
+  public void testAvailability() {
+    ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance(Simple.class, null);
+    assertNotNull(p);
+    assertTrue(p.getClass() == DefaultArgumentProcessor.class);
+  }
 
-    /**
-     * Verify parsing context is correctly created
-     */
-    @Test
-    public void testParsingContextWithNormalBean()
-    {
-        DefaultArgumentProcessor<Simple> p =
-            new DefaultArgumentProcessor<Simple>( Simple.class, null );
-        Option a = p.getContext().optionWithShortName( "i" );
-        assertEquals( "i", a.getName() );
-        assertEquals( "tint", a.getLongName() );
-        assertFalse( a.isFlag() );
+  /**
+   * Verify parsing context is correctly created
+   */
+  @Test
+  public void testParsingContextWithNormalBean() {
+    DefaultArgumentProcessor<Simple> p = new DefaultArgumentProcessor<Simple>(Simple.class, null);
+    Option a = p.getContext().optionWithShortName("i");
+    assertEquals("i", a.getName());
+    assertEquals("tint", a.getLongName());
+    assertFalse(a.isFlag());
 
-        Option b = p.getContext().optionWithLongName( "field1" );
-        assertEquals( "f", b.getName() );
-        assertEquals( "field1", b.getLongName() );
-        assertEquals( "field1", b.getLongName() );
-    }
+    Option b = p.getContext().optionWithLongName("field1");
+    assertEquals("f", b.getName());
+    assertEquals("field1", b.getLongName());
+    assertEquals("field1", b.getLongName());
+  }
 
-    /**
-     * @throws IOException
-     */
-    @Test
-    public void testPrintHelp()
-        throws IOException
-    {
-        ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance( Simple.class, null );
-        p.printHelp( new PrintWriter( new OutputStreamWriter( System.out ), true ) );
-    }
+  /**
+   * @throws IOException
+   */
+  @Test
+  public void testPrintHelp() throws IOException {
+    ArgumentProcessor<Simple> p = ArgumentProcessor.newInstance(Simple.class, null);
+    p.printHelp(new PrintWriter(new OutputStreamWriter(System.out), true));
+  }
 }
diff --git a/src/test/java/org/cyclopsgroup/jcli/jline/ArgumentsInspectorTest.java b/src/test/java/org/cyclopsgroup/jcli/jline/ArgumentsInspectorTest.java
index dc14444..cd80087 100644
--- a/src/test/java/org/cyclopsgroup/jcli/jline/ArgumentsInspectorTest.java
+++ b/src/test/java/org/cyclopsgroup/jcli/jline/ArgumentsInspectorTest.java
@@ -14,36 +14,32 @@
  *
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
-public class ArgumentsInspectorTest
-{
-    private ArgumentsInspector ins;
+public class ArgumentsInspectorTest {
+  private ArgumentsInspector ins;
 
-    /**
-     * Setup object to test
-     *
-     * @throws IntrospectionException
-     */
-    @Before
-    public void setUp()
-        throws IntrospectionException
-    {
-        ins = new ArgumentsInspector( ArgumentProcessor.forType( Simple.class ).createParsingContext() );
-    }
+  /**
+   * Setup object to test
+   *
+   * @throws IntrospectionException
+   */
+  @Before
+  public void setUp() throws IntrospectionException {
+    ins = new ArgumentsInspector(ArgumentProcessor.forType(Simple.class).createParsingContext());
+  }
 
-    /**
-     * Test state change of a sevies of argument consumption
-     */
-    @Test
-    public void testConsume()
-    {
-        assertEquals( ArgumentsInspectorState.READY, ins.getState() );
-        ins.consume( "xyz" );
-        assertEquals( ArgumentsInspectorState.ARGUMENT, ins.getState() );
-        assertEquals( "xyz", ins.getCurrentValue() );
-        ins.consume( "-i" );
-        assertEquals( ArgumentsInspectorState.OPTION, ins.getState() );
-        ins.consume( "1234" );
-        assertEquals( ArgumentsInspectorState.OPTION_VALUE, ins.getState() );
-        assertEquals( "i", ins.getCurrentOption().getName() );
-    }
+  /**
+   * Test state change of a sevies of argument consumption
+   */
+  @Test
+  public void testConsume() {
+    assertEquals(ArgumentsInspectorState.READY, ins.getState());
+    ins.consume("xyz");
+    assertEquals(ArgumentsInspectorState.ARGUMENT, ins.getState());
+    assertEquals("xyz", ins.getCurrentValue());
+    ins.consume("-i");
+    assertEquals(ArgumentsInspectorState.OPTION, ins.getState());
+    ins.consume("1234");
+    assertEquals(ArgumentsInspectorState.OPTION_VALUE, ins.getState());
+    assertEquals("i", ins.getCurrentOption().getName());
+  }
 }
diff --git a/src/test/java/org/cyclopsgroup/jcli/jline/CliCompletorTest.java b/src/test/java/org/cyclopsgroup/jcli/jline/CliCompletorTest.java
index d6ccf40..5e0bbbe 100644
--- a/src/test/java/org/cyclopsgroup/jcli/jline/CliCompletorTest.java
+++ b/src/test/java/org/cyclopsgroup/jcli/jline/CliCompletorTest.java
@@ -22,154 +22,133 @@
  *
  * @author <a href="mailto:jiaqi.guo@gmail.com">Jiaqi Guo</a>
  */
-public class CliCompletorTest
-{
-    private List<Candidate> candidates;
+public class CliCompletorTest {
+  private List<Candidate> candidates;
 
-    private CliCompletor cc;
+  private CliCompletor cc;
 
-    private Mockery context;
+  private Mockery context;
 
-    private LineReader lineReader;
+  private LineReader lineReader;
 
-    private ParsedLine parsedLine;
+  private ParsedLine parsedLine;
 
-    /**
-     * Set up completor to test
-     *
-     * @throws IntrospectionException
-     */
-    @Before
-    public void setUp()
-        throws IntrospectionException
-    {
-        cc = new CliCompletor( new Simple(), new QuotedValueTokenizer() );
-        candidates = new ArrayList<Candidate>();
-        context = new Mockery();
-        lineReader = context.mock(LineReader.class);
-        parsedLine = context.mock(ParsedLine.class);
-    }
+  /**
+   * Set up completor to test
+   *
+   * @throws IntrospectionException
+   */
+  @Before
+  public void setUp() throws IntrospectionException {
+    cc = new CliCompletor(new Simple(), new QuotedValueTokenizer());
+    candidates = new ArrayList<Candidate>();
+    context = new Mockery();
+    lineReader = context.mock(LineReader.class);
+    parsedLine = context.mock(ParsedLine.class);
+  }
 
-    /**
-     * @throws IntrospectionException
-     */
-    @Test
-    public void testCompleteWithEmpty()
-        throws IntrospectionException
-    {
-        context.checking( new Expectations()
-        {
-            {
-                oneOf( parsedLine ).line();
-                will( returnValue( "" ) );
-            }
-        } );
-        cc.complete( lineReader, parsedLine, candidates );
-        String[] expecteds = {"-2", "-b", "-f", "-i", "11111", "22222", "33333"};
-        for (int i = 0; i < expecteds.length; i++)
-        {
-            assertThat(candidates.get(i).value(), is(expecteds[i]));
-        }
+  /**
+   * @throws IntrospectionException
+   */
+  @Test
+  public void testCompleteWithEmpty() throws IntrospectionException {
+    context.checking(new Expectations() {
+      {
+        oneOf(parsedLine).line();
+        will(returnValue(""));
+      }
+    });
+    cc.complete(lineReader, parsedLine, candidates);
+    String[] expecteds = {"-2", "-b", "-f", "-i", "11111", "22222", "33333"};
+    for (int i = 0; i < expecteds.length; i++) {
+      assertThat(candidates.get(i).value(), is(expecteds[i]));
     }
+  }
 
-    /**
-     * Test with input <code>--</code>
-     */
-    @Test
-    public void testCompleteWithLongOptionPrefix()
-    {
-        context.checking( new Expectations()
-        {
-            {
-                oneOf( parsedLine ).line();
-                will( returnValue( "--" ) );
-            }
-        } );
-        cc.complete( lineReader, parsedLine,  candidates );
-        String[] expecteds = {"--boolean", "--field1", "--field2", "--tint"};
-        for (int i = 0; i < expecteds.length; i++)
-        {
-            assertThat(candidates.get(i).value(), is(expecteds[i]));
-        }
+  /**
+   * Test with input <code>--</code>
+   */
+  @Test
+  public void testCompleteWithLongOptionPrefix() {
+    context.checking(new Expectations() {
+      {
+        oneOf(parsedLine).line();
+        will(returnValue("--"));
+      }
+    });
+    cc.complete(lineReader, parsedLine, candidates);
+    String[] expecteds = {"--boolean", "--field1", "--field2", "--tint"};
+    for (int i = 0; i < expecteds.length; i++) {
+      assertThat(candidates.get(i).value(), is(expecteds[i]));
     }
+  }
 
-    /**
-     * Test with input <code>-f </code>
-     */
-    @Test
-    public void testCompleteWithOption()
-    {
-        context.checking( new Expectations()
-        {
-            {
-                oneOf( parsedLine ).line();
-                will( returnValue( "-f " ) );
-            }
-        } );
-        cc.complete( lineReader, parsedLine, candidates );
-        String[] expecteds = {"aaaa", "bbbb", "cccc"};
-        for (int i = 0; i < expecteds.length; i++)
-        {
-            assertThat(candidates.get(i).value(), is(expecteds[i]));
-        }
+  /**
+   * Test with input <code>-f </code>
+   */
+  @Test
+  public void testCompleteWithOption() {
+    context.checking(new Expectations() {
+      {
+        oneOf(parsedLine).line();
+        will(returnValue("-f "));
+      }
+    });
+    cc.complete(lineReader, parsedLine, candidates);
+    String[] expecteds = {"aaaa", "bbbb", "cccc"};
+    for (int i = 0; i < expecteds.length; i++) {
+      assertThat(candidates.get(i).value(), is(expecteds[i]));
     }
+  }
 
-    /**
-     * Test with input <code>-</code>
-     */
-    @Test
-    public void testCompleteWithOptionPrefix()
-    {
-        context.checking( new Expectations()
-        {
-            {
-                oneOf( parsedLine ).line();
-                will( returnValue( "-" ) );
-            }
-        } );
-        cc.complete( lineReader, parsedLine, candidates );
-        String[] expecteds = {"-2", "-b", "-f", "-i"};
-        for (int i = 0; i < expecteds.length; i++)
-        {
-            assertThat(candidates.get(i).value(), is(expecteds[i]));
-        }
+  /**
+   * Test with input <code>-</code>
+   */
+  @Test
+  public void testCompleteWithOptionPrefix() {
+    context.checking(new Expectations() {
+      {
+        oneOf(parsedLine).line();
+        will(returnValue("-"));
+      }
+    });
+    cc.complete(lineReader, parsedLine, candidates);
+    String[] expecteds = {"-2", "-b", "-f", "-i"};
+    for (int i = 0; i < expecteds.length; i++) {
+      assertThat(candidates.get(i).value(), is(expecteds[i]));
     }
+  }
 
-    /**
-     * Test with input <code>--f</code>
-     */
-    @Test
-    public void testCompleteWithPartialLongOption()
-    {
-        context.checking( new Expectations()
-        {
-            {
-                oneOf( parsedLine ).line();
-                will( returnValue( "--f" ) );
-            }
-        } );
-        cc.complete( lineReader, parsedLine, candidates );
-        String[] expecteds = {"--field1", "--field2"};
-        for (int i = 0; i < expecteds.length; i++)
-        {
-            assertThat(candidates.get(i).value(), is(expecteds[i]));
-        }
+  /**
+   * Test with input <code>--f</code>
+   */
+  @Test
+  public void testCompleteWithPartialLongOption() {
+    context.checking(new Expectations() {
+      {
+        oneOf(parsedLine).line();
+        will(returnValue("--f"));
+      }
+    });
+    cc.complete(lineReader, parsedLine, candidates);
+    String[] expecteds = {"--field1", "--field2"};
+    for (int i = 0; i < expecteds.length; i++) {
+      assertThat(candidates.get(i).value(), is(expecteds[i]));
     }
+  }
 
-    /**
-     * Test with <code>-i 1 -f 11</code>
-     */
-    @Test
-    public void testCompleteWithSecondOption()
-    {
-        context.checking( new Expectations()
-        {
-            {
-                oneOf( parsedLine ).line();
-                will( returnValue( "-i 1 -f aa" ) );
-            }
-        } );
-        cc.complete( lineReader, parsedLine, candidates );
-        assertThat(candidates.get(0).value(), is("aaaa"));
-    }
+  /**
+   * Test with <code>-i 1 -f 11</code>
+   */
+  @Test
+  public void testCompleteWithSecondOption() {
+    context.checking(new Expectations() {
+      {
+        oneOf(parsedLine).line();
+        will(returnValue("-i 1 -f aa"));
+      }
+    });
+    cc.complete(lineReader, parsedLine, candidates);
+    assertThat(candidates.get(0).value(), is("aaaa"));
+  }
 }