tty-option 0.1.0 → 0.3.0

data/lib/tty/option/param_conversion.rb

@@ -10,24 +10,26 @@ module TTY
       #
       # @example
       #   param = Parameter::Argument.create(:foo, convert: :int)
-      #   ParamConversion[param, "12"] # => 12
+      #   result = ParamConversion[param, "12"]
+      #   result.value # => 12
       #
       # @api public
       def call(param, value)
-        return Result.success(value) unless param.convert?
+        return Result.success(value) if !param.convert? || value.nil?
 
-        case cast = param.convert
-        when Proc
-          Result.success(cast.(value))
+        cast = param.convert
+        cast = cast.is_a?(Proc) ? cast : Conversions[cast]
+        converted = cast.(value)
+
+        if converted == Const::Undefined
+          Result.failure(InvalidConversionArgument.new(param, value))
         else
-          Result.success(Conversions[cast].(value))
+          Result.success(converted)
         end
-      rescue ConversionError
-        Result.failure(InvalidConversionArgument.new(param, value))
       end
       module_function :call
 
-      alias :[] :call
+      alias [] call
       module_function :[]
     end # ParamConversion
   end # Option

data/lib/tty/option/param_permitted.rb

@@ -13,17 +13,21 @@ module TTY
       #
       # @api public
       def call(param, value)
-        return Result.success(value) unless param.permit?
+        return Result.success(value) if !param.permit? || value.nil?
 
-        if param.permit.include?(value)
+        unpermitted = Array(value) - Array(param.permit)
+
+        if unpermitted.empty?
           Result.success(value)
         else
-          Result.failure(UnpermittedArgument.new(param, value))
+          Result.failure(unpermitted.map do |val|
+            UnpermittedArgument.new(param, val)
+          end)
         end
       end
       module_function :call
 
-      alias :[] :call
+      alias [] call
       module_function :[]
     end # ParamPermitted
   end # Option

data/lib/tty/option/param_validation.rb

@@ -4,45 +4,149 @@ require_relative "result"
 
 module TTY
   module Option
+    # Responsible for parameter validation
+    #
+    # @api private
     module ParamValidation
       # Validate parameter value against validation rule
       #
       # @example
-      #   param = Parameter::Option.create(:foo, validate: '\d+')
-      #   ParamValidation[param, "12"] # => "12"
+      #   param = TTY::Option::Parameter::Option.create(:foo, validate: "\d+")
+      #   TTY::Option::ParamValidation[param, "12"] # => "12"
+      #
+      # @param [TTY::Option::Parameter] param
+      #   the parameter with a validation rule
+      # @param [Object] value
+      #   the value to validate
+      #
+      # @return [TTY::Option::Result]
       #
       # @api public
-      def call(param, values)
-        return Result.success(values) unless param.validate?
+      def call(param, value)
+        return Result.success(value) if !param.validate? || value.nil?
 
         errors = []
-
-        result = Array(values).reduce([]) do |acc, value|
-          valid = case param.validate
-                  when Proc
-                    param.validate.(value)
-                  when Regexp
-                    !param.validate.match(value.to_s).nil?
-                  end
-
-          if valid
-            acc << value
-          else
-            errors << TTY::Option::InvalidArgument.new(param, value)
-          end
-          acc
+        result = validate_object(param, value) do |error|
+          errors << error
         end
 
         if errors.empty?
-          Result.success(result.size <= 1 ? result.first : result)
+          Result.success(result)
         else
           Result.failure(errors)
         end
       end
       module_function :call
 
-      alias :[] :call
+      alias [] call
       module_function :[]
+
+      # Validate an object
+      #
+      # @param [TTY::Option::Parameter] param
+      #   the parameter with a validation rule
+      # @param [Object] value
+      #   the value to validate
+      #
+      # @yield [TTY::Option::InvalidArgument]
+      #
+      # @return [Object, nil]
+      #
+      # @api private
+      def validate_object(param, value, &block)
+        case value
+        when Array
+          validate_array(param, value, &block)
+        when Hash
+          validate_hash(param, value, &block)
+        else
+          error = valid_or_error(param, value)
+          error ? block.(error) && return : value
+        end
+      end
+      module_function :validate_object
+      private_class_method :validate_object
+
+      # Validate array values
+      #
+      # @param [TTY::Option::Parameter] param
+      #   the parameter with a validation rule
+      # @param [Object] values
+      #   the values in an array to validate
+      #
+      # @yield [TTY::Option::InvalidArgument]
+      #
+      # @return [Array]
+      #
+      # @api private
+      def validate_array(param, values)
+        values.each_with_object([]) do |value, acc|
+          error = valid_or_error(param, value)
+          error ? yield(error) : acc << value
+        end
+      end
+      module_function :validate_array
+      private_class_method :validate_array
+
+      # Validate hash values
+      #
+      # @param [TTY::Option::Parameter] param
+      #   the parameter with a validation rule
+      # @param [Object] values
+      #   the values in a hash to validate
+      #
+      # @yield [TTY::Option::InvalidArgument]
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def validate_hash(param, values)
+        values.each_with_object({}) do |value, acc|
+          error = valid_or_error(param, value)
+          error ? yield(error) : acc[value[0]] = value[1]
+        end
+      end
+      module_function :validate_hash
+      private_class_method :validate_hash
+
+      # Create an error for an invalid parameter value
+      #
+      # @param [TTY::Option::Parameter] param
+      #   the parameter with a validation rule
+      # @param [Object] value
+      #   the value to validate
+      #
+      # @return [TTY::Option::InvalidArgument, nil]
+      #
+      # @api private
+      def valid_or_error(param, value)
+        return if valid?(param, value)
+
+        TTY::Option::InvalidArgument.new(param, value)
+      end
+      module_function :valid_or_error
+      private_class_method :valid_or_error
+
+      # Check whether a parameter value is valid or not
+      #
+      # @param [TTY::Option::Parameter] param
+      #   the parameter with a validation rule
+      # @param [Object] value
+      #   the value to validate
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def valid?(param, value)
+        case param.validate
+        when Proc
+          param.validate.(value)
+        when Regexp
+          !param.validate.match(value.to_s).nil?
+        end
+      end
+      module_function :valid?
+      private_class_method :valid?
     end # ParamValidation
   end # Option
 end # TTY

data/lib/tty/option/parameter.rb

@@ -11,6 +11,12 @@ module TTY
       include DSL::Arity
       include DSL::Conversion
 
+      # Zero or more parameter arity pattern
+      ZERO_OR_MORE_ARITY = /\*|any/.freeze
+
+      # One or more parameter arity pattern
+      ONE_OR_MORE_ARITY = /\+/.freeze
+
       # A parameter factory
       #
       # @api public
@@ -32,20 +38,20 @@ module TTY
       def initialize(key, **settings, &block)
         @key = key
         @settings = {}
-        settings.each do |key, val|
-          case key.to_sym
+        settings.each do |name, val|
+          case name.to_sym
           when :arity
             val = check_arity(val)
           when :default
             val = check_default(val)
           when :optional
-            key, val = :required, check_required(!val)
+            name, val = :required, check_required(!val)
           when :permit
             val = check_permitted(val)
           when :validate
             val = check_validation(val)
           end
-          @settings[key.to_sym] = val
+          @settings[name.to_sym] = val
         end
 
         instance_eval(&block) if block_given?
@@ -136,7 +142,7 @@ module TTY
       end
 
       def required?
-        @settings.fetch(:required) { false }
+        @settings.fetch(:required, false)
       end
 
       def hidden
@@ -144,7 +150,7 @@ module TTY
       end
 
       def hidden?
-        @settings.fetch(:hidden) { false }
+        @settings.fetch(:hidden, false)
       end
 
       def display?
@@ -203,6 +209,7 @@ module TTY
       # @api public
       def ==(other)
         return false unless instance_of?(other.class)
+
         name == other.name && to_h == other.to_h
       end
 
@@ -211,6 +218,7 @@ module TTY
       # @api public
       def eql?(other)
         return false unless instance_of?(other.class)
+
         name.eql?(other.name) && to_h.eql?(other.to_h)
       end
 
@@ -250,15 +258,14 @@ module TTY
         end
 
         case value.to_s
-        when %r{\*|any} then value = -1
-        when %r{\+}     then value = -2
-        else value = value.to_i
-        end
-
-        if value.zero?
-          raise ConfigurationError, "#{to_sym} '#{name}' arity cannot be zero"
+        when ZERO_OR_MORE_ARITY then -1
+        when ONE_OR_MORE_ARITY then -2
+        else value.to_i
+        end.tap do |val|
+          if val.zero?
+            raise ConfigurationError, "#{to_sym} '#{name}' arity cannot be zero"
+          end
         end
-        value
       end
 
       # @api private
@@ -267,7 +274,8 @@ module TTY
           value
         else
           raise ConfigurationError,
-                "#{to_sym} '#{name}' permitted value needs to be an Array"
+                "#{to_sym} '#{name}' permitted value needs to be " \
+                "an Array or a Hash"
         end
       end
 

data/lib/tty/option/parameters.rb

@@ -13,7 +13,16 @@ module TTY
       # @api private
       def self.define_query(name)
         define_method(:"#{name}?") do
-          !self.public_send(name).empty?
+          !public_send(name).empty?
+        end
+      end
+
+      # Define a predicate method to check if a parameter is supported
+      #
+      # @api private
+      def self.define_param_query(name)
+        define_method(:"#{name}?") do |param|
+          public_send(:"#{name}s").map(&:key).include?(param)
         end
       end
 
@@ -37,6 +46,11 @@ module TTY
       define_query :options
       define_query :environments
 
+      define_param_query :argument
+      define_param_query :keyword
+      define_param_query :option
+      define_param_query :environment
+
       # A parameters list
       #
       # @api private

data/lib/tty/option/parser/arguments.rb

@@ -109,7 +109,7 @@ module TTY
           values = []
           arity = arg.arity.abs - 1
 
-          arity.times do |i|
+          arity.times do
             break if @argv.empty?
             value = @argv.shift
             if argument?(value)

data/lib/tty/option/parser/arity_check.rb

@@ -12,7 +12,7 @@ module TTY
         def add(param)
           @multiplies << param
         end
-        alias :<< :add
+        alias << add
 
         # Check if parameter matches arity
         #

data/lib/tty/option/parser/environments.rb

@@ -150,10 +150,10 @@ module TTY
             if allowed
               case value
               when Hash
-                (@parsed[env_arg.key] ||=  {}).merge!(value)
+                (@parsed[env_arg.key] ||= {}).merge!(value)
               else
                 Array(value).each do |v|
-                  (@parsed[env_arg.key] ||=  []) << v
+                  (@parsed[env_arg.key] ||= []) << v
                 end
               end
             else

data/lib/tty/option/parser/keywords.rb

@@ -142,7 +142,7 @@ module TTY
                 (@parsed[kwarg.key] ||= {}).merge!(value)
               else
                 Array(value).each do |v|
-                  (@parsed[kwarg.key] ||=  []) << v
+                  (@parsed[kwarg.key] ||= []) << v
                 end
               end
             else

data/lib/tty/option/parser/options.rb

@@ -175,7 +175,12 @@ module TTY
                 @remaining << long
               end
             elsif matching_options == 1
-              value = long[opt.long_name.size..-1]
+              # option stuck together with the argument
+              if sep.nil? && rest.empty?
+                value = long[opt.long_name.size..-1]
+              else
+                value = rest
+              end
             else
               @error_aggregator.(AmbiguousOption.new("option '#{long}' is ambiguous"))
             end

data/lib/tty/option/parser/param_types.rb

@@ -4,6 +4,18 @@ module TTY
   module Option
     class Parser
       module ParamTypes
+        # Positional argument pattern
+        ARGUMENT_PARAMETER = /^[^-][^=]*\z/.freeze
+
+        # Environment variable pattern
+        ENV_VAR_PARAMETER = /^[\p{Lu}_\-\d]+=/.freeze
+
+        # Keyword pattern
+        KEYWORD_PARAMETER = /^([^-=][\p{Ll}_\-\d]*)=([^=]+)/.freeze
+
+        # Option and flag pattern
+        OPTION_PARAMETER = /^-./.freeze
+
         # Check if value looks like an argument
         #
         # @param [String] value
@@ -12,7 +24,7 @@ module TTY
         #
         # @api public
         def argument?(value)
-          !value.match(/^[^-][^=]*\z/).nil?
+          !value.match(ARGUMENT_PARAMETER).nil?
         end
 
         # Check if value is an environment variable
@@ -23,7 +35,7 @@ module TTY
         #
         # @api public
         def env_var?(value)
-          !value.match(/^[\p{Lu}_\-\d]+=/).nil?
+          !value.match(ENV_VAR_PARAMETER).nil?
         end
 
         # Check to see if value is a keyword
@@ -32,7 +44,7 @@ module TTY
         #
         # @api public
         def keyword?(value)
-          !value.to_s.match(/^([^-=][\p{Ll}_\-\d]*)=([^=]+)/).nil?
+          !value.to_s.match(KEYWORD_PARAMETER).nil?
         end
 
         # Check if value looks like an option
@@ -43,7 +55,7 @@ module TTY
         #
         # @api public
         def option?(value)
-          !value.match(/^-./).nil?
+          !value.match(OPTION_PARAMETER).nil?
         end
       end # ParamTypes
     end # Parser

data/lib/tty/option/parser/required_check.rb

@@ -12,7 +12,7 @@ module TTY
         def add(param)
           @required << param
         end
-        alias :<< :add
+        alias << add
 
         def delete(param)
           @required.delete(param)

data/lib/tty/option/parser.rb

@@ -15,7 +15,7 @@ module TTY
         keywords: TTY::Option::Parser::Keywords,
         arguments: TTY::Option::Parser::Arguments,
         environments: TTY::Option::Parser::Environments
-      }
+      }.freeze
 
       ARGUMENT_SEPARATOR = /^-{2,}$/.freeze
 

data/lib/tty/option/pipeline.rb

@@ -11,7 +11,7 @@ module TTY
         ParamConversion,
         ParamPermitted,
         ParamValidation
-      ]
+      ].freeze
 
       # Create a param processing pipeline
       #

data/lib/tty/option/result.rb

@@ -18,29 +18,51 @@ module TTY
         Failure.new(value)
       end
 
+      # Wrapped value
+      #
+      # @api public
       attr_reader :value
 
+      # Reason for failure
+      #
+      # @api public
       attr_reader :error
 
+      # Check whether or not a result is a success monad
+      #
+      # @return [Boolean]
+      #
+      # @api public
       def success?
         is_a?(Success)
       end
 
+      # Check whether or not a result is a failure class
+      #
+      # @return [Boolean]
+      #
+      # @api public
       def failure?
         is_a?(Failure)
       end
 
+      # Success monad containing a value
+      #
+      # @api private
       class Success < Result
         def initialize(value)
           @value = value
         end
       end
 
+      # Failure monad containing an error
+      #
+      # @api private
       class Failure < Result
         def initialize(error)
           @error = error
         end
       end
-    end
-  end
-end
+    end # Result
+  end # Option
+end # TTY