micro-optparse 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d818c3f17d7145292be780c6a915949bffb67ff9
-  data.tar.gz: c95aeea5d5eb0985b17abe704f26419b0ba6283e
+  metadata.gz: e5841fd47f0f0334f7e574fb4eeb4b8d3558459c
+  data.tar.gz: f4247e4c8222e4fbc36e8e1c711d72a5ba0501bf
 SHA512:
-  metadata.gz: ab7a238179cc66385bc1c3e02ff7da394f67d5cfda3e12d1c9b82cee9232bb06528d645d7dbe930cee6ef42509c036eac88650ad868cc79461652aeea34ee801
-  data.tar.gz: 0145bd617acdefce3a925999c96c736cae33dbb260a8c5f9e6c70579d8f5ee986ba4da9922b29294032224e2e1896753d4b85f83dfaccb9c00efc60724fba575
+  metadata.gz: e5be7e4d71a36166fe0bbbd4cb31e34799600317e991ed3e484a33265a35181ecad556bb44adc4880c421a5ffdc9acb98468a1887fa178f842a4fdc6da409061
+  data.tar.gz: c30b91a5c788683983105e8c958a86a1aa73ffbc8e1c0a95de5d0df6e9ccf16184fd9f6775234f0a2e808373bf0e188aa8fef567276bb1a996cacb99f451fe62

data/CHANGES.md

@@ -1,6 +1,12 @@
 Version History
 ===============
 
+Version 1.2.1 (2017-10-02)
+--------------------------
+
+* Adjusted parsing of default values to look for `Integer` rather `Fixnum`
+  to be compatible with Ruby 2.4.0.
+
 Version 1.2.0 (2013-12-29)
 --------------------------
 

data/README.md

@@ -48,12 +48,13 @@ What this piece of code does is the following:
 * it creates a help message and help options, with the banner above the options
 * it creates a version option, which displays the given text
 * it creates a long accessor for each option, according to the symbol - for example `"--verbose"` for `:verbose`
-* it crease a short accessor, which is the first character of the long accessor (automatically resolves duplicates)
+* it creates a short accessor, which is the first character of the long accessor (automatically resolves duplication)
+* it converts under_score options in Ruby to hypenated-options for the CLI, e.g. `:plus_selection` becomes `--plus-selection`
 * it checks if the class of the input and the default value match
-* it creates a switch, if no default value exist or the default value is `true` or `false`
-* when value\_in\_set is given, it validates if the input value is in the given array
-* when value_matches is given, it validates if the input value matches the regular expression
-* when value_satisfies is given, it validates if the lamda or Proc evaluates to `true`, when fed with the input value
+* it creates a switch if no default value exist or the default value is `true` or `false`
+* when `value_in_set` is given, it validates if the input value is in the given array
+* when `value_matches` is given, it validates if the input value matches the regular expression
+* when `value_satisfies` is given, it validates if the lambda or Proc evaluates to `true` when fed with the input value
 * it stores all parsed arguments and default values in the options hash, i.e. to access the value of `:mutation` in your script, write `options[:mutation]`
 
 The automatically generated help message looks like this:

data/lib/micro-optparse/parser.rb

@@ -46,7 +46,7 @@ class Parser
         @used_short << short = o[:settings][:no_short] ? nil : o[:settings][:short] || short_from(o[:name])
         @result[o[:name]] = o[:settings][:default] || false unless o[:settings][:optional] # set default
         name = o[:name].to_s.gsub("_", "-")
-        klass = o[:settings][:default].class == Fixnum ? Integer : o[:settings][:default].class
+        klass = o[:settings][:default].is_a?(Integer) ? Integer : o[:settings][:default].class
 
         args = [o[:description]]
         args << "-" + short if short
@@ -70,7 +70,7 @@ class Parser
     rescue OptionParser::ParseError => e
       puts e.message ; exit(1)
     end
-    
+
     validate(@result) if self.respond_to?("validate")
     @result
   end

data/lib/micro-optparse/version.rb

@@ -1,5 +1,5 @@
 module Micro
   module Optparse
-    VERSION = "1.2.0"
+    VERSION = "1.2.1"
   end
 end

data/spec/parser_spec.rb

@@ -11,21 +11,21 @@ describe Parser do
       p.option :chance, "set mutation chance", :default => 0.8, :value_satisfies => lambda {|x| x >= 0.0 && x <= 1.0}
     end
   end
-  
+
   describe "parsing of default values" do
     it "should assume false as default value if no default value was given" do
       result = @evolutionary_algorithm_parser.process!([])
-      result[:verbose].should == false
+      expect(result[:verbose]).to eql false
     end
-    
+
     it "should return default values if called without arguments" do
       result = @evolutionary_algorithm_parser.process!([])
-      result[:severity].should == 4
-      result[:verbose].should == false
-      result[:mutation].should == "MightyMutation"
-      result[:plus_selection].should == true
-      result[:selection].should == "BestSelection"
-      result[:chance].should == 0.8
+      expect(result[:severity]).to eql 4
+      expect(result[:verbose]).to eql false
+      expect(result[:mutation]).to eql "MightyMutation"
+      expect(result[:plus_selection]).to eql true
+      expect(result[:selection]).to eql "BestSelection"
+      expect(result[:chance]).to eql 0.8
     end
 
     it "should not return a default value if the argument is declared optional" do
@@ -33,8 +33,8 @@ describe Parser do
         p.option :optarg, "optional argument", :optional => true
       end
       result = parser.process!()
-      result.has_key?(:optarg).should == false
-      result[:optarg].should == nil
+      expect(result.has_key?(:optarg)).to eql false
+      expect(result[:optarg]).to eql nil
     end
   end
 
@@ -43,59 +43,59 @@ describe Parser do
       args = ["--severity", "5", "--verbose", "--mutation", "DumbMutation",
               "--no-plus-selection", "--selection", "WorstSelection", "--chance", "0.1"]
       result = @evolutionary_algorithm_parser.process!(args)
-      result[:severity].should == 5
-      result[:verbose].should == true
-      result[:mutation].should == "DumbMutation"
-      result[:plus_selection].should == false
-      result[:selection].should == "WorstSelection"
-      result[:chance].should == 0.1
-    end
-    
+      expect(result[:severity]).to eql 5
+      expect(result[:verbose]).to eql true
+      expect(result[:mutation]).to eql "DumbMutation"
+      expect(result[:plus_selection]).to eql false
+      expect(result[:selection]).to eql "WorstSelection"
+      expect(result[:chance]).to eql 0.1
+    end
+
     it "should display overwritten values accordingly when the 'long=value' form was used" do
       args = ["--severity=5", "--mutation=DumbMutation", "--selection=WorstSelection", "--chance=0.1"]
       result = @evolutionary_algorithm_parser.process!(args)
-      result[:severity].should == 5
-      result[:mutation].should == "DumbMutation"
-      result[:selection].should == "WorstSelection"
-      result[:chance].should == 0.1
+      expect(result[:severity]).to eql 5
+      expect(result[:mutation]).to eql "DumbMutation"
+      expect(result[:selection]).to eql "WorstSelection"
+      expect(result[:chance]).to eql 0.1
     end
 
     it "should display overwritten values accordingly when short option names were used" do
       # there is no short form to set switches to false
       args = ["-s", "5", "-v", "-m", "DumbMutation", "--no-plus-selection", "-l", "WorstSelection", "-c", "0.1"]
       result = @evolutionary_algorithm_parser.process!(args)
-      result[:severity].should == 5
-      result[:verbose].should == true
-      result[:mutation].should == "DumbMutation"
-      result[:plus_selection].should == false
-      result[:selection].should == "WorstSelection"
-      result[:chance].should == 0.1
+      expect(result[:severity]).to eql 5
+      expect(result[:verbose]).to eql true
+      expect(result[:mutation]).to eql "DumbMutation"
+      expect(result[:plus_selection]).to eql false
+      expect(result[:selection]).to eql "WorstSelection"
+      expect(result[:chance]).to eql 0.1
     end
   end
-  
+
   describe "parsing of several arrays using the same parser" do
     it "should not manipulate old results" do
       result1 = @evolutionary_algorithm_parser.process!(["--severity=5"])
       result2 = @evolutionary_algorithm_parser.process!(["--severity=6"])
       result3 = @evolutionary_algorithm_parser.process!([])
 
-      result1[:severity].should == 5
-      result2[:severity].should == 6
-      result3[:severity].should == 4
+      expect(result1[:severity]).to eql 5
+      expect(result2[:severity]).to eql 6
+      expect(result3[:severity]).to eql 4
     end
   end
-  
+
   describe "empty parser" do
     it "should be allowed to create a parser with an empty block" do
       parser = Parser.new { }
-      parser.should_not be_nil
-      parser.class.should == Parser
+      expect(parser).not_to be_nil
+      expect(parser.class).to eql Parser
     end
-    
+
     it "should be allowed to create a parser without a block" do
       parser = Parser.new
-      parser.should_not be_nil
-      parser.class.should == Parser
+      expect(parser).not_to be_nil
+      expect(parser.class).to eql Parser
     end
   end
 
@@ -106,7 +106,7 @@ describe Parser do
       end
 
       input = ['--listarg', 'foo,bar,baz']
-      parser.process!(input)[:listarg].should == ['foo', 'bar', 'baz']
+      expect(parser.process!(input)[:listarg]).to eql ['foo', 'bar', 'baz']
     end
 
     it "should allow multiple argument lists" do
@@ -117,8 +117,8 @@ describe Parser do
 
       input = ['-f', 'foo,bar,baz', '-s', 'blah,blah,blah']
       result = parser.process!(input)
-      result[:first_listarg].should == ['foo', 'bar', 'baz']
-      result[:second_listarg].should == ['blah', 'blah', 'blah']
+      expect(result[:first_listarg]).to eql ['foo', 'bar', 'baz']
+      expect(result[:second_listarg]).to eql ['blah', 'blah', 'blah']
     end
   end
 
@@ -130,7 +130,7 @@ describe Parser do
       end
 
       result = parser.process!([])
-      result.length.should == 0 # all optional
+      expect(result.length).to eql 0 # all optional
     end
 
     it "should allow to overwrite default settings" do
@@ -140,17 +140,17 @@ describe Parser do
       end
 
       result = parser.process!([])
-      result[:foo].should == "Foo"
-      result[:bar].should == "Bar"
+      expect(result[:foo]).to eql "Foo"
+      expect(result[:bar]).to eql "Bar"
     end
   end
-  
+
   describe "help message" do
     it "should show help message when called with --help or -h" do
       results = [`ruby spec/programs/eating.rb -h`, `ruby spec/programs/eating.rb --help`]
       results.each do |result|
-        result.should include("--help")
-        result.should include("Show this message")
+        expect(result).to include("--help")
+        expect(result).to include("Show this message")
       end
     end
   end
@@ -158,12 +158,12 @@ describe Parser do
   describe "banner message" do
     it "should include the banner info in the help message" do
       result = `ruby spec/programs/eating.rb --help`
-      result.should include("This is a banner")
+      expect(result).to include("This is a banner")
     end
 
     it "should include the default banner info if no banner message was set" do
       result = `ruby spec/programs/empty.rb --help`
-      result.should include("Usage: empty [options]")
+      expect(result).to include("Usage: empty [options]")
     end
   end
 
@@ -172,13 +172,13 @@ describe Parser do
       # here -V is used for version, as -v is already taken for the verbose switch
       results = [`ruby spec/programs/eating.rb -V`, `ruby spec/programs/eating.rb --version`]
       results.each do |result|
-        result.strip.should == "EatingScript 1.0 (c) Florian Pilz 2011"
+        expect(result.strip).to eql "EatingScript 1.0 (c) Florian Pilz 2011"
       end
     end
 
     it "should display the version when called with -v" do
       result = `ruby spec/programs/version.rb -v`
-      result.strip.should == "VersionScript 0.0 (c) Florian Pilz 2011"
+      expect(result.strip).to eql "VersionScript 0.0 (c) Florian Pilz 2011"
     end
 
     it "should display a warning when --version or -v was called but no version was set" do
@@ -187,7 +187,7 @@ describe Parser do
         `ruby spec/programs/empty.rb -v 2>&1`
       ]
       results.each do |result|
-        result.strip.should == "empty: version unknown"
+        expect(result.strip).to eql "empty: version unknown"
       end
     end
   end
@@ -195,82 +195,82 @@ describe Parser do
   describe "warnings from optparse" do
     it "should display a warning if an argument was invalid" do
       result = `ruby spec/programs/eating.rb --free-beer`
-      result.strip.should == "invalid option: --free-beer"
+      expect(result.strip).to eql "invalid option: --free-beer"
     end
 
     it "should display a warning if another argument is needed" do
       result = `ruby spec/programs/eating.rb --eat-cake`
-      result.strip.should == "missing argument: --eat-cake"
+      expect(result.strip).to eql "missing argument: --eat-cake"
     end
 
     it "should display a warning if an argument of the wrong type was given" do
       result = `ruby spec/programs/eating.rb --eat-marshmellows OMFG!!!`
-      result.strip.should == "invalid argument: --eat-marshmellows OMFG!!!"
+      expect(result.strip).to eql "invalid argument: --eat-marshmellows OMFG!!!"
     end
 
     it "should display a warning if autocompletion of an argument was ambiguous" do
       result = `ruby spec/programs/eating.rb --eat yummy!`
-      result.strip.should == "ambiguous option: --eat"
+      expect(result.strip).to eql "ambiguous option: --eat"
     end
   end
 
   describe "warnings if validation failed" do
     it "should display a warning if validation value_in_set failed" do
       result = `ruby spec/programs/eating.rb --eat-bagel AshBagel`
-      result.strip.should match(/Parameter for --eat-bagel must be in \[SalmonBagel,\s?ParmesanBagel\]/)
+      expect(result.strip).to match(/Parameter for --eat-bagel must be in \[SalmonBagel,\s?ParmesanBagel\]/)
     end
 
     it "should display a warning if validation value_matches failed" do
       result = `ruby spec/programs/eating.rb --eat-cake Chocolate`
-      result.strip.should == "Parameter for --eat-cake must match /Cake/"
+      expect(result.strip).to eql "Parameter for --eat-cake must match /Cake/"
     end
 
     it "should display a warning if validation value_satisfies failed" do
       result = `ruby spec/programs/eating.rb --eat-cake 12Cakes`
-      result.strip.should == "Parameter for --eat-cake must satisfy given conditions (see description)"
+      expect(result.strip).to eql "Parameter for --eat-cake must satisfy given conditions (see description)"
     end
 
     it "should validate all validations if several are given for an option" do
       result = `ruby spec/programs/eating.rb --eat-cake VanillaBrownie`
-      result.strip.should == "Parameter for --eat-cake must match /Cake/"
+      expect(result.strip).to eql "Parameter for --eat-cake must match /Cake/"
 
       result = `ruby spec/programs/eating.rb --eat-cake 2VanillaCakes`
-      result.strip.should == "Parameter for --eat-cake must satisfy given conditions (see description)"
+      expect(result.strip).to eql "Parameter for --eat-cake must satisfy given conditions (see description)"
     end
   end
 
   describe "automatic assignment of default accessors" do
     it "should assign a different character for the short accessor if the first / second / ... is already taken" do
       result = `ruby spec/programs/eating.rb --help`
-      result.should include("--eat-cake")
-      result.should include("-a, --eat-salad")
-      result.should include("-t, --eat-bagel")
-      result.should include("-n, --[no-]eat-nothing")
-      result.should include("-m, --eat-marshmellow")
-      result.should include("-e, --eat-me")
+      expect(result).to include("--eat-cake")
+      expect(result).to include("-a, --eat-salad")
+      expect(result).to include("-t, --eat-bagel")
+      expect(result).to include("-n, --[no-]eat-nothing")
+      expect(result).to include("-m, --eat-marshmellow")
+      expect(result).to include("-e, --eat-me")
     end
   end
 
   describe "assigns short for every param" do
     it "should use every short only once" do
       result  = `ruby spec/programs/short.rb --help`
-      result.scan(/\s-a/).length.should == 1
-      result.scan(/\s-b/).length.should == 1
-      result.scan(/\s-c/).length.should == 1
+      expect(result.scan(/\s-a/).length).to eql 1
+      expect(result.scan(/\s-b/).length).to eql 1
+      expect(result.scan(/\s-c/).length).to eql 1
     end
 
     it "should use first char as short if all have been used" do
       result  = `ruby spec/programs/short.rb --help`
-      result.should include("-a, --acb")
-      result.should include("-b, --bac")
-      result.should include("-c, --cba")
+      expect(result).to include("-a, --acb")
+      expect(result).to include("-b, --bac")
+      expect(result).to include("-c, --cba")
     end
 
     it "should be possible to prevent creation of short arguments" do
       result  = `ruby spec/programs/noshort.rb --help`
-      result.should_not include("-f, --foo")
-      result.should include("--foo")
-      result.should include("-b, --bar")
+      expect(result).not_to include("-f, --foo")
+      expect(result).to include("--foo")
+      expect(result).to include("-b, --bar")
     end
   end
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: micro-optparse
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Florian Pilz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-29 00:00:00.000000000 Z
+date: 2017-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: This is an lightweight option parser, which is less than 80 lines short.
@@ -34,7 +34,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - CHANGES.md
 - Gemfile
 - MIT-LICENSE
@@ -60,17 +60,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: An lightweight option parser, which is 80 lines short.