active_type 0.1.3 → 0.2.0

data/lib/active_type/nested_attributes/nests_many_association.rb

@@ -0,0 +1,71 @@
+require 'active_type/nested_attributes/association'
+
+module ActiveType
+
+  module NestedAttributes
+
+    class NestsManyAssociation < Association
+
+      def assign_attributes(parent, attributes_collection)
+        return if attributes_collection.nil?
+
+        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
+
+        new_records = []
+
+        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.sort_by { |i, _| i.to_i }.map { |_, attributes| attributes }
+          end
+        end
+
+        attributes_collection.each do |attributes|
+          attributes = attributes.with_indifferent_access
+          next if reject?(parent, attributes)
+
+          destroy = truthy?(attributes.delete(:_destroy)) && @allow_destroy
+
+          if id = attributes.delete(:id)
+            child = fetch_child(parent, id.to_i)
+            if destroy
+              child.mark_for_destruction
+            else
+              child.attributes = attributes
+            end
+          elsif !destroy
+            new_records << build_child(parent, attributes)
+          end
+        end
+
+        add_children(parent, new_records)
+      end
+
+
+      private
+
+      def add_child(parent, child)
+        add_children(parent, [child])
+      end
+
+      def add_children(parent, children)
+        parent[@target_name] = assigned_children(parent) + children
+      end
+
+      def assign_children(parent, children)
+        parent[@target_name] = children
+      end
+
+      def derive_class_name
+        @target_name.to_s.classify
+      end
+
+    end
+
+  end
+
+end

data/lib/active_type/nested_attributes/nests_one_association.rb

@@ -0,0 +1,56 @@
+require 'active_type/nested_attributes/association'
+
+module ActiveType
+
+  module NestedAttributes
+
+    class AssignmentError < StandardError; end
+
+    class NestsOneAssociation < Association
+
+      def assign_attributes(parent, attributes)
+        return if attributes.nil?
+        attributes = attributes.with_indifferent_access
+        return if reject?(parent, attributes)
+
+        assigned_child = assigned_children(parent).first
+        destroy = truthy?(attributes.delete(:_destroy)) && @allow_destroy
+
+        if id = attributes.delete(:id)
+          assigned_child ||= fetch_child(parent, id.to_i)
+          if assigned_child
+            if assigned_child.id == id.to_i
+              assigned_child.attributes = attributes
+            else
+              raise AssignmentError, "child record '#{@target_name}' did not match id '#{id}'"
+            end
+            if destroy
+              assigned_child.mark_for_destruction
+            end
+          end
+        elsif !destroy
+          assigned_child ||= add_child(parent, build_child(parent, {}))
+          assigned_child.attributes = attributes
+        end
+      end
+
+
+      private
+
+      def add_child(parent, child)
+        parent[@target_name] = child
+      end
+
+      def assign_children(parent, children)
+        parent[@target_name] = children.first
+      end
+
+      def derive_class_name
+        @target_name.to_s.camelize
+      end
+
+    end
+
+  end
+
+end

data/lib/active_type/nested_attributes.rb

@@ -0,0 +1,39 @@
+require 'active_type/nested_attributes/builder'
+
+module ActiveType
+
+  module NestedAttributes
+
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :_nested_attribute_scopes
+    end
+
+    module ClassMethods
+
+      def nests_one(association_name, options = {})
+        Builder.new(self, generated_nested_attribute_methods).build(association_name, :one, options)
+      end
+
+      def nests_many(association_name, options = {})
+        Builder.new(self, generated_nested_attribute_methods).build(association_name, :many, options)
+      end
+
+
+      private
+
+      def generated_nested_attribute_methods
+        @generated_nested_attribute_methods ||= begin
+          mod = Module.new
+          include mod
+          mod
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/active_type/no_table.rb

@@ -39,29 +39,42 @@ module ActiveType
       yield
     end
 
-    def create(*)
-      true
+    def destroy
+      @destroyed = true
+      freeze
     end
 
-    def create_record(*)
-      true
+    def reload
+      self
     end
 
-    def update(*)
+
+    private
+
+    def create(*)
       true
     end
 
-    def update_record(*)
+    def update(*)
       true
     end
 
-    def destroy
-      @destroyed = true
-      freeze
-    end
+    if ActiveRecord::Base.private_method_defined?(:create_record)
+      def create_record(*)
+        true
+      end
 
-    def reload
-      self
+      def update_record(*)
+        true
+      end
+    else
+      def _create_record(*)
+        true
+      end
+
+      def _update_record(*)
+        true
+      end
     end
 
   end

data/lib/active_type/object.rb

@@ -1,5 +1,6 @@
 require 'active_type/no_table'
 require 'active_type/virtual_attributes'
+require 'active_type/nested_attributes'
 
 module ActiveType
 
@@ -7,6 +8,7 @@ module ActiveType
 
     include NoTable
     include VirtualAttributes
+    include NestedAttributes
 
   end
 

data/lib/active_type/record.rb

@@ -1,5 +1,6 @@
 require 'active_type/virtual_attributes'
 require 'active_type/extended_record'
+require 'active_type/nested_attributes'
 
 module ActiveType
 
@@ -8,6 +9,7 @@ module ActiveType
     @abstract_class = true
 
     include VirtualAttributes
+    include NestedAttributes
     include ExtendedRecord
 
   end

data/lib/active_type/version.rb

@@ -1,3 +1,3 @@
 module ActiveType
-  VERSION = '0.1.3'
+  VERSION = '0.2.0'
 end

data/lib/active_type/virtual_attributes.rb

@@ -1,15 +1,17 @@
 module ActiveType
 
-  class InvalidAttributeNameError < StandardError; end
-  class MissingAttributeError < StandardError; end
+  class InvalidAttributeNameError < ::StandardError; end
+  class MissingAttributeError < ::StandardError; end
+  class ArgumentError < ::ArgumentError; end
 
   module VirtualAttributes
 
     class VirtualColumn < ActiveRecord::ConnectionAdapters::Column
 
-      def initialize(name, type)
+      def initialize(name, type, options)
         @name = name
         @type = type
+        @options = options
       end
 
       def type_cast(value)
@@ -43,23 +45,35 @@ module ActiveType
         end
       end
 
+      def default_value(object)
+        default = @options[:default]
+        default.respond_to?(:call) ? object.instance_eval(&default) : default
+      end
+
     end
 
-    class AccessorGenerator
+    class Builder
 
-      def initialize(mod)
+      def initialize(owner, mod)
+        @owner = owner
         @module = mod
       end
 
-      def generate_accessors(name)
+      def build(name, type, options)
         validate_attribute_name!(name)
-        generate_reader(name)
-        generate_writer(name)
+        options.assert_valid_keys(:default)
+        add_virtual_column(name, type, options)
+        build_reader(name)
+        build_writer(name)
       end
 
       private
 
-      def generate_reader(name)
+      def add_virtual_column(name, type, options)
+        @owner.virtual_columns_hash = @owner.virtual_columns_hash.merge(name.to_s => VirtualColumn.new(name, type, options.slice(:default)))
+      end
+
+      def build_reader(name)
         @module.module_eval <<-BODY, __FILE__, __LINE__ + 1
           def #{name}
             read_virtual_attribute('#{name}')
@@ -71,7 +85,7 @@ module ActiveType
         BODY
       end
 
-      def generate_writer(name)
+      def build_writer(name)
         @module.module_eval <<-BODY, __FILE__, __LINE__ + 1
           def #{name}=(value)
             write_virtual_attribute('#{name}', value)
@@ -127,8 +141,14 @@ module ActiveType
 
     def read_virtual_attribute(name)
       name = name.to_s
-      virtual_attributes_cache[name] ||= begin
-        self.singleton_class._virtual_column(name).type_cast(virtual_attributes[name])
+      if virtual_attributes_cache.has_key?(name)
+        virtual_attributes_cache[name]
+      else
+        virtual_attributes_cache[name] = begin
+          virtual_column = self.singleton_class._virtual_column(name)
+          raw_value = virtual_attributes.fetch(name) { virtual_column.default_value(self) }
+          virtual_column.type_cast(raw_value)
+        end
       end
     end
 
@@ -178,9 +198,11 @@ module ActiveType
         end
       end
 
-      def attribute(name, type = nil)
-        self.virtual_columns_hash = virtual_columns_hash.merge(name.to_s => VirtualColumn.new(name, type))
-        AccessorGenerator.new(generated_virtual_attribute_methods).generate_accessors(name)
+      def attribute(name, *args)
+        options = args.extract_options!
+        type = args.first
+
+        Builder.new(self, generated_virtual_attribute_methods).build(name, type, options)
       end
 
     end

data/lib/active_type.rb

@@ -2,5 +2,7 @@
 
 require 'active_type/version'
 
+require 'active_record'
+
 require 'active_type/record'
 require 'active_type/object'

data/spec/active_type/extended_record_spec.rb

@@ -20,6 +20,9 @@ module ExtendedRecordSpec
     attribute :another_virtual_string, :string
   end
 
+  class InheritingFromExtendedRecord < ExtendedRecord
+    attribute :yet_another_virtual_string, :string
+  end
 
   class ExtendedRecordWithValidations < ExtendedActiveTypeRecord
     validates :persisted_string, :presence => true
@@ -38,6 +41,10 @@ describe "ActiveType::Record[ActiveRecord::Base]" do
     subject.should be_a(ExtendedRecordSpec::BaseRecord)
   end
 
+  it 'has the same model name as the base class' do
+    subject.class.model_name.singular.should == ExtendedRecordSpec::BaseRecord.model_name.singular
+  end
+
   describe 'constructors' do
     subject { ExtendedRecordSpec::ExtendedRecord }
 
@@ -92,6 +99,57 @@ describe "ActiveType::Record[ActiveRecord::Base]" do
 
 end
 
+describe "class ... < ActiveType::Record[ActiveRecord::Base]" do
+
+  subject { ExtendedRecordSpec::InheritingFromExtendedRecord.new }
+
+  it 'is inherits from the base type' do
+    subject.should be_a(ExtendedRecordSpec::ExtendedRecord)
+  end
+
+  it 'has the same model name as the base class' do
+    subject.class.model_name.singular.should == ExtendedRecordSpec::BaseRecord.model_name.singular
+  end
+
+  describe '#attributes' do
+
+    it 'returns a hash of virtual and persisted attributes' do
+      subject.persisted_string = "string"
+      subject.another_virtual_string = "string"
+      subject.yet_another_virtual_string = "string"
+
+      subject.attributes.should == {
+        "another_virtual_string" => "string",
+        "yet_another_virtual_string" => "string",
+        "id" => nil,
+        "persisted_string" => "string",
+        "persisted_integer" => nil,
+        "persisted_time" => nil,
+        "persisted_date" => nil,
+        "persisted_boolean" => nil
+      }
+    end
+
+  end
+
+  describe 'persistence' do
+    it 'persists to the database' do
+      subject.persisted_string = "persisted string"
+      subject.save.should be_true
+
+      subject.class.find(subject.id).persisted_string.should == "persisted string"
+    end
+  end
+
+  describe '.find' do
+    it 'returns an instance of the inheriting model' do
+      subject.save
+
+      subject.class.find(subject.id).should be_a(subject.class)
+    end
+  end
+
+end
 
 describe "ActiveType::Record[ActiveType::Record]" do