parameters 0.2.3 → 0.3.0

data/lib/parameters/types/integer.rb

@@ -0,0 +1,31 @@
+require 'parameters/types/object'
+
+module Parameters
+  module Types
+    class Integer < Object
+
+      #
+      # Coerces a value into an Integer.
+      #
+      # @param [::String, #to_i] value
+      #   The value to coerce.
+      #
+      # @return [::Integer]
+      #   The coerced Integer.
+      #
+      def self.coerce(value)
+        case value
+        when ::String
+          value.to_i(0)
+        else
+          if value.respond_to?(:to_i)
+            value.to_i
+          else
+            0
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/parameters/types/object.rb

@@ -0,0 +1,50 @@
+require 'parameters/types/type'
+
+module Parameters
+  module Types
+    class Object < Type
+
+      #
+      # The Ruby Class the Type represents.
+      #
+      # @return [Class]
+      #   The Ruby Class that matches the Types name.
+      #
+      def self.to_ruby
+        @ruby_class ||= ::Object.const_get(self.name.split('::').last)
+      end
+
+      #
+      # Determines if the value is an Object.
+      #
+      # @return [true]
+      #
+      def self.===(value)
+        value.kind_of?(to_ruby)
+      end
+
+      #
+      # Coerces the value into an Object.
+      #
+      # @param [::Object] value
+      #   The value to coerce.
+      #
+      # @return [value]
+      #   Passes through the value.
+      #
+      def self.coerce(value)
+        value
+      end
+
+      #
+      # Determines if the value is an Object.
+      #
+      # @return [true]
+      #
+      def ===(value)
+        value.kind_of?(to_ruby)
+      end
+
+    end
+  end
+end

data/lib/parameters/types/proc.rb

@@ -0,0 +1,35 @@
+require 'parameters/types/type'
+
+module Parameters
+  module Types
+    class Proc < Type
+
+      # The callback that will coerce values
+      attr_reader :callback
+
+      #
+      # Creates a new Proc type.
+      #
+      # @param [#call] callback
+      #   The callback that will handle the actual coercion.
+      #
+      def initialize(callback)
+        @callback = callback
+      end
+
+      #
+      # Coerces the value using the callback.
+      #
+      # @param [::Object] value
+      #   The value to coerce.
+      #
+      # @return [::Object]
+      #   The result of the callback.
+      #
+      def coerce(value)
+        @callback.call(value)
+      end
+
+    end
+  end
+end

data/lib/parameters/types/regexp.rb

@@ -0,0 +1,26 @@
+require 'parameters/types/object'
+
+module Parameters
+  module Types
+    class Regexp < Object
+
+      #
+      # Coerces a value into a Regular Expression.
+      #
+      # @param [#to_regexp, #to_s] value
+      #   The value to coerce.
+      #
+      # @return [::Regexp]
+      #   The coerced Regular Expression.
+      #
+      def self.coerce(value)
+        if value.respond_to?(:to_regexp)
+          value.to_regexp
+        else
+          ::Regexp.new(value.to_s)
+        end
+      end
+
+    end
+  end
+end

data/lib/parameters/types/set.rb

@@ -0,0 +1,28 @@
+require 'parameters/types/array'
+
+require 'set'
+
+module Parameters
+  module Types
+    class Set < Array
+
+      #
+      # Coerces a value into a Set.
+      #
+      # @param [#to_set, ::Object] value
+      #   The value to coerce.
+      #
+      # @return [::Set]
+      #   The coerced Set.
+      #
+      def self.coerce(value)
+        if value.respond_to?(:to_set)
+          value.to_set
+        else
+          ::Set[value]
+        end
+      end
+
+    end
+  end
+end

data/lib/parameters/types/string.rb

@@ -0,0 +1,22 @@
+require 'parameters/types/object'
+
+module Parameters
+  module Types
+    class String < Object
+
+      #
+      # Coerces a value into a String.
+      #
+      # @param [#to_s] value
+      #   The value to coerce.
+      #
+      # @return [::String]
+      #   The coerced String.
+      #
+      def self.coerce(value)
+        value.to_s
+      end
+
+    end
+  end
+end

data/lib/parameters/types/symbol.rb

@@ -0,0 +1,26 @@
+require 'parameters/types/object'
+
+module Parameters
+  module Types
+    class Symbol < Object
+
+      #
+      # Coerces a value into a Symbol.
+      #
+      # @param [#to_sym, #to_s] value
+      #   The value to coerce.
+      #
+      # @return [::Symbol]
+      #   The coerced Symbol.
+      #
+      def self.coerce(value)
+        if value.respond_to?(:to_sym)
+          value.to_sym
+        else
+          value.to_s.to_sym
+        end
+      end
+
+    end
+  end
+end

data/lib/parameters/types/time.rb

@@ -0,0 +1,33 @@
+require 'parameters/types/object'
+
+require 'time'
+
+module Parameters
+  module Types
+    class Time < Object
+
+      #
+      # Coerces a value into a Time object.
+      #
+      # @param [Integer, #to_time, #to_s] value
+      #   The value to coerce.
+      #
+      # @return [::Time]
+      #   The coerced Time object.
+      #
+      def self.coerce(value)
+        case value
+        when Integer
+          ::Time.at(value)
+        else
+          if value.respond_to?(:to_time)
+            value.to_time
+          else
+            ::Time.parse(value.to_s)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/parameters/types/type.rb

@@ -0,0 +1,65 @@
+module Parameters
+  module Types
+    class Type
+
+      #
+      # The Ruby Class the type represents.
+      #
+      # @return [Class]
+      #   A Ruby Class the Type represents.
+      #
+      # @abstract
+      #
+      def self.to_ruby
+      end
+
+      #
+      # @see to_ruby
+      #
+      def to_ruby
+        self.class.to_ruby
+      end
+
+      #
+      # Determines if the value is an instance of the Type.
+      #
+      # @return [Boolean]
+      #   Specifies whether the value is already an instance of the Type.
+      #
+      # @abstract
+      #
+      def self.===(value)
+        false
+      end
+
+      #
+      # Coerces an Object into an instances of the Type.
+      #
+      # @param [Object] value
+      #   The value to coerce.
+      #
+      # @return [Object]
+      #   The coerced value.
+      #
+      # @abstract
+      #
+      def self.coerce(value)
+      end
+
+      #
+      # @see ===
+      #
+      def ===(value)
+        self.class === value
+      end
+
+      #
+      # @see coerce
+      #
+      def coerce(value)
+        self.class.coerce(value)
+      end
+
+    end
+  end
+end

data/lib/parameters/types/types.rb

@@ -0,0 +1,96 @@
+require 'parameters/types/hash'
+require 'parameters/types/set'
+require 'parameters/types/array'
+require 'parameters/types/boolean'
+require 'parameters/types/object'
+require 'parameters/types/proc'
+require 'parameters/types/class'
+
+module Parameters
+  #
+  # @since 0.3.0
+  #
+  # @api private
+  #
+  module Types
+    #
+    # Determines if a Type is defined.
+    #
+    # @param [Symbol, String] name
+    #   The name of the type.
+    #
+    # @return [Boolean]
+    #   Specifies whether the type was defined within {Types}.
+    #
+    def self.type_defined?(name)
+      const_defined?(name) && (const_get(name) < Type)
+    end
+
+    #
+    # Looks up a Type.
+    #
+    # @param [Symbol, String] name
+    #   The name of the type.
+    #
+    # @return [Type]
+    #   The type within {Types}.
+    #
+    # @raise [NameError]
+    #   The type could not be found.
+    #
+    def self.type_get(name)
+      type = const_get(name)
+
+      unless type < Type
+        raise(NameError,"unknown Parameter Type: #{name}")
+      end
+
+      return type
+    end
+
+    #
+    # Maps a Hash, Set, Array, Proc or Class to a Type.
+    #
+    # @param [Hash, Set, Array, Proc, Class] type
+    #   The Ruby Class or Hash, Set, Array, Proc to map to a Type.
+    #
+    # @return [Types::Type]
+    #   The mapped type.
+    #
+    # @raise [TypeError]
+    #   The Ruby Type could not be mapped to a Parameter Type.
+    #
+    def self.[](type)
+      case type
+      when ::Hash
+        key_type, value_type = type.entries[0]
+
+        Hash.new(self[key_type],self[value_type])
+      when ::Set
+        Set.new(self[type.entries[0]])
+      when ::Array
+        Array.new(self[type[0]])
+      when ::Proc
+        Proc.new(type)
+      when true
+        Boolean
+      when nil
+        Object
+      when ::Class
+        if type_defined?(type.name)
+          type_get(type.name)
+        else
+          Class.new(type)
+        end
+      when ::Module
+        if type_defined?(type.name)
+          type_get(type.name)
+        else
+          raise(TypeError,"unknown parameter type: #{type.inspect}")
+        end
+      else
+        raise(TypeError,"invalid parameter type: #{type.inspect}")
+      end
+    end
+  end
+end

data/lib/parameters/types/uri.rb

@@ -0,0 +1,41 @@
+require 'parameters/types/object'
+
+require 'uri'
+
+module Parameters
+  module Types
+    class URI < Object
+
+      #
+      # Determines if the value is already a URI.
+      #
+      # @param [Object] value
+      #   The value to inspect.
+      #
+      # @return [Boolean]
+      #   Specifies whether the value inherits `URI::Generic`.
+      #
+      def self.===(value)
+        value.kind_of?(::URI::Generic)
+      end
+
+      #
+      # Coerces a value into a URI.
+      #
+      # @param [#to_uri, #to_s] value
+      #   The value to coerce.
+      # 
+      # @return [URI::Generic]
+      #   The coerced URI.
+      #
+      def self.coerce(value)
+        if value.respond_to?(:to_uri)
+          value.to_uri
+        else
+          ::URI.parse(value.to_s)
+        end
+      end
+
+    end
+  end
+end