tty-option 0.1.0 → 0.3.0

data/lib/tty/option/aggregate_errors.rb

@@ -75,12 +75,12 @@ module TTY
         output = []
         space_indent = " " * indent
         if messages.count == 1
-          message = messages.first
+          msg = messages.first
           label = "Error: "
           output << "#{space_indent}#{label}" \
-                    "#{wrap(message, indent: indent + label.length, width: width)}"
+                    "#{wrap(msg, indent: indent + label.length, width: width)}"
         else
-          output << space_indent + "Errors:"
+          output << "#{space_indent}Errors:"
           messages.each_with_index do |message, num|
             entry = "  #{num + 1}) "
             output << "#{space_indent}#{entry}" \

data/lib/tty/option/const.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TTY
+  module Option
+    module Const
+      Undefined = Object.new.tap do |obj|
+        def obj.to_s
+          "undefined"
+        end
+
+        def obj.inspect
+          "undefined".inspect
+        end
+      end
+    end # Const
+  end # Option
+end # TTY

data/lib/tty/option/conversions.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "const"
 require_relative "converter"
 
 module TTY
@@ -10,13 +11,6 @@ module TTY
       TRUE_VALUES = /^(true|y(es)?|t|1)$/i.freeze
       FALSE_VALUES = /^(false|n(o)?|f|0)$/i.freeze
 
-      # @api public
-      def self.raise_invalid_argument(conv_name, val)
-        raise ConversionError,
-              format("invalid value of %<value>s for %<conv>s conversion",
-                     value: val.inspect, conv: conv_name.inspect)
-      end
-
       convert :bool, :boolean do |val|
         case val.to_s
         when TRUE_VALUES
@@ -24,16 +18,18 @@ module TTY
         when FALSE_VALUES
           false
         else
-          raise_invalid_argument(:bool, val)
+          Const::Undefined
         end
       end
 
       convert :date do |val|
+        require "date" unless defined?(::Date)
+        next val if val.is_a?(::Date)
+
         begin
-          require "date" unless defined?(::Date)
           ::Date.parse(val)
         rescue ArgumentError, TypeError
-          raise_invalid_argument(:date, val)
+          Const::Undefined
         end
       end
 
@@ -41,7 +37,7 @@ module TTY
         begin
           Float(val)
         rescue ArgumentError, TypeError
-          raise_invalid_argument(:float, val)
+          Const::Undefined
         end
       end
 
@@ -49,56 +45,68 @@ module TTY
         begin
           Float(val).to_i
         rescue ArgumentError, TypeError
-          raise_invalid_argument(:integer, val)
+          Const::Undefined
         end
       end
 
       convert :pathname, :path do |val|
-        require "pathname"
-        ::Pathname.new(val.to_s)
+        require "pathname" unless defined?(::Pathname)
+        next val if val.is_a?(::Pathname)
+
+        begin
+          ::Pathname.new(val)
+        rescue TypeError
+          Const::Undefined
+        end
       end
 
       convert :regexp do |val|
         begin
-          Regexp.new(val.to_s)
+          Regexp.new(val)
         rescue TypeError, RegexpError
-          raise_invalid_argument(:regexp, val)
+          Const::Undefined
         end
       end
 
       convert :sym, :symbol do |val|
         begin
           String(val).to_sym
-        rescue ArgumentError
-          raise_invalid_argument(:symbol, val)
+        rescue ArgumentError, TypeError
+          Const::Undefined
         end
       end
 
       convert :uri do |val|
+        require "uri" unless defined?(::URI)
+        next val if val.is_a?(::URI)
+
         begin
-          require "uri"
           ::URI.parse(val)
         rescue ::URI::InvalidURIError
-          raise_invalid_argument(:uri, val)
+          Const::Undefined
         end
       end
 
       convert :list, :array do |val|
-        (val.respond_to?(:to_a) ? val : val.split(/(?<!\\),/))
-          .map { |v| v.strip.gsub(/\\,/, ",") }
-          .reject(&:empty?)
+        next Const::Undefined if val.nil?
+        next Array(val) unless val.respond_to?(:split)
+
+        val.split(/(?<!\\),/)
+           .map { |v| v.strip.gsub(/\\,/, ",") }
+           .reject(&:empty?)
       end
 
       convert :map, :hash do |val|
-        values = val.respond_to?(:to_a) ? val : val.split(/[& ]/)
+        next Const::Undefined if val.nil?
+        next val if val.is_a?(Hash)
+
+        values = val.respond_to?(:split) ? val.split(/[& ]/) : Array(val)
         values.each_with_object({}) do |pair, pairs|
-          key, value = pair.split(/[=:]/, 2)
-          if (current = pairs[key.to_sym])
-            pairs[key.to_sym] = Array(current) << value
-          else
-            pairs[key.to_sym] = value
-          end
-          pairs
+          is_string = pair.respond_to?(:split)
+          key, value = is_string ? pair.split(/[=:]/, 2) : pair
+          new_key = is_string ? key.to_sym : key
+          current = pairs[new_key]
+          pairs[new_key] = current ? Array(current) << value : value
         end
       end
 
@@ -107,16 +115,26 @@ module TTY
 
         [:"#{type}_list", :"#{type}_array", :"#{type}s"].each do |new_type|
           convert new_type do |val|
-            conversions[:list].(val).map do |obj|
-              conversions[type].(obj)
+            list_conversion = conversions[:list].(val)
+            next list_conversion if list_conversion == Const::Undefined
+
+            list_conversion.map do |obj|
+              converted = conversions[type].(obj)
+              break converted if converted == Const::Undefined
+              converted
             end
           end
         end
 
         [:"#{type}_map", :"#{type}_hash"].each do |new_type|
           convert new_type do |val|
+            map_conversion = conversions[:map].(val)
+            next map_conversion if map_conversion == Const::Undefined
+
             conversions[:map].(val).each_with_object({}) do |(k, v), h|
-              h[k] = conversions[type].(v)
+              converted = conversions[type].(v)
+              break converted if converted == Const::Undefined
+              h[k] = converted
             end
           end
         end

data/lib/tty/option/converter.rb

@@ -32,7 +32,7 @@ module TTY
         names.each do |name|
           if contain?(name)
             raise ConversionAlreadyDefined,
-                "conversion #{name.inspect} is already defined"
+                  "conversion #{name.inspect} is already defined"
           end
           conversions[name] = block
         end
@@ -56,7 +56,7 @@ module TTY
       # @api public
       def raise_unsupported_error(conv_name)
         raise UnsupportedConversion,
-             "unsupported conversion type #{conv_name.inspect}"
+              "unsupported conversion type #{conv_name.inspect}"
       end
     end # Converter
   end # Option

data/lib/tty/option/deep_dup.rb

@@ -2,47 +2,70 @@
 
 module TTY
   module Option
+    # Responsible for deep copying an object
+    #
+    # @api private
     module DeepDup
       NONDUPLICATABLE = [
-        Symbol, TrueClass, FalseClass, NilClass, Numeric, Method
+        Symbol, TrueClass, FalseClass, NilClass, Numeric, Method, UnboundMethod
       ].freeze
 
-      # Duplicate an object making a deep copy
+      # Deep copy an object
+      #
+      # @example
+      #   DeepDeup.deep_dup({foo: {bar: [1, 2]}})
       #
       # @param [Object] object
+      #   the object to deep copy
+      # @param [Hash] cache
+      #   the cache of copied objects
+      #
+      # @return [Object]
       #
       # @api public
-      def self.deep_dup(object)
-        case object
-        when String then object.dup
-        when *NONDUPLICATABLE then object
-        when Hash   then deep_dup_hash(object)
-        when Array  then deep_dup_array(object)
-        else object.dup
-        end
+      def self.deep_dup(object, cache = {})
+        cache[object.object_id] ||=
+          case object
+          when *NONDUPLICATABLE then object
+          when Array then deep_dup_array(object, cache)
+          when Hash  then deep_dup_hash(object, cache)
+          else object.dup
+          end
       end
 
-      # A deep copy of hash
+      # Deep copy an array
       #
-      # @param [Hash] object
+      # @param [Array] object
+      #   the array object to deep copy
+      # @param [Hash] cache
+      #   the cache of copied objects
+      #
+      # @return [Array]
       #
       # @api private
-      def self.deep_dup_hash(object)
-        object.each_with_object({}) do |(key, val), new_hash|
-          new_hash[deep_dup(key)] = deep_dup(val)
+      def self.deep_dup_array(object, cache)
+        object.each_with_object(cache[object.object_id] = []) do |val, array|
+          array << deep_dup(val, cache)
         end
       end
+      private_class_method :deep_dup_array
 
-      # A deep copy of array
+      # Deep copy a hash
       #
-      # @param [Array] object
+      # @param [Hash] object
+      #   the hash object to deep copy
+      # @param [Hash] cache
+      #   the cache of copied objects
+      #
+      # @return [Hash]
       #
       # @api private
-      def self.deep_dup_array(object)
-        object.each_with_object([]) do |val, new_array|
-          new_array << deep_dup(val)
+      def self.deep_dup_hash(object, cache)
+        object.each_with_object(cache[object.object_id] = {}) do |(k, v), hash|
+          hash[deep_dup(k, cache)] = deep_dup(v, cache)
         end
       end
+      private_class_method :deep_dup_hash
     end # DeepDup
   end # Option
 end # TTY

data/lib/tty/option/dsl.rb

@@ -28,10 +28,10 @@ module TTY
       # @api public
       def usage(**properties, &block)
         @usage ||= Usage.create(**properties, &block).tap do |usage|
-                    if usage.command.empty?
-                      usage.command(dasherize(demodulize(self.name)))
-                    end
-                  end
+                     unless usage.command? || usage.no_command?
+                       usage.command(dasherize(demodulize(self.name)))
+                     end
+                   end
       end
 
       # Specify an argument
@@ -69,7 +69,7 @@ module TTY
       #
       # @api public
       def flag(name, **settings, &block)
-        defaults = { default: false }
+        defaults = {default: false}
         option(name, **defaults.merge(settings), &block)
       end
 

data/lib/tty/option/errors.rb

@@ -22,6 +22,22 @@ module TTY
     # Raised during command line input parsing
     class ParseError < Error
       attr_accessor :param
+
+      # Format value
+      #
+      # @param [Object] value
+      #   the value to format
+      #
+      # @example
+      #   format_value([:a, 1])
+      #   # => a:1
+      #
+      # @return [String]
+      #
+      # @api public
+      def format_value(value)
+        value.respond_to?(:to_ary) ? value.join(":") : value.to_s
+      end
     end
 
     # Raised when found unrecognized parameter
@@ -39,7 +55,7 @@ module TTY
           @param = param_or_message
 
           message = format(MESSAGE,
-                           value: value,
+                           value: format_value(value),
                            name: param.name,
                            type: param.to_sym)
         else
@@ -129,16 +145,30 @@ module TTY
         if param_or_message.is_a?(Parameter)
           @param = param_or_message
           message = format(MESSAGE,
-                           value: value,
+                           value: format_value(value),
                            name: param.name,
                            type: param.to_sym,
-                           choices: param.permit.join(", "))
+                           choices: format_choices(param.permit))
         else
           message = param_or_message
         end
 
         super(message)
       end
+
+      private
+
+      # Format permitted choices
+      #
+      # @param [Array<Object>] choices
+      #   the choices to format
+      #
+      # @return [String]
+      #
+      # @api private
+      def format_choices(choices)
+        choices.map { |val| format_value(val) }.join(", ")
+      end
     end
   end # Option
 end # TTY