Make sure cli outputs usage in case of an error

For example when no command is provided.
Fixes #110

Author: pesse

pom.xml

@@ -4,7 +4,7 @@
 
   <groupId>org.utplsql</groupId>
   <artifactId>cli</artifactId>
-  <version>3.1.2-SNAPSHOT</version>
+  <version>3.1.3-SNAPSHOT</version>
   <packaging>jar</packaging>
 
   <name>cli</name>

src/main/java/org/utplsql/cli/Cli.java

@@ -3,9 +3,6 @@
 import com.beust.jcommander.JCommander;
 import com.beust.jcommander.Parameter;
 import com.beust.jcommander.ParameterException;
-import org.utplsql.api.exception.DatabaseNotCompatibleException;
-import org.utplsql.api.exception.UtPLSQLNotInstalledException;
-import org.utplsql.cli.exception.DatabaseConnectionFailed;
 
 public class Cli {
 
@@ -26,36 +23,31 @@ static int runWithExitCode( String[] args ) {
         JCommander jc = new JCommander();
         jc.setProgramName("utplsql");
 
-        CommandProvider cmdProvider = new CommandProvider();
+        CommandProvider cmdProvider = new CommandProvider(jc);
 
         cmdProvider.commands().forEach(cmd -> jc.addCommand(cmd.getCommand(), cmd));
 
         int exitCode = DEFAULT_ERROR_CODE;
 
-        try {
-            jc.parse(args);
+        if ( args.length >= 1 && args[0].equals("-h") ) // Help?
+        {
+            exitCode = 0;
+            jc.usage();
+        }
+        else {
+            try {
+                jc.parse(args);
 
-            exitCode = cmdProvider.getCommand(jc.getParsedCommand()).run();
+                exitCode = cmdProvider.getCommand(jc.getParsedCommand()).run();
 
-        } catch (ParameterException e) {
-            if (jc.getParsedCommand() != null) {
-                System.err.println(e.getMessage());
-                jc.usage(jc.getParsedCommand());
-            } else {
-                jc.usage();
+            } catch (ParameterException e) {
+                exitCode = new HelpCommand(jc, e.getMessage()).run();
+            } catch (Exception e) {
+                e.printStackTrace();
             }
-        }  catch (Exception e) {
-            e.printStackTrace();
         }
 
         return exitCode;
     }
 
-    private static class HelpCommand {
-
-        @Parameter(names = {HELP_CMD, "--help"}, help = true)
-        public boolean callHelp;
-
-    }
-
 }

src/main/java/org/utplsql/cli/CommandProvider.java

@@ -1,14 +1,18 @@
 package org.utplsql.cli;
 
+import com.beust.jcommander.JCommander;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.Stream;
 
 public class CommandProvider {
 
     private Map<String, ICommand> commands;
+    private JCommander jCommander;
 
-    public CommandProvider() {
+    public CommandProvider( JCommander jCommander ) {
+        this.jCommander = jCommander;
         init();
     }
 
@@ -18,6 +22,7 @@ private void init() {
         addCommand(new RunCommand());
         addCommand(new VersionInfoCommand());
         addCommand(new ReportersCommand());
+        addCommand(new HelpCommand(jCommander));
     }
 
     private void addCommand( ICommand command ) {
@@ -28,7 +33,7 @@ public ICommand getCommand( String key ) {
         if ( commands.containsKey(key))
             return commands.get(key.toLowerCase());
         else
-            return new HelpCommand("Unknown command: '" + key + "'");
+            return new HelpCommand(jCommander, "Unknown command: '" + key + "'");
     }
 
     public Stream<ICommand> commands() {

src/main/java/org/utplsql/cli/HelpCommand.java

@@ -1,19 +1,38 @@
 package org.utplsql.cli;
 
+import com.beust.jcommander.JCommander;
+
+/** Simple Help-Command which outputs an (optional) error message and the command line usage
+ * @author pesse
+ */
 public class HelpCommand implements ICommand {
 
     private String errorMessage;
+    private JCommander jCommander;
+
+    public HelpCommand(JCommander jCommander) {
+        this.jCommander = jCommander;
+    }
 
-    public HelpCommand( String errorMessage ) {
+    public HelpCommand( JCommander jCommander, String errorMessage ) {
+        this.jCommander = jCommander;
         this.errorMessage = errorMessage;
     }
 
     @Override
     public int run() {
-        if ( errorMessage != null )
+        if ( errorMessage != null ) {
             System.out.println(errorMessage);
-
-        return 1;
+            if (jCommander.getParsedCommand() != null)
+                jCommander.usage(jCommander.getParsedCommand());
+            else
+                jCommander.usage();
+            return 1;
+        }
+        else {
+            jCommander.usage();
+            return 0;
+        }
     }
 
     @Override

src/test/java/org/utplsql/cli/HelpCommandTest.java

@@ -0,0 +1,49 @@
+package org.utplsql.cli;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.utplsql.cli.util.SystemOutCapturer;
+
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class HelpCommandTest {
+
+
+    private SystemOutCapturer capturer;
+
+    @BeforeEach
+    public void setupCaptureSystemOut() {
+        capturer = new SystemOutCapturer();
+    }
+
+    @Test
+    public void callHelp() {
+
+        capturer.start();
+        int result = TestHelper.runApp("-h");
+        String output = capturer.stop();
+
+        assertEquals(0, result);
+        assertTrue(output.contains("Usage:"));
+    }
+
+    @Test
+    public void callWithNoArgs() {
+
+        capturer.start();
+        int result = TestHelper.runApp();
+        String output = capturer.stop();
+
+        assertEquals(1, result);
+        assertTrue(output.contains("Usage:"));
+    }
+
+    @AfterEach
+    public void cleanupCaptureSystemOut() throws IOException {
+        capturer.stop();
+    }
+}