slop 4.9.2 → 4.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db594ae38cd4d8b8d078d3b3854e5dce764f4763107caacc02b0b270c33098d8
-  data.tar.gz: 6e1348ca3f3d642bff87411d33c78b2f3d1b654c11c079a228f327f82648cd5f
+  metadata.gz: 2d4b4855a341f5e05c71ec19242556039ea85f4d339560dec38c24beb8831691
+  data.tar.gz: 95fcb3512ee937216387467758a05992d72bbfad627fd79b939277a204c941ad
 SHA512:
-  metadata.gz: b578d6d172adf2b9c88d482fe27798d97a821b83ef7ff4f8b6e8ed37d63cd7f7963b9634b9f734e80d744c0fc077f47bc2a08e00feed02af90452c6415383494
-  data.tar.gz: 8fc6007694ba5df48585ac6561c1ec68cf50141d92cb6f080d50b6de700a0244aefd3d3d647f7ccee197c57cfcd3ad4721b2c88039ab6f9667cb47d4dc705620
+  metadata.gz: c0ecc669117cf0c6336e3dfb1cf65c5019a0d638205a2497511121e102f7af7f48f175ded4c03d382257710da679970e4e405b84bee44a0613781d90b5bd4b63
+  data.tar.gz: 867c2ef751092ce4fafe9010f1b6ddb9ec7ee9adcdd2d020353129e7189b3ea8224f33ac368b773cca1298c297b159054775fb71074691e8ce9e20f780a58388

data/.github/workflows/ci.yml

@@ -22,10 +22,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ "2.0", "2.1", "2.2", "2.3", "2.4", "2.5", "2.6", "2.7", "3.0", "3.1", head, jruby, truffleruby ]
+        ruby: [ "2.0", "2.1", "2.2", "2.3", "2.4", "2.5", "2.6", "2.7", "3.0", "3.1", "3.2", head, jruby, truffleruby ]
     name: Ruby ${{ matrix.ruby }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:

data/CHANGELOG.md

@@ -1,6 +1,17 @@
 Changelog
 =========
 
+v4.10.0 (2023-02-15)
+
+Features:
+  * Add support for optional type validation [#278](https://github.com/leejarvis/slop/pull/278) (Victor Gama)
+
+v4.9.3 (2022-09-30)
+-------------------
+
+Bug fixes:
+  * Fix explicitly false boolean options and allow for additional false arguments [#276](https://github.com/leejarvis/slop/pull/276) (Eugene Otto)
+
 v4.9.2 (2022-03-26)
 -------------------
 

data/README.md

@@ -22,17 +22,19 @@ opts = Slop.parse do |o|
   o.bool '-v', '--verbose', 'enable verbose mode'
   o.bool '-q', '--quiet', 'suppress output (quiet mode)'
   o.bool '-c', '--check-ssl-certificate', 'check SSL certificate for host'
+  o.bool '-k', '--use-keychain', 'store passphrase in OS keychain'
   o.on '--version', 'print the version' do
     puts Slop::VERSION
     exit
   end
 end
 
-ARGV #=> -v --login alice --host 192.168.0.1 -m post --check-ssl-certificate
+ARGV #=> -v --login alice --host 192.168.0.1 -m post --check-ssl-certificate --use-keychain false
 
 opts[:host]                 #=> 192.168.0.1
 opts[:login]                #=> alice
 opts[:method]               #=> :post
+opts[:use_keychain]         #=> false
 opts.verbose?               #=> true
 opts.quiet?                 #=> false
 opts.check_ssl_certificate? #=> true
@@ -53,7 +55,7 @@ Built in Option types are as follows:
 
 ```ruby
 o.string  #=> Slop::StringOption, expects an argument
-o.bool    #=> Slop::BoolOption, no argument, aliased to BooleanOption
+o.bool    #=> Slop::BoolOption, argument optional, aliased to BooleanOption
 o.integer #=> Slop::IntegerOption, expects an argument, aliased to IntOption
 o.float   #=> Slop::FloatOption, expects an argument
 o.array   #=> Slop::ArrayOption, expects an argument
@@ -202,6 +204,8 @@ Slop will raise errors for the following:
 * An option used without an argument when it expects one: `Slop::MissingArgument`
 * An option used that Slop doesn't know about: `Slop::UnknownOption`
 * An option marked as `required` when not provided: `Slop::MissingRequiredOption`
+* An option marked as `validate_types`, with an argument that does not match its
+type (i.e. `bla` for `integer`): `Slop::InvalidOptionValue`
 
 These errors inherit from `Slop::Error`, so you can rescue them all.
 Alternatively you can suppress these errors with the `suppress_errors` config
@@ -220,6 +224,33 @@ opts = Slop.parse do
 end
 ```
 
+Validating Types
+----------------
+
+By default, Slop does not validate whether an argument is a valid value for a
+given option; instead, if the option has a default value, it will be used over
+the invalid argument provided.
+In order to have types (such as `integer` and `float`) validate and indicate
+that the provided value is invalid, an extra option can be either provided to
+the argument itself, or its option set:
+
+```ruby
+opts = Slop::Options.new
+opts.int "-p", "--port", "a port", default: 80, validate_types: true
+
+parser = Slop::Parser.new(opts)
+result = parser.parse(["--port", "bla"])
+# invalid value for -p, --port (Slop::InvalidOptionValue)
+
+# Or to the option set...
+opts = Slop::Options.new(validate_types: true)
+opts.int "-p", "--port", "a port", default: 80
+
+parser = Slop::Parser.new(opts)
+result = parser.parse(["--port", "bla"])
+# invalid value for -p, --port (Slop::InvalidOptionValue)
+```
+
 Printing help
 -------------
 
@@ -277,4 +308,4 @@ end
 Commands
 --------
 
-Slop not longer has built in support for git-style subcommands.
+Slop no longer has built in support for git-style subcommands.

data/lib/slop/error.rb

@@ -38,4 +38,16 @@ module Slop
   # Suppress with the `suppress_errors` config option.
   class MissingRequiredOption < Error
   end
+
+  # Raised when a given option is provided by the user and does not
+  # match the expected format for that type. This is only raised if
+  # validate_types is set to true.
+  class InvalidOptionValue < Error
+    attr_reader :flag
+
+    def initialize(msg, flag)
+      super(msg)
+      @flag = flag
+    end
+  end
 end

data/lib/slop/option.rb

@@ -56,7 +56,11 @@ module Slop
           raise Slop::MissingArgument.new("missing argument for #{flag}", flags)
         end
       else
-        @value = call(value)
+        if validate_type? && !valid?(value) && !suppress_errors?
+          raise Slop::InvalidOptionValue.new("invalid value for #{flag}", flags)
+        end
+
+        @value = valid?(value) && call(value)
       end
 
       block.call(@value) if block.respond_to?(:call)
@@ -107,6 +111,13 @@ module Slop
       config[:required]
     end
 
+    # Returns true if an exception should be raised when this option value can't
+    # be parsed into the desired type or does not conform to the expected type's
+    # format
+    def validate_type?
+      config[:validate_type] || config[:validate_types]
+    end
+
     # Returns all flags joined by a comma. Used by the help string.
     def flag
       flags.join(", ")
@@ -119,6 +130,13 @@ module Slop
       key.to_sym
     end
 
+    # Override this if you want to provide a custom validator for a type. This
+    # method must return whether the provided value is valid for the current
+    # argument's type
+    def valid?(value)
+      true
+    end
+
     # Returns true if this option should be displayed with dashes transformed into underscores.
     def underscore_flags?
       config[:underscore_flags]

data/lib/slop/options.rb

@@ -7,6 +7,7 @@ module Slop
       type:             "null",
       banner:           true,
       underscore_flags: true,
+      validate_types:   false,
     }
 
     # The Array of Option instances we've created.
@@ -24,6 +25,9 @@ module Slop
     # The String banner prefixed to the help string.
     attr_accessor :banner
 
+    # Whether we should validate types of values provided by the user
+    attr_accessor :validate_types
+
     def initialize(**config, &block)
       @options    = []
       @separators = []

data/lib/slop/types.rb

@@ -21,6 +21,15 @@ module Slop
   class BoolOption < Option
     attr_accessor :explicit_value
 
+    FALSE_VALUES = [false, 'false', 'no', 'off', '0'].freeze
+    TRUE_VALUES = [true, 'true', 'yes', 'on', '1'].freeze
+    VALID_VALUES = (FALSE_VALUES + TRUE_VALUES).freeze
+
+    def valid?(value)
+      return true if value.is_a?(String) && value.start_with?("--")
+      value.nil? || VALID_VALUES.include?(value)
+    end
+
     def call(value)
       self.explicit_value = value
       !force_false?
@@ -35,7 +44,7 @@ module Slop
     end
 
     def force_false?
-      explicit_value == false
+      FALSE_VALUES.include?(explicit_value)
     end
 
     def default_value
@@ -50,8 +59,14 @@ module Slop
 
   # Cast the option argument to an Integer.
   class IntegerOption < Option
+    INT_STRING_REGEXP = /\A[+-]?\d+\z/.freeze
+
+    def valid?(value)
+      value =~ INT_STRING_REGEXP
+    end
+
     def call(value)
-      value =~ /\A[+-]?\d+\z/ && value.to_i
+      value.to_i
     end
   end
   IntOption = IntegerOption
@@ -60,8 +75,12 @@ module Slop
   class FloatOption < Option
     FLOAT_STRING_REGEXP = /\A[+-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+-]?\d+)?\z/.freeze
 
+    def valid?(value)
+      value =~ FLOAT_STRING_REGEXP
+    end
+
     def call(value)
-      value =~ FLOAT_STRING_REGEXP && value.to_f
+      value.to_f
     end
   end
 

data/lib/slop.rb

@@ -6,7 +6,7 @@ require 'slop/types'
 require 'slop/error'
 
 module Slop
-  VERSION = '4.9.2'
+  VERSION = '4.10.0'
 
   # Parse an array of options (defaults to ARGV). Accepts an
   # optional hash of configuration options and block.

data/test/error_test.rb

@@ -63,3 +63,18 @@ describe Slop::MissingRequiredOption do
     opts.parse []
   end
 end
+
+describe Slop::InvalidOptionValue do
+  it "raises when an option has an invalid value" do
+    opts = Slop::Options.new(validate_types: true)
+    opts.integer "-n", "--number", default: 10
+    assert_raises(Slop::InvalidOptionValue) { opts.parse %w(-n foo) }
+  end
+
+  it "does not raise when errors are suppressed" do
+    opts = Slop::Options.new(suppress_errors: true)
+    opts.integer "-n", "--number", default: 10, validate_type: true
+    r = opts.parse %w(-n foo)
+    assert_equal(10, r[:n])
+  end
+end

data/test/types_test.rb

@@ -31,12 +31,14 @@ end
 describe Slop::BoolOption do
   before do
     @options  = Slop::Options.new
-    @verbose  = @options.bool "--verbose"
+    @verbose  = @options.bool "--verbose", validate_type: true
     @quiet    = @options.bool "--quiet"
     @inversed = @options.bool "--inversed", default: true
+    @explicit = @options.bool "--explicit", validate_type: true
     @bloc     = @options.bool("--bloc"){|val| (@bloc_val ||= []) << val}
     @result   = @options.parse %w(--verbose --no-inversed
-                                  --bloc --no-bloc)
+                                  --bloc --no-bloc
+                                  --explicit=false)
   end
 
   it "returns true if used" do
@@ -54,13 +56,23 @@ describe Slop::BoolOption do
   it "will invert the value passed to &block via --no- prefix" do
     assert_equal [true, false], @bloc_val
   end
+
+  it "returns false when explicitly false" do
+    assert_equal false, @result[:explicit]
+  end
+
+  it "raises with invalid types" do
+    assert_raises(Slop::InvalidOptionValue) do
+      @result.parser.parse %w(--verbose foo)
+    end
+  end
 end
 
 describe Slop::IntegerOption do
   before do
     @options = Slop::Options.new
     @age     = @options.integer "--age"
-    @minus   = @options.integer "--minus"
+    @minus   = @options.integer "--minus", validate_type: true
     @plus    = @options.integer "--plus"
     @result  = @options.parse %w(--age 20 --minus -10 --plus +30)
   end
@@ -75,6 +87,12 @@ describe Slop::IntegerOption do
     @result.parser.parse %w(--age hello)
     assert_nil @result[:age]
   end
+
+  it "raises with invalid types" do
+    assert_raises(Slop::InvalidOptionValue) do
+      @result.parser.parse %w(--minus foo)
+    end
+  end
 end
 
 describe Slop::FloatOption do
@@ -82,7 +100,7 @@ describe Slop::FloatOption do
     @options = Slop::Options.new
     @apr     = @options.float "--apr"
     @apr_value = 2.9
-    @minus = @options.float "--minus"
+    @minus = @options.float "--minus", validate_type: true
     @plus = @options.float "--plus"
     @scientific_notation = @options.float "--scientific-notation"
     @scientific_notation_value = 4e21
@@ -119,6 +137,12 @@ describe Slop::FloatOption do
     @result.parser.parse %w(--apr hello)
     assert_nil @result[:apr]
   end
+
+  it "raises with invalid types" do
+    assert_raises(Slop::InvalidOptionValue) do
+      @result.parser.parse %w(--minus foo)
+    end
+  end
 end
 
 describe Slop::ArrayOption do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slop
 version: !ruby/object:Gem::Version
-  version: 4.9.2
+  version: 4.10.0
 platform: ruby
 authors:
 - Lee Jarvis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-26 00:00:00.000000000 Z
+date: 2023-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -86,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Simple Lightweight Option Parsing