mixture 0.1.0

data/lib/mixture/errors.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Mixture
+  # All mixture errors inherit this.
+  class BasicError < StandardError
+  end
+
+  # Occurs when a value can't be coerced into another value.
+  class CoercionError < BasicError
+  end
+
+  class ValidationError < BasicError
+  end
+end

data/lib/mixture/extensions/attributable.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module Mixture
+  module Extensions
+    # Has the mixture have attributes.
+    module Attributable
+      # The class methods for attribution.
+      module ClassMethods
+        def attribute(name, options = {})
+          name = name.to_s.intern
+          attr = attributes.create(name, options)
+          define_method(attr.getter) {     attribute(name)    }
+          define_method(attr.setter) { |v| attribute(name, v) }
+          attr
+        end
+
+        def attributes
+          @_attributes ||= AttributeList.new
+        end
+      end
+
+      # The instance methods for attribution.
+      module InstanceMethods
+        # Sets the attributes on the instance.
+        def attributes=(attrs)
+          attrs.each { |key, value| attribute(key, value) }
+        end
+
+        def attributes
+          Hash[self.class.attributes.map do |name, attr|
+            [name, instance_variable_get(attr.ivar)]
+          end]
+        end
+
+        def unknown_attribute(attr)
+          fail ArgumentError, "Unknown attribute #{attr} passed"
+        end
+
+        def attribute(key, value = Undefined)
+          attr = self.class.attributes.fetch(key) do
+            return unknown_attribute(key)
+          end
+
+          return instance_variable_get(attr.ivar) if value == Undefined
+
+          value = attr.update(value)
+          instance_variable_set(attr.ivar, value)
+        end
+      end
+
+      # Called by Ruby when the module is included.  This just
+      # extends the base by the {ClassMethods} module and includes
+      # into the base the {InstanceMethods} module.
+      #
+      # @param base [Object]
+      # @return [void]
+      # @api private
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+      end
+    end
+  end
+end

data/lib/mixture/extensions/coercable.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Mixture
+  module Extensions
+    # Extends the attribute definition to allow coercion.
+    module Coercable
+      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
+      end
+
+      # Called by Ruby when the module is included.
+      #
+      # @param base [Object]
+      # @return [void]
+      # @api private
+      def self.included(base)
+        base.attributes.callbacks[:update] << method(:coerce_attribute)
+      end
+    end
+  end
+end

data/lib/mixture/extensions/hashable.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require "forwardable"
+
+module Mixture
+  module Extensions
+    # Has the mixture respond to `#[]` and `#[]=`.
+    module Hashable
+      extend Forwardable
+      include Enumerable
+      include Comparable
+
+      delegate [:each, :<=>] => :attributes
+
+      def [](key)
+        attribute(key.to_s.intern)
+      end
+
+      def []=(key, value)
+        attribute(key.to_s.intern, value)
+      end
+
+      def key?(key)
+        self.class.attributes.key?(key.to_s.intern)
+      end
+
+      def fetch(key, default = Unknown)
+        case
+        when key?(key.to_s.intern) then attribute(key.to_s.intern)
+        when block_given?          then yield(key.to_s.intern)
+        when default != Unknown    then default
+        else fail KeyError, "Undefined attribute #{key.to_s.intern}"
+        end
+      end
+    end
+  end
+end

data/lib/mixture/extensions/validatable.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module Mixture
+  module Extensions
+    # Allows attributes to be validated based on a predefined set of
+    # principles.
+    module Validatable
+      # The class methods.
+      module ClassMethods
+        # Creates a new validation for the given attribute.  The
+        # attribute _must_ be defined before this call, otherwise it
+        # _will_ error.
+        def validate(name, options = {})
+          attributes.fetch(name).options[:validate] = options
+        end
+      end
+
+      # The instance methods.
+      module InstanceMethods
+        # Validates the attributes on the record.
+        def valid?
+          @errors = Hash.new { |h, k| h[k] = [] }
+          self.class.attributes.each do |name, attribute|
+            next unless attribute.options[:validate]
+            Validate.validate(self, attribute, attribute(name))
+          end
+          !@errors.values.any?(&:any?)
+        end
+
+        def invalid?
+          !valid?
+        end
+
+        def errors
+          @errors ||= Hash.new { |h, k| h[k] = [] }
+        end
+      end
+
+      # Called by Ruby when the module is included.  This just
+      # extends the base by the {ClassMethods} module and includes
+      # into the base the {InstanceMethods} module.
+      #
+      # @param base [Object]
+      # @return [void]
+      # @api private
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+      end
+    end
+  end
+end

data/lib/mixture/extensions.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Mixture
+  # All of the extensions of mixture.  Handles registration of
+  # extensions, so that extensions can be referend by a name instead
+  # of the constant.
+  module Extensions
+    def self.register(name, extension)
+      extensions[name.to_s.downcase.intern] = extension
+    end
+
+    def self.[](name)
+      extensions.fetch(name)
+    end
+
+    def self.extensions
+      @_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
+  end
+end

data/lib/mixture/model.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Mixture
+  # A model.
+  #
+  # @example
+  #   class MyClass
+  #     include Mixture::Model
+  #     mixture_modules :attributable, :hashable
+  #   end
+  module Model
+  end
+end

data/lib/mixture/type.rb

@@ -0,0 +1,142 @@
+# 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 = {}
+    BooleanClass = Class.new
+    InstanceClass = Class.new
+
+    BUILTIN_TYPES = %w(
+      Object Array Hash Integer Rational Float Set String Symbol
+      Time Date DateTime
+    ).map(&:intern).freeze
+
+    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 value is a {Type}, it returns the value.  If the
+    # given value is already defined as a {Type}, it returns the
+    # {Type}.  If the value's class is already defined as a {Type},
+    # it returns the class's {Type}; otherwise, it returns the types
+    # for Class and Object, depending on if the value is a Class or
+    # not, respectively.
+    #
+    # @example
+    #   Mixture::Type.infer(Integer) # => Mixture::Type::Integer
+    #
+    # @example
+    #   Mixture::Type.infer(1) # => Mixture::Type::Integer
+    #
+    # @example
+    #   Mixture::Type.infer(MyClass) # => Mixture::Type::Instance
+    #
+    # @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
+
+    def self.infer_class(klass)
+      if klass.is_a?(Type)
+        klass
+      else
+        basic_ancestors = klass.ancestors - ancestors
+        from(basic_ancestors.find { |a| @instances.key?(a) } || klass)
+      end
+    end
+
+    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[InstanceClass] = new(InstanceClass, name: "Instance")
+      const_set("Instance", @instances[InstanceClass])
+      @instances[NilClass] = new(NilClass, name: "Nil")
+      const_set("Nil", @instances[NilClass])
+    end
+
+    attr_reader :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
+
+    def to_s
+      "#{self.class.name}(#{@name})"
+    end
+    alias_method :inspect, :to_s
+
+    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

data/lib/mixture/validate/base.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Mixture
+  module Validate
+    class Base
+      def initialize(options)
+        @options = options
+      end
+
+      def validate(record, attribute, value)
+        @record = record
+        @attribute = attribute
+        @value = value
+      end
+
+      def error(message)
+        fail ValidationError, message
+      end
+    end
+  end
+end

data/lib/mixture/validate/match.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Mixture
+  module Validate
+    # Checks that a value matches.
+    class Match < Base
+      def validate(record, attribute, value)
+        super
+        error("Value does not match") unless match?
+      end
+
+      def match?
+        @value =~ @options
+      end
+    end
+  end
+end

data/lib/mixture/validate/presence.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Mixture
+  module Validate
+    # Checks that a value is present.
+    class Presence < Base
+      def validate(record, attribute, value)
+        super
+        error("Value is empty") if empty?
+      end
+
+      def empty?
+        @value.nil? || (@value.respond_to?(:empty?) && @value.empty?)
+      end
+    end
+  end
+end

data/lib/mixture/validate.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Mixture
+  module Validate
+    def self.register(name, validator)
+      validations[name] = validator
+    end
+
+    def self.validations
+      @_validations ||= {}
+    end
+
+    require "mixture/validate/base"
+    require "mixture/validate/match"
+    require "mixture/validate/presence"
+
+    register :match, Match
+    register :format, Match
+    register :presence, Presence
+
+    def self.validate(record, attribute, value)
+      attribute.options[:validate].each do |k, v|
+        validator = validations.fetch(k).new(v)
+        validate_with(validator, record, attribute, value)
+      end
+    end
+
+    def self.validate_with(validator, record, attribute, value)
+      validator.validate(record, attribute, value)
+
+    rescue ValidationError => e
+      record.errors[attribute] << e
+    end
+  end
+end

data/lib/mixture/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+#
+module Mixture
+  # The current version of Mixture.
+  #
+  # @return [String]
+  VERSION = "0.1.0"
+end

data/lib/mixture.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require "set"
+require "time"
+require "date"
+
+# The mixture module.
+module Mixture
+  # An undefined value.  This is used in place so that we can be sure
+  # that an argument wasn't passed.
+  #
+  # @return [Object]
+  Undefined = Object.new.freeze
+
+  # A proc that returns its first argument.
+  #
+  # @return [Proc{(Object) => Object}]
+  Itself = proc { |value| value }
+
+  require "mixture/version"
+  require "mixture/errors"
+  require "mixture/type"
+  require "mixture/attribute"
+  require "mixture/attribute_list"
+  require "mixture/coerce"
+  require "mixture/validate"
+  require "mixture/extensions"
+  require "mixture/type"
+end

data/mixture.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "mixture/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mixture"
+  spec.version       = Mixture::VERSION
+  spec.authors       = ["Jeremy Rodi"]
+  spec.email         = ["redjazz96@gmail.com"]
+
+  spec.summary       = "Handle validation, coercion, and attributes."
+  spec.description   = "Handle validation, coercion, and attributes."
+  spec.homepage      = "https://github.com/medcat/mixture"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+    .reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files
+    .grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  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"
+end