gli 1.6.0 → 2.0.0.rc3

data/test/tc_help.rb

@@ -0,0 +1,223 @@
+require 'test_helper'
+
+class TC_testHelp < Clean::Test::TestCase
+  include TestHelper
+
+  def setup
+    @option_index = 0
+    @real_columns = ENV['COLUMNS']
+    ENV['COLUMNS'] = '1024'
+    @output = StringIO.new
+    @error = StringIO.new
+  end
+
+  def teardown
+    ENV['COLUMNS'] = @real_columns
+  end
+
+  class TestApp
+    include GLI::App
+  end
+
+  test_that "the help command is configured properly when created" do
+    Given {
+      @command = GLI::Commands::Help.new(TestApp.new,@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
+    }
+  end
+
+  test_that "invoking help with no arguments results in listing all commands and global options" do
+    Given a_GLI_app
+    And {
+      @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 {
+      @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}'.  Use 'gli help' for a list of commands/)
+    }
+  end
+
+  test_that "invoking help with a known command shows help for that command" do
+    Given a_GLI_app
+    And {
+      @command_name = cm = any_command_name
+      @desc         = d  = any_desc
+      @long_desc    = ld = any_desc
+      @switch       = s  = any_option
+      @switch_desc  = sd = any_desc
+      @flag         = f  = any_option
+      @flag_desc    = fd = any_desc
+
+      @app.instance_eval do
+        desc d
+        long_desc ld
+        command cm do |c|
+
+          c.desc sd
+          c.switch s
+
+          c.desc fd
+          c.flag f
+
+          c.action {}
+        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")
+      assert_output_contained("-" + @switch,"command switch")
+      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 {
+      @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
+
+private
+
+  def a_GLI_app(omit_options=false)
+    lambda {
+      @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]],
+      ]
+      @switches = switches = [
+        [any_desc.strip,[any_option]],
+        [any_desc.strip,[any_option,any_long_option]],
+      ]
+
+      @commands = commands = [
+        [any_desc.strip,[any_command_name]],
+        [any_desc.strip,[any_command_name,any_command_name]],
+      ]
+
+      @app = TestApp.new
+      @app.instance_eval do
+        program_desc program_description
+
+        unless omit_options
+          flags.each do |(description,arg,flag_names)|
+            desc description
+          arg_name arg
+          flag flag_names
+          end
+
+          switches.each do |(description,switch_names)|
+            desc description
+          switch switch_names
+          end
+        end
+
+        commands.each do |(description,command_names)|
+          desc description
+          command command_names do |c| 
+            c.action {} 
+          end
+        end
+      end
+    }
+  end
+
+  def assert_top_level_help_output
+    assert_output_contained(@program_description)
+
+    @commands.each do |(description,command_names)|
+      assert_output_contained(/#{command_names.join(', ')}\s+-\s+#{description}/,"For command #{command_names.join(',')}")
+    end
+    assert_output_contained(/help\s+-\s+#{@command.description}/)
+
+    @switches.each do |(description,switch_names)|
+      expected_switch_names = switch_names.map { |_| _.length == 1 ? "-#{_}" : "--\\[no-\\]#{_}" }.join(', ')
+      assert_output_contained(/#{expected_switch_names}\s+-\s+#{description}/,"For switch #{switch_names.join(',')}")
+    end
+
+    @flags.each do |(description,arg,flag_names)|
+      expected_flag_names = flag_names.map { |_| _.length == 1 ? "-#{_}" : "--#{_}" }.join(', ')
+      assert_output_contained(/#{expected_flag_names}[ =]#{arg}\s+-\s+#{description}/,"For flag #{flag_names.join(',')}")
+    end
+
+    assert_output_contained('GLOBAL OPTIONS')
+    assert_output_contained('COMMANDS')
+    assert_output_contained(/\[global options\] command \[command options\] \[arguments\.\.\.\]/)
+  end
+
+  def assert_error_contained(string_or_regexp,desc='')
+    string_or_regexp = /#{string_or_regexp}/ if string_or_regexp.kind_of?(String)
+    assert_match string_or_regexp,@error.string,desc
+  end
+
+  def assert_output_contained(string_or_regexp,desc='')
+    string_or_regexp = /#{string_or_regexp}/ if string_or_regexp.kind_of?(String)
+    assert_match string_or_regexp,@output.string,desc
+  end
+
+  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
+  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
+  end
+
+  def any_desc
+    Faker::Lorem.words(10).join(' ')[0..30].gsub(/\s*$/,'')
+  end
+
+  def any_command_name
+    Faker::Lorem.words(10)[rand(10)]
+  end
+end

data/test/tc_options.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class TC_testOptions < Clean::Test::TestCase
+  include TestHelper
+  include GLI
+
+  def test_by_method
+    o = Options.new
+    o.name = 'verbose'
+    assert_equal 'verbose', o.name
+    assert_equal 'verbose', o[:name]
+    assert_equal 'verbose', o['name']
+  end
+  
+  def test_by_string
+    o = Options.new
+    o['name'] = 'verbose'
+    assert_equal 'verbose', o.name
+    assert_equal 'verbose', o[:name]
+    assert_equal 'verbose', o['name']
+  end
+  
+  def test_by_symbol
+    o = Options.new
+    o[:name] = 'verbose'
+    assert_equal 'verbose', o.name
+    assert_equal 'verbose', o[:name]
+    assert_equal 'verbose', o['name']
+  end
+
+end

data/test/tc_subcommands.rb

@@ -0,0 +1,162 @@
+require 'test_helper'
+
+class TC_testSubCommand < Clean::Test::TestCase
+  include TestHelper
+
+  def setup
+    @app = CLIApp.new
+    @app.reset
+    @fake_stderr = FakeStdOut.new
+    @app.error_device=@fake_stderr
+    ENV.delete('GLI_DEBUG')
+  end
+
+  ['add','new'].each do |name|
+    test_that "We run the 'add' subcommand using '#{name}'" do
+      Given we_have_a_command_with_two_subcommands
+      When  run_app('remote',name,'-f','foo','bar')
+      Then  assert_command_ran_with(:add, :command_options => {:f => true}, :args => %w(foo bar))
+    end
+  end
+
+  test_that "with subcommands, but not using one on the command-line, we run the base action" do
+    Given we_have_a_command_with_two_subcommands
+    When  run_app('remote','foo','bar')
+    Then  assert_command_ran_with(:base, :command_options => {:f => false}, :args => %w(foo bar))
+  end
+
+  test_that "switches and flags defined on a subcommand are available" do
+    Given we_have_a_command_with_two_subcommands(:switches => [:addswitch], :flags => [:addflag])
+    When  run_app('remote','add','--addswitch','--addflag','foo','bar')
+    Then  assert_command_ran_with(:add,:command_options => { :addswitch => true, :addflag => 'foo', :f => false },
+                                       :args => ['bar'])
+  end
+
+  test_that "we can nest subcommands very deep" do
+    Given {
+      @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'
+    }
+    When run_app('remote','add','some','cmd','-s','blah')
+    Then assert_command_ran_with(:cmd, :command_options => {:s => true, :f => false},:args => ['blah'])
+  end
+
+  test_that "when any command in the chain has no action, but there's still arguments, indicate we have an unknown command" do
+    Given a_very_deeply_nested_command_structure
+    Then {
+      assert_raises GLI::UnknownCommand do
+        When run_app('remote','add','some','foo')
+      end
+      assert_match /Unknown command 'foo'/,@fake_stderr.to_s
+    }
+  end
+
+  test_that "when a command in the chain has no action, but there's NO additional arguments, indicate we need a subcommand" do
+    Given a_very_deeply_nested_command_structure
+    Then {
+      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)
+    lambda { @exit_code = @app.run(args) }
+  end
+
+  def a_very_deeply_nested_command_structure
+    lambda {
+      @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)
+    lambda {
+      @run_results.each do |command,results|
+        if command == expected_command
+          assert_equal(Hash(options[:global_options]),results[0])
+          assert_equal(Hash(options[:command_options]),results[1])
+          assert_equal(options[:args],results[2])
+        else
+          assert_nil results
+        end
+      end
+    }
+  end
+
+  def Hash(possibly_nil_hash)
+    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 = {})
+    lambda {
+      @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

data/test/tc_switch.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class TC_testSwitch < Clean::Test::TestCase
+  include TestHelper
+  include GLI
+
+  def test_basics_simple
+    Given switch_with_names(:filename)
+    Then attributes_should_be_set
+    And name_should_be(:filename)
+    And aliases_should_be(nil)
+  end
+
+  def test_basics_kinda_complex
+    Given switch_with_names([:f])
+    Then attributes_should_be_set
+    And name_should_be(:f)
+    And aliases_should_be(nil)
+  end
+
+  def test_basics_complex
+    Given switch_with_names([:f,:file,:filename])
+    Then attributes_should_be_set
+    And name_should_be(:f)
+    And aliases_should_be([:file,:filename])
+    And {
+      assert_equal ["-f","--[no-]file","--[no-]filename"],@switch.arguments_for_option_parser
+    }
+  end
+
+  def test_includes_negatable
+    assert_equal '-a',Switch.name_as_string('a')
+    assert_equal '--[no-]foo',Switch.name_as_string('foo')
+  end
+
+  private 
+
+  def switch_with_names(names)
+    lambda do
+      @options = {
+        :desc => 'Filename',
+        :long_desc => 'The Filename',
+      }
+      @switch = Switch.new(names,@options)
+      @cli_option = @switch
+    end
+  end
+
+  def attributes_should_be_set
+    lambda {
+      assert_equal(@options[:desc],@switch.description)
+      assert_equal(@options[:long_desc],@switch.long_description)
+      assert(@switch.usage != nil)
+    }
+  end
+
+end