active_data 0.0.1 → 0.1.0

data/lib/active_data/attributes/base.rb

@@ -0,0 +1,64 @@
+module ActiveData
+  module Attributes
+    class Base
+      attr_reader :name, :options
+
+      def initialize name, options = {}, &block
+        @name = name.to_sym
+        @options = options
+        @options[:default] = block if block
+      end
+
+      def type
+        @type ||= options[:type] || String
+      end
+
+      def values
+        @values ||= options[:in].dup if options[:in]
+      end
+
+      def default
+        @default ||= options[:default].respond_to?(:call) ? options[:default] : proc { options[:default] }
+      end
+
+      def default_value instance
+        default.call instance
+      end
+
+      def type_cast value
+        type.active_data_type_cast value
+      end
+
+      def generate_instance_methods context
+        context.class_eval <<-EOS
+          def #{name}
+            read_attribute(:#{name})
+          end
+
+          def #{name}= value
+            write_attribute(:#{name}, value)
+          end
+
+          def #{name}?
+            read_attribute(:#{name}).present?
+          end
+
+          def #{name}_before_type_cast
+            read_attribute_before_type_cast(:#{name})
+          end
+        EOS
+      end
+
+      def generate_singleton_methods context
+        if values
+          context.class_eval <<-EOS
+            def #{name}_values
+              _attributes[:#{name}].values
+            end
+          EOS
+        end
+      end
+
+    end
+  end
+end

data/lib/active_data/attributes/localized.rb

@@ -0,0 +1,42 @@
+module ActiveData
+  module Attributes
+    class Localized < Base
+
+      def default_value *args
+        {}
+      end
+
+      def generate_instance_methods context
+        context.class_eval <<-EOS
+          def #{name}_translations
+            read_attribute(:#{name})
+          end
+
+          def #{name}_translations= value
+            write_attribute(:#{name}, value)
+          end
+
+          def #{name}
+            read_localized_attribute(:#{name})
+          end
+
+          def #{name}= value
+            write_localized_attribute(:#{name}, value)
+          end
+
+          def #{name}?
+            read_localized_attribute(:#{name}).present?
+          end
+
+          def #{name}_before_type_cast
+            read_localized_attribute_before_type_cast(:#{name})
+          end
+        EOS
+      end
+
+      def generate_singleton_methods context
+      end
+
+    end
+  end
+end

data/lib/active_data/model/associations/many.rb

@@ -0,0 +1,24 @@
+module ActiveData
+  module Model
+    module Associations
+      class Many
+        attr_reader :name, :klass, :options
+
+        def initialize name, options = {}
+          @name, @options = name.to_s, options
+          @klass ||= options[:class] || (options[:class_name].to_s.presence || name.to_s.classify).safe_constantize
+          raise "Can not determine class for `#{name}` association" unless @klass
+        end
+
+        def class_name
+          klass.to_s
+        end
+
+        def collection?
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/active_data/model/associations.rb

@@ -0,0 +1,49 @@
+require 'active_data/model/associations/many'
+
+module ActiveData
+  module Model
+    module Associations
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_associations, :instance_reader => false, :instance_writer => false
+        self._associations = ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      module ClassMethods
+
+        def reflect_on_association name
+          _associations[name]
+        end
+
+        def associations
+          _associations
+        end
+
+        def association_names
+          _associations.keys
+        end
+
+        def embeds_many name, options = {}
+          association = Many.new name, options
+          define_collection_reader association
+          define_collection_writer association
+          self._associations = _associations.merge!(association.name => association)
+        end
+
+        def define_collection_reader association
+          define_method association.name do
+            instance_variable_get("@#{association.name}") || association.klass.collection([])
+          end
+        end
+
+        def define_collection_writer association
+          define_method "#{association.name}=" do |value|
+            instance_variable_set "@#{association.name}", association.klass.collection(value)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_data/model/attributable.rb

@@ -1,61 +1,44 @@
-require 'active_data/model/serializable'
-
 module ActiveData
   module Model
     module Attributable
-      include Serializable
       extend ActiveSupport::Concern
 
       included do
         class_attribute :_attributes, :instance_reader => false, :instance_writer => false
         self._attributes = ActiveSupport::HashWithIndifferentAccess.new
 
+        extend generated_class_attributes_methods
+        include generated_instance_attributes_methods
+
         delegate :attribute_default, :to => 'self.class'
       end
 
       module ClassMethods
-        def attribute name, options = {}, &block
-          default = options.is_a?(Hash) ? options[:default] : options
-          type = options.is_a?(Hash) ? normalize_type(options[:type]) : String
-          self._attributes = self._attributes.merge(name => {
-            default: (block || default),
-            type: type
-          })
-
-          define_method name do
-            read_attribute(name)
-          end
-          define_method "#{name}_before_type_cast" do
-            read_attribute_before_type_cast(name)
-          end
-          define_method "#{name}?" do
-            read_attribute(name).present?
-          end
-          define_method "#{name}=" do |value|
-            write_attribute(name, value)
+        def build_attribute name, options = {}, &block
+          klass = case options[:type].to_s
+          when 'Localized'
+            ActiveData::Attributes::Localized
+          else
+            ActiveData::Attributes::Base
           end
+          klass.new name, options, &block
+        end
 
-          if options.is_a?(Hash) && options[:in]
-            define_singleton_method "#{name}_values" do
-              options[:in].dup
-            end
-          end
+        def attribute name, options = {}, &block
+          attribute = build_attribute(name, options, &block)
+          self._attributes = _attributes.merge(attribute.name => attribute)
+
+          attribute.generate_instance_methods generated_instance_attributes_methods
+          attribute.generate_singleton_methods generated_class_attributes_methods
+          attribute
         end
 
-        def normalize_type type
-          case type
-          when String, Symbol then
-            type.to_s.camelize.safe_constantize
-          when nil then
-            String
-          else
-            type
-          end
+        def generated_class_attributes_methods
+          @generated_class_attributes_methods ||= Module.new
         end
 
-        def attribute_default name
-          default = _attributes[name][:default]
-          default.respond_to?(:call) ? default.call : default
+        def generated_instance_attributes_methods
+          @generated_instance_attributes_methods ||= Module.new
         end
 
         def initialize_attributes
@@ -67,17 +50,22 @@ module ActiveData
       end
 
       def read_attribute name
-        @attributes[name].nil? ? attribute_default(name) : @attributes[name]
+        attribute = self.class._attributes[name]
+        source = @attributes[name].nil? ? attribute.default_value(self) : @attributes[name]
+        attribute.type_cast source
       end
       alias_method :[], :read_attribute
 
+      def has_attribute? name
+        @attributes.key? name
+      end
+
       def read_attribute_before_type_cast name
-        deserialize(send(name))
+        @attributes[name]
       end
 
       def write_attribute name, value
-        type = self.class._attributes[name][:type]
-        @attributes[name] = serialize(value, type)
+        @attributes[name] = value
       end
       alias_method :[]=, :write_attribute
 
@@ -104,6 +92,10 @@ module ActiveData
         self.attributes = attributes
       end
 
+      def reverse_update_attributes attributes
+        reverse_assign_attributes(attributes)
+      end
+
     private
 
       def assign_attributes attributes
@@ -113,6 +105,13 @@ module ActiveData
         self.attributes
       end
 
+      def reverse_assign_attributes attributes
+        (attributes.presence || {}).each do |(name, value)|
+          send("#{name}=", value) if respond_to?("#{name}=") && respond_to?(name) && send(name).blank?
+        end
+        self.attributes
+      end
+
     end
   end
 end

data/lib/active_data/model/collectionizable/proxy.rb

@@ -32,7 +32,7 @@ module ActiveData
         end
 
         module ClassMethods
-          def modelize value
+          def active_data_type_cast value
             new value
           end
         end

data/lib/active_data/model/collectionizable.rb

@@ -6,13 +6,12 @@ module ActiveData
       extend ActiveSupport::Concern
 
       included do
-        collectionize
+        collectionize Array
       end
 
       module ClassMethods
 
         def collectionize collection_superclass = nil
-          collection_superclass ||= Array
           collection = Class.new(collection_superclass) do
             include ActiveData::Model::Collectionizable::Proxy
           end

data/lib/active_data/model/extensions/array.rb

@@ -4,12 +4,8 @@ module ActiveData
       module Array
         extend ActiveSupport::Concern
 
-        def demodelize
-          join(', ')
-        end
-
         module ClassMethods
-          def modelize value
+          def active_data_type_cast value
             case value
             when String then
               value.split(',').map(&:strip)

data/lib/active_data/model/extensions/big_decimal.rb

@@ -0,0 +1,17 @@
+module ActiveData
+  module Model
+    module Extensions
+      module BigDecimal
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def active_data_type_cast value
+            ::BigDecimal.new value.to_s if value.to_s =~ /\A\d+(?:\.\d*)?\Z/
+          end
+        end
+      end
+    end
+  end
+end
+
+BigDecimal.send :include, ActiveData::Model::Extensions::BigDecimal

data/lib/active_data/model/extensions/boolean.rb

@@ -5,21 +5,29 @@ module ActiveData
         extend ActiveSupport::Concern
 
         MAPPING = {
-          "1" => true,
-          "0" => false,
-          "t" => true,
-          "f" => false,
-          "T" => true,
-          "F" => false,
-          "true" => true,
-          "false" => false,
-          "TRUE" => true,
-          "FALSE" => false
+          1 => true,
+          0 => false,
+          '1' => true,
+          '0' => false,
+          't' => true,
+          'f' => false,
+          'T' => true,
+          'F' => false,
+          true => true,
+          false => false,
+          'true' => true,
+          'false' => false,
+          'TRUE' => true,
+          'FALSE' => false,
+          'y' => true,
+          'n' => false,
+          'yes' => true,
+          'no' => false,
         }
 
         module ClassMethods
-          def modelize value
-            MAPPING[value.to_s]
+          def active_data_type_cast value
+            MAPPING[value]
           end
         end
       end

data/lib/active_data/model/extensions/date.rb

@@ -5,7 +5,7 @@ module ActiveData
         extend ActiveSupport::Concern
 
         module ClassMethods
-          def modelize value
+          def active_data_type_cast value
             case value
             when String then
               Date.parse(value.to_s) rescue nil

data/lib/active_data/model/extensions/float.rb

@@ -0,0 +1,17 @@
+module ActiveData
+  module Model
+    module Extensions
+      module Float
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def active_data_type_cast value
+            value.try(:to_f) if value.to_s =~ /\A\d+(?:\.\d*)?\Z/
+          end
+        end
+      end
+    end
+  end
+end
+
+Float.send :include, ActiveData::Model::Extensions::Float

data/lib/active_data/model/extensions/hash.rb

@@ -4,12 +4,8 @@ module ActiveData
       module Hash
         extend ActiveSupport::Concern
 
-        def demodelize
-          nil
-        end
-
         module ClassMethods
-          def modelize value
+          def active_data_type_cast value
             case value
             when Hash then
               value

data/lib/active_data/model/extensions/integer.rb

@@ -5,8 +5,8 @@ module ActiveData
         extend ActiveSupport::Concern
 
         module ClassMethods
-          def modelize value
-            value.try(:to_i) if value.to_s =~ /\A\d+\Z/
+          def active_data_type_cast value
+            value.try(:to_i) if value.to_s =~ /\A\d+(?:\.\d*)?\Z/
           end
         end
       end

data/lib/active_data/model/extensions/localized.rb

@@ -0,0 +1,22 @@
+module ActiveData
+  module Model
+    module Extensions
+      module Localized
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def active_data_type_cast value
+            case value
+            when Hash then
+              value.stringify_keys!
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Localized.send :include, ActiveData::Model::Extensions::Localized

data/lib/active_data/model/extensions/string.rb

@@ -5,7 +5,7 @@ module ActiveData
         extend ActiveSupport::Concern
 
         module ClassMethods
-          def modelize value
+          def active_data_type_cast value
             value.to_s if value.present?
           end
         end

data/lib/active_data/model/extensions.rb

@@ -2,4 +2,8 @@ unless defined?(Boolean)
   class Boolean; end
 end
 
+unless defined?(Localized)
+  class Localized; end
+end
+
 Dir["#{File.dirname(__FILE__)}/extensions/*.rb"].each { |f| require f }

data/lib/active_data/model/localizable.rb

@@ -0,0 +1,31 @@
+module ActiveData
+  module Model
+    module Localizable
+      extend ActiveSupport::Concern
+
+      included do
+      end
+
+      module ClassMethods
+        def fallbacks locale
+          ::I18n.respond_to?(:fallbacks) ? ::I18n.fallbacks[locale] : [locale]
+        end
+
+        def locale
+          I18n.locale
+        end
+      end
+
+      def read_localized_attribute name, locale = self.class.locale
+        translations = read_attribute(name)
+        translations[self.class.fallbacks(locale).detect { |fallback| translations[fallback.to_s] }]
+      end
+      alias_method :read_localized_attribute_before_type_cast, :read_localized_attribute
+
+      def write_localized_attribute name, value, locale = self.class.locale
+        translations = read_attribute(name)
+        write_attribute(name, translations.merge(locale.to_s => value))
+      end
+    end
+  end
+end

data/lib/active_data/model/nested_attributes.rb

@@ -0,0 +1,52 @@
+module ActiveData
+  module Model
+    module NestedAttributes
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def nested_attributes? association_name
+          method_defined?(:"#{association_name}_attributes=")
+        end
+
+        def accepts_nested_attributes_for *attr_names
+          attr_names.each do |association_name|
+            reflection = reflect_on_association association_name
+            type = (reflection.collection? ? :collection : :one_to_one)
+
+            class_eval <<-EOS, __FILE__, __LINE__ + 1
+              if method_defined?(:#{association_name}_attributes=)
+                remove_method(:#{association_name}_attributes=)
+              end
+              def #{association_name}_attributes=(attributes)
+                assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
+              end
+            EOS
+          end
+        end
+
+      end
+
+      def assign_nested_attributes_for_collection_association(association_name, attributes_collection, assignment_opts = {})
+        unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+          raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+        end
+
+        if attributes_collection.is_a? Hash
+          keys = attributes_collection.keys
+          attributes_collection = if keys.include?('id') || keys.include?(:id)
+            Array.wrap(attributes_collection)
+          else
+            attributes_collection.values
+          end
+        end
+
+        reflection = self.class.reflect_on_association association_name
+
+        send("#{association_name}=", attributes_collection.map do |attributes|
+          reflection.klass.new attributes
+        end)
+      end
+    end
+  end
+end

data/lib/active_data/model/parameterizable.rb

@@ -0,0 +1,29 @@
+module ActiveData
+  module Model
+    module Parameterizable
+      extend ActiveSupport::Concern
+
+      def to_params options = nil
+        hash = serializable_hash options
+
+        self.class.association_names.each do |association_name|
+          if self.class.nested_attributes? association_name
+            records = send(association_name)
+            hash["#{association_name}_attributes"] = if records.is_a?(Enumerable)
+              attributes = {}
+              records.each_with_index do |a, i|
+                key = a.has_attribute?(:id) && a.id? ? a.id : i
+                attributes[key.to_s] = a.serializable_hash
+              end
+              attributes
+            else
+              records.serializable_hash
+            end
+          end
+        end
+
+        hash
+      end
+    end
+  end
+end

data/lib/active_data/model.rb

@@ -1,9 +1,18 @@
+require 'active_data/model/extensions'
 require 'active_data/model/collectionizable'
 require 'active_data/model/attributable'
-require 'active_data/model/extensions'
+require 'active_data/model/localizable'
+require 'active_data/model/associations'
+require 'active_data/model/nested_attributes'
+require 'active_data/model/parameterizable'
+
+require 'active_data/attributes/base'
+require 'active_data/attributes/localized'
 
 module ActiveData
   module Model
+    class NotFound < ::StandardError
+    end
 
     extend ActiveSupport::Concern
 
@@ -17,7 +26,11 @@ module ActiveData
       include ActiveModel::Serializers::Xml
 
       include Attributable
+      include Localizable
       include Collectionizable
+      include Associations
+      include NestedAttributes
+      include Parameterizable
       extend ActiveModel::Callbacks
       extend ActiveModel::Naming
       extend ActiveModel::Translation
@@ -36,8 +49,7 @@ module ActiveData
     end
 
     module ClassMethods
-      def instantiate attributes = nil
-        attributes ||= {}
+      def instantiate attributes
         return attributes if attributes.instance_of? self
 
         instance = allocate
@@ -67,4 +79,4 @@ module ActiveData
     end
 
   end
-end
+end

data/lib/active_data/version.rb

@@ -1,3 +1,3 @@
 module ActiveData
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/lib/active_data/model/associations_spec.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations do
+
+  class Assoc
+    include ActiveData::Model
+
+    attribute :name
+  end
+
+  let(:klass) do
+    Class.new do
+      include ActiveData::Model
+
+      attribute :name
+      embeds_many :assocs
+    end
+  end
+
+  let(:instance){klass.new(:name => 'world')}
+
+  context do
+    specify { instance.assocs.should be_empty }
+    specify { instance.assocs.should be_instance_of Assoc::Collection }
+    specify { instance.assocs.count.should == 0 }
+  end
+
+  context 'accessor' do
+    before { instance.assocs = [Assoc.new(:name => 'foo'), Assoc.new(:name => 'bar')] }
+    specify { instance.assocs.count.should == 2 }
+    specify { instance.assocs[0].name.should == 'foo' }
+    specify { instance.assocs[1].name.should == 'bar' }
+  end
+end

data/spec/lib/active_data/model/attributable_spec.rb

@@ -9,8 +9,9 @@ describe ActiveData::Model::Attributable do
       attr_reader :name
 
       attribute :hello
-      attribute :count, type: :integer, default: 10
-      attribute(:calc, type: :integer) {2 + 3}
+      attribute :count, type: Integer, default: 10
+      attribute(:calc, type: Integer) { 2 + 3 }
+      attribute :enum, type: Integer, in: [1, 2, 3]
 
       def initialize name = nil
         @attributes = self.class.initialize_attributes
@@ -20,16 +21,17 @@ describe ActiveData::Model::Attributable do
   end
 
   context do
-    subject{klass.new('world')}
-    its(:attributes){should == {"hello"=>nil, "count"=>10, "calc"=>5}}
-    its(:present_attributes){should == {"count"=>10, "calc"=>5}}
-    its(:name){should == 'world'}
-    its(:hello){should be_nil}
-    its(:count){should == 10}
-    its(:calc){should == 5}
-    specify{expect{subject.hello = 'worlds'}.to change{subject.hello}.from(nil).to('worlds')}
-    specify{expect{subject.count = 20}.to change{subject.count}.from(10).to(20)}
-    specify{expect{subject.calc = 15}.to change{subject.calc}.from(5).to(15)}
+    subject { klass.new('world') }
+    specify { klass.enum_values == [1, 2, 3] }
+    its(:attributes) { should ==  { "hello"=>nil, "count"=>10, "calc"=>5, "enum" => nil }  }
+    its(:present_attributes) { should ==  { "count"=>10, "calc"=>5 }  }
+    its(:name) { should == 'world' }
+    its(:hello) { should be_nil }
+    its(:count) { should == 10 }
+    its(:calc) { should == 5 }
+    specify { expect { subject.hello = 'worlds' } .to change { subject.hello } .from(nil).to('worlds') }
+    specify { expect { subject.count = 20 } .to change { subject.count } .from(10).to(20) }
+    specify { expect { subject.calc = 15 } .to change { subject.calc } .from(5).to(15) }
   end
 
-end
+end

data/spec/lib/active_data/model/attributes/localized_spec.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Localized do
+  let(:klass) do
+    Class.new do
+      include ActiveData::Model
+
+      attribute :name, type: Localized
+    end
+  end
+  let(:translations) { { en: 'Hello', ru: 'Привет' } }
+  before { I18n.locale = :en }
+
+  describe '#name_translations' do
+    subject { klass.new name_translations: translations }
+    its(:name_translations) { should == translations.stringify_keys }
+    its(:name) { should == translations[:en] }
+  end
+
+  describe '#name' do
+    subject { klass.new name: 'Hello' }
+    its(:name_translations) { should == { 'en' => 'Hello' } }
+    its(:name) { should == 'Hello' }
+  end
+
+  describe '#name_before_type_cast' do
+    let(:object) { Object.new }
+    subject { klass.new name: object }
+    its(:name_before_type_cast) { should == object }
+  end
+
+  context 'fallbacks' do
+    subject { klass.new name_translations: { ru: 'Привет' } }
+    context do
+      its(:name) { should be_nil }
+    end
+
+    context do
+      before do
+        require "i18n/backend/fallbacks"
+        I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+        I18n.fallbacks.map(en: :ru)
+      end
+      its(:name) { should == 'Привет' }
+    end
+  end
+end

data/spec/lib/active_data/model/nested_attributes_spec.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations do
+
+  class Assoc
+    include ActiveData::Model
+
+    attribute :name
+  end
+
+  let(:klass) do
+    Class.new do
+      include ActiveData::Model
+
+      attribute :name
+      embeds_many :assocs
+
+      accepts_nested_attributes_for :assocs
+    end
+  end
+
+  let(:instance){klass.new(:name => 'world')}
+
+  context do
+    before { instance.assocs_attributes = [{:name => 'foo'}, {:name => 'bar'}] }
+    specify { instance.assocs.count.should == 2 }
+    specify { instance.assocs.first.name.should == 'foo' }
+    specify { instance.assocs.last.name.should == 'bar' }
+  end
+
+  context do
+    before { instance.assocs_attributes = {1 => {:name => 'baz'}, 2 => {:name => 'foo'}} }
+    specify { instance.assocs.count.should == 2 }
+    specify { instance.assocs.first.name.should == 'baz' }
+    specify { instance.assocs.last.name.should == 'foo' }
+  end
+
+  context do
+    before { instance.assocs_attributes = {1 => {:name => 'baz'}, 2 => {:name => 'foo'}} }
+    specify { instance.to_params.should == {
+      "name" => "world",
+      "assocs_attributes" => {'0' => {"name" => "baz"}, '1' => {"name" => "foo"}}
+    } }
+  end
+end

data/spec/lib/active_data/model/{serializable_spec.rb → type_cast_spec.rb}

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 require 'spec_helper'
 
-describe ActiveData::Model::Serializable do
+describe 'typecasting' do
 
   let(:klass) do
     Class.new do
@@ -10,6 +10,8 @@ describe ActiveData::Model::Serializable do
 
       attribute :string, type: String
       attribute :integer, type: Integer
+      attribute :float, type: Float
+      attribute :big_decimal, type: BigDecimal
       attribute :boolean, type: Boolean
       attribute :array, type: Array
 
@@ -32,11 +34,37 @@ describe ActiveData::Model::Serializable do
     specify{subject.tap{|s| s.integer = 'hello'}.integer.should == nil}
     specify{subject.tap{|s| s.integer = '123hello'}.integer.should == nil}
     specify{subject.tap{|s| s.integer = '123'}.integer.should == 123}
+    specify{subject.tap{|s| s.integer = '123.5'}.integer.should == 123}
     specify{subject.tap{|s| s.integer = 123}.integer.should == 123}
+    specify{subject.tap{|s| s.integer = 123.5}.integer.should == 123}
     specify{subject.tap{|s| s.integer = nil}.integer.should == nil}
     specify{subject.tap{|s| s.integer = [123]}.integer.should == nil}
   end
 
+  context 'float' do
+    specify{subject.tap{|s| s.float = 'hello'}.float.should == nil}
+    specify{subject.tap{|s| s.float = '123hello'}.float.should == nil}
+    specify{subject.tap{|s| s.float = '123'}.float.should == 123.0}
+    specify{subject.tap{|s| s.float = '123.'}.float.should == 123.0}
+    specify{subject.tap{|s| s.float = '123.5'}.float.should == 123.5}
+    specify{subject.tap{|s| s.float = 123}.float.should == 123.0}
+    specify{subject.tap{|s| s.float = 123.5}.float.should == 123.5}
+    specify{subject.tap{|s| s.float = nil}.float.should == nil}
+    specify{subject.tap{|s| s.float = [123.5]}.float.should == nil}
+  end
+
+  context 'big_decimal' do
+    specify{subject.tap{|s| s.big_decimal = 'hello'}.big_decimal.should == nil}
+    specify{subject.tap{|s| s.big_decimal = '123hello'}.big_decimal.should == nil}
+    specify{subject.tap{|s| s.big_decimal = '123'}.big_decimal.should == BigDecimal.new('123.0')}
+    specify{subject.tap{|s| s.big_decimal = '123.'}.big_decimal.should == BigDecimal.new('123.0')}
+    specify{subject.tap{|s| s.big_decimal = '123.5'}.big_decimal.should == BigDecimal.new('123.5')}
+    specify{subject.tap{|s| s.big_decimal = 123}.big_decimal.should == BigDecimal.new('123.0')}
+    specify{subject.tap{|s| s.big_decimal = 123.5}.big_decimal.should == BigDecimal.new('123.5')}
+    specify{subject.tap{|s| s.big_decimal = nil}.big_decimal.should == nil}
+    specify{subject.tap{|s| s.big_decimal = [123.5]}.big_decimal.should == nil}
+  end
+
   context 'boolean' do
     specify{subject.tap{|s| s.boolean = 'hello'}.boolean.should == nil}
     specify{subject.tap{|s| s.boolean = 'true'}.boolean.should == true}

data/spec/lib/active_data/model_spec.rb

@@ -14,10 +14,10 @@ describe ActiveData::Model do
 
   specify{model.i18n_scope.should == :active_data}
   specify{model.new.should_not be_persisted}
-  specify{model.instantiate.should be_an_instance_of model}
-  specify{model.instantiate.should be_persisted}
+  specify{model.instantiate({}).should be_an_instance_of model}
+  specify{model.instantiate({}).should be_persisted}
 
   context 'Fault tolerance' do
-    specify{expect{model.new(:foo => 'bar')}.not_to raise_error}
+    specify{ expect { model.new(:foo => 'bar') }.not_to raise_error }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_data
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-21 00:00:00.000000000 Z
+date: 2012-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -93,22 +93,34 @@ files:
 - Rakefile
 - active_data.gemspec
 - lib/active_data.rb
+- lib/active_data/attributes/base.rb
+- lib/active_data/attributes/localized.rb
 - lib/active_data/model.rb
+- lib/active_data/model/associations.rb
+- lib/active_data/model/associations/many.rb
 - lib/active_data/model/attributable.rb
 - lib/active_data/model/collectionizable.rb
 - lib/active_data/model/collectionizable/proxy.rb
 - lib/active_data/model/extensions.rb
 - lib/active_data/model/extensions/array.rb
+- lib/active_data/model/extensions/big_decimal.rb
 - lib/active_data/model/extensions/boolean.rb
 - lib/active_data/model/extensions/date.rb
+- lib/active_data/model/extensions/float.rb
 - lib/active_data/model/extensions/hash.rb
 - lib/active_data/model/extensions/integer.rb
+- lib/active_data/model/extensions/localized.rb
 - lib/active_data/model/extensions/string.rb
-- lib/active_data/model/serializable.rb
+- lib/active_data/model/localizable.rb
+- lib/active_data/model/nested_attributes.rb
+- lib/active_data/model/parameterizable.rb
 - lib/active_data/version.rb
+- spec/lib/active_data/model/associations_spec.rb
 - spec/lib/active_data/model/attributable_spec.rb
+- spec/lib/active_data/model/attributes/localized_spec.rb
 - spec/lib/active_data/model/collectionizable_spec.rb
-- spec/lib/active_data/model/serializable_spec.rb
+- spec/lib/active_data/model/nested_attributes_spec.rb
+- spec/lib/active_data/model/type_cast_spec.rb
 - spec/lib/active_data/model_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -123,12 +135,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 3544919037103939136
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 3544919037103939136
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -136,8 +154,11 @@ signing_key:
 specification_version: 3
 summary: Working with hashes in AR style
 test_files:
+- spec/lib/active_data/model/associations_spec.rb
 - spec/lib/active_data/model/attributable_spec.rb
+- spec/lib/active_data/model/attributes/localized_spec.rb
 - spec/lib/active_data/model/collectionizable_spec.rb
-- spec/lib/active_data/model/serializable_spec.rb
+- spec/lib/active_data/model/nested_attributes_spec.rb
+- spec/lib/active_data/model/type_cast_spec.rb
 - spec/lib/active_data/model_spec.rb
 - spec/spec_helper.rb

data/lib/active_data/model/serializable.rb

@@ -1,18 +0,0 @@
-module ActiveData
-  module Model
-    module Serializable
-
-      class UnknownAttribute < ::StandardError
-      end
-
-      def serialize value, type
-        type.modelize(value)
-      end
-
-      def deserialize value
-        value.respond_to? :demodelize ? value.demodelize : value.to_s
-      end
-
-    end
-  end
-end