id 0.0.12 → 0.1

data/lib/id/form/active_model_form.rb

@@ -1,41 +0,0 @@
-module Id
-  module Form
-    class ActiveModelForm
-      include ActiveModel::Validations
-      include ActiveModel::Conversion
-      extend  ActiveModel::Naming
-
-      def self.i18n_scope
-        :id
-      end
-
-      def initialize(model)
-        @model = model
-      end
-
-      def persisted?
-        false
-      end
-
-      def to_model
-        self
-      end
-
-      def to_partial_path
-        model.respond_to?(:to_partial_path) ? model.to_partial_path : super
-      end
-
-      private
-
-      def method_missing(name, *args, &block)
-        model.send(name, *args, &block)
-      end
-
-      def memoize(f, &b)
-        instance_variable_get("@#{f}") || instance_variable_set("@#{f}", b.call)
-      end
-
-      attr_reader :model
-    end
-  end
-end

data/lib/id/form/descriptor.rb

@@ -1,27 +0,0 @@
-module Id
-  module Form
-    module Descriptor
-
-      def field(f, options={})
-        FieldWithFormSupport.new(self, f, options).define
-      end
-
-      def form &block
-        form_object.send :instance_exec, &block
-      end
-
-      def form_object
-        base = self
-        @form_object ||= Class.new(ActiveModelForm) do
-          eingenclass = class << self
-            self
-          end
-          eingenclass.send(:define_method, :model_name) do
-            ActiveModel::Name.new(self, nil, base.name)
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/id/form/field_form.rb

@@ -1,14 +0,0 @@
-class FieldForm
-
-  def self.define(field)
-    field.model.form_object.instance_eval do
-      define_method field.name do
-        memoize field.name do
-          Option[model.send(field.name)].flatten.value_or nil if model.data.has_key? field.key
-        end
-      end
-      attr_writer field.name
-    end
-  end
-
-end

data/lib/id/form/field_with_form_support.rb

@@ -1,12 +0,0 @@
-module Id
-  module Form
-    class FieldWithFormSupport < Id::Model::Field
-
-      def hook_define
-        FieldForm.define(self)
-      end
-
-    end
-  end
-end
-

data/lib/id/missing_attribute_error.rb

@@ -1,4 +0,0 @@
-module Id
-  class MissingAttributeError < StandardError
-  end
-end

data/lib/id/model/association.rb

@@ -1,49 +0,0 @@
-module Id
-  module Model
-    class Association < Field
-
-      def type
-        options.fetch(:type) { inferred_class }
-      end
-
-      def inferred_class
-        hierarchy.parent.const_get(inferred_class_name)
-      end
-
-      def inferred_class_name
-        @inferred_class_name ||= name.to_s.classify
-      end
-
-      def hierarchy
-        @hierarchy ||= Hierarchy.new(model.name, inferred_class_name)
-      end
-
-      class Hierarchy
-
-        def initialize(path, child)
-          @path = path
-          @child = child
-        end
-
-        def parent
-          @parent ||= constants.find do |c|
-            c.ancestors.find { |anc| anc.const_defined? child }
-          end
-        end
-
-        def constants
-          hierarchy.map(&:constantize)
-        end
-
-        private
-
-        def hierarchy(name=path)
-          name.match /(.*)::.*$/
-          $1 ? [name] + hierarchy($1) : [name]
-        end
-
-        attr_reader :path, :child
-      end
-    end
-  end
-end

data/lib/id/model/definer.rb

@@ -1,23 +0,0 @@
-module Id
-  module Model
-    class Definer
-
-      def self.method_memoize(context, name, &value_block)
-        method(context, name) do |object|
-          object.instance_eval do
-            memoize(name, &value_block)
-          end
-        end
-      end
-
-      def self.method(context, name, &value_block)
-        context.instance_eval do
-          define_method name do
-            value_block.call(self)
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/id/model/descriptor.rb

@@ -1,23 +0,0 @@
-module Id
-  module Model
-    module Descriptor
-
-      def field(f, options={})
-        Field.new(self, f, options).define
-      end
-
-      def has_one(f, options={})
-        HasOne.new(self, f, options).define
-      end
-
-      def has_many(f, options={})
-        HasMany.new(self, f, options).define
-      end
-
-      def to_proc
-        lambda { |data| new data }
-      end
-
-    end
-  end
-end

data/lib/id/model/field.rb

@@ -1,61 +0,0 @@
-module Id
-  module Model
-    class Field
-
-      def initialize(model, name, options)
-        @model = model
-        @name = name
-        @options = options
-      end
-
-      def define
-        Definer.method_memoize(model, name) { |data| value_of(data) }
-        Definer.method(model, "#{name}?") { |obj| presence_of(obj.data) }
-        hook_define
-      end
-
-      def hook_define
-      end
-
-      def value_of(data)
-        value = data.fetch(key, &default_value)
-        optional ? Option[value].map{ |d| cast d } : cast(value)
-      end
-
-      def presence_of(data)
-        data.has_key?(key) && data.fetch(key)
-      end
-
-      def cast(value)
-        TypeCasts.cast(options.fetch(:type, false), value)
-      end
-
-      def key
-        options.fetch(:key, name).to_s
-      end
-
-      def default_value
-        proc do
-          if default? then default
-          elsif !optional? then raise MissingAttributeError, key end
-        end
-      end
-
-      def default?
-        options.has_key?(:default)
-      end
-
-      def default
-        options.fetch(:default)
-      end
-
-      def optional?
-        options.fetch(:optional, false)
-      end
-      alias_method :optional, :optional?
-
-      attr_reader :model, :name, :options
-
-    end
-  end
-end

data/lib/id/model/has_many.rb

@@ -1,11 +0,0 @@
-module Id
-  module Model
-    class HasMany < Association
-
-      def value_of(data)
-        data.fetch(key, []).map { |r| type.new(r) }
-      end
-
-    end
-  end
-end

data/lib/id/model/has_one.rb

@@ -1,17 +0,0 @@
-module Id
-  module Model
-    class HasOne < Association
-
-      def value_of(data)
-        if optional?
-          child = data.fetch(key, nil)
-          child.nil? ? None : Some[type.new(child)]
-        else
-          child = data.fetch(key) { raise MissingAttributeError, key }
-          type.new(child) unless child.nil?
-        end
-      end
-
-    end
-  end
-end

data/lib/id/model/type_casts.rb

@@ -1,96 +0,0 @@
-module Id
-  module Model
-    module TypeCasts
-
-      def self.cast(type, value)
-        casts.fetch(type, Identity).new(value).cast
-      end
-
-      protected
-
-      def self.register(cast)
-        casts[cast.type] = cast
-      end
-
-      private
-
-      def self.casts
-        @casts ||= {}
-      end
-
-      class Cast
-
-        def initialize(value)
-          @value = value
-        end
-
-        def cast
-          value.is_a?(type) ? value : conversion
-        end
-
-        def type
-          self.class.type
-        end
-
-        def conversion
-          raise NotImplementedError
-        end
-
-        private
-
-        def self.type
-          raise NotImplementedError
-        end
-
-        attr_reader :value
-
-      end
-
-      class Identity < Cast
-        def cast
-          value
-        end
-      end
-
-      class Date < Cast
-
-        def self.type
-          ::Date
-        end
-
-        def conversion
-          ::Date.parse value
-        end
-
-        TypeCasts.register(self)
-      end
-
-      class Time < Cast
-
-        def self.type
-          ::Time
-        end
-
-        def conversion
-          ::Time.parse value
-        end
-
-        TypeCasts.register(self)
-      end
-
-      class Money < Cast
-
-        def self.type
-          ::Money
-        end
-
-        def conversion
-          ::Money.new value.to_i
-        end
-
-        TypeCasts.register(self)
-      end
-
-    end
-  end
-end

data/spec/lib/id/model/association_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Id::Model::Association do
-
-  module Foo
-    module Bar
-      module Baz
-        class Quux
-        end
-      end
-    end
-  end
-
-  let (:model) { stub(:name => "Foo::Bar::Baz::Quux") }
-  let (:has_one) { Id::Model::Association.new(model, "yak", {}) }
-
-  describe "hierarchy" do
-    it "builds the class and module hierarchy for the model" do
-      has_one.hierarchy.constants.should eq [
-        Foo::Bar::Baz::Quux,
-        Foo::Bar::Baz,
-        Foo::Bar,
-        Foo
-      ]
-    end
-  end
-end

data/spec/lib/id/model/form_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-class Gerbil
-  include Id::Model
-  include Id::Form
-
-  field :name
-  field :paws
-
-  form do
-    validates_presence_of :name
-    validates_length_of :name, :maximum => 4
-  end
-
-  def name_in_caps
-    name.upcase
-  end
-
-end
-
-module Id
-  module Model
-    describe Form do
-
-      let (:gerbil) { Gerbil.new(:name => 'Berty') }
-      let (:form)   { gerbil.as_form }
-
-      subject { gerbil.as_form }
-
-      it_behaves_like "ActiveModel"
-
-      it 'is delegated to by the model for errors' do
-        gerbil.errors.should eq form.errors
-        gerbil.valid?.should eq form.valid?
-      end
-
-      it 'responds to to_model' do
-        subject.to_model.should eq subject
-      end
-
-      it 'has the same fields as the model' do
-        form.name.should eq 'Berty'
-      end
-
-      it 'works with active model validations' do
-        form.should_not be_valid
-        form.name = 'Bert'
-        form.should be_valid
-      end
-
-      it 'delegates to the model' do
-        form.name_in_caps.should eq 'BERTY'
-      end
-    end
-  end
-end