cri 2.7.0 → 2.7.1

data/test/test_command_runner.rb

@@ -1,12 +1,10 @@
-# encoding: utf-8
-
 module Cri
   class CommandRunnerTestCase < Cri::TestCase
     def setup
       super
 
-      @options   = { :vehicle => 'pig' }
-      @arguments = %w( baby_monkey )
+      @options   = { vehicle: 'pig' }
+      @arguments = %w(baby_monkey)
       @command   = Cri::Command.new
     end
 

data/test/test_option_parser.rb

@@ -1,19 +1,17 @@
-# encoding: utf-8
-
 module Cri
   class OptionParserTestCase < Cri::TestCase
     def test_parse_without_options
-      input       = %w( foo bar baz )
+      input       = %w(foo bar baz)
       definitions = []
 
       parser = Cri::OptionParser.parse(input, definitions)
 
-      assert_equal({},                      parser.options)
+      assert_equal({}, parser.options)
       assert_equal(%w(foo bar baz), parser.arguments)
     end
 
     def test_parse_with_invalid_option
-      input       = %w( foo -x )
+      input       = %w(foo -x)
       definitions = []
 
       assert_raises(Cri::OptionParser::IllegalOptionError) do
@@ -22,9 +20,9 @@ module Cri
     end
 
     def test_parse_with_unused_options
-      input       = %w( foo )
+      input       = %w(foo)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+        { long: 'aaa', short: 'a', argument: :forbidden },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
@@ -33,9 +31,9 @@ module Cri
     end
 
     def test_parse_with_long_valueless_option
-      input       = %w( foo --aaa bar )
+      input       = %w(foo --aaa bar)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+        { long: 'aaa', short: 'a', argument: :forbidden },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
@@ -45,33 +43,33 @@ module Cri
     end
 
     def test_parse_with_long_valueful_option
-      input       = %w( foo --aaa xxx bar )
+      input       = %w(foo --aaa xxx bar)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :required },
+        { long: 'aaa', short: 'a', argument: :required },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
 
-      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal({ aaa: 'xxx' }, parser.options)
       assert_equal(%w(foo bar), parser.arguments)
     end
 
     def test_parse_with_long_valueful_equalsign_option
-      input       = %w( foo --aaa=xxx bar )
+      input       = %w(foo --aaa=xxx bar)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :required },
+        { long: 'aaa', short: 'a', argument: :required },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
 
-      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal({ aaa: 'xxx' }, parser.options)
       assert_equal(%w(foo bar), parser.arguments)
     end
 
     def test_parse_with_long_valueful_option_with_missing_value
-      input       = %w( foo --aaa )
+      input       = %w(foo --aaa)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :required },
+        { long: 'aaa', short: 'a', argument: :required },
       ]
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
@@ -80,10 +78,10 @@ module Cri
     end
 
     def test_parse_with_two_long_valueful_options
-      input       = %w( foo --all --port 2 )
+      input       = %w(foo --all --port 2)
       definitions = [
-        { :long => 'all',  :short => 'a', :argument => :required  },
-        { :long => 'port', :short => 'p', :argument => :required },
+        { long: 'all',  short: 'a', argument: :required },
+        { long: 'port', short: 'p', argument: :required },
       ]
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
@@ -92,9 +90,9 @@ module Cri
     end
 
     def test_parse_with_long_valueless_option_with_optional_value
-      input       = %w( foo --aaa )
+      input       = %w(foo --aaa)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :optional },
+        { long: 'aaa', short: 'a', argument: :optional },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
@@ -104,23 +102,23 @@ module Cri
     end
 
     def test_parse_with_long_valueful_option_with_optional_value
-      input       = %w( foo --aaa xxx )
+      input       = %w(foo --aaa xxx)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :optional },
+        { long: 'aaa', short: 'a', argument: :optional },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
 
-      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal({ aaa: 'xxx' }, parser.options)
       assert_equal(['foo'], parser.arguments)
     end
 
     def test_parse_with_long_valueless_option_with_optional_value_and_more_options
-      input       = %w( foo --aaa -b -c )
+      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 },
+        { long: 'aaa', short: 'a', argument: :optional  },
+        { long: 'bbb', short: 'b', argument: :forbidden },
+        { long: 'ccc', short: 'c', argument: :forbidden },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
@@ -132,9 +130,9 @@ module Cri
     end
 
     def test_parse_with_short_valueless_options
-      input       = %w( foo -a bar )
+      input       = %w(foo -a bar)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+        { long: 'aaa', short: 'a', argument: :forbidden },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
@@ -144,9 +142,9 @@ module Cri
     end
 
     def test_parse_with_short_valueful_option_with_missing_value
-      input       = %w( foo -a )
+      input       = %w(foo -a)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :required },
+        { long: 'aaa', short: 'a', argument: :required },
       ]
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
@@ -155,11 +153,11 @@ module Cri
     end
 
     def test_parse_with_short_combined_valueless_options
-      input       = %w( foo -abc bar )
+      input       = %w(foo -abc bar)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :forbidden },
-        { :long => 'bbb', :short => 'b', :argument => :forbidden },
-        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+        { long: 'aaa', short: 'a', argument: :forbidden },
+        { long: 'bbb', short: 'b', argument: :forbidden },
+        { long: 'ccc', short: 'c', argument: :forbidden },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
@@ -171,11 +169,11 @@ module Cri
     end
 
     def test_parse_with_short_combined_valueful_options_with_missing_value
-      input       = %w( foo -abc bar )
+      input       = %w(foo -abc bar)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :required  },
-        { :long => 'bbb', :short => 'b', :argument => :forbidden },
-        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+        { long: 'aaa', short: 'a', argument: :required  },
+        { long: 'bbb', short: 'b', argument: :forbidden },
+        { long: 'ccc', short: 'c', argument: :forbidden },
       ]
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
@@ -184,10 +182,10 @@ module Cri
     end
 
     def test_parse_with_two_short_valueful_options
-      input       = %w( foo -a -p 2 )
+      input       = %w(foo -a -p 2)
       definitions = [
-        { :long => 'all',  :short => 'a', :argument => :required  },
-        { :long => 'port', :short => 'p', :argument => :required },
+        { long: 'all',  short: 'a', argument: :required },
+        { long: 'port', short: 'p', argument: :required },
       ]
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
@@ -196,9 +194,9 @@ module Cri
     end
 
     def test_parse_with_short_valueless_option_with_optional_value
-      input       = %w( foo -a )
+      input       = %w(foo -a)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :optional },
+        { long: 'aaa', short: 'a', argument: :optional },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
@@ -208,23 +206,23 @@ module Cri
     end
 
     def test_parse_with_short_valueful_option_with_optional_value
-      input       = %w( foo -a xxx )
+      input       = %w(foo -a xxx)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :optional },
+        { long: 'aaa', short: 'a', argument: :optional },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
 
-      assert_equal({ :aaa => 'xxx' },  parser.options)
+      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 )
+      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 },
+        { long: 'aaa', short: 'a', argument: :optional  },
+        { long: 'bbb', short: 'b', argument: :forbidden },
+        { long: 'ccc', short: 'c', argument: :forbidden },
       ]
 
       parser = Cri::OptionParser.parse(input, definitions)
@@ -236,30 +234,30 @@ module Cri
     end
 
     def test_parse_with_single_hyphen
-      input       = %w( foo - bar )
+      input       = %w(foo - bar)
       definitions = []
 
       parser = Cri::OptionParser.parse(input, definitions)
 
-      assert_equal({},                    parser.options)
+      assert_equal({}, parser.options)
       assert_equal(['foo', '-', 'bar'], parser.arguments)
     end
 
     def test_parse_with_end_marker
-      input       = %w( foo bar -- -x --yyy -abc )
+      input       = %w(foo bar -- -x --yyy -abc)
       definitions = []
 
       parser = Cri::OptionParser.parse(input, definitions)
 
-      assert_equal({},                                            parser.options)
+      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 )
+      input       = %w(foo --aaa -- zzz)
       definitions = [
-        { :long => 'aaa', :short => 'a', :argument => :required },
+        { long: 'aaa', short: 'a', argument: :required },
       ]
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
@@ -268,10 +266,10 @@ module Cri
     end
 
     def test_parse_with_multiple_options
-      input = %w( foo -o test -o test2 -v -v -v)
+      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 },
+        { long: 'long', short: 'o', argument: :required, multiple: true },
+        { long: 'verbose', short: 'v', multiple: true },
       ]
       parser = Cri::OptionParser.parse(input, definitions)
 

data/test/test_string_formatter.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Cri
   class CoreExtTestCase < Cri::TestCase
     def formatter

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cri
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.7.1
 platform: ruby
 authors:
 - Denis Defreyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-29 00:00:00.000000000 Z
+date: 2016-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colored
@@ -38,8 +38,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-description: Cri allows building easy-to-use commandline interfaces with support for
-  subcommands.
+description: Cri allows building easy-to-use command-line interfaces with support
+  for subcommands.
 email: denis.defreyne@stoneship.org
 executables: []
 extensions: []
@@ -101,9 +101,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: a library for building easy-to-use commandline tools
+summary: a library for building easy-to-use command-line tools
 test_files: []
-has_rdoc: