gli 2.9.0 → 2.20.0

data/test/{tc_gli.rb → unit/gli_test.rb}

@@ -1,18 +1,7 @@
-# 1.9 adds realpath to resolve symlinks; 1.8 doesn't
-# have this method, so we add it so we get resolved symlinks
-# and compatibility
-unless File.respond_to? :realpath
-  class File
-    def self.realpath path
-      return realpath(File.readlink(path)) if symlink?(path)
-      path
-    end
-  end
-end
+require_relative "test_helper"
+require_relative "support/fake_std_out"
 
-require 'test_helper'
-
-class TC_testGLI < Clean::Test::TestCase
+class GLITest < MiniTest::Test
   include TestHelper
 
   def setup
@@ -24,7 +13,7 @@ class TC_testGLI < Clean::Test::TestCase
     $stderr = @fake_stderr
     @app = CLIApp.new
 
-    @config_file = File.expand_path(File.dirname(File.realpath(__FILE__)) + '/new_config.yaml')
+    @config_file = File.expand_path(File.dirname(File.realpath(__FILE__)) + '/support/new_config.yml')
     @gli_debug = ENV['GLI_DEBUG']
     @app.error_device=@fake_stderr
     ENV.delete('GLI_DEBUG')
@@ -84,6 +73,7 @@ class TC_testGLI < Clean::Test::TestCase
     assert_equal 64, @app.run(['foo']), "Expected exit status to be 64"
     assert  @fake_stderr.contained?(/flag is required/), @fake_stderr.strings.inspect
     assert  @fake_stderr.contained?(/other_flag is required/), @fake_stderr.strings.inspect
+    assert  @fake_stderr.contained?(/flag is required, other_flag is required/), @fake_stderr.strings.inspect
     assert !@called
 
     assert_equal 0, @app.run(['foo','--flag=bar','--other_flag=blah']), "Expected exit status to be 0 #{@fake_stderr.strings.join(',')}"
@@ -104,6 +94,7 @@ class TC_testGLI < Clean::Test::TestCase
     assert_equal 64, @app.run(['foo']), "Expected exit status to be 64"
     assert  @fake_stderr.contained?(/flag is required/), @fake_stderr.strings.inspect
     assert  @fake_stderr.contained?(/other_flag is required/), @fake_stderr.strings.inspect
+    assert  @fake_stderr.contained?(/flag is required, other_flag is required/), @fake_stderr.strings.inspect
     assert !@called
 
     assert_equal 0, @app.run(['--flag=bar','--other_flag=blah','foo']), "Expected exit status to be 0 #{@fake_stderr.strings.join(',')}"
@@ -139,10 +130,12 @@ class TC_testGLI < Clean::Test::TestCase
   def test_init_from_config
     failure = nil
     @app.reset
-    @app.config_file(File.expand_path(File.dirname(File.realpath(__FILE__)) + '/config.yaml'))
+    @app.config_file(File.expand_path(File.dirname(File.realpath(__FILE__)) + '/support/gli_test_config.yml'))
     @app.flag :f
     @app.switch :s
     @app.flag :g
+    @app.default_value true
+    @app.switch :t
     called = false
     @app.command :command do |c|
       c.flag :f
@@ -157,6 +150,7 @@ class TC_testGLI < Clean::Test::TestCase
           assert !o[:f]
           assert !g[:s]
           assert o[:s]
+          assert !g[:t]
         rescue Exception => ex
           failure = ex
         end
@@ -170,7 +164,7 @@ class TC_testGLI < Clean::Test::TestCase
   def test_command_line_overrides_config
     failure = nil
     @app.reset
-    @app.config_file(File.expand_path(File.dirname(File.realpath(__FILE__)) + '/config.yaml'))
+    @app.config_file(File.expand_path(File.dirname(File.realpath(__FILE__)) + '/support/gli_test_config.yml'))
     @app.flag :f
     @app.switch :s
     @app.flag :g
@@ -202,7 +196,7 @@ class TC_testGLI < Clean::Test::TestCase
   end
 
   def test_no_overwrite_config
-    config_file = File.expand_path(File.dirname(File.realpath(__FILE__)) + '/config.yaml')
+    config_file = File.expand_path(File.dirname(File.realpath(__FILE__)) + '/support/gli_test_config.yml')
     config_file_contents = File.read(config_file)
     @app.reset
     @app.config_file(config_file)
@@ -227,9 +221,9 @@ class TC_testGLI < Clean::Test::TestCase
     @app.reset
     @app.config_file(@config_file)
     @app.flag :f
-    @app.switch :s
+    @app.switch :s, :salias
     @app.switch :w
-    @app.flag :bigflag
+    @app.flag :bigflag, :bigalias
     @app.flag :biggestflag
     @app.command :foo do |c|
     end
@@ -247,7 +241,9 @@ class TC_testGLI < Clean::Test::TestCase
 
     assert_equal 'foo',written_config[:f]
     assert_equal 'bleorgh',written_config[:bigflag]
+    assert !written_config[:bigalias]
     assert written_config[:s]
+    assert !written_config[:salias]
     assert !written_config[:w]
     assert_nil written_config[:biggestflag]
     assert written_config[GLI::InitConfig::COMMANDS_KEY]
@@ -513,7 +509,7 @@ class TC_testGLI < Clean::Test::TestCase
     end
     @switch_value = nil
 
-    assert_raises(RuntimeError) do 
+    assert_raises(RuntimeError) do
       @app.command [:foo] do |c|
         c.switch :switch, :default_value => true, :negatable => false
       end
@@ -663,6 +659,23 @@ class TC_testGLI < Clean::Test::TestCase
     assert_raises(GLI::CustomExit) { @app.run(['foo']) }
   end
 
+  def test_gli_help_does_not_raise_on_debug
+    ENV['GLI_DEBUG'] = 'true'
+
+    @app.reset
+    @app.command(:multiply) do |c|
+      c.action do |g,o,a|
+        # Nothing
+      end
+    end
+
+    begin
+      @app.run(['multiply', '--help'])
+    rescue GLI::CustomExit
+      assert false, "Expected no exception"
+    end
+  end
+
   class ConvertMe
     attr_reader :value
     def initialize(value)
@@ -697,6 +710,48 @@ class TC_testGLI < Clean::Test::TestCase
     assert_equal 'crud',@baz.value
   end
 
+  def test_that_flags_can_be_used_multiple_times
+    @app.reset
+    @app.flag :flag, :multiple => true
+    @app.command :foo do |c|
+      c.action do |options, _, _|
+        @flag = options[:flag]
+      end
+    end
+
+    assert_equal 0,@app.run(%w(--flag 1 --flag=2 --flag 3 foo)),@fake_stderr.to_s
+
+    assert_equal ['1','2','3'],@flag
+  end
+
+  def test_that_multiple_use_flags_are_empty_arrays_by_default
+    @app.reset
+    @app.flag :flag, :multiple => true
+    @app.command :foo do |c|
+      c.action do |options, _, _|
+        @flag = options[:flag]
+      end
+    end
+
+    assert_equal 0,@app.run(['foo']),@fake_stderr.to_s
+
+    assert_equal [],@flag
+  end
+
+  def test_that_multiple_use_flags_can_take_other_defaults
+    @app.reset
+    @app.flag :flag, :multiple => true, :default_value => ['1']
+    @app.command :foo do |c|
+      c.action do |options, _, _|
+        @flag = options[:flag]
+      end
+    end
+
+    assert_equal 0,@app.run(['foo']),@fake_stderr.to_s
+
+    assert_equal ['1'],@flag
+  end
+
   def test_that_we_mutate_ARGV_by_default
     @app.reset
     @app.flag :f
@@ -748,38 +803,26 @@ class TC_testGLI < Clean::Test::TestCase
     do_test_switch_create_compact(object)
   end
 
-  def some_descriptions
-    lambda {
-      @description = 'this is a description'
-      @long_description = 'this is a very long description'
-    }
-  end
-
-  def assert_switch_was_made(object,switch) 
-    lambda {
-      assert object.switches[switch]
-      assert_equal @description,object.switches[switch].description,"For switch #{switch}"
-      assert_equal @long_description,object.switches[switch].long_description,"For switch #{switch}"
-      assert(object.usage != nil) if object.respond_to? :usage
-    }
-  end
-
   def do_test_switch_create_classic(object)
-    Given some_descriptions
-    When {
-      object.desc @description
-      object.long_desc @long_description
-      object.switch :f
-    }
-    Then assert_switch_was_made(object,:f)
+    @description = 'this is a description'
+    @long_description = 'this is a very long description'
+    object.desc @description
+    object.long_desc @long_description
+    object.switch :f
+    assert object.switches[:f]
+    assert_equal @description,object.switches[:f].description,"For switch #{:f}"
+    assert_equal @long_description,object.switches[:f].long_description,"For switch #{:f}"
+    assert(object.usage != nil) if object.respond_to? :usage
   end
 
   def do_test_switch_create_compact(object)
-    Given some_descriptions
-    When {
-      object.switch :g, :desc => @description, :long_desc => @long_description
-    }
-    Then assert_switch_was_made(object,:g)
+    @description = 'this is a description'
+    @long_description = 'this is a very long description'
+    object.switch :g, :desc => @description, :long_desc => @long_description
+    assert object.switches[:g]
+    assert_equal @description,object.switches[:g].description,"For switch #{:g}"
+    assert_equal @long_description,object.switches[:g].long_description,"For switch #{:g}"
+    assert(object.usage != nil) if object.respond_to? :usage
   end
 
   def do_test_switch_create_twice(object)

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'