tty-option 0.2.0 → 0.3.0

data/lib/tty/option/conversions.rb

@@ -23,8 +23,10 @@ module TTY
       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
           Const::Undefined
@@ -48,13 +50,19 @@ module TTY
       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
           Const::Undefined
         end
@@ -63,14 +71,16 @@ module TTY
       convert :sym, :symbol do |val|
         begin
           String(val).to_sym
-        rescue ArgumentError
+        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
           Const::Undefined
@@ -79,24 +89,24 @@ module TTY
 
       convert :list, :array do |val|
         next Const::Undefined if val.nil?
+        next Array(val) unless val.respond_to?(:split)
 
-        (val.respond_to?(:map) ? val : val.to_s.split(/(?<!\\),/))
-          .map { |v| v.strip.gsub(/\\,/, ",") }
-          .reject(&:empty?)
+        val.split(/(?<!\\),/)
+           .map { |v| v.strip.gsub(/\\,/, ",") }
+           .reject(&:empty?)
       end
 
       convert :map, :hash do |val|
         next Const::Undefined if val.nil?
+        next val if val.is_a?(Hash)
 
-        values = val.respond_to?(:each) ? val : val.to_s.split(/[& ]/)
+        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
 

data/lib/tty/option/deep_dup.rb

@@ -2,46 +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 *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/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