mixture 0.2.0 → 0.3.0

data/lib/mixture/types.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+require "thread_safe"
+
+module Mixture
+  # Contains information about types.
+  module Types
+    # A list of all of the types (non-anonymous) that are known.
+    #
+    # @return [Array<Class>]
+    def self.types
+      @types ||= ThreadSafe::Array.new
+    end
+
+    # A list of the mappings that all types have.  This is used
+    # primarily to map a type's symbol name to its type (e.g.
+    # `:string` to `String`).  This is also used for boolean mapping.
+    #
+    # @return [Hash{Symbol => Mixture::Types::Type}]
+    def self.mappings
+      ::Hash[types.flat_map do |type|
+        type.mappings.map do |name|
+          [name, type]
+        end
+      end]
+    end
+
+    # Infers an object's type.  It first checks the mappings to see if
+    # the object given is in the mappings; if it's not, it checks if
+    # it is a class.  If it is a class, it passes it over to
+    # {.infer_class}; otherwise, it passes it over to {.infer_type}.
+    #
+    # @see .mappings
+    # @see .infer_class
+    # @see .infer_type
+    # @param object [Object] The object to infer the type of.
+    # @return [Mixture::Types::Type] The type of the object.
+    def self.infer(object)
+      mappings.fetch(object) do
+        if object.is_a?(::Class)
+          infer_class(object)
+        else
+          infer_type(object)
+        end
+      end
+    end
+
+    # Infers the class of the given object.  If the object is a type,
+    # it just returns the object.  Otherwise, it searches types for a
+    # primitive that matches the object.  If one is found, it is
+    # returned; otherwise, a new `Class` type is created using
+    # {Class.[]}.  This is primarily used for user-defined classes.
+    #
+    # @example Creating a type for a user-defined class.
+    #   class MyClass; end
+    #   Mixture::Types.infer(MyClass) # => Mixture::Types::Class[MyClass]
+    # @api private
+    # @see Class.[]
+    # @param object [Class] The object to infer the type of.
+    # @return [Mixture::Types::Type] The type of the object.
+    def self.infer_class(object)
+      return object if object <= Type
+      types.find { |type| type.options[:primitive] == object } || Class[object]
+    end
+
+    # Infers the type of the object.  If the object is an array or set,
+    # it returns an {Array} or {Set} type with the object's first
+    # element's type as the member type.  Otherwise, it tries to find
+    # a type that matches the object using {Type.matches?}.  This will
+    # almost always return a type, if not {Object}.
+    #
+    # @note This may not return a type if the object is a
+    #   {BasicObject}.  This is because of the constraints on the
+    #   {Object} type.
+    # @example Infers the type of an array of elements.
+    #   Mixture::Types.infer([1])
+    #   # => Mixture::Types::Array[Mixture::Types::Integer]
+    # @api private
+    # @param object [Object]  The object to infer.
+    # @return [Mixture::Types::Type] The inferred type.
+    def self.infer_type(object)
+      case object
+      when ::Array then Array[infer(object.first)]
+      when ::Set   then Set[infer(object.first)]
+      else types.reverse.find { |type| type.matches?(object) }
+      end
+    end
+  end
+end
+
+require "mixture/types/type"
+require "mixture/types/access"
+require "mixture/types/object"
+require "mixture/types/enumerable"
+require "mixture/types/collection"
+require "mixture/types/class"
+require "mixture/types/boolean"
+require "mixture/types/numeric"
+require "mixture/types/array"
+require "mixture/types/date"
+require "mixture/types/datetime"
+require "mixture/types/float"
+require "mixture/types/hash"
+require "mixture/types/integer"
+require "mixture/types/nil"
+require "mixture/types/rational"
+require "mixture/types/set"
+require "mixture/types/string"
+require "mixture/types/symbol"
+require "mixture/types/time"

data/lib/mixture/version.rb

@@ -5,5 +5,5 @@ module Mixture
   # The current version of Mixture.
   #
   # @return [String]
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/mixture.rb

@@ -9,6 +9,16 @@ module Mixture
   # An undefined value.  This is used in place so that we can be sure
   # that an argument wasn't passed.
   #
+  # @example As a placeholder.
+  #   def self.constraint(value = Undefined, &block)
+  #     if value != Undefined
+  #       constraints << value
+  #     elsif block_given?
+  #       constraints << block
+  #     else
+  #       raise ArgumentError, "Expected an argument or block"
+  #     end
+  #   end
   # @return [Object]
   Undefined = Object.new.freeze
 
@@ -17,13 +27,23 @@ module Mixture
   # @return [Proc{(Object) => Object}]
   Itself = proc { |value| value }
 
+  # Finalizes all of the Mixture modules.
+  #
+  # @return [void]
+  def self.finalize
+    Mixture::Coerce.finalize
+    Mixture::Extensions.finalize
+    nil
+  end
+
   require "mixture/version"
   require "mixture/errors"
-  require "mixture/type"
+  require "mixture/types"
   require "mixture/attribute"
   require "mixture/attribute_list"
   require "mixture/coerce"
   require "mixture/validate"
   require "mixture/extensions"
-  require "mixture/type"
+
+  finalize
 end

data/mixture.gemspec

@@ -25,7 +25,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "coveralls"
-  spec.add_development_dependency "rubocop"
+
+  spec.add_dependency "thread_safe", "~> 0.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mixture
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-10 00:00:00.000000000 Z
+date: 2015-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,47 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: thread_safe
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '0.3'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.3'
 description: Handle validation, coercion, and attributes.
 email:
 - redjazz96@gmail.com
@@ -105,6 +77,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- ".yardopts"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -117,6 +90,7 @@ files:
 - lib/mixture/coerce.rb
 - lib/mixture/coerce/array.rb
 - lib/mixture/coerce/base.rb
+- lib/mixture/coerce/class.rb
 - lib/mixture/coerce/date.rb
 - lib/mixture/coerce/datetime.rb
 - lib/mixture/coerce/float.rb
@@ -136,7 +110,27 @@ files:
 - lib/mixture/extensions/hashable.rb
 - lib/mixture/extensions/validatable.rb
 - lib/mixture/model.rb
-- lib/mixture/type.rb
+- lib/mixture/types.rb
+- lib/mixture/types/access.rb
+- lib/mixture/types/array.rb
+- lib/mixture/types/boolean.rb
+- lib/mixture/types/class.rb
+- lib/mixture/types/collection.rb
+- lib/mixture/types/date.rb
+- lib/mixture/types/datetime.rb
+- lib/mixture/types/enumerable.rb
+- lib/mixture/types/float.rb
+- lib/mixture/types/hash.rb
+- lib/mixture/types/integer.rb
+- lib/mixture/types/nil.rb
+- lib/mixture/types/numeric.rb
+- lib/mixture/types/object.rb
+- lib/mixture/types/rational.rb
+- lib/mixture/types/set.rb
+- lib/mixture/types/string.rb
+- lib/mixture/types/symbol.rb
+- lib/mixture/types/time.rb
+- lib/mixture/types/type.rb
 - lib/mixture/validate.rb
 - lib/mixture/validate/base.rb
 - lib/mixture/validate/exclusion.rb

data/lib/mixture/type.rb

@@ -1,188 +0,0 @@
-# encoding: utf-8
-
-require "forwardable"
-
-module Mixture
-  # A type.  This can be represented as a constant.  This is normally
-  # anything that inherits `Class`.  One instance per type.
-  class Type
-    extend Forwardable
-    @instances = {}
-    # A class to represent the Boolean type (i.e. true, false), since
-    # ruby doesn't have a Boolean class.
-    #
-    # @return [Class]
-    BooleanClass = Class.new
-
-    # Ancestors that two classes might have in common with each other.
-    #
-    # @return [Array<Module, Class>]
-    COMMON_ANCESTORS = BooleanClass.ancestors - [BooleanClass]
-
-    # The builtin types of Ruby.  These are initialized as types
-    # before anything else happens.
-    #
-    # @return [Array<Symbol>]
-    BUILTIN_TYPES = %w(
-      Object Array Hash Integer Rational Float Set String Symbol
-      Time Date DateTime
-    ).map(&:intern).freeze
-
-    # The aliases for types.  This overrides any other possible
-    # inferences that this class can make.  For example, `true` and
-    # `false` are automatically mapped to `BooleanClass`.
-    #
-    # @return [Hash{Object, Symbol => Class}]
-    TYPE_ALIASES = {
-      true => BooleanClass,
-      false => BooleanClass,
-      nil => NilClass,
-      nil: NilClass,
-      bool: BooleanClass,
-      boolean: BooleanClass,
-      str: ::String,
-      string: ::String,
-      int: ::Integer,
-      integer: ::Integer,
-      rational: ::Rational,
-      float: ::Float,
-      array: ::Array,
-      set: ::Set,
-      symbol: ::Symbol,
-      time: ::Time,
-      date_time: ::DateTime,
-      date: ::Date
-    }.freeze
-
-    # Protect our class from being initialized by accident by anyone
-    # who doesn't know what they're doing.  They would have to try
-    # really hard to initialize this class, and in which case, that
-    # is acceptable.
-    private_class_method :new
-
-    # Returns a {Type} from a given class.  It assumes that the type
-    # given is a class, and passes it to `#new` - which will error if
-    # it isn't.
-    #
-    # @param type [Class] A type.
-    # @return [Mixture::Type]
-    def self.from(type)
-      @instances.fetch(type) do
-        @instances[type] = new(type)
-      end
-    end
-
-    # (see .from)
-    def self.[](type)
-      from(type)
-    end
-
-    # Determines the best type that represents the given value.  If
-    # the given type is listed in {TYPE_ALIASES}, it uses the alias
-    # value for a lookup.  If the given type is a {Type}, it returns
-    # the type.  If the given type is a `Class`, it uses {.infer_class}.
-    # Otherwise, it uses {.infer_class} on the type's class.
-    #
-    # @example
-    #   Mixture::Type.infer(Integer) # => Mixture::Type::Integer
-    #
-    # @example
-    #   Mixture::Type.infer(1) # => Mixture::Type::Integer
-    #
-    # @example
-    #   Mixture::Type.infer(MyClass) # => Mixture::Type[MyClass]
-    #
-    # @example
-    #   Mixture::Type.infer(Object.new) # => Mixture::Type::Object
-    #
-    # @param value [Object] The value to infer.
-    # @return [Mixture::Type]
-    def self.infer(value)
-      case
-      when TYPE_ALIASES.key?(value) then from(TYPE_ALIASES[value])
-      when value.is_a?(Type)        then value
-      when value.is_a?(Class)       then infer_class(value)
-      else infer_class(value.class)
-      end
-    end
-
-    # Infer a classes' type.  If the class is a type, it returns the
-    # type.  Otherwise, it checks the most basic ancestors (most basic
-    # ancestors being any ancestors not shared with a new class) for
-    # any classes that have a {Type}; if there are none, it creates a
-    # new type from the class.
-    #
-    # @param klass [Class] The class to infer type from.
-    # @return [Mixture::Type]
-    def self.infer_class(klass)
-      if klass.is_a?(Type)
-        klass
-      else
-        basic_ancestors = klass.ancestors - COMMON_ANCESTORS
-        from(basic_ancestors.find { |a| @instances.key?(a) } || klass)
-      end
-    end
-
-    # Loads the builtin types.  This includes `Boolean` and `Nil`.
-    #
-    # @see BUILTIN_TYPES
-    # @see BooleanClass
-    # @return [void]
-    def self.load
-      BUILTIN_TYPES.each do |sym|
-        const_set(sym, from(::Object.const_get(sym)))
-      end
-
-      @instances[BooleanClass] = new(BooleanClass, name: "Boolean")
-      const_set("Boolean", @instances[BooleanClass])
-      @instances[NilClass] = new(NilClass, name: "Nil")
-      const_set("Nil", @instances[NilClass])
-    end
-
-    # The name of the type.  If this wasn't provided upon
-    # initialization, it is guessed to be the class's name, which is
-    # normally good enough.
-    #
-    # @return [String]
-    attr_reader :name
-
-    # Initialize the type.  The class given _must_ be a class;
-    # otherwise, it will error.  A name can be provided as an option.
-    #
-    # @param type [Class] The type to create.
-    # @param options [Hash{Symbol => Object}] The options.
-    # @option options [String] :name The name to provide the type
-    #   with.  If this is not provided, it uses the class name.
-    def initialize(type, options = {})
-      fail ArgumentError, "Expected a Class, got #{type.class}" unless
-        type.is_a?(Class)
-      @type = type
-      @name = options.fetch(:name, @type.name)
-    end
-
-    # Creates a string representation of the type.  This normally has
-    # the format `Mixture::Type(Class)`, where `Class` is the class.
-    #
-    # @return [String]
-    def to_s
-      "#{self.class.name}(#{@name})"
-    end
-    alias_method :inspect, :to_s
-
-    # Creates a `:to_` method name for the type.
-    #
-    # @example
-    #   Mixture::Type[Array].method_name # => :to_array
-    def method_name
-      @_method_name ||= begin
-        body = name
-               .gsub(/^([A-Z])/) { |m| m.downcase }
-               .gsub(/::([A-Z])/) { |_, m| "_#{m.downcase}" }
-               .gsub(/([A-Z])/) { |m| "_#{m.downcase}" }
-        :"to_#{body}"
-      end
-    end
-  end
-end
-
-Mixture::Type.load