cri 2.6.1 → 2.7.0

data/test/test_command_dsl.rb

@@ -1,187 +1,211 @@
 # encoding: utf-8
 
-class Cri::CommandDSLTestCase < Cri::TestCase
-
-  def test_create_command
-    # Define
-    dsl = Cri::CommandDSL.new
-    dsl.instance_eval do
-      name        'moo'
-      usage       'dunno whatever'
-      summary     'does stuff'
-      description 'This command does a lot of stuff.'
-
-      option    :a, :aaa, 'opt a', :argument => :optional, :multiple => true
-      required  :b, :bbb, 'opt b'
-      optional  :c, :ccc, 'opt c'
-      flag      :d, :ddd, 'opt d'
-      forbidden :e, :eee, 'opt e'
-
-      run do |opts, args|
-        $did_it_work = :probably
+module Cri
+  class CommandDSLTestCase < Cri::TestCase
+    def test_create_command
+      # Define
+      dsl = Cri::CommandDSL.new
+      dsl.instance_eval do
+        name        'moo'
+        usage       'dunno whatever'
+        summary     'does stuff'
+        description 'This command does a lot of stuff.'
+
+        option    :a, :aaa, 'opt a', :argument => :optional, :multiple => true
+        required  :b, :bbb, 'opt b'
+        optional  :c, :ccc, 'opt c'
+        flag      :d, :ddd, 'opt d'
+        forbidden :e, :eee, 'opt e'
+        flag      :f, :fff, 'opt f', :hidden => true
+
+        run do |_opts, _args|
+          $did_it_work = :probably
+        end
       end
-    end
-    command = dsl.command
-
-    # Run
-    $did_it_work = :sadly_not
-    command.run(%w( -a x -b y -c -d -e ))
-    assert_equal :probably, $did_it_work
-
-    # Check
-    assert_equal 'moo', command.name
-    assert_equal 'dunno whatever', command.usage
-    assert_equal 'does stuff', command.summary
-    assert_equal 'This command does a lot of stuff.', command.description
-
-    # Check options
-    expected_option_definitions = Set.new([
-      { :short => 'a', :long => 'aaa', :desc => 'opt a', :argument => :optional, :multiple => true,   :block => nil },
-      { :short => 'b', :long => 'bbb', :desc => 'opt b', :argument => :required, :multiple => false,  :block => nil },
-      { :short => 'c', :long => 'ccc', :desc => 'opt c', :argument => :optional, :multiple => false,  :block => nil },
-      { :short => 'd', :long => 'ddd', :desc => 'opt d', :argument => :forbidden, :multiple => false, :block => nil },
-      { :short => 'e', :long => 'eee', :desc => 'opt e', :argument => :forbidden, :multiple => false, :block => nil }
+      command = dsl.command
+
+      # Run
+      $did_it_work = :sadly_not
+      command.run(%w( -a x -b y -c -d -e ))
+      assert_equal :probably, $did_it_work
+
+      # Check
+      assert_equal 'moo', command.name
+      assert_equal 'dunno whatever', command.usage
+      assert_equal 'does stuff', command.summary
+      assert_equal 'This command does a lot of stuff.', command.description
+
+      # Check options
+      expected_option_definitions = Set.new([
+        { :short => 'a', :long => 'aaa', :desc => 'opt a', :argument => :optional,  :multiple => true,  :hidden => false, :block => nil },
+        { :short => 'b', :long => 'bbb', :desc => 'opt b', :argument => :required,  :multiple => false, :hidden => false, :block => nil },
+        { :short => 'c', :long => 'ccc', :desc => 'opt c', :argument => :optional,  :multiple => false, :hidden => false, :block => nil },
+        { :short => 'd', :long => 'ddd', :desc => 'opt d', :argument => :forbidden, :multiple => false, :hidden => false, :block => nil },
+        { :short => 'e', :long => 'eee', :desc => 'opt e', :argument => :forbidden, :multiple => false, :hidden => false, :block => nil },
+        { :short => 'f', :long => 'fff', :desc => 'opt f', :argument => :forbidden, :multiple => false, :hidden => true,  :block => nil },
       ])
-    actual_option_definitions = Set.new(command.option_definitions)
-    assert_equal expected_option_definitions, actual_option_definitions
-  end
+      actual_option_definitions = Set.new(command.option_definitions)
+      assert_equal expected_option_definitions, actual_option_definitions
+    end
 
-  def test_optional_options
-    # Define
-    dsl = Cri::CommandDSL.new
-    dsl.instance_eval do
-      name        'moo'
-      usage       'dunno whatever'
-      summary     'does stuff'
-      description 'This command does a lot of stuff.'
+    def test_optional_options
+      # Define
+      dsl = Cri::CommandDSL.new
+      dsl.instance_eval do
+        name        'moo'
+        usage       'dunno whatever'
+        summary     'does stuff'
+        description 'This command does a lot of stuff.'
 
-      flag :s,  nil,   'short'
-      flag nil, :long, 'long'
+        flag :s,  nil,   'short'
+        flag nil, :long, 'long'
 
-      run do |opts, args|
-        $did_it_work = :probably
+        run do |_opts, _args|
+          $did_it_work = :probably
+        end
       end
-    end
-    command = dsl.command
-
-    # Run
-    $did_it_work = :sadly_not
-    command.run(%w( -s --long ))
-    assert_equal :probably, $did_it_work
-
-    # Check options
-    expected_option_definitions = Set.new([
-      { :short => 's', :long => nil,    :desc => 'short', :argument => :forbidden, :multiple => false, :block => nil },
-      { :short => nil, :long => 'long', :desc => 'long',  :argument => :forbidden, :multiple => false, :block => nil }
-    ])
-    actual_option_definitions = Set.new(command.option_definitions)
-    assert_equal expected_option_definitions, actual_option_definitions
-  end
+      command = dsl.command
 
-  def test_multiple
-    # Define
-    dsl = Cri::CommandDSL.new
-    dsl.instance_eval do
-      flag     :f, :flag,     'sample flag option',     :multiple => true
-      required :r, :required, 'sample required option', :multiple => true
-      optional :o, :optional, 'sample optional option', :multiple => true
+      # Run
+      $did_it_work = :sadly_not
+      command.run(%w( -s --long ))
+      assert_equal :probably, $did_it_work
 
-      run { |opts, args| }
+      # Check options
+      expected_option_definitions = Set.new([
+        { :short => 's', :long => nil,    :desc => 'short', :argument => :forbidden, :multiple => false, :hidden => false, :block => nil },
+        { :short => nil, :long => 'long', :desc => 'long',  :argument => :forbidden, :multiple => false, :hidden => false, :block => nil },
+      ])
+      actual_option_definitions = Set.new(command.option_definitions)
+      assert_equal expected_option_definitions, actual_option_definitions
     end
-    command = dsl.command
-
-    # Check options
-    expected_option_definitions = Set.new([
-      { :short => 'f', :long => 'flag',     :desc => 'sample flag option',     :argument => :forbidden, :multiple => true, :block => nil },
-      { :short => 'r', :long => 'required', :desc => 'sample required option', :argument => :required,  :multiple => true, :block => nil },
-      { :short => 'o', :long => 'optional', :desc => 'sample optional option', :argument => :optional,  :multiple => true, :block => nil },
-    ])
-    actual_option_definitions = Set.new(command.option_definitions)
-    assert_equal expected_option_definitions, actual_option_definitions
-  end
 
-  def test_required_short_and_long
-    # Define
-    dsl = Cri::CommandDSL.new
-    assert_raises ArgumentError do
+    def test_multiple
+      # Define
+      dsl = Cri::CommandDSL.new
       dsl.instance_eval do
-        option nil, nil, 'meh'
+        flag     :f, :flag,     'flag', :multiple => true
+        required :r, :required, 'req',  :multiple => true
+        optional :o, :optional, 'opt',  :multiple => true
+
+        run { |_opts, _args| }
       end
+      command = dsl.command
+
+      # Check options
+      expected_option_definitions = Set.new([
+        { :short => 'f', :long => 'flag',     :desc => 'flag', :argument => :forbidden, :multiple => true, :hidden => false, :block => nil },
+        { :short => 'r', :long => 'required', :desc => 'req',  :argument => :required,  :multiple => true, :hidden => false, :block => nil },
+        { :short => 'o', :long => 'optional', :desc => 'opt',  :argument => :optional,  :multiple => true, :hidden => false, :block => nil },
+      ])
+      actual_option_definitions = Set.new(command.option_definitions)
+      assert_equal expected_option_definitions, actual_option_definitions
     end
-    assert_raises ArgumentError do
+
+    def test_hidden
+      # Define
+      dsl = Cri::CommandDSL.new
       dsl.instance_eval do
-        flag nil, nil, 'meh'
+        flag     :f, :flag,     'flag', :hidden => true
+        required :r, :required, 'req',  :hidden => true
+        optional :o, :optional, 'opt',  :hidden => true
+
+        run { |_opts, _args| }
       end
+      command = dsl.command
+
+      # Check options
+      expected_option_definitions = Set.new([
+        { :short => 'f', :long => 'flag',     :desc => 'flag', :argument => :forbidden, :multiple => false, :hidden => true, :block => nil },
+        { :short => 'r', :long => 'required', :desc => 'req',  :argument => :required,  :multiple => false, :hidden => true, :block => nil },
+        { :short => 'o', :long => 'optional', :desc => 'opt',  :argument => :optional,  :multiple => false, :hidden => true, :block => nil },
+      ])
+      actual_option_definitions = Set.new(command.option_definitions)
+      assert_equal expected_option_definitions, actual_option_definitions
     end
-    assert_raises ArgumentError do
-      dsl.instance_eval do
-        required nil, nil, 'meh'
+
+    def test_required_short_and_long
+      # Define
+      dsl = Cri::CommandDSL.new
+      assert_raises ArgumentError do
+        dsl.instance_eval do
+          option nil, nil, 'meh'
+        end
       end
-    end
-    assert_raises ArgumentError do
-      dsl.instance_eval do
-        optional nil, nil, 'meh'
+      assert_raises ArgumentError do
+        dsl.instance_eval do
+          flag nil, nil, 'meh'
+        end
+      end
+      assert_raises ArgumentError do
+        dsl.instance_eval do
+          required nil, nil, 'meh'
+        end
+      end
+      assert_raises ArgumentError do
+        dsl.instance_eval do
+          optional nil, nil, 'meh'
+        end
       end
     end
-  end
 
-  def test_subcommand
-    # Define
-    dsl = Cri::CommandDSL.new
-    dsl.instance_eval do
-      name 'super'
-      subcommand do |c|
-        c.name 'sub'
+    def test_subcommand
+      # Define
+      dsl = Cri::CommandDSL.new
+      dsl.instance_eval do
+        name 'super'
+        subcommand do |c|
+          c.name 'sub'
+        end
       end
+      command = dsl.command
+
+      # Check
+      assert_equal 'super', command.name
+      assert_equal 1,       command.subcommands.size
+      assert_equal 'sub',   command.subcommands.to_a[0].name
     end
-    command = dsl.command
 
-    # Check
-    assert_equal 'super', command.name
-    assert_equal 1,       command.subcommands.size
-    assert_equal 'sub',   command.subcommands.to_a[0].name
-  end
+    def test_aliases
+      # Define
+      dsl = Cri::CommandDSL.new
+      dsl.instance_eval do
+        aliases :moo, :aah
+      end
+      command = dsl.command
 
-  def test_aliases
-    # Define
-    dsl = Cri::CommandDSL.new
-    dsl.instance_eval do
-      aliases :moo, :aah
+      # Check
+      assert_equal %w( aah moo ), command.aliases.sort
     end
-    command = dsl.command
-
-    # Check
-    assert_equal %w( aah moo ), command.aliases.sort
-  end
 
-  def test_run_arity
-    dsl = Cri::CommandDSL.new
-    assert_raises ArgumentError do
-      dsl.instance_eval do
-        run do |a, b, c, d, e|
+    def test_run_arity
+      dsl = Cri::CommandDSL.new
+      assert_raises ArgumentError do
+        dsl.instance_eval do
+          run do |_a, _b, _c, _d, _e|
+          end
         end
       end
     end
-  end
 
-  def test_runner
-    # Define
-    dsl = Cri::CommandDSL.new
-    dsl.instance_eval <<-EOS
-      class Cri::CommandDSLTestCaseCommandRunner < Cri::CommandRunner
-        def run
-          $works = arguments[0]
+    def test_runner
+      # Define
+      dsl = Cri::CommandDSL.new
+      dsl.instance_eval <<-EOS
+        class Cri::CommandDSLTestCaseCommandRunner < Cri::CommandRunner
+          def run
+            $did_it_work = arguments[0]
+          end
         end
-      end
 
-      runner Cri::CommandDSLTestCaseCommandRunner
-EOS
-    command = dsl.command
+        runner Cri::CommandDSLTestCaseCommandRunner
+  EOS
+      command = dsl.command
 
-    # Check
-    $works = false
-    command.run(%w( certainly ))
-    assert_equal 'certainly', $works
+      # Check
+      $did_it_work = false
+      command.run(%w( certainly ))
+      assert_equal 'certainly', $did_it_work
+    end
   end
-
 end

data/test/test_command_runner.rb

@@ -1,32 +1,31 @@
 # encoding: utf-8
 
-class Cri::CommandRunnerTestCase < Cri::TestCase
-
-  def setup
-    super
-
-    @options   = { :vehicle => 'pig' }
-    @arguments = %w( baby_monkey )
-    @command   = Cri::Command.new
-  end
-
-  def test_initialize
-
-    runner = Cri::CommandRunner.new(@options, @arguments, @command)
+module Cri
+  class CommandRunnerTestCase < Cri::TestCase
+    def setup
+      super
+
+      @options   = { :vehicle => 'pig' }
+      @arguments = %w( baby_monkey )
+      @command   = Cri::Command.new
+    end
 
-    assert_equal @options,   runner.options
-    assert_equal @arguments, runner.arguments
-    assert_equal @command,   runner.command
-  end
+    def test_initialize
+      runner = Cri::CommandRunner.new(@options, @arguments, @command)
 
-  def test_call_run
-    assert_raises(Cri::NotImplementedError) do
-      Cri::CommandRunner.new(@options, @arguments, @command).call
+      assert_equal @options,   runner.options
+      assert_equal @arguments, runner.arguments
+      assert_equal @command,   runner.command
     end
 
-    assert_raises(Cri::NotImplementedError) do
-      Cri::CommandRunner.new(@options, @arguments, @command).run
+    def test_call_run
+      assert_raises(Cri::NotImplementedError) do
+        Cri::CommandRunner.new(@options, @arguments, @command).call
+      end
+
+      assert_raises(Cri::NotImplementedError) do
+        Cri::CommandRunner.new(@options, @arguments, @command).run
+      end
     end
   end
-
 end

data/test/test_option_parser.rb

@@ -1,294 +1,282 @@
 # encoding: utf-8
 
-class Cri::OptionParserTestCase < Cri::TestCase
+module Cri
+  class OptionParserTestCase < Cri::TestCase
+    def test_parse_without_options
+      input       = %w( foo bar baz )
+      definitions = []
 
-  def test_parse_without_options
-    input       = %w( foo bar baz )
-    definitions = []
-
-    parser = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({},                      parser.options)
-    assert_equal([ 'foo', 'bar', 'baz' ], parser.arguments)
-  end
-
-  def test_parse_with_invalid_option
-    input       = %w( foo -x )
-    definitions = []
-
-    result = nil
-
-    assert_raises(Cri::OptionParser::IllegalOptionError) do
       parser = Cri::OptionParser.parse(input, definitions)
-    end
-  end
-
-  def test_parse_with_unused_options
-    input       = %w( foo )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden }
-    ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
-
-    assert(!parser.options[:aaa])
-  end
-
-  def test_parse_with_long_valueless_option
-    input       = %w( foo --aaa bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden }
-    ]
+      assert_equal({},                      parser.options)
+      assert_equal(%w(foo bar baz), parser.arguments)
+    end
 
-    parser = Cri::OptionParser.parse(input, definitions)
+    def test_parse_with_invalid_option
+      input       = %w( foo -x )
+      definitions = []
 
-    assert(parser.options[:aaa])
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
-
-  def test_parse_with_long_valueful_option
-    input       = %w( foo --aaa xxx bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
+      assert_raises(Cri::OptionParser::IllegalOptionError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    parser = Cri::OptionParser.parse(input, definitions)
+    def test_parse_with_unused_options
+      input       = %w( foo )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+      ]
 
-    assert_equal({ :aaa => 'xxx' },  parser.options)
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
+      parser = Cri::OptionParser.parse(input, definitions)
 
-  def test_parse_with_long_valueful_equalsign_option
-    input       = %w( foo --aaa=xxx bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
+      assert(!parser.options[:aaa])
+    end
 
-    parser = Cri::OptionParser.parse(input, definitions)
+    def test_parse_with_long_valueless_option
+      input       = %w( foo --aaa bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+      ]
 
-    assert_equal({ :aaa => 'xxx' },  parser.options)
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
+      parser = Cri::OptionParser.parse(input, definitions)
 
-  def test_parse_with_long_valueful_option_with_missing_value
-    input       = %w( foo --aaa )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
+      assert(parser.options[:aaa])
+      assert_equal(%w(foo bar), parser.arguments)
+    end
 
-    result = nil
+    def test_parse_with_long_valueful_option
+      input       = %w( foo --aaa xxx bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
       parser = Cri::OptionParser.parse(input, definitions)
-    end
-  end
 
-  def test_parse_with_two_long_valueful_options
-    input       = %w( foo --all --port 2 )
-    definitions = [
-      { :long => 'all',  :short => 'a', :argument => :required  },
-      { :long => 'port', :short => 'p', :argument => :required }
-    ]
+      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal(%w(foo bar), parser.arguments)
+    end
 
-    result = nil
+    def test_parse_with_long_valueful_equalsign_option
+      input       = %w( foo --aaa=xxx bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
       parser = Cri::OptionParser.parse(input, definitions)
+
+      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal(%w(foo bar), parser.arguments)
     end
-  end
 
-  def test_parse_with_long_valueless_option_with_optional_value
-    input       = %w( foo --aaa )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
+    def test_parse_with_long_valueful_option_with_missing_value
+      input       = %w( foo --aaa )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    assert(parser.options[:aaa])
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+    def test_parse_with_two_long_valueful_options
+      input       = %w( foo --all --port 2 )
+      definitions = [
+        { :long => 'all',  :short => 'a', :argument => :required  },
+        { :long => 'port', :short => 'p', :argument => :required },
+      ]
 
-  def test_parse_with_long_valueful_option_with_optional_value
-    input       = %w( foo --aaa xxx )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    parser = Cri::OptionParser.parse(input, definitions)
+    def test_parse_with_long_valueless_option_with_optional_value
+      input       = %w( foo --aaa )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional },
+      ]
 
-    assert_equal({ :aaa => 'xxx' },  parser.options)
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+      parser = Cri::OptionParser.parse(input, definitions)
 
-  def test_parse_with_long_valueless_option_with_optional_value_and_more_options
-    input       = %w( foo --aaa -b -c )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional  },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
+      assert(parser.options[:aaa])
+      assert_equal(['foo'], parser.arguments)
+    end
 
-    parser = Cri::OptionParser.parse(input, definitions)
+    def test_parse_with_long_valueful_option_with_optional_value
+      input       = %w( foo --aaa xxx )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional },
+      ]
 
-    assert(parser.options[:aaa])
-    assert(parser.options[:bbb])
-    assert(parser.options[:ccc])
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+      parser = Cri::OptionParser.parse(input, definitions)
 
-  def test_parse_with_short_valueless_options
-    input       = %w( foo -a bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden }
-    ]
+      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal(['foo'], parser.arguments)
+    end
 
-    parser = Cri::OptionParser.parse(input, definitions)
+    def test_parse_with_long_valueless_option_with_optional_value_and_more_options
+      input       = %w( foo --aaa -b -c )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional  },
+        { :long => 'bbb', :short => 'b', :argument => :forbidden },
+        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+      ]
 
-    assert(parser.options[:aaa])
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
+      parser = Cri::OptionParser.parse(input, definitions)
 
-  def test_parse_with_short_valueful_option_with_missing_value
-    input       = %w( foo -a )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
+      assert(parser.options[:aaa])
+      assert(parser.options[:bbb])
+      assert(parser.options[:ccc])
+      assert_equal(['foo'], parser.arguments)
+    end
 
-    result = nil
+    def test_parse_with_short_valueless_options
+      input       = %w( foo -a bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+      ]
 
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
       parser = Cri::OptionParser.parse(input, definitions)
-    end
-  end
-
-  def test_parse_with_short_combined_valueless_options
-    input       = %w( foo -abc bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      assert(parser.options[:aaa])
+      assert_equal(%w(foo bar), parser.arguments)
+    end
 
-    assert(parser.options[:aaa])
-    assert(parser.options[:bbb])
-    assert(parser.options[:ccc])
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
+    def test_parse_with_short_valueful_option_with_missing_value
+      input       = %w( foo -a )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-  def test_parse_with_short_combined_valueful_options_with_missing_value
-    input       = %w( foo -abc bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required  },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    result = nil
+    def test_parse_with_short_combined_valueless_options
+      input       = %w( foo -abc bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+        { :long => 'bbb', :short => 'b', :argument => :forbidden },
+        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+      ]
 
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
       parser = Cri::OptionParser.parse(input, definitions)
+
+      assert(parser.options[:aaa])
+      assert(parser.options[:bbb])
+      assert(parser.options[:ccc])
+      assert_equal(%w(foo bar), parser.arguments)
     end
-  end
 
-  def test_parse_with_two_short_valueful_options
-    input       = %w( foo -a -p 2 )
-    definitions = [
-      { :long => 'all',  :short => 'a', :argument => :required  },
-      { :long => 'port', :short => 'p', :argument => :required }
-    ]
+    def test_parse_with_short_combined_valueful_options_with_missing_value
+      input       = %w( foo -abc bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required  },
+        { :long => 'bbb', :short => 'b', :argument => :forbidden },
+        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+      ]
+
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    result = nil
+    def test_parse_with_two_short_valueful_options
+      input       = %w( foo -a -p 2 )
+      definitions = [
+        { :long => 'all',  :short => 'a', :argument => :required  },
+        { :long => 'port', :short => 'p', :argument => :required },
+      ]
 
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      parser = Cri::OptionParser.parse(input, definitions)
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
     end
-  end
 
-  def test_parse_with_short_valueless_option_with_optional_value
-    input       = %w( foo -a )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
+    def test_parse_with_short_valueless_option_with_optional_value
+      input       = %w( foo -a )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(parser.options[:aaa])
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+      assert(parser.options[:aaa])
+      assert_equal(['foo'], parser.arguments)
+    end
 
-  def test_parse_with_short_valueful_option_with_optional_value
-    input       = %w( foo -a xxx )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
+    def test_parse_with_short_valueful_option_with_optional_value
+      input       = %w( foo -a xxx )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({ :aaa => 'xxx' },  parser.options)
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal(['foo'], parser.arguments)
+    end
 
-  def test_parse_with_short_valueless_option_with_optional_value_and_more_options
-    input       = %w( foo -a -b -c )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional  },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
+    def test_parse_with_short_valueless_option_with_optional_value_and_more_options
+      input       = %w( foo -a -b -c )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional  },
+        { :long => 'bbb', :short => 'b', :argument => :forbidden },
+        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(parser.options[:aaa])
-    assert(parser.options[:bbb])
-    assert(parser.options[:ccc])
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+      assert(parser.options[:aaa])
+      assert(parser.options[:bbb])
+      assert(parser.options[:ccc])
+      assert_equal(['foo'], parser.arguments)
+    end
 
-  def test_parse_with_single_hyphen
-    input       = %w( foo - bar )
-    definitions = []
+    def test_parse_with_single_hyphen
+      input       = %w( foo - bar )
+      definitions = []
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({},                    parser.options)
-    assert_equal([ 'foo', '-', 'bar' ], parser.arguments)
-  end
+      assert_equal({},                    parser.options)
+      assert_equal(['foo', '-', 'bar'], parser.arguments)
+    end
 
-  def test_parse_with_end_marker
-    input       = %w( foo bar -- -x --yyy -abc )
-    definitions = []
+    def test_parse_with_end_marker
+      input       = %w( foo bar -- -x --yyy -abc )
+      definitions = []
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({},                                            parser.options)
-    assert_equal([ 'foo', 'bar', '-x', '--yyy', '-abc' ],       parser.arguments)
-    assert_equal([ 'foo', 'bar', '--', '-x', '--yyy', '-abc' ], parser.arguments.raw)
-  end
+      assert_equal({},                                            parser.options)
+      assert_equal(['foo', 'bar', '-x', '--yyy', '-abc'],       parser.arguments)
+      assert_equal(['foo', 'bar', '--', '-x', '--yyy', '-abc'], parser.arguments.raw)
+    end
 
-  def test_parse_with_end_marker_between_option_key_and_value
-    input       = %w( foo --aaa -- zzz )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
+    def test_parse_with_end_marker_between_option_key_and_value
+      input       = %w( foo --aaa -- zzz )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      parser = Cri::OptionParser.parse(input, definitions)
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
     end
-  end
 
-  def test_parse_with_multiple_options
-    input = %w( foo -o test -o test2 -v -v -v)
-    definitions = [
-      { :long => 'long', :short => 'o', :argument => :required, :multiple => true },
-      { :long => 'verbose', :short => 'v', :multiple => true }
-    ]
-    parser = Cri::OptionParser.parse(input, definitions)
+    def test_parse_with_multiple_options
+      input = %w( foo -o test -o test2 -v -v -v)
+      definitions = [
+        { :long => 'long', :short => 'o', :argument => :required, :multiple => true },
+        { :long => 'verbose', :short => 'v', :multiple => true },
+      ]
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal(['test', 'test2'], parser.options[:long])
-    assert_equal(3, parser.options[:verbose].size)
+      assert_equal(%w(test test2), parser.options[:long])
+      assert_equal(3, parser.options[:verbose].size)
+    end
   end
-
 end