mixture 0.2.0 → 0.3.0

data/lib/mixture/coerce.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
 require "mixture/coerce/base"
-require "mixture/coerce/array"
 require "mixture/coerce/date"
+require "mixture/coerce/array"
 require "mixture/coerce/datetime"
 require "mixture/coerce/float"
 require "mixture/coerce/hash"
@@ -32,24 +32,46 @@ module Mixture
     #
     # @return [Hash{Mixture::Type => Mixture::Coerce::Base}]
     def self.coercers
-      @_coercers ||= {}
+      @_coercers ||= ThreadSafe::Hash.new
     end
 
     # Returns a block that takes one argument: the value.
     #
-    # @param from [Mixture::Type]
+    # @param from [Mixture::Types::Type]
     #   The type to coerce from.
-    # @param to [Mixture::Type]
+    # @param to [Mixture::Types::Type]
     #   The type to coerce to.
-    # @return [Proc{(Object) => Object}]
+    # @return [Proc{(Object, Mixture::Types::Object) => Object}]
     def self.coerce(from, to)
       coercers
         .fetch(from) { fail CoercionError, "No coercer for #{from}" }
         .to(to)
     end
 
+    # Performs the actual coercion, since blocks require a value and
+    # type arguments.
+    #
+    # @param type [Mixture::Types::Type] The type to coerce to.
+    # @param value [Object] The value to coerce.
+    # @return [Object] The coerced value.
+    def self.perform(type, value)
+      to = Types.infer(type)
+      from = Types.infer(value)
+      block = coerce(from, to)
+
+      begin
+        block.call(value, to)
+      rescue CoercionError
+        raise
+      rescue StandardError => e
+        raise CoercionError, "#{e.class}: #{e.message}", e.backtrace
+      end
+    end
+
     # Registers the default coercions.
-    def self.load
+    #
+    # @return [void]
+    def self.finalize
       register Array
       register Date
       register DateTime
@@ -64,7 +86,5 @@ module Mixture
       register Symbol
       register Time
     end
-
-    load
   end
 end

data/lib/mixture/extensions/coercable.rb

@@ -7,6 +7,7 @@ module Mixture
       # Performs the coercion for the attribute and the value.
       # It is used in a `:update` callback.
       #
+      # @see Coerce.perform
       # @param attribute [Attribute] The attribute
       # @param value [Object] The new value.
       # @return [Object] The new new value.
@@ -14,16 +15,7 @@ module Mixture
       #   running.
       def self.coerce_attribute(attribute, value)
         return value unless attribute.options[:type]
-        attr_type = Type.infer(attribute.options[:type])
-        value_type = Type.infer(value)
-
-        block = Coerce.coerce(value_type, attr_type)
-
-        begin
-          block.call(value)
-        rescue StandardError => e
-          raise CoercionError, "#{e.class}: #{e.message}", e.backtrace
-        end
+        Coerce.perform(attribute.options[:type], value)
       end
 
       # Called by Ruby when the module is included.

data/lib/mixture/extensions.rb

@@ -1,5 +1,10 @@
 # encoding: utf-8
 
+require "mixture/extensions/attributable"
+require "mixture/extensions/coercable"
+require "mixture/extensions/hashable"
+require "mixture/extensions/validatable"
+
 module Mixture
   # All of the extensions of mixture.  Handles registration of
   # extensions, so that extensions can be referend by a name instead
@@ -32,14 +37,15 @@ module Mixture
       @_extensions ||= {}
     end
 
-    require "mixture/extensions/attributable"
-    require "mixture/extensions/coercable"
-    require "mixture/extensions/hashable"
-    require "mixture/extensions/validatable"
-
-    register :attribute, Attributable
-    register :coerce, Coercable
-    register :hash, Hashable
-    register :validate, Validatable
+    # Finalizes the extension module.  It registers the extensions in
+    # Mixture.
+    #
+    # @return [void]
+    def self.finalize
+      register :attribute, Attributable
+      register :coerce, Coercable
+      register :hash, Hashable
+      register :validate, Validatable
+    end
   end
 end

data/lib/mixture/types/access.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # Used by certain types to create subtypes of those types.  This
+    # is useful in collections and hashes, wherein the collection
+    # members and hash keys/values all have types as well (and need
+    # to be coerced to them).
+    module Access
+      # Creates a subtype with the given member types.  Any number of
+      # subtypes may be used.  If a class hasn't been created with the
+      # subtypes, it creates a new one.
+      #
+      # @see #create
+      # @param subs [Object] The subtypes to use.
+      # @return [Class] The new subtype.
+      def [](*subs)
+        options[:types].fetch([self, subs]) do
+          create(subs)
+        end
+      end
+
+      private
+
+      # Actually creates the subtype.  This should never be called
+      # outside of {.[]}.  If `:noinfer` is set in the supertype's
+      # options, it doesn't infer the type of each subtype; otherwise,
+      # it does.
+      #
+      # @param subs [Array<Object>] The subtypes.
+      # @return [Class] The new subtype.
+      def create(subs)
+        subtype = ::Class.new(self)
+        members = if options[:noinfer]
+                    subs
+                  else
+                    subs.map { |sub| Types.infer(sub) }
+                  end
+        name    = "#{inspect}[#{members.join(', ')}]"
+        subtype.options.merge!(members: members, name: name)
+        options[:types][[self, subs]] = subtype
+      end
+    end
+  end
+end

data/lib/mixture/types/array.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # The array type.  This is a collection, and as such, can be used
+    # with the `.[]` accessor.
+    class Array < Collection
+      options[:primitive] = ::Array
+      options[:method] = :to_array
+      as :array
+    end
+  end
+end

data/lib/mixture/types/boolean.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # The boolean type.  Unfortunately, ruby doesn't have a clear cut
+    # boolean primitive (it has `TrueClass` and `FalseClass`, but no
+    # `Boolean` class), so we set the primitive to nil to prevent
+    # odd stuff from happening.  It can still be matched by other
+    # values.
+    class Boolean < Object
+      options[:primitive] = nil
+      as :bool, :boolean, true, false
+
+      constraints.clear
+      constraint do |value|
+        [TrueClass, FalseClass].include?(value.class)
+      end
+    end
+  end
+end

data/lib/mixture/types/class.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A class type.  This can be subtyped, and is subtyped for
+    # non-primitive classes.
+    class Class < Object
+      options[:primitive] = ::Class
+      options[:noinfer]   = true
+      options[:member]    = Object
+      options[:method]    = :to_class
+      options[:types]     = ThreadSafe::Cache.new
+      extend Access
+    end
+  end
+end

data/lib/mixture/types/collection.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A collection.  This is recognized as an actual set of values,
+    # rather than just being enumerable.  The set of values have a
+    # defined type.
+    class Collection < Enumerable
+      options[:members] = [Object]
+      options[:types]   = ThreadSafe::Cache.new
+      extend Access
+    end
+  end
+end

data/lib/mixture/types/date.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A date type.  I don't know why ruby has Date, DateTime, and
+    # Time, but someone thinks we need it.
+    class Date < Object
+      options[:primitive] = ::Date
+      options[:method] = :to_date
+      as :date
+    end
+  end
+end

data/lib/mixture/types/datetime.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A datetime type.  I don't know why Ruby has a Date, DateTime, and
+    # Time type, but someone thinks we needs it.
+    class DateTime < Object
+      options[:primitive] = ::DateTime
+      options[:method] = :to_datetime
+      as :datetime
+    end
+  end
+end

data/lib/mixture/types/enumerable.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # An enumerable.  This is any value that inherits `Enumerable`.
+    class Enumerable < Object
+      options[:primitive] = ::Enumerable
+      constraint do |value|
+        # include Enumerable adds Enumerable to the ancestors list.
+        value.class.ancestors.include?(::Enumerable)
+      end
+    end
+  end
+end

data/lib/mixture/types/float.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A float.  Not much to say here.
+    class Float < Numeric
+      options[:primitive] = ::Float
+      options[:method] = :to_float
+      as :float
+    end
+  end
+end

data/lib/mixture/types/hash.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A hash.  This is also accessable, and expects two member types;
+    # one for the keys, and one for the values.
+    class Hash < Object
+      options[:primitive] = ::Hash
+      options[:members]   = [Object, Object]
+      options[:method]    = :to_hash
+      options[:types]     = ThreadSafe::Cache.new
+      extend Access
+    end
+  end
+end

data/lib/mixture/types/integer.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # An integer.  Not much to say here.
+    class Integer < Numeric
+      options[:primitive] = ::Integer
+      options[:method] = :to_integer
+      as :int, :integer
+    end
+  end
+end

data/lib/mixture/types/nil.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # Represents a nil type.  This has no coercions.
+    class Nil < Object
+      options[:primitive] = ::NilClass
+      as nil
+    end
+  end
+end

data/lib/mixture/types/numeric.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A numeric.  This is inherited by {Integer}, {Float}, and
+    # {Rational}.  Those should be used for coercion instead of this.
+    # This just helps represent the type hirearchy.
+    class Numeric < Object
+      options[:primitive] = ::Numeric
+    end
+  end
+end

data/lib/mixture/types/object.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # An object.  This adds the basic constraints all types (that
+    # inherit from Object) have; i.e., it must be an object, and
+    # it must be the type's primitive.
+    class Object < Type
+      options[:primitive] = ::Object
+      options[:method] = :to_object
+      as :object
+
+      constraint do |value|
+        # This may seem a bit odd, but this returns false for
+        # BasicObject; and since this is meant to represent Objects,
+        # we want to make sure that the value isn't a BasicObject.
+        # rubocop:disable Style/CaseEquality
+        ::Object === value
+        # rubocop:enable Style/CaseEquality
+      end
+      constraint { |value| value.is_a?(options[:primitive]) }
+    end
+  end
+end

data/lib/mixture/types/rational.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A rational.  I've personally never used this, but I don't see it
+    # as a bad thing.
+    class Rational < Numeric
+      options[:primitive] = ::Rational
+      options[:method] = :to_rational
+      as :rational
+    end
+  end
+end

data/lib/mixture/types/set.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A set.  This is similar to array, but with brilliant iteration
+    # and indexing(?) times.
+    #
+    # @see Array
+    # @see http://ruby-doc.org/stdlib/libdoc/set/rdoc/Set.html
+    class Set < Collection
+      options[:primitive] = ::Set
+      options[:method] = :to_set
+      as :set
+    end
+  end
+end

data/lib/mixture/types/string.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A string.
+    class String < Object
+      options[:primitive] = ::String
+      options[:method] = :to_string
+      as :str, :string
+    end
+  end
+end

data/lib/mixture/types/symbol.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A symbol.  Don't really use this for coercion; in Ruby 2.2.2,
+    # they added garbage collection for symbols; however, it is still
+    # not a brilliant idea to turn user input into symbols.
+    class Symbol < Object
+      options[:primitive] = ::Symbol
+      options[:method] = :to_symbol
+      as :symbol
+    end
+  end
+end

data/lib/mixture/types/time.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A time type.  I'm not sure why Ruby has a Date, DateTime, and
+    # Time object, but someone thinks we need it.
+    class Time < Object
+      options[:primitive] = ::Time
+      options[:method] = :to_time
+      as :time
+    end
+  end
+end

data/lib/mixture/types/type.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+
+module Mixture
+  module Types
+    # A single type.  A type is _never_ instantized; it is used as a
+    # class to represent a type of value.
+    class Type
+      private_class_method :new
+      private_class_method :allocate
+
+      # The options for the type.  This is inherited by subtypes.
+      #
+      # @return [Hash{Symbol => Object}]
+      def self.options
+        @options ||= ThreadSafe::Hash.new
+      end
+
+      # Constraints on the type.  A value will not match the type if
+      # any of these constraints fail.  This is inherited by subtypes.
+      #
+      # @return [Array<Proc{(Object) => Boolean}>]
+      def self.constraints
+        @constraints ||= ThreadSafe::Array.new
+      end
+
+      # Returns all of the names that this type can go under.  This is
+      # used for {Types.mappings} and for inference.
+      #
+      # @see Types.mappings
+      # @return [Array<Symbol, Object>]
+      def self.mappings
+        @mappings ||= ThreadSafe::Array.new
+      end
+
+      # Sets some names that this type can go under.  This is used
+      # for {Type.mappings} and for inference.
+      #
+      # @see Types.mappings
+      # @see .mappings
+      # @param names [Symbol, Object]
+      # @return [void]
+      def self.as(*names)
+        mappings.concat(names)
+      end
+
+      # Called by ruby when a class inherits this class.  This just
+      # propogates the options and constraints to the new subclass.
+      #
+      # @param sub [Class] The new subclass.
+      # @return [void]
+      def self.inherited(sub)
+        Types.types << sub unless sub.anonymous?
+        sub.options.merge!(options)
+        sub.constraints.concat(constraints)
+      end
+
+      # Checks if the given value passes all of the constraints
+      # defined on this type.  Each constraint is executed within the
+      # context of the class, to provide access to {.options}.
+      #
+      # @param value [Object] The object to check.
+      # @return [Boolean]
+      def self.matches?(value)
+        constraints.all? do |constraint|
+          class_exec(value, &constraint)
+        end
+      end
+
+      # Determines if this type is equal to another type.  This is
+      # used by Ruby's hash, and is used to make an anonymous type
+      # equal to its supertype (e.g.
+      # `Types::Array[Types::Integer] == Types::Array`), mainly for
+      # coercion.
+      #
+      # @param other [Object]
+      # @return [Boolean]
+      def self.eql?(other)
+        if anonymous?
+          superclass == other
+        elsif other.respond_to?(:anonymous?) && other.anonymous?
+          other.superclass.eql?(self)
+        else
+          super
+        end
+      end
+
+      # (see .eql?)
+      def self.==(other)
+        eql?(other)
+      end
+
+      # Used by ruby's Hash, this determines the hash of the type.  If
+      # this is anonymous, it uses its supertype's hash.
+      #
+      # @see .eql?
+      # @return [Numeric]
+      def self.hash
+        if anonymous?
+          superclass.hash
+        else
+          super
+        end
+      end
+
+      # If this class is anonymous.  This is counting on the fact that
+      # the name of an anonymous class is nil; however, assigning a
+      # class to a constant on initialization of a class will make
+      # that class non-anonymous.
+      #
+      # @return [Boolean]
+      def self.anonymous?
+        name.nil?
+      end
+
+      # Inspects the class.  If the class is anonymous, it uses the
+      # `:name` value in the options if it exists.  Otherwise, it
+      # passes it up the chain.
+      #
+      # @return [String]
+      def self.inspect
+        to_s
+      end
+
+      # (see .inspect)
+      def self.to_s
+        if anonymous? && options.key?(:name)
+          options[:name]
+        else
+          super
+        end
+      end
+
+      # This is used to determine if a specific object is this type.
+      # There can be many constraints, and they're all used to check
+      # the given object.
+      #
+      # @note Constraints are not meant for _validation_.  Constraints
+      #   are **purely** meant for identification, and should be used
+      #   as such.
+      #
+      # @overload self.constraint(value)
+      #   Adds the value as a constraint.  Ideally, this should
+      #   respond to `#call`.
+      #
+      #   @example Subclass constraint.
+      #     constraint(->(value) { value.is_a?(String) })
+      #   @param value [#call] The constraint to add.
+      #   @return [void]
+      #
+      # @overload self.constraint(&block)
+      #   Adds the block as a constraint.
+      #
+      #   @example Subclass constraint.
+      #     constraint { |value| value.is_a?(String) }
+      #   @yield [value]
+      #   @yieldparam value [Object] The value to check.
+      #   @yieldreturn [Boolean] If the constraint was passed.
+      #   @return [void]
+      def self.constraint(value = Undefined, &block)
+        if block_given?
+          constraints << block
+        elsif value != Undefined
+          constraints << value
+        else
+          fail ArgumentError, "Expected an argument or a block, " \
+            "got neither"
+        end
+      end
+    end
+  end
+end