gli 2.19.2 → 2.20.0

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

data/test/unit/subcommands_test.rb

@@ -0,0 +1,245 @@
+require_relative "test_helper"
+require_relative "support/fake_std_out"
+
+class SubcommandsTest < 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')
+  end
+
+  def teardown
+    $stdout = @original_stdout
+    $stderr = @original_stderr
+  end
+
+  def test_we_run_add_command_using_add
+    we_have_a_command_with_two_subcommands
+    run_app('remote',"add",'-f','foo','bar')
+    assert_command_ran_with(:add, :command_options => {:f => true}, :args => %w(foo bar))
+  end
+  def test_we_run_add_command_using_new
+    we_have_a_command_with_two_subcommands
+    run_app('remote',"new",'-f','foo','bar')
+    assert_command_ran_with(:add, :command_options => {:f => true}, :args => %w(foo bar))
+  end
+
+  def test_subcommands_not_used_on_command_line_uses_base_action
+    we_have_a_command_with_two_subcommands
+    run_app('remote','foo','bar')
+    assert_command_ran_with(:base, :command_options => {:f => false}, :args => %w(foo bar))
+  end
+
+  def test_switches_and_flags_on_subcommand_available
+    we_have_a_command_with_two_subcommands(:switches => [:addswitch], :flags => [:addflag])
+    run_app('remote','add','--addswitch','--addflag','foo','bar')
+    assert_command_ran_with(:add,:command_options => { :addswitch => true, :addflag => 'foo', :f => false },
+                            :args => ['bar'])
+  end
+
+  def test_help_flag_works_in_normal_mode
+    @app.subcommand_option_handling :normal
+    we_have_a_command_with_two_subcommands
+    @app.run(["remote", "add", "--help"]) rescue nil
+    refute_match /^error/, @fake_stderr.to_s, "should not output an error message"
+  end
+
+  def test_help_flag_works_in_legacy_mode
+    @app.subcommand_option_handling :legacy
+    we_have_a_command_with_two_subcommands
+    @app.run(["remote", "add", "--help"]) rescue nil
+    refute_match /^error/, @fake_stderr.to_s, "should not output an error message"
+  end
+
+  def test_we_can_reopen_commands_to_add_new_subcommands
+    @app.command :remote do |p|
+      p.command :add do |c|
+        c.action do |global_options,command_options,args|
+          @ran_command = :add
+        end
+      end
+    end
+    @app.command :remote do |p|
+      p.command :new do |c|
+        c.action do |global_options,command_options,args|
+          @ran_command = :new
+        end
+      end
+    end
+    run_app('remote','new')
+    assert_equal(@ran_command, :new)
+    run_app('remote', 'add')
+    assert_equal(@ran_command, :add)
+  end
+
+  def test_reopening_commands_doesnt_readd_to_output
+    @app.command :remote do |p|
+      p.command(:add) { }
+    end
+    @app.command :remote do |p|
+      p.command(:new) { }
+    end
+    command_names = @app.instance_variable_get("@commands_declaration_order").collect { |c| c.name }
+    assert_equal 1, command_names.grep(:remote).size
+  end
+
+
+  def test_we_can_reopen_commands_without_causing_conflicts
+    @app.command :remote do |p|
+      p.command :add do |c|
+        c.action do |global_options,command_options,args|
+          @ran_command = :remote_add
+        end
+      end
+    end
+    @app.command :local do |p|
+      p.command :add do |c|
+        c.action do |global_options,command_options,args|
+          @ran_command = :local_add
+        end
+      end
+    end
+    run_app('remote','add')
+    assert_equal(@ran_command, :remote_add)
+    run_app('local', 'add')
+    assert_equal(@ran_command, :local_add)
+  end
+
+
+  def test_we_can_nest_subcommands_very_deep
+    @run_results = { :add => nil, :rename => nil, :base => nil }
+    @app.command :remote do |c|
+
+      c.switch :f
+      c.command :add do |add|
+        add.command :some do |some|
+          some.command :cmd do |cmd|
+            cmd.switch :s
+            cmd.action do |global_options,command_options,args|
+              @run_results[:cmd] = [global_options,command_options,args]
+            end
+          end
+        end
+      end
+    end
+    ENV['GLI_DEBUG'] = 'true'
+    run_app('remote','add','some','cmd','-s','blah')
+    assert_command_ran_with(:cmd, :command_options => {:s => true, :f => false},:args => ['blah'])
+  end
+
+  def test_when_any_command_has_no_action_but_there_are_args_indicate_unknown_command
+    a_very_deeply_nested_command_structure
+    assert_raises GLI::UnknownCommand do
+      When run_app('remote','add','some','foo')
+    end
+    assert_match /Unknown command 'foo'/,@fake_stderr.to_s
+  end
+
+  def test_when_any_command_has_no_action_but_there_are_no_args_indicate_subcommand_needed
+    a_very_deeply_nested_command_structure
+    assert_raises GLI::BadCommandLine do
+      When run_app('remote','add','some')
+    end
+    assert_match /Command 'some' requires a subcommand/,@fake_stderr.to_s
+  end
+
+private
+
+  def run_app(*args)
+    @exit_code = @app.run(args)
+  end
+
+  def a_very_deeply_nested_command_structure
+    @run_results = { :add => nil, :rename => nil, :base => nil }
+    @app.command :remote do |c|
+
+      c.switch :f
+      c.command :add do |add|
+        add.command :some do |some|
+          some.command :cmd do |cmd|
+            cmd.switch :s
+            cmd.action do |global_options,command_options,args|
+              @run_results[:cmd] = [global_options,command_options,args]
+            end
+          end
+        end
+      end
+    end
+    ENV['GLI_DEBUG'] = 'true'
+  end
+
+  # expected_command - name of command exepcted to have been run
+  # options:
+  #   - global_options => hash of expected options
+  #   - command_options => hash of expected command options
+  #   - args => array of expected args
+  def assert_command_ran_with(expected_command,options)
+    global_options = options[:global_options] || { :help => false }
+    @run_results.each do |command,results|
+      if command == expected_command
+        assert_equal(indifferent_hash(global_options),results[0])
+        assert_equal(indifferent_hash(options[:command_options]),results[1])
+        assert_equal(options[:args],results[2])
+      else
+        assert_nil results
+      end
+    end
+  end
+
+  def indifferent_hash(possibly_nil_hash)
+    return {} if possibly_nil_hash.nil?
+    possibly_nil_hash.keys.each do |key|
+      if key.kind_of? Symbol
+        possibly_nil_hash[key.to_s] = possibly_nil_hash[key] unless possibly_nil_hash.has_key?(key.to_s)
+      elsif key.kind_of? String
+        possibly_nil_hash[key.to_sym] = possibly_nil_hash[key] unless possibly_nil_hash.has_key?(key.to_sym)
+      end
+    end
+    possibly_nil_hash
+  end
+
+  # options - 
+  #     :flags => flags to add to :add
+  #     :switiches => switiches to add to :add
+  def we_have_a_command_with_two_subcommands(options = {})
+    @run_results = { :add => nil, :rename => nil, :base => nil }
+    @app.command :remote do |c|
+
+      c.switch :f
+
+      c.desc "add a remote"
+      c.command [:add,:new] do |add|
+
+        Array(options[:flags]).each { |_| add.flag _ }
+        Array(options[:switches]).each { |_| add.switch _ }
+        add.action do |global_options,command_options,args|
+          @run_results[:add] = [global_options,command_options,args]
+        end
+      end
+
+      c.desc "rename a remote"
+      c.command :rename do |rename|
+        rename.action do |global_options,command_options,args|
+          @run_results[:rename] = [global_options,command_options,args]
+        end
+      end
+
+      c.action do |global_options,command_options,args|
+        @run_results[:base] = [global_options,command_options,args]
+      end
+    end
+    ENV['GLI_DEBUG'] = 'true'
+  end
+end