id 0.0.12 → 0.1

data/lib/id/boolean.rb

@@ -0,0 +1,8 @@
+module Id::Boolean
+  extend self
+
+  def parse(value)
+    ['yes', 'true', '1'].include?(value.to_s.downcase)
+  end
+
+end

data/lib/id/coercion.rb

@@ -0,0 +1,38 @@
+module Id::Coercion
+  extend self
+
+  def register(from, to, &coercion)
+    warn "Id - Overwriting existing coercion" if coercions.has_key?([from, to])
+    coercions[[from, to]] = coercion
+  end
+
+  def coerce(value, type)
+    return value.map { |v| coerce(v, type) } if value.is_a? Option
+    return (value || []).map { |v| coerce(v, type.first) } if type.is_a? Array
+    return value if value.is_a? type
+    return type.new(value) if type.include? Id::Model
+
+    coercion = coercions.fetch([value.class, type], false)
+    fail Id::CoercionError, [value.class, type] unless coercion
+    coercion.call(value)
+  end
+
+  private
+
+  def coercions
+    @coercions ||= {}
+  end
+
+end
+
+class Id::CoercionError < StandardError
+  def initialize((from, to))
+    super "No available coercion from #{from} to #{to}"
+  end
+end
+
+Id::Coercion.register String, Integer,     &:to_i
+Id::Coercion.register String, Float,       &:to_f
+Id::Coercion.register String, Date,        &Date.method(:parse)
+Id::Coercion.register String, Time,        &Time.method(:parse)
+Id::Coercion.register String, Id::Boolean, &Id::Boolean.method(:parse)

data/lib/id/eta_expansion.rb

@@ -0,0 +1,5 @@
+module Id::EtaExpansion
+  def to_proc
+    -> data { new data }
+  end
+end

data/lib/id/field.rb

@@ -0,0 +1,46 @@
+module Id::Field
+
+  def field(name, options = {})
+    definition = Definition.new(name, options)
+    define_field!(definition)
+    define_predicate!(definition)
+    fields[name] = definition
+  end
+
+  def fields
+    @fields ||= {}
+  end
+
+  private
+
+  def self.extended(base)
+    base.send(:define_method, :fields) { self.class.fields }
+  end
+
+  def define_field!(definition)
+    send :define_method, definition.name do
+      _data[definition.key] or fail Id::MissingAttributeError, [self, definition]
+    end
+  end
+
+  def define_predicate!(definition)
+    send :define_method, "#{definition.name}?" do
+      value = _data[definition.key]
+      value && !value.is_a?(None)
+    end
+  end
+
+end
+
+class Id::MissingAttributeError < StandardError
+  def initialize((model, field))
+    super "#{model.class.name} had a nil value for '#{field.name}'.\n\n" +
+          "*** Field information ***\n#{field.to_s}\n\n" +
+          "*** Model data ***\n#{model.data.inspect}\n\n" +
+          "If you're trying to use an Id::Model in a Rails form, make sure:\n" +
+          "* You 'include Id::Form' in your model\n" +
+          "* You have the following line in your 'config/application.rb': \n\n" +
+          "    config.action_view.default_form_builder = Id::FormBuilder\n\n"
+
+  end
+end

data/lib/id/field/definition.rb

@@ -0,0 +1,44 @@
+module Id::Field
+  class Definition
+    def initialize(name, options)
+      @name = name
+      @options = options
+    end
+
+    def default
+      options.fetch(:default, nil)
+    end
+
+    def default!
+      default.is_a?(Proc) ? default.call : default
+    end
+
+    def key
+      options.fetch(:key, name).to_s
+    end
+
+    def type
+      options.fetch(:type, Object)
+    end
+
+    def optional?
+      options.fetch(:optional, false)
+    end
+
+    def to_s
+      Id::Field::Summary.new(self).to_s
+    end
+
+    def value(data)
+      # the following code is a bit verbose but can't use || as false is valid here
+      value = data[key]
+      value = data[key.to_sym] if value.nil?
+      value = default!         if value.nil?
+      value = Option[value]    if optional?
+
+      Id::Coercion.coerce(value, type) unless value.nil?
+    end
+
+    attr_reader :name, :options
+  end
+end

data/lib/id/field/summary.rb

@@ -0,0 +1,35 @@
+module Id::Field
+  class Summary
+    def initialize(definition)
+      @definition = definition
+    end
+
+    def to_s
+      [name, type, key, optional, default].compact.join("\n")
+    end
+
+    private
+    attr_reader :definition
+
+    def name
+      "Name: #{definition.name}"
+    end
+
+    def type
+      "Type: #{definition.type}" unless definition.type == Object
+    end
+
+    def key
+      "Key in hash: #{definition.key}" unless definition.key == definition.name.to_s
+    end
+
+    def optional
+      "Optional: true" if definition.optional?
+    end
+
+    def default
+      default = definition.default
+      "Default: #{default.is_a?(Proc) ? 'Lambda' : default}" unless default.nil?
+    end
+  end
+end

data/lib/id/form.rb

@@ -1,21 +1,49 @@
-module Id
-  module Form
+module Id::Form
 
-    def as_form
-      @form_object ||= self.class.form_object.new(self)
-    end
+  def active_model
+    @active_model ||= form_class.new(self, _data)
+  end
 
-    def errors
-      as_form.errors
-    end
+  def as_form
+    warn '[DEPRECATION] calling `as_form` is deprecated, please use `to_model` instead'
+    to_model
+  end
 
-    def valid?
-      as_form.valid?
-    end
+  def persisted?
+    false
+  end
+
+  delegate :valid?, :errors, to: :active_model
 
-    def self.included(base)
-      base.extend(Descriptor)
+  private
+  def form_class
+    self.class.form_class
+  end
+
+  def self.included(base)
+    base.send :include, ActiveModel::Conversion
+    base.send :extend,  Id::Validations, Id::FormBackwardsCompatibility
+    base.send :extend,  ActiveModel::Naming
+    base.send :alias_method, :to_model, :active_model
+
+    base.define_singleton_method :form_class do
+      base = self
+      @form_class ||= Class.new(Id::ActiveModel) do
+        eigenclass = class << self; self end
+        eigenclass.send :define_method, :model_name do
+          base.send(:model_name)
+        end
+      end
     end
+  end
 
+end
+
+if defined?(ActionView::Helpers::FormBuilder)
+  class Id::FormBuilder < ActionView::Helpers::FormBuilder
+    def initialize(object_name, object, template, options)
+      object = object.is_a?(Id::Model) ? object.to_model : object
+      super object_name, object, template, options
+    end
   end
 end

data/lib/id/form_backwards_compatibility.rb

@@ -0,0 +1,6 @@
+module Id::FormBackwardsCompatibility
+  def form(&block)
+    warn '[DEPRECATION] form is no longer needed - validation can be specified at the top level of the model'
+    form_class.send :instance_exec, &block
+  end
+end

data/lib/id/hashifier.rb

@@ -1,28 +1,17 @@
-module Id
-  class Hashifier
+module Id::Hashifier
+  extend self
 
-    def self.hashify(data)
-      new(data).hashify
+  def enhash(value)
+    case value
+    when Hash
+      value.reduce({}) { |acc, (k, v)| acc.merge(k.to_s => enhash(v)) }
+    when Array
+      value.map { |v| enhash(v) }
+    when Id::Model
+      value.to_hash
+    else
+      value
     end
-
-    def initialize(data)
-      @data = data
-    end
-
-    def hashify
-      Hash[data.map { |k, v| [ k.to_s, as_data(v) ] }]
-    end
-
-    private
-
-    def as_data(v)
-      case v
-      when Id::Model then v.data
-      when Array then v.first.is_a?(Id::Model) ? v.map(&:data) : v
-      when Hash then Hashifier.hashify(v)
-      else v end
-    end
-
-    attr_reader :data
   end
+
 end

data/lib/id/model.rb

@@ -1,37 +1,41 @@
-module Id
-  module Model
-    attr_reader :data
+module Id::Model
 
-    def initialize(data = {})
-      @data = Hashifier.hashify(data)
+  def initialize(_data = {})
+    @_data = fields.reduce({}) do |acc, (_, field)|
+      acc.merge(field.key => field.value(_data))
     end
+  end
 
-    def set(values)
-      self.class.new(data.merge(Hashifier.hashify(values)))
-    end
+  def set(update)
+    updated = _data.merge(update.stringify_keys)
+    self.class.new(updated)
+  end
 
-    def unset(*keys)
-      self.class.new(data.except(*keys.map(&:to_s)))
-    end
+  def unset(*fields)
+    fields  = fields.map(&:to_s)
+    updated = _data.except(*fields)
+    self.class.new(updated)
+  end
 
-    def eql? other
-      other.is_a?(Id::Model) && other.data.eql?(self.data)
-    end
-    alias_method :==, :eql?
+  def eql? other
+    other.is_a?(Id::Model) && other._data.eql?(self._data)
+  end
+  alias_method :==, :eql?
 
-    def hash
-      data.hash
-    end
+  def hash
+    _data.hash
+  end
 
-    private
+  def data
+    @data ||= Id::Hashifier.enhash(_data)
+  end
 
-    def self.included(base)
-      base.extend(Descriptor)
-    end
+  alias_method :to_hash, :data
 
-    def memoize(f, &b)
-      instance_variable_get("@#{f}") || instance_variable_set("@#{f}", b.call(data))
-    end
+  protected
+  attr_reader :_data
 
+  def self.included(base)
+    base.send :extend, Id::Field, Id::Association, Id::EtaExpansion
   end
 end

data/lib/id/timestamps.rb

@@ -1,20 +1,20 @@
-module Id
-  module Timestamps
-    def self.included(base)
-      base.field :created_at
-      base.field :updated_at
-    end
+module Id::Timestamps
+  def self.included(base)
+    base.field :created_at
+    base.field :updated_at
+  end
 
-    def initialize(data = {})
-      super data.merge(:created_at => data.fetch('created_at', Time.now))
-    end
+  def initialize(_data = {})
+    now = Time.now
+    super ({ created_at: now, updated_at: now }).merge(_data)
+  end
 
-    def set(values)
-      self.class.new(super.data.merge(:updated_at => Time.now))
-    end
+  def set(update)
+    super update.merge(updated_at: Time.now)
+  end
 
-    def unset(*keys)
-      self.class.new(super.data.merge(:updated_at => Time.now))
-    end
+  def unset(update)
+    super.set({})
   end
+
 end

data/lib/id/validations.rb

@@ -0,0 +1,8 @@
+module Id::Validations
+  delegate :validate,              to: :form_class
+  delegate :validates,             to: :form_class
+  delegate :validates!,            to: :form_class
+  delegate :validates_each,        to: :form_class
+  delegate :validates_with,        to: :form_class
+  delegate :validates_presence_of, to: :form_class
+end

data/spec/examples/cat_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+class Mouse; include Id::Model end
+
+class Cat
+  include Id::Model
+
+  field :name
+  field :paws,     type: Integer
+  field :mice,     type: Array[Mouse]
+  field :friendly, type: Id::Boolean
+end
+
+describe Cat do
+  it 'has a name' do
+    cat = Cat.new(name: 'Tracy')
+    expect(cat.name).to eq 'Tracy'
+  end
+
+  it 'has an integer number of paws' do
+    cat = Cat.new(paws: '3')
+    expect(cat.paws).to eq 3
+  end
+
+  it 'has an array of mice' do
+    cat = Cat.new(mice: [{},{},{}])
+    expect(cat.mice).to have(3).items
+    cat.mice.each { |mouse| expect(mouse).to be_a Mouse }
+  end
+
+  it 'is either friendly or unfriendly' do
+    cat = Cat.new(friendly: 'yes')
+    expect(cat).to be_friendly
+    cat = Cat.new(friendly: 'nope')
+    expect(cat).not_to be_friendly
+  end
+end