optimist_xl 3.1.1

data/test/optimist_xl/permitted_test.rb

@@ -0,0 +1,92 @@
+require 'stringio'
+require 'test_helper'
+
+module OptimistXL
+
+class PermittedTest < ::MiniTest::Test
+  def setup
+    @p = Parser.new
+  end
+
+  def parser
+    @p ||= Parser.new
+  end
+
+  def test_permitted_invalid_value
+    err_regexp = /permitted values for option "bad" must be either nil, Range, Regexp or an Array/
+    assert_raises(ArgumentError) {
+      @p.opt 'bad', 'desc', :permitted => 1
+    }
+    assert_raises(ArgumentError) {
+      @p.opt 'bad', 'desc', :permitted => "A"
+    }
+    assert_raises_errmatch(ArgumentError, err_regexp) {
+      @p.opt 'bad', 'desc', :permitted => :abcd
+    }
+  end
+
+  def test_permitted_with_string_array
+    @p.opt 'fiz', 'desc', :type => 'string', :permitted => ['foo', 'bar']
+    @p.parse(%w(--fiz foo))
+    assert_raises_errmatch(CommandlineError, /option '--fiz' only accepts one of: foo, bar/) {
+      @p.parse(%w(--fiz buz))
+    }
+  end
+  
+  def test_permitted_with_symbol_array
+    @p.opt 'fiz', 'desc', :type => 'string', :permitted => %i[dog cat]
+    @p.parse(%w(--fiz dog)) 
+    @p.parse(%w(--fiz cat)) 
+    assert_raises_errmatch(CommandlineError, /option '--fiz' only accepts one of: dog, cat/) {
+      @p.parse(%w(--fiz rat))
+    }
+  end
+
+  def test_permitted_with_numeric_array
+    @p.opt 'mynum', 'desc', :type => Integer, :permitted => [1,2,4]
+    @p.parse(%w(--mynum 1)) 
+    @p.parse(%w(--mynum 4)) 
+    assert_raises_errmatch(CommandlineError, /option '--mynum' only accepts one of: 1, 2, 4/) {
+      @p.parse(%w(--mynum 3))
+    }
+  end
+
+  def test_permitted_with_numeric_range
+    @p.opt 'fiz', 'desc', :type => Integer, :permitted => 1..3
+    opts = @p.parse(%w(--fiz 1))
+    assert_equal opts['fiz'], 1
+    opts = @p.parse(%w(--fiz 3))
+    assert_equal opts['fiz'], 3
+    assert_raises_errmatch(CommandlineError, /option '--fiz' only accepts value in range of: 1\.\.3/) {
+      @p.parse(%w(--fiz 4))
+    }
+  end
+
+  def test_permitted_with_regexp
+    @p.opt 'zipcode', 'desc', :type => String, :permitted => /^[0-9]{5}$/
+    @p.parse(%w(--zipcode 39762))
+    err_regexp = %r|option '--zipcode' only accepts value matching: ...0.9..5|
+    assert_raises_errmatch(CommandlineError, err_regexp) {
+      @p.parse(%w(--zipcode A9A9AA))
+    }
+  end
+  
+  def test_permitted_with_reason
+    # test all keys passed into the formatter for the permitted_response
+    @p.opt 'zipcode', 'desc', type: String, permitted: /^[0-9]{5}$/,
+           permitted_response: "opt %{arg} should be a zipcode but you have %{value}"
+    @p.opt :wig, 'wig', type: Integer, permitted: 1..4,
+           permitted_response: "opt %{arg} exceeded four wigs (%{valid_string}), %{permitted}, but you gave '%{given}'"
+    err_regexp = %r|opt --zipcode should be a zipcode but you have A9A9AA|
+    assert_raises_errmatch(CommandlineError, err_regexp) {
+      @p.parse(%w(--zipcode A9A9AA))
+    }
+    err_regexp = %r|opt --wig exceeded four wigs \(value in range of: 1\.\.4\), 1\.\.4, but you gave '5'|
+    assert_raises_errmatch(CommandlineError, err_regexp) {
+      @p.parse(%w(--wig 5))
+    }
+  end
+
+  
+end
+end

data/test/optimist_xl/subcommands_test.rb

@@ -0,0 +1,153 @@
+require 'stringio'
+require 'test_helper'
+
+module OptimistXL
+
+module SubcommandTests
+
+  def if_did_you_mean_enabled
+    if (Module::const_defined?("DidYouMean") &&
+        Module::const_defined?("DidYouMean::JaroWinkler") &&
+        Module::const_defined?("DidYouMean::Levenshtein"))
+      yield
+    end
+  end
+  
+  # fails when no args provided
+  def test_subcommand_noargs
+    assert_raises(OptimistXL::CommandlineError, /No subcommand provided/) do
+      @p.parse([])
+    end
+  end
+
+  # ok when global help provided
+  def test_subcommand_global_help
+    assert_raises(OptimistXL::HelpNeeded) do
+      @p.parse(%w(-h))
+    end
+    sio = StringIO.new "w"
+    @p.educate sio
+    assert_match(/list\s+show the list/, sio.string)
+    assert_match(/create\s*\n/, sio.string)
+  end
+
+  # fails when invalid param given
+  def test_subcommand_invalid_opt
+    assert_raises_errmatch(OptimistXL::CommandlineError, /unknown argument '--boom'/) do
+      @p.parse(%w(--boom))
+    end
+  end
+  
+  # fails when invalid subcommand given
+  def test_subcommand_invalid_subcmd
+    assert_raises_errmatch(OptimistXL::CommandlineError, /unknown subcommand 'boom'/) do
+      @p.parse(%w(boom))
+    end
+  end
+  
+  # ok when valid subcommand given
+  def test_subcommand_ok_noopts
+    @p.parse(%w(list))
+    @p.parse(%w(create))
+  end
+
+  # ok when valid subcommand given with help param
+  def test_subcommand_help_subcmd1
+    err = assert_raises(OptimistXL::HelpNeeded) do
+      @p.parse(%w(list --help))
+    end
+
+    sio = StringIO.new "w"
+    err.parser.educate sio
+    assert_match(/all.*list all the things/, sio.string)
+    assert_match(/help.*Show this message/, sio.string)
+  end
+  
+  def test_subcommand_help_subcmd2
+    err = assert_raises(OptimistXL::HelpNeeded) do
+      @p.parse(%w(create --help))
+    end
+    sio = StringIO.new "w"
+    err.parser.educate sio
+    assert_match(/partial.*create a partial thing/, sio.string)
+    assert_match(/name.*creation name/, sio.string)
+    assert_match(/help.*Show this message/, sio.string)
+  end
+  
+  # fails when valid subcommand given with invalid param
+  def test_subcommand_invalid_subopt
+    assert_raises_errmatch(OptimistXL::CommandlineError, /unknown argument '--foo' for command 'list'/) do
+      @p.parse(%w(list --foo))
+    end
+    assert_raises_errmatch(OptimistXL::CommandlineError, /unknown argument '--bar' for command 'create'/) do
+      @p.parse(%w(create --bar))
+    end
+  end
+
+  # ok when valid subcommand given with valid params
+  def test_subcommand_ok
+    @p.parse(%w(list --all))
+    @p.parse(%w(create --partial --name duck))
+  end
+
+  
+end
+
+class SubcommandsWithGlobalOptTest < ::MiniTest::Test
+  include SubcommandTests
+  def setup
+    @p = Parser.new
+    @p.opt :some_global_stropt, 'Some global string option', type: :string, short: :none
+    @p.opt :some_global_flag, 'Some global flag'
+    @p.subcmd :list, "show the list" do
+      opt :all, 'list all the things', type: :boolean
+    end
+    @p.subcmd "create" do
+      opt :partial, 'create a partial thing', type: :boolean
+      opt :name,    'creation name', type: :string
+    end
+  end
+
+  def test_subcommand_ok_gopts
+    @p.parse(%w(--some-global-flag list --all))
+    @p.parse(%w(--some-global-stropt GHI create --partial --name duck))
+    # handles minimal-length partial-long arguments
+    @p.parse(%w(--some-global-s GHI create --par --na duck))
+  end
+  
+  def test_subcommand_invalid_gopts
+    assert_raises_errmatch(OptimistXL::CommandlineError, /unknown argument '--all'/) do
+      @p.parse(%w(--all list --all))
+    end
+    # handles misspellings property on subcommands
+    if_did_you_mean_enabled do
+      err_regex = /unknown argument '--partul' for command 'create'.  Did you mean: \[--partial\]/
+      assert_raises_errmatch(OptimistXL::CommandlineError, err_regex) do
+        @p.parse(%w(--some-global-stropt GHI create --partul --name duck))
+      end
+    end
+  end
+
+end
+
+class SubcommandsWithoutGlobalOptTest < ::MiniTest::Test
+  include SubcommandTests
+  def setup
+    @p = Parser.new
+    @p.subcmd :list, "show the list" do
+      opt :all, 'list all the things', type: :boolean
+    end
+    @p.subcmd "create" do
+      opt :partial, 'create a partial thing', type: :boolean
+      opt :name,    'creation name', type: :string
+    end
+  end
+
+  def test_subcommand_invalid_gopts
+    assert_raises_errmatch(OptimistXL::CommandlineError, /unknown argument '--some-global-flag'/) do
+      @p.parse(%w(--some-global-flag list --all))
+    end
+  end
+end
+
+end

data/test/optimist_xl/version_needed_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module OptimistXL
+  class VersionNeededTest < ::MiniTest::Test
+    def test_class
+      assert_kind_of Exception, vn("message")
+    end
+
+    def test_message
+      assert "message", vn("message").message
+    end
+
+    private
+
+    def vn(*args)
+      VersionNeeded.new(*args)
+    end
+  end
+end

data/test/optimist_xl_test.rb

@@ -0,0 +1,190 @@
+require 'test_helper'
+
+class OptimistXLTest < MiniTest::Test
+  def setup
+    OptimistXL.send(:instance_variable_set, "@last_parser", nil)
+  end
+
+  def parser(&block)
+    OptimistXL::Parser.new(&block)
+  end
+
+  def test_options
+    opts = OptimistXL.options %w(-f) do
+      opt :f
+    end
+
+    assert_equal true, opts[:f]
+  end
+
+  def test_options_die_default
+    assert_stderr(/Error: unknown argument.*Try --help/m) do
+      assert_system_exit(-1) do
+        OptimistXL.options %w(-f) do
+          opt :x
+        end
+      end
+    end
+  end
+
+  def test_options_die_educate_on_error
+    assert_stderr(/Error: unknown argument.*Options/m) do
+      assert_system_exit(-1) do
+        OptimistXL.options %w(-f) do
+          opt :x
+          educate_on_error
+        end
+      end
+    end
+  end
+
+  def test_die_without_options_ever_run
+    assert_raises(ArgumentError) { OptimistXL.die 'hello' }
+  end
+
+  def test_die
+    assert_stderr(/Error: issue with parsing/) do
+      assert_system_exit(-1) do
+        OptimistXL.options []
+        OptimistXL.die "issue with parsing"
+      end
+    end
+  end
+
+  def test_die_custom_error_code
+    assert_stderr(/Error: issue with parsing/) do
+      assert_system_exit(5) do
+        OptimistXL.options []
+        OptimistXL.die "issue with parsing", nil, 5
+      end
+    end
+  end
+
+  def test_die_custom_error_code_two_args
+    assert_stderr(/Error: issue with parsing/) do
+      assert_system_exit(5) do
+        OptimistXL.options []
+        OptimistXL.die "issue with parsing", 5
+      end
+    end
+  end
+
+  def test_educate_without_options_ever_run
+    assert_raises(ArgumentError) { OptimistXL.educate }
+  end
+
+  def test_educate
+    assert_stdout(/Show this message/) do
+      assert_system_exit(0) do
+        OptimistXL.options []
+        OptimistXL.educate
+      end
+    end
+  end
+
+  def test_with_standard_exception_options
+    p = parser do
+      opt :f
+    end
+
+    opts = OptimistXL::with_standard_exception_handling p do
+      p.parse %w(-f)
+    end
+
+    assert_equal true, opts[:f]
+  end
+
+  def test_with_standard_exception_version_exception
+    p = parser do
+      version "5.5"
+    end
+
+    assert_stdout(/5\.5/) do
+      assert_system_exit(0) do
+        OptimistXL::with_standard_exception_handling p do
+          raise OptimistXL::VersionNeeded
+        end
+      end
+    end
+  end
+
+  def test_with_standard_exception_version_flag
+    p = parser do
+      version "5.5"
+    end
+
+    assert_stdout(/5\.5/) do
+      assert_system_exit(0) do
+        OptimistXL::with_standard_exception_handling p do
+          p.parse %w(-v)
+        end
+      end
+    end
+  end
+
+  def test_with_standard_exception_die_exception
+    assert_stderr(/Error: cl error/) do
+      assert_system_exit(-1) do
+        p = parser
+        OptimistXL.with_standard_exception_handling(p) do
+          raise ::OptimistXL::CommandlineError.new('cl error')
+        end
+      end
+    end
+  end
+
+  def test_with_standard_exception_die_exception_custom_error
+    assert_stderr(/Error: cl error/) do
+      assert_system_exit(5) do
+        p = parser
+        OptimistXL.with_standard_exception_handling(p) do
+          raise ::OptimistXL::CommandlineError.new('cl error', 5)
+        end
+      end
+    end
+  end
+
+  def test_with_standard_exception_die
+    assert_stderr(/Error: cl error/) do
+      assert_system_exit(-1) do
+        p = parser
+        OptimistXL.with_standard_exception_handling(p) do
+          p.die 'cl error'
+        end
+      end
+    end
+  end
+
+  def test_with_standard_exception_die_custom_error
+    assert_stderr(/Error: cl error/) do
+      assert_system_exit(3) do
+        p = parser
+        OptimistXL.with_standard_exception_handling(p) do
+          p.die 'cl error', nil, 3
+        end
+      end
+    end
+  end
+
+  def test_with_standard_exception_help_needed
+    assert_stdout(/Options/) do
+      assert_system_exit(0) do
+        p = parser
+        OptimistXL.with_standard_exception_handling(p) do
+          raise OptimistXL::HelpNeeded.new(parser: p)
+        end
+      end
+    end
+  end
+
+  def test_with_standard_exception_help_needed_flag
+    assert_stdout(/Options/) do
+      assert_system_exit(0) do
+        p = parser
+        OptimistXL.with_standard_exception_handling(p) do
+          p.parse(%w(-h))
+        end
+      end
+    end
+  end
+end