mixture 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e1746012422c7e9f856706e2820d0423f404784
-  data.tar.gz: 0591ce1acb37f9805c37b06298bf7f4c10c4f3f7
+  metadata.gz: 0ecfd79715637290b6e55e9bfdf26de13054e50a
+  data.tar.gz: 78d922593da25b673897de662496788600790516
 SHA512:
-  metadata.gz: 6a2b4634e7d03ef8ed5e8c4730895e497bd1c98307f87f012f27ab4d4a1d401912076c39b366194d52cdeaf1f9beb2dcf673c57729b6f8f679a0656bb39280f1
-  data.tar.gz: a15206cb105329873a6890deeb46d8aa797385835315568a427c3e98272a8d3862f3af158777a9afbe077c546621b3af42b89ac7427a1a2e5bc073558407669e
+  metadata.gz: 74ead02c239ae1add84099d0a2d0f688519a67871e31766550ef72ba219ef5a1c2f1d01dad6df95127cf73216e59539f2fe69b60d12ca4c7bca79105f3e3950e
+  data.tar.gz: f1e0670bb6a7b59daf8647b8cbf8fe88db17bd1a41a53b9944825852488a71d2f000212a9b5a0fb6cea0f944d019f857193851a45cb856ea4dd3c1d48ecd21d7

data/.yardopts

@@ -0,0 +1 @@
+-m markdown

data/Gemfile

@@ -2,5 +2,9 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in mixture.gemspec
+# These are in here for reasons.
+gem "pry"
+gem "rubocop"
+gem "coveralls"
+
 gemspec

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    mixture (0.2.0)
+    mixture (0.3.0)
+      thread_safe (~> 0.3)
 
 GEM
   remote: https://rubygems.org/
@@ -68,6 +69,7 @@ GEM
     term-ansicolor (1.3.2)
       tins (~> 1.0)
     thor (0.19.1)
+    thread_safe (0.3.5)
     tins (1.5.4)
     unf (0.1.4)
       unf_ext

data/README.md

@@ -103,11 +103,17 @@ Adding a coercer is also simple:
 
 ```ruby
 module MyLibrary
+  module Types
+    class MyObject < Mixture::Types::Object
+      options[:primitive] = nil
+      constraint { |value| ... }
+    end
+  end
   module Coerce
     class MyObject < Mixture::Coerce::Base
-      type Mixture::Type[MyLibrary::MyObject]
+      type MyLibrary::Types::MyObject
 
-      coerce_to(Mixture::Type::Array) do |value|
+      coerce_to(Mixture::Types::Array) do |value|
         value.to_a
       end
     end
@@ -115,6 +121,23 @@ module MyLibrary
 end
 ```
 
+Although the builtin coercers should do well.
+
+A more complex example:
+
+```ruby
+module MyLibrary
+  class Something
+    include Mixture::Model
+
+    attribute :name, type: String
+    attribute :files, type: Array[String]
+    attribute :authors, type: Set[Author]
+    attribute :dependencies, type: Set[Dependency]
+  end
+end
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at

data/lib/mixture/attribute.rb

@@ -36,27 +36,30 @@ module Mixture
       @list.callbacks[:update].inject(value) { |a, e| e.call(self, a) }
     end
 
+    # @!attribute [r] ivar
     # The instance variable for this attribute.
     #
-    # @example
+    # @example Retrieve the instance variable.
     #   attribute.ivar # => :@name
     # @return [Symbol]
     def ivar
       @_ivar ||= :"@#{@name}"
     end
 
+    # @!attribute [r] getter
     # The getter method for this attribute.
     #
-    # @example
+    # @example Retrieve the getter.
     #   attribute.getter # => :name
     # @return [Symbol]
     def getter
       @name
     end
 
+    # @!attribute [r] setter
     # The setter method for this attribute.
     #
-    # @example
+    # @example Retrieve the setter.
     #   attribute.setter # :name=
     # @return [Symbol]
     def setter

data/lib/mixture/coerce/array.rb

@@ -4,12 +4,27 @@ module Mixture
   module Coerce
     # Handles coercion of the Array class.
     class Array < Base
-      type Type::Array
+      type Types::Array
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::Array, Itself)
-      coerce_to(Type::Set, :to_set)
-      coerce_to(Type::Hash) { |value| ::Hash[value] }
+      coerce_to(Types::Object, Itself)
+
+      coerce_to(Types::Array) do |value, type|
+        member = type.options.fetch(:members).first
+        value.map { |e| Coerce.perform(member, e) }
+      end
+
+      coerce_to(Types::Set) do |value, type|
+        member = type.options.fetch(:members).first
+        value.map { |e| Coerce.perform(member, e) }
+      end
+
+      coerce_to(Types::Hash) do |value, type|
+        member = type.options.fetch(:members)
+        ::Hash[value.map do |element|
+          [Coerce.perform(member[0], element[0]),
+           Coerce.perform(member[1], element[1])]
+        end]
+      end
     end
   end
 end

data/lib/mixture/coerce/base.rb

@@ -31,7 +31,26 @@ module Mixture
       #
       # @return [Hash{Mixture::Type => Symbol}]
       def self.coercions
-        @_coercions ||= {}
+        @_coercions ||= ThreadSafe::Hash.new
+      end
+
+      # This is a method that's called by ruby interally.  We're going
+      # to use it to hook into the coercions, to allow a class
+      # coercion.
+      #
+      # @param base [Class] A subclass.
+      # @return [void]
+      def self.inherited(base)
+        super # for Singleton
+        base.coerce_to(Types::Class) do |value, type|
+          member = type.options.fetch(:members).first
+          if member.respond_to?(:coerce) then member.coerce(value)
+          elsif member.respond_to?(:new) then member.new(value)
+          else
+            fail CoercionError, "Expected #{member} to " \
+                 "respond to #coerce, #new"
+          end
+        end
       end
 
       # This is a DSL for the class itself.  It essentially defines a
@@ -41,12 +60,13 @@ module Mixture
       #   This is a DSL for the class itself.  It essentially defines
       #   a method to perform the coercion of the given type.
       #
-      #   @param to [Mixture::Type] The type to coerce to.
-      #   @yield [value] The block is called with the value to coerce
-      #     when coercion needs to happen.  Note that the block is not
-      #     used as the body of the method - the method returns the
-      #     block.
+      #   @param to [Mixture::Types::Type] The type to coerce to.
+      #   @yield [value, type] The block is called with the value to
+      #     coerce when coercion needs to happen.  Note that the
+      #     block is not used as the body of the method - the method
+      #     returns the block.
       #   @yieldparam value [Object] The object to coerce.
+      #   @yieldparam type [Mixture::Types::Type] The destination type.
       #   @yieldreturn [Object] The coerced value.
       #   @return [void]
       #
@@ -54,27 +74,43 @@ module Mixture
       #   This is a DSL for the class itself.  It essentially defines
       #   a method to perform the coercion of the given type.
       #
-      #   @param to [Mixture::Type] The type to coerce to.
-      #   @param value [Proc] The block that is called with the value
-      #     for coercion.  This block is returned by the defined
-      #     coercion method.
+      #   @param to [Mixture::Types::Type] The type to coerce to.
+      #   @param value [Proc, Symbol] The block that is called with
+      #     the value for coercion.  This block is returned by
+      #     the defined coercion method.  If it's a symbol, it's
+      #     turned into a block.  Note that this doesn't use
+      #     Symbol#to_proc; it uses a similar block that ignores
+      #     the excess paramters.
       #   @return [void]
-      #
-      def self.coerce_to(to, value = Undefined, &block)
-        fail ArgumentError, "Expected Mixture::Type, got #{to.class}" unless
-          to.is_a?(Mixture::Type)
+      def self.coerce_to(to, data = Undefined, &block)
+        fail ArgumentError, "Expected Mixture::Types::Type, got #{to}" unless
+          to <= Mixture::Types::Type
 
-        body = case
-               when value != Undefined
-                 value.to_proc
-               when block_given?
-                 block
-               else
-                 fail ArgumentError, "Expected a block"
-               end
+        body = data_block(data, &block)
+        coercions[to] = to.options[:method]
+        define_method(to.options[:method]) { body }
+      end
 
-        coercions[to] = to.method_name
-        define_method(to.method_name) { body }
+      # Turns a data/block given to {.coerce_to} into a block worthy
+      # of a body for a method.
+      #
+      # @param data [Proc, Symbol] A proc/symbol to be used for a
+      #   method.
+      # @yield (see .coerce_to)
+      # @yieldparam (see .coerce_to)
+      # @yieldreturn (see .coerce_to)
+      # @return [void]
+      def self.data_block(data, &block)
+        case
+        when data.is_a?(::Symbol)
+          proc { |value| value.public_send(data) }
+        when data.is_a?(::Proc)
+          data
+        when block_given?
+          block
+        else
+          fail ArgumentError, "Expected a block, got #{data.inspect}"
+        end
       end
 
       # (see #to)
@@ -90,8 +126,8 @@ module Mixture
       # @return [Proc{(Object) => Object}]
       def to(type)
         method_name = self.class.coercions.fetch(type) do
-          fail CoercionError,
-               "Undefined coercion of #{self.class.type} => #{type}"
+          fail CoercionError, "Undefined coercion #{self.class.type} " \
+            "=> #{type}" unless method_name
         end
 
         public_send(method_name)

data/lib/mixture/coerce/class.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Mixture
+  module Coerce
+    # A class coercion.
+    class Class < Base
+      type Types::Class
+
+      coerce_to(Types::Object, Itself)
+    end
+  end
+end

data/lib/mixture/coerce/date.rb

@@ -4,17 +4,17 @@ module Mixture
   module Coerce
     # Handles coercion of the Date class.
     class Date < Base
-      type Type::Date
+      type Types::Date
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::String, :to_s)
-      coerce_to(Type::Time, :to_time)
-      coerce_to(Type::Date, :to_date)
-      coerce_to(Type::DateTime, :to_datetime)
-      coerce_to(Type::Array) { |value| value.to_time.to_a }
-      coerce_to(Type::Float) { |value| value.to_time.to_f }
-      coerce_to(Type::Integer) { |value| value.to_time.to_i }
-      coerce_to(Type::Rational) { |value| value.to_time.to_r }
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::String, :to_s)
+      coerce_to(Types::Time, :to_time)
+      coerce_to(Types::Date, :to_date)
+      coerce_to(Types::DateTime, :to_datetime)
+      coerce_to(Types::Array) { |value| value.to_time.to_a }
+      coerce_to(Types::Float) { |value| value.to_time.to_f }
+      coerce_to(Types::Integer) { |value| value.to_time.to_i }
+      coerce_to(Types::Rational) { |value| value.to_time.to_r }
     end
   end
 end

data/lib/mixture/coerce/datetime.rb

@@ -4,17 +4,17 @@ module Mixture
   module Coerce
     # Handles coercion of the DateTime class.
     class DateTime < Base
-      type Type::DateTime
+      type Types::DateTime
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::String, :to_s)
-      coerce_to(Type::Time, :to_time)
-      coerce_to(Type::Date, :to_date)
-      coerce_to(Type::DateTime, :to_datetime)
-      coerce_to(Type::Array) { |value| value.to_time.to_a }
-      coerce_to(Type::Float) { |value| value.to_time.to_f }
-      coerce_to(Type::Integer) { |value| value.to_time.to_i }
-      coerce_to(Type::Rational) { |value| value.to_time.to_r }
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::String, :to_s)
+      coerce_to(Types::Time, :to_time)
+      coerce_to(Types::Date, :to_date)
+      coerce_to(Types::DateTime, :to_datetime)
+      coerce_to(Types::Array) { |value| value.to_time.to_a }
+      coerce_to(Types::Float) { |value| value.to_time.to_f }
+      coerce_to(Types::Integer) { |value| value.to_time.to_i }
+      coerce_to(Types::Rational) { |value| value.to_time.to_r }
     end
   end
 end

data/lib/mixture/coerce/float.rb

@@ -4,16 +4,16 @@ module Mixture
   module Coerce
     # Handles coercion of the Float class.
     class Float < Base
-      type Type::Float
+      type Types::Float
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::String, :to_s)
-      coerce_to(Type::Float, Itself)
-      coerce_to(Type::Integer, :to_i)
-      coerce_to(Type::Rational, :to_r)
-      coerce_to(Type::Time) { |value| ::Time.at(value) }
-      coerce_to(Type::Date) { |value| ::Time.at(value).to_date }
-      coerce_to(Type::DateTime) { |value| ::Time.at(value).to_datetime }
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::String, :to_s)
+      coerce_to(Types::Float, Itself)
+      coerce_to(Types::Integer, :to_i)
+      coerce_to(Types::Rational, :to_r)
+      coerce_to(Types::Time) { |value| ::Time.at(value) }
+      coerce_to(Types::Date) { |value| ::Time.at(value).to_date }
+      coerce_to(Types::DateTime) { |value| ::Time.at(value).to_datetime }
     end
   end
 end

data/lib/mixture/coerce/hash.rb

@@ -4,11 +4,17 @@ module Mixture
   module Coerce
     # Handles coercion of the Hash class.
     class Hash < Base
-      type Type::Hash
+      type Types::Hash
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::Hash, Itself)
-      coerce_to(Type::Array, :to_a)
+      coerce_to(Types::Object, Itself)
+
+      coerce_to(Types::Hash) do |value, type|
+        members = type.options.fetch(:members)
+        ::Hash[value.map do |k, v|
+          [Coerce.perform(members[0], k),
+           Coerce.perform(members[1], v)]
+        end]
+      end
     end
   end
 end

data/lib/mixture/coerce/integer.rb

@@ -4,16 +4,16 @@ module Mixture
   module Coerce
     # Handles coercion of the Integer class.
     class Integer < Base
-      type Type::Integer
+      type Types::Integer
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::String, :to_s)
-      coerce_to(Type::Float, :to_f)
-      coerce_to(Type::Rational, :to_r)
-      coerce_to(Type::Integer, Itself)
-      coerce_to(Type::Time) { |value| ::Time.at(value) }
-      coerce_to(Type::Date) { |value| ::Time.at(value).to_date }
-      coerce_to(Type::DateTime) { |value| ::Time.at(value).to_datetime }
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::String, :to_s)
+      coerce_to(Types::Float, :to_f)
+      coerce_to(Types::Rational, :to_r)
+      coerce_to(Types::Integer, Itself)
+      coerce_to(Types::Time) { |value| ::Time.at(value) }
+      coerce_to(Types::Date) { |value| ::Time.at(value).to_date }
+      coerce_to(Types::DateTime) { |value| ::Time.at(value).to_datetime }
     end
   end
 end

data/lib/mixture/coerce/nil.rb

@@ -4,17 +4,17 @@ module Mixture
   module Coerce
     # Handles coercion of the Nil class.
     class Nil < Base
-      type Type::Nil
+      type Types::Nil
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::String) { "" }
-      coerce_to(Type::Array) { [] }
-      coerce_to(Type::Float) { 0.0 }
-      coerce_to(Type::Hash) { {} }
-      coerce_to(Type::Integer) { 0 }
-      coerce_to(Type::Rational) { Rational(0, 1) }
-      coerce_to(Type::Set) { Set.new }
-      coerce_to(Type::Symbol) { :"" }
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::String) { "" }
+      coerce_to(Types::Array) { [] }
+      coerce_to(Types::Float) { 0.0 }
+      coerce_to(Types::Hash) { {} }
+      coerce_to(Types::Integer) { 0 }
+      coerce_to(Types::Rational) { Rational(0, 1) }
+      coerce_to(Types::Set) { Set.new }
+      coerce_to(Types::Symbol) { :"" }
     end
   end
 end

data/lib/mixture/coerce/object.rb

@@ -4,7 +4,7 @@ module Mixture
   module Coerce
     # Handles coercion of the Object class.
     class Object < Base
-      type Type::Object
+      type Types::Object
 
       # Tries a set of methods on the object, before failing with a
       # coercion error.
@@ -21,18 +21,18 @@ module Mixture
         end
       end
 
-      coerce_to(Type::Array, TryMethods[:to_a, :to_ary, :to_array])
-      coerce_to(Type::Date, TryMethods[:to_date])
-      coerce_to(Type::DateTime, TryMethods[:to_datetime])
-      coerce_to(Type::Float, TryMethods[:to_f, :to_float])
-      coerce_to(Type::Hash, TryMethods[:to_h, :to_hash])
-      coerce_to(Type::Integer, TryMethods[:to_i, :to_integer])
-      coerce_to(Type::Object, :dup)
-      coerce_to(Type::Rational, TryMethods[:to_r, :to_rational])
-      coerce_to(Type::Set, TryMethods[:to_set])
-      coerce_to(Type::String, TryMethods[:to_s, :to_str, :to_string])
-      coerce_to(Type::Symbol, TryMethods[:to_sym, :intern, :to_symbol])
-      coerce_to(Type::Time, TryMethods[:to_time])
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::Array, TryMethods[:to_a, :to_ary, :to_array])
+      coerce_to(Types::Date, TryMethods[:to_date])
+      coerce_to(Types::DateTime, TryMethods[:to_datetime])
+      coerce_to(Types::Float, TryMethods[:to_f, :to_float])
+      coerce_to(Types::Hash, TryMethods[:to_h, :to_hash])
+      coerce_to(Types::Integer, TryMethods[:to_i, :to_integer])
+      coerce_to(Types::Rational, TryMethods[:to_r, :to_rational])
+      coerce_to(Types::Set, TryMethods[:to_set])
+      coerce_to(Types::String, TryMethods[:to_s, :to_str, :to_string])
+      coerce_to(Types::Symbol, TryMethods[:to_sym, :intern, :to_symbol])
+      coerce_to(Types::Time, TryMethods[:to_time])
     end
   end
 end

data/lib/mixture/coerce/rational.rb

@@ -4,16 +4,16 @@ module Mixture
   module Coerce
     # Handles coercion of the Rational class.
     class Rational < Base
-      type Type::Rational
+      type Types::Rational
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::Rational, Itself)
-      coerce_to(Type::Time) { |value| ::Time.at(value) }
-      coerce_to(Type::Date) { |value| ::Time.at(value).to_date }
-      coerce_to(Type::DateTime) { |value| ::Time.at(value).to_datetime }
-      coerce_to(Type::Float, :to_f)
-      coerce_to(Type::Integer, :to_i)
-      coerce_to(Type::String, :to_s)
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::Rational, Itself)
+      coerce_to(Types::Time) { |value| ::Time.at(value) }
+      coerce_to(Types::Date) { |value| ::Time.at(value).to_date }
+      coerce_to(Types::DateTime) { |value| ::Time.at(value).to_datetime }
+      coerce_to(Types::Float, :to_f)
+      coerce_to(Types::Integer, :to_i)
+      coerce_to(Types::String, :to_s)
     end
   end
 end

data/lib/mixture/coerce/set.rb

@@ -4,11 +4,19 @@ module Mixture
   module Coerce
     # Handles coercion of the Set class.
     class Set < Base
-      type Type::Set
+      type Types::Set
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::Set, :dup)
-      coerce_to(Type::Array, :to_a)
+      coerce_to(Types::Object, Itself)
+
+      coerce_to(Types::Set) do |value, type|
+        member = type.options.fetch(:members).first
+        value.map { |e| Coerce.perform(member, e) }.to_set
+      end
+
+      coerce_to(Types::Array) do |value, type|
+        member = type.options.fetch(:members).first
+        value.map { |e| Coerce.perform(member, e) }.to_a
+      end
     end
   end
 end

data/lib/mixture/coerce/string.rb

@@ -4,16 +4,16 @@ module Mixture
   module Coerce
     # Handles coercion of the String class.
     class String < Base
-      type Type::String
+      type Types::String
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::String, :dup)
-      coerce_to(Type::Symbol, :to_sym)
-      coerce_to(Type::Integer, :to_i)
-      coerce_to(Type::Float, :to_f)
-      coerce_to(Type::Time) { |value| ::Time.parse(value) }
-      coerce_to(Type::Date) { |value| ::Date.parse(value) }
-      coerce_to(Type::DateTime) { |value| ::DateTime.parse(value) }
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::String, :dup)
+      coerce_to(Types::Symbol, :to_sym)
+      coerce_to(Types::Integer, :to_i)
+      coerce_to(Types::Float, :to_f)
+      coerce_to(Types::Time) { |value| ::Time.parse(value) }
+      coerce_to(Types::Date) { |value| ::Date.parse(value) }
+      coerce_to(Types::DateTime) { |value| ::DateTime.parse(value) }
     end
   end
 end

data/lib/mixture/coerce/symbol.rb

@@ -4,11 +4,11 @@ module Mixture
   module Coerce
     # Handles coercion of the Numeric class.
     class Symbol < Base
-      type Type::Symbol
+      type Types::Symbol
 
-      coerce_to(Type::Object, Itself)
-      coerce_to(Type::String, :to_s)
-      coerce_to(Type::Symbol, Itself)
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::String, :to_s)
+      coerce_to(Types::Symbol, Itself)
     end
   end
 end

data/lib/mixture/coerce/time.rb

@@ -4,16 +4,17 @@ module Mixture
   module Coerce
     # Handles coercion of the Time class.
     class Time < Base
-      type Type::Time
+      type Types::Time
 
-      coerce_to(Type::String, :to_s)
-      coerce_to(Type::Integer, :to_i)
-      coerce_to(Type::Float, :to_f)
-      coerce_to(Type::Rational, :to_r)
-      coerce_to(Type::Array, :to_a)
-      coerce_to(Type::Time, Itself)
-      coerce_to(Type::Date, :to_date)
-      coerce_to(Type::DateTime, :to_datetime)
+      coerce_to(Types::Object, Itself)
+      coerce_to(Types::String, :to_s)
+      coerce_to(Types::Integer, :to_i)
+      coerce_to(Types::Float, :to_f)
+      coerce_to(Types::Rational, :to_r)
+      coerce_to(Types::Array, :to_a)
+      coerce_to(Types::Time, Itself)
+      coerce_to(Types::Date, :to_date)
+      coerce_to(Types::DateTime, :to_datetime)
     end
   end
 end