gli 2.11.0 → 2.20.0

data/test/{tc_help.rb → unit/help_test.rb}

@@ -1,6 +1,6 @@
-require 'test_helper'
+require_relative "test_helper"
 
-class TC_testHelp < Clean::Test::TestCase
+class HelpTest < MiniTest::Test
   include TestHelper
 
   def setup
@@ -24,86 +24,61 @@ class TC_testHelp < Clean::Test::TestCase
     include GLI::App
   end
 
-  test_that "the help command is configured properly when created" do
-    Given {
-      app = TestApp.new
-      app.subcommand_option_handling :normal
-      @command = GLI::Commands::Help.new(app,@output,@error)
-    }
-    Then {
-      assert_equal   'help',@command.name.to_s
-      assert_nil     @command.aliases
-      assert_equal   'command',@command.arguments_description
-      assert_not_nil @command.description
-      assert_not_nil @command.long_description
-      assert         @command.skips_pre
-      assert         @command.skips_post
-      assert         @command.skips_around
-    }
+  def test_help_command_configured_properly_when_created
+    app = TestApp.new
+    app.subcommand_option_handling :normal
+    @command = GLI::Commands::Help.new(app,@output,@error)
+    assert_equal   'help',@command.name.to_s
+    assert_nil     @command.aliases
+    assert_equal   'command',@command.arguments_description
+    refute_nil @command.description
+    refute_nil @command.long_description
+    assert         @command.skips_pre
+    assert         @command.skips_post
+    assert         @command.skips_around
   end
 
-  test_that "the help command can be configured to skip things declaratively" do
-    Given {
+  def test_the_help_command_can_be_configured_to_skip_things_declaratively
       app = TestApp.new
       app.subcommand_option_handling :normal
       @command = GLI::Commands::Help.new(app,@output,@error)
       GLI::Commands::Help.skips_pre    = false
       GLI::Commands::Help.skips_post   = false
       GLI::Commands::Help.skips_around = false
-    }
-    Then {
       assert !@command.skips_pre
       assert !@command.skips_post
       assert !@command.skips_around
-    }
   end
 
-  test_that "the help command can be configured to skip things declaratively regardless of when it the object was created" do
-    Given {
+  def test_the_help_command_can_be_configured_to_skip_things_declaratively_regardless_of_when_the_object_was_created
       GLI::Commands::Help.skips_pre    = false
       GLI::Commands::Help.skips_post   = false
       GLI::Commands::Help.skips_around = false
       app = TestApp.new
       app.subcommand_option_handling :normal
       @command = GLI::Commands::Help.new(app,@output,@error)
-    }
-    Then {
       assert !@command.skips_pre
       assert !@command.skips_post
       assert !@command.skips_around
-    }
   end
 
-  test_that "invoking help with no arguments results in listing all commands and global options" do
-    Given a_GLI_app
-    And {
+  def test_invoking_help_with_no_arguments_results_in_listing_all_commands_and_global_options
+    setup_GLI_app
       @command = GLI::Commands::Help.new(@app,@output,@error)
-    }
-    When {
       @command.execute({},{},[])
-    }
-    Then {
       assert_top_level_help_output
-    }
   end
 
-  test_that "invoking help with a command that doesn't exist shows an error" do
-    Given a_GLI_app
-    And {
+  def test_invoking_help_with_a_command_that_doesnt_exist_shows_an_error
+    setup_GLI_app
       @command = GLI::Commands::Help.new(@app,@output,@error)
       @unknown_command_name = any_command_name
-    }
-    When {
       @command.execute({},{},[@unknown_command_name])
-    }
-    Then {
       assert_error_contained(/error: Unknown command '#{@unknown_command_name}'./)
-    }
   end
 
-  test_that "invoking help with a known command shows help for that command" do
-    Given a_GLI_app
-    And {
+  def test_invoking_help_with_a_known_command_shows_help_for_that_command
+    setup_GLI_app
       @command_name = cm = any_command_name
       @desc         = d  = any_desc
       @long_desc    = ld = any_desc
@@ -127,11 +102,7 @@ class TC_testHelp < Clean::Test::TestCase
         end
       end
       @command = GLI::Commands::Help.new(@app,@output,@error)
-    }
-    When {
       @command.execute({},{},[@command_name])
-    }
-    Then {
       assert_output_contained(@command_name,"Name of the command")
       assert_output_contained(@desc,"Short description")
       assert_output_contained(@long_desc,"Long description")
@@ -139,27 +110,19 @@ class TC_testHelp < Clean::Test::TestCase
       assert_output_contained(@switch_desc,"switch description")
       assert_output_contained("-" + @flag,"command flag")
       assert_output_contained(@flag_desc,"flag description")
-    }
   end
 
-  test_that 'invoking help for an app with no global options omits [global options] from the usage string' do
-    Given a_GLI_app(:no_options)
-    And {
+  def test_invoking_help_with_no_global_options_omits_the_global_options_placeholder_from_usage
+    setup_GLI_app(:no_options)
       @command = GLI::Commands::Help.new(@app,@output,@error)
-    }
-    When {
       @command.execute({},{},[])
-    }
-    Then {
       refute_output_contained(/\[global options\] command \[command options\] \[arguments\.\.\.\]/)
       refute_output_contained('GLOBAL OPTIONS')
       assert_output_contained(/command \[command options\] \[arguments\.\.\.\]/)
-    }
   end
 
-  test_that "invoking help with a known command when no global options are present omits [global options] from the usage string" do
-    Given a_GLI_app(:no_options)
-    And {
+  def test_invoking_help_with_a_known_command_when_no_global_options_are_present_omits_placeholder_from_the_usage_string
+    setup_GLI_app(:no_options)
       @command_name = cm = any_command_name
       @desc         = d  = any_desc
       @long_desc    = ld = any_desc
@@ -183,20 +146,14 @@ class TC_testHelp < Clean::Test::TestCase
         end
       end
       @command = GLI::Commands::Help.new(@app,@output,@error)
-    }
-    When {
       @command.execute({},{},[@command_name])
-    }
-    Then {
       refute_output_contained(/\[global options\]/)
       assert_output_contained(/\[command options\]/)
       assert_output_contained('COMMAND OPTIONS')
-    }
   end
 
-  test_that "invoking help with a known command when no global options nor command options are present omits [global options] and [command options] from the usage string" do
-    Given a_GLI_app(:no_options)
-    And {
+  def test_omits_both_placeholders_when_no_options_present
+    setup_GLI_app(:no_options)
       @command_name = cm = any_command_name
       @desc         = d  = any_desc
       @long_desc    = ld = any_desc
@@ -209,20 +166,14 @@ class TC_testHelp < Clean::Test::TestCase
         end
       end
       @command = GLI::Commands::Help.new(@app,@output,@error)
-    }
-    When {
       @command.execute({},{},[@command_name])
-    }
-    Then {
       refute_output_contained(/\[global options\]/)
       refute_output_contained(/\[command options\]/)
       refute_output_contained('COMMAND OPTIONS')
-    }
   end
 
-  test_that "invoking help with a known command that has no command options omits [command options] from the usage string" do
-    Given a_GLI_app
-    And {
+  def test_no_command_options_omits_command_options_placeholder
+    setup_GLI_app
       @command_name = cm = any_command_name
       @desc         = d  = any_desc
       @long_desc    = ld = any_desc
@@ -235,19 +186,13 @@ class TC_testHelp < Clean::Test::TestCase
         end
       end
       @command = GLI::Commands::Help.new(@app,@output,@error)
-    }
-    When {
       @command.execute({},{},[@command_name])
-    }
-    Then {
       assert_output_contained(/\[global options\]/)
       refute_output_contained(/\[command options\]/)
       refute_output_contained('COMMAND OPTIONS')
-    }
   end
 
-  test_that "omitting default_description doesn't blow up" do
-    Given {
+  def test_omitting_default_description_doesnt_blow_up
       app = TestApp.new
       app.instance_eval do
         subcommand_option_handling :normal
@@ -266,23 +211,20 @@ class TC_testHelp < Clean::Test::TestCase
         end
       end
       @command = GLI::Commands::Help.new(app,@output,@error)
-    }
-    When {
-      @code = lambda { @command.execute({},{},['top']) }
-    }
-    Then {
-      assert_nothing_raised(&@code)
-    }
+      begin
+        @command.execute({},{},['top'])
+      rescue => ex
+        assert false, "Expected no exception, got: #{ex.message}"
+      end
   end
 
 private
 
-  def a_GLI_app(omit_options=false)
-    lambda {
+  def setup_GLI_app(omit_options=false)
       @program_description = program_description = any_desc
       @flags = flags = [
-        [any_desc.strip,any_arg_name,[any_option]],
-        [any_desc.strip,any_arg_name,[any_option,any_long_option]],
+        [any_desc.strip,:foo,[any_option]],
+        [any_desc.strip,:bar,[any_option,any_long_option]],
       ]
       @switches = switches = [
         [any_desc.strip,[any_option]],
@@ -302,24 +244,23 @@ private
         unless omit_options
           flags.each do |(description,arg,flag_names)|
             desc description
-          arg_name arg
-          flag flag_names
+            arg_name arg
+            flag flag_names
           end
 
           switches.each do |(description,switch_names)|
             desc description
-          switch switch_names
+            switch switch_names
           end
         end
 
         commands.each do |(description,command_names)|
           desc description
-          command command_names do |c| 
-            c.action {} 
+          command command_names do |c|
+            c.action {}
           end
         end
       end
-    }
   end
 
   def assert_top_level_help_output
@@ -357,29 +298,29 @@ private
 
   def refute_output_contained(string_or_regexp,desc='')
     string_or_regexp = /#{string_or_regexp}/ if string_or_regexp.kind_of?(String)
-    assert_no_match string_or_regexp,@output.string,desc
+    refute_match string_or_regexp,@output.string,desc
   end
 
   def any_option
     ('a'..'z').to_a[@option_index].tap { @option_index += 1 }
   end
-  
-  def any_long_option
-    Faker::Lorem.words(10)[rand(10)]
-  end
 
-  def any_arg_name
-    any_string :max => 20
+  def any_long_option
+    ["foo","bar","blah"].sample
   end
 
   def any_desc
-    Faker::Lorem.words(10).join(' ')[0..30].gsub(/\s*$/,'')
+    [
+      "This command does some stuff",
+      "Do things and whatnot",
+      "Behold the power of this command"
+    ].sample
   end
 
   def any_command_name
-    command_name = Faker::Lorem.words(10)[rand(10)]
+    command_name = ["new","edit","delete","create","update"].sample
     while @command_names_used.include?(command_name)
-      command_name = Faker::Lorem.words(10)[rand(10)]
+      command_name = ["new","edit","delete","create","update"].sample
     end
     @command_names_used << command_name
     command_name

data/test/{tc_options.rb → unit/options_test.rb}

@@ -1,6 +1,6 @@
-require 'test_helper'
+require_relative "test_helper"
 
-class TC_testOptions < Clean::Test::TestCase
+class OptiosnTest < MiniTest::Test
   include TestHelper
 
   def test_by_method
@@ -10,7 +10,7 @@ class TC_testOptions < Clean::Test::TestCase
     assert_equal 'verbose', o[:name]
     assert_equal 'verbose', o['name']
   end
-  
+
   def test_by_string
     o = GLI::Options.new
     o['name'] = 'verbose'
@@ -18,7 +18,7 @@ class TC_testOptions < Clean::Test::TestCase
     assert_equal 'verbose', o[:name]
     assert_equal 'verbose', o['name']
   end
-  
+
   def test_by_symbol
     o = GLI::Options.new
     o[:name] = 'verbose'

data/test/unit/subcommand_parsing_test.rb

@@ -0,0 +1,263 @@
+require_relative "test_helper"
+require_relative "support/fake_std_out"
+
+class SubcommandParsingTest < MiniTest::Test
+  include TestHelper
+
+  def setup
+    @fake_stdout = FakeStdOut.new
+    @fake_stderr = FakeStdOut.new
+
+    @original_stdout = $stdout
+    $stdout = @fake_stdout
+    @original_stderr = $stderr
+    $stderr = @fake_stderr
+
+    @app = CLIApp.new
+    @app.reset
+    @app.subcommand_option_handling :legacy
+    @app.error_device=@fake_stderr
+    ENV.delete('GLI_DEBUG')
+
+    @results = {}
+    @exit_code = 0
+  end
+
+  def teardown
+    $stdout = @original_stdout
+    $stderr = @original_stderr
+  end
+
+  def test_commands_options_may_clash_with_globals_and_it_gets_sorted_out
+    setup_app_with_subcommands_storing_results
+    @app.run(%w(-f global command1 -f command -s foo))
+    assert_equal  'command1',@results[:command_name]
+    assert_equal  'global',  @results[:global_options][:f],'global'
+    assert       !@results[:global_options][:s]
+    assert_equal  'command', @results[:command_options][:f]
+    assert        @results[:command_options][:s]
+  end
+
+  def test_in_legacy_mode_subcommand_options_all_share_a_namespace
+    setup_app_with_subcommands_storing_results
+    @app.run(%w(-f global command1 -f command -s subcommand10 -f sub))
+    with_clue {
+      assert_equal  'subcommand10',@results[:command_name]
+      assert_equal  'global',      @results[:global_options][:f],'global'
+      assert       !@results[:global_options][:s]
+      assert_equal  'sub', @results[:command_options][:f]
+      assert        @results[:command_options][:s]
+      assert_nil    @results[:command_options][GLI::Command::PARENT]
+      assert_nil    @results[:command_options][GLI::Command::PARENT]
+    }
+  end
+
+  def test_in_normal_mode_each_subcommand_has_its_own_namespace
+    setup_app_with_subcommands_storing_results :normal
+    @app.run(%w(-f global command1 -f command -s subcommand10 -f sub))
+    with_clue {
+      assert_equal  'subcommand10',@results[:command_name]
+      assert_equal  'global',      @results[:global_options][:f],'global'
+      assert       !@results[:global_options][:s]
+      assert_equal  'sub', @results[:command_options][:f]
+      assert       !@results[:command_options][:s]
+      assert_equal  'command',@results[:command_options][GLI::Command::PARENT][:f]
+      assert        @results[:command_options][GLI::Command::PARENT][:s]
+    }
+  end
+
+  def test_in_loose_mode_with_autocomplete_false_it_doesnt_autocorrect_a_sub_command
+    setup_app_with_subcommand_storing_results :normal, false, :loose
+    @app.run(%w(-f global command -f flag -s subcomm  -f subflag))
+    with_clue {
+      assert_equal "command",@results[:command_name]
+    }
+  end
+
+  def test_in_strict_mode_with_autocomplete_false_it_doesnt_autocorrect_a_sub_command
+    setup_app_with_subcommand_storing_results :normal, false, :strict
+    @app.run(%w(-f global command -f flag -s subcomm  -f subflag))
+    with_clue {
+      assert_equal nil,@results[:command_name]
+      assert       @fake_stderr.contained?(/error: Too many arguments for command/)
+    }
+  end
+
+  def test_in_loose_mode_argument_validation_is_ignored
+    setup_app_with_arguments 1, 1, false, :loose
+    run_app_with_X_arguments 0
+    with_clue {
+      assert_equal 0, @results[:number_of_args_give_to_action]
+      assert_equal 0, @exit_code
+    }
+  end
+
+  def test_in_strict_mode_subcommand_option_handling_must_be_normal
+    setup_app_with_arguments 1, 1, false, :strict, :legacy
+    run_app_with_X_arguments 1
+    with_clue {
+      assert_nil      @results[:number_of_args_give_to_action]
+      assert_equal 1, @exit_code
+      assert          @fake_stderr.contained?(/you must enable normal subcommand_option_handling/)
+    }
+  end
+
+  [
+    [1 , 1 , false , 1  ]    ,
+    [1 , 1 , false , 2  ]    ,
+    [1 , 1 , true  , 1  ]    ,
+    [1 , 1 , true  , 2  ]    ,
+    [1 , 1 , true  , 3  ]    ,
+    [1 , 1 , true  , 30 ]    ,
+    [0 , 0 , false , 0  ]    ,
+    [0 , 1 , false , 1  ]    ,
+    [0 , 1 , false , 0  ]    ,
+    [1 , 0 , false , 1  ]    ,
+    [0 , 0 , true  , 0  ]    ,
+    [0 , 0 , true  , 10 ]
+
+  ].each do |number_required, number_optional, has_multiple, number_generated|
+    define_method "test_strict_options_success_cases_#{number_required}_#{number_optional}_#{has_multiple}_#{number_generated}" do
+      setup_app_with_arguments number_required, number_optional, has_multiple, :strict
+      run_app_with_X_arguments number_generated
+      with_clue {
+        assert_equal number_generated, @results[:number_of_args_give_to_action]
+        assert_equal 0, @exit_code
+        assert !@fake_stderr.contained?(/Not enough arguments for command/)
+        assert !@fake_stderr.contained?(/Too many arguments for command/)
+      }
+    end
+  end
+
+  [
+    [1 , 1 , false , 3  , :too_many]   ,
+    [0 , 0 , false , 1  , :too_many]   ,
+    [1 , 1 , false , 0  , :not_enough] ,
+    [1 , 1 , true  , 0  , :not_enough] ,
+    [1 , 0 , false , 0  , :not_enough] ,
+
+  ].each do |number_required, number_optional, has_multiple, number_generated, status|
+    define_method "test_strict_options_failure_cases_#{number_required}_#{number_optional}_#{has_multiple}_#{number_generated}_#{status}" do
+      setup_app_with_arguments number_required, number_optional, has_multiple, :strict
+      run_app_with_X_arguments number_generated
+      with_clue {
+        if status == :not_enough then
+          assert_nil @results[:number_of_args_give_to_action]
+          assert_equal 64, @exit_code
+          assert @fake_stderr.contained?(/Not enough arguments for command/)
+        elsif status == :too_many then
+          assert_nil @results[:number_of_args_give_to_action]
+          assert_equal 64, @exit_code
+          assert @fake_stderr.contained?(/Too many arguments for command/)
+        else
+          assert false
+        end
+      }
+    end
+  end
+
+private
+  def with_clue(&block)
+    block.call
+  rescue Exception
+    dump = ""
+    PP.pp "\nRESULTS---#{@results}", dump unless @results.empty?
+    PP.pp "\nSTDERR---\n#{@fake_stderr.to_s}", dump
+    PP.pp "\nSTDOUT---\n#{@fake_stdout.to_s}", dump
+    @original_stdout.puts dump
+    raise
+  end
+
+  def setup_app_with_subcommand_storing_results(subcommand_option_handling_strategy, autocomplete, arguments_handling_strategy)
+    @app.subcommand_option_handling subcommand_option_handling_strategy
+    @app.autocomplete_commands autocomplete
+    @app.arguments arguments_handling_strategy
+    @app.flag ['f','flag']
+    @app.switch ['s','switch']
+
+    @app.command "command" do |c|
+      c.flag ['f','flag']
+      c.switch ['s','switch']
+      c.action do |global,options,args|
+        @results = {
+          :command_name => "command",
+          :global_options => global,
+          :command_options => options,
+          :args => args
+        }
+      end
+
+      c.command "subcommand" do |subcommand|
+        subcommand.flag ['f','flag']
+        subcommand.flag ['foo']
+        subcommand.switch ['s','switch']
+        subcommand.action do |global,options,args|
+          @results = {
+            :command_name => "subcommand",
+            :global_options => global,
+            :command_options => options,
+            :args => args
+          }
+        end
+      end
+    end
+  end
+
+  def setup_app_with_subcommands_storing_results(subcommand_option_handling_strategy = :legacy)
+    @app.subcommand_option_handling subcommand_option_handling_strategy
+    @app.flag ['f','flag']
+    @app.switch ['s','switch']
+
+    2.times do |i|
+      @app.command "command#{i}" do |c|
+        c.flag ['f','flag']
+        c.switch ['s','switch']
+        c.action do |global,options,args|
+          @results = {
+            :command_name => "command#{i}",
+            :global_options => global,
+            :command_options => options,
+            :args => args
+          }
+        end
+
+        2.times do |j|
+          c.command "subcommand#{i}#{j}" do |subcommand|
+            subcommand.flag ['f','flag']
+            subcommand.flag ['foo']
+            subcommand.switch ['s','switch']
+            subcommand.action do |global,options,args|
+              @results = {
+                :command_name => "subcommand#{i}#{j}",
+                :global_options => global,
+                :command_options => options,
+                :args => args
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def setup_app_with_arguments(number_required_arguments, number_optional_arguments, has_argument_multiple, arguments_handling_strategy = :loose, subcommand_option_handling_strategy = :normal)
+    @app.arguments arguments_handling_strategy
+    @app.subcommand_option_handling subcommand_option_handling_strategy
+
+    number_required_arguments.times { |i| @app.arg("needed#{i}") }
+    number_optional_arguments.times { |i| @app.arg("optional#{i}", :optional) }
+    @app.arg :multiple, [:multiple, :optional] if has_argument_multiple
+
+    @app.command :cmd do |c|
+      c.action do |g,o,a|
+        @results = {
+          :number_of_args_give_to_action => a.size
+        }
+      end
+    end
+  end
+
+  def run_app_with_X_arguments(number_arguments)
+    @exit_code = @app.run [].tap{|args| args << "cmd"; number_arguments.times {|i| args << "arg#{i}"}}
+  end
+end