datamappify 0.60.0 → 0.70.0.beta1

data/lib/datamappify/entity/association/validation.rb

@@ -0,0 +1,59 @@
+module Datamappify
+  module Entity
+    module Association
+      # Passes referenced validation errors onto the main entity
+      module Validation
+        def self.included(klass)
+          klass.class_eval do
+            attr_accessor :referenced_errors
+
+            validate :association_validation
+
+            def referenced_errors
+              @referenced_errors ||= {}
+            end
+          end
+        end
+
+        # @param context [Symbol]
+        #   e.g. :create or :update
+        #
+        # @return [Boolean]
+        def valid?(context = nil)
+          aggregate_validation_errors(context)
+
+          super
+        end
+
+        private
+
+        # @param (see #valid?)
+        #
+        # @return [void]
+        def aggregate_validation_errors(context)
+          self.associations.each do |association|
+            self.send(association).reject(&:destroy?).each do |entity|
+              entity.invalid?(context) && referenced_entity_validation_errors(entity)
+            end
+          end
+        end
+
+        # @param (see #valid?)
+        #
+        # @return [void]
+        def referenced_entity_validation_errors(entity)
+          entity.errors.messages.each do |attr, msgs|
+            self.referenced_errors["#{entity.class.model_name.element}__#{attr}"] = msgs
+          end
+        end
+
+        # @return [void]
+        def association_validation
+          self.referenced_errors.each do |name, msgs|
+            self.errors.add name, msgs.join(', ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/entity/association.rb

@@ -0,0 +1,44 @@
+require 'datamappify/entity/compatibility/association/active_record'
+require 'datamappify/entity/association/reference'
+require 'datamappify/entity/association/validation'
+
+module Datamappify
+  module Entity
+    module Association
+      def self.included(klass)
+        klass.class_eval do
+          cattr_accessor :associations
+          self.associations = []
+
+          include Reference
+          include Validation
+          extend  DSL
+        end
+      end
+
+      module DSL
+        prepend Compatibility::Association::ActiveRecord
+
+        # @param name [Symbol, String]
+        #
+        # @param options [Hash]
+        #
+        # @return [void]
+        def belongs_to(name, options = {})
+          references name
+        end
+
+        # @param name [Symbol, String]
+        #
+        # @param options [Hash]
+        #
+        # @return [void]
+        def has_many(name, options = {})
+          attribute name, Array[options[:via]]
+
+          self.associations << name
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/entity/{active_model/compatibility.rb → compatibility/active_model.rb}

@@ -1,8 +1,8 @@
 module Datamappify
   module Entity
-    module ActiveModel
+    module Compatibility
       # Add non-entity related stuff so that an entity can be used in say, forms
-      module Compatibility
+      module ActiveModel
         # @return [Boolean]
         def persisted?
           !id.blank?

data/lib/datamappify/entity/compatibility/active_record.rb

@@ -0,0 +1,22 @@
+module Datamappify
+  module Entity
+    module Compatibility
+      # Add non-entity related stuff so that an entity can be used in say, forms
+      module ActiveRecord
+        # @return [Array<Symbol>]
+        IGNORED_ATTRIBUTE_NAMES = [:_destroy]
+
+        def self.included(klass)
+          klass.class_eval do
+            attribute :_destroy, Virtus::Attribute::Boolean, :default => false
+          end
+        end
+
+        # @return [Boolean]
+        def destroy?
+          !!_destroy
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/entity/compatibility/association/active_record.rb

@@ -0,0 +1,43 @@
+module Datamappify
+  module Entity
+    module Compatibility
+      module Association
+        # Compatibility layer for ActionRecord
+        module ActiveRecord
+          # Adds `association_name_attributes` as required by
+          # nested attributes assignment
+          #
+          # @param (see DSL#has_many)
+          def has_many(name, options = {})
+            super
+
+            self.class_eval <<-CODE, __FILE__, __LINE__ + 1
+              def #{name}_attributes=(params = {})
+                new_entites = params.map do |index, attributes|
+                  attributes.delete('id') if attributes['id'].blank?
+                  #{options[:via]}.new(attributes)
+                end
+
+                # resets the association attribute if nil,
+                # this will reset it back to an empty array
+                self.#{name} ||= nil
+
+                self.#{name} = self.#{name}.map do |entity|
+                  new_entites.detect { |e| e.id == entity.id } || entity
+                end
+
+                new_entites.each do |entity|
+                  entity_is_already_added = entity.id && self.#{name}.map(&:id).include?(entity.id)
+
+                  unless entity_is_already_added
+                    self.#{name} << entity
+                  end
+                end
+              end
+            CODE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/entity/composable/attributes.rb

@@ -17,35 +17,27 @@ module Datamappify
           def build_attributes
             @entity_class.attribute_set.each do |attribute|
               unless excluded_attributes.include?(attribute.name)
-                @entity.attribute_set << build_attribute(attribute.name, attribute.writer)
+                @entity.attribute_set << build_attribute(attribute)
               end
             end
           end
 
           # @return [Array]
           def excluded_attributes
-            @excluded_attributes ||= @entity_class.reference_keys << :id
+            @excluded_attributes ||= @entity_class.reference_keys + [:id, *@entity_class::IGNORED_ATTRIBUTE_NAMES]
           end
 
-          # @param attribute_name [Symbol]
-          #
-          # @param attribute_writer [Virtus::Attribute::Writer]
+          # @param attribute [Virtus::Attribute]
           #
           # @return [Virtus::Attribute]
-          def build_attribute(attribute_name, attribute_writer)
-            name = if @options[:prefix_with]
-              Attribute.prefix(attribute_name, @options[:prefix_with])
+          def build_attribute(attribute)
+            attribute_name = if @options[:prefix_with]
+              Attribute.prefix(attribute.name, @options[:prefix_with])
             else
-              attribute_name
+              attribute.name
             end
 
-            Virtus::Attribute.build(
-              name,
-              attribute_writer.primitive,
-              :default    => attribute_writer.default_value,
-              :visibility => attribute_writer.visibility,
-              :coercer    => attribute_writer.coercer
-            )
+            Virtus::Attribute.build(attribute.type, attribute.options.merge(:name => attribute_name))
           end
         end
       end

data/lib/datamappify/entity.rb

@@ -1,9 +1,10 @@
 require 'observer'
 require 'virtus'
-require 'datamappify/entity/active_model/compatibility'
+require 'datamappify/entity/compatibility/active_model'
+require 'datamappify/entity/compatibility/active_record'
 require 'datamappify/entity/lazy_checking'
 require 'datamappify/entity/composable'
-require 'datamappify/entity/relation'
+require 'datamappify/entity/association'
 require 'datamappify/entity/inspectable'
 
 module Datamappify
@@ -11,13 +12,14 @@ module Datamappify
     def self.included(klass)
       klass.class_eval do
         include Observable
+        include Virtus.model
+        include Equalizer.new(*klass.attribute_set)
         include ::ActiveModel::Model
-        include ActiveModel::Compatibility
-        include Virtus
-        include Virtus::Equalizer.new(inspect)
+        include Compatibility::ActiveModel
+        include Compatibility::ActiveRecord
         include LazyChecking
         include Composable
-        include Relation
+        include Association
         include Inspectable
 
         attribute :id, Integer

data/lib/datamappify/lazy/attributes_handler.rb

@@ -8,7 +8,7 @@ module Datamappify
       # @param entity [Entity]
       def initialize(entity)
         @entity              = entity
-        @uncached_attributes = entity.attributes.keys
+        @uncached_attributes = entity.attributes.keys - entity.class::IGNORED_ATTRIBUTE_NAMES
 
         entity.add_observer(self)
       end

data/lib/datamappify/lazy.rb

@@ -1,5 +1,4 @@
 require 'datamappify/lazy/source_attributes_walker'
-require 'datamappify/lazy/source_attributes_walker'
 require 'datamappify/lazy/attributes_handler'
 
 module Datamappify

data/lib/datamappify/repository/mapping_dsl.rb

@@ -43,6 +43,15 @@ module Datamappify
 
         self.current_group_options = {}
       end
+
+      # @param name [Symbol, String]
+      #
+      # @param options [Hash]
+      #
+      # @return [void]
+      def references(name, options = {})
+        data_mapper.references[name.to_sym] = options
+      end
     end
   end
 end

data/lib/datamappify/repository/query_method/criteria.rb

@@ -0,0 +1,21 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      class Criteria < Method
+        # @return [Array<Entity>]
+        def perform
+          results = dispatch_criteria_to_default_source(
+            :Criteria, data_mapper.entity_class, criteria, data_mapper.attributes
+          )
+
+          MultiResultBlender.new(self).blend(results)
+        end
+
+        # @see Method#reader?
+        def reader?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/destroy.rb

@@ -4,7 +4,7 @@ module Datamappify
       class Destroy < Method
         # @return [void, false]
         def perform
-          dispatch_criteria_to_default_source(:Destroy, @entity.id)
+          dispatch_criteria_to_default_source(:Destroy, entity.id)
         end
 
         # @see Method#writer?

data/lib/datamappify/repository/query_method/exists.rb

@@ -4,7 +4,7 @@ module Datamappify
       class Exists < Method
         # @return [Boolean]
         def perform
-          dispatch_criteria_to_default_source(:Exists, @entity)
+          dispatch_criteria_to_default_source(:Exists, entity)
         end
 
         # @see Method#reader?

data/lib/datamappify/repository/query_method/find.rb

@@ -2,18 +2,10 @@ module Datamappify
   module Repository
     module QueryMethod
       class Find < Method
-        # @param options (see Method#initialize)
-        #
-        # @param id [Integer]
-        def initialize(options, id)
-          super
-          @id = id
-        end
-
         # @return [Entity, nil]
         def perform
           entity = data_mapper.entity_class.new
-          entity.id = @id
+          entity.id = criteria
 
           if dispatch_criteria_to_default_source(:Exists, entity)
             dispatch_criteria_to_providers(:FindByKey, entity)

data/lib/datamappify/repository/query_method/method/multi_result_blender.rb

@@ -0,0 +1,24 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      class Method
+        class MultiResultBlender
+          # @param method_instance [Method]
+          def initialize(method_instance)
+            @method = method_instance
+          end
+
+          # @param results [Array<Entity>]
+          #
+          # @return [Array<Entity>]
+          def blend(results)
+            results.each do |entity|
+              @method.states.find(entity)
+              @method.walk_references(:Find, entity)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/method/reference_handler.rb

@@ -0,0 +1,60 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      class Method
+        class ReferenceHandler
+          def initialize(options = {})
+            @entity         = options[:entity]
+            @criteria_name  = options[:criteria_name]
+            @reference_name = options[:reference_name]
+            @repository     = options[:reference_options][:via]
+            @query_method   = options[:query_method]
+          end
+
+          # @return [void]
+          def execute
+            perform_read  if @query_method.reader?
+            perform_write if @query_method.writer?
+          end
+
+          private
+
+          # @return [void]
+          def perform_read
+            @entity.send("#{@reference_name}=", fetch_referenced_entities)
+          end
+
+          # @return [void]
+          def perform_write
+            referenced_entities.each do |entity|
+              if entity.destroy?
+                if entity.persisted?
+                  @repository.destroy!(entity)
+                end
+              else
+                entity.send("#{reference_key}=", @entity.id)
+                @repository.states.mark_as_dirty(entity)
+                @repository.save!(entity)
+              end
+            end
+          end
+
+          # @return [Array]
+          def fetch_referenced_entities
+            @repository.where(reference_key => @entity.id)
+          end
+
+          # @return [Array]
+          def referenced_entities
+            @entity.send(@reference_name)
+          end
+
+          # @return (see Data::Mapper::Attribute#reference_key)
+          def reference_key
+            @query_method.data_mapper.attributes.first.reference_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/method/source_attributes_walker.rb

@@ -27,16 +27,31 @@ module Datamappify
           #
           # @return [void]
           def execute(&block)
-            @attributes.classify(&:source_class).each do |source_class, attributes|
-              if do_walk?(source_class, attributes)
-                block.call(@provider_name, source_class, attributes)
-                walk_performed(attributes)
+            if @query_method && @query_method.writer?
+              @attributes.classify(&:source_class).each do |source_class, attributes|
+                perform_walk(source_class, attributes, &block)
               end
+            else
+              perform_walk(@attributes.first.source_class, @attributes, &block)
             end
           end
 
           private
 
+          # @param source_class [Class]
+          #
+          # @param attributes [Set<Data::Mapper::Attribute>]
+          #
+          # @yield (see #execute)
+          #
+          # @return [void]
+          def perform_walk(source_class, attributes, &block)
+            if do_walk?(source_class, attributes)
+              block.call(@provider_name, source_class, attributes)
+              walk_performed(attributes)
+            end
+          end
+
           # Whether it is necessary to do the walk
           #
           # @param source_class [Class]

data/lib/datamappify/repository/query_method/method.rb

@@ -11,17 +11,24 @@ module Datamappify
         # @return [UnitOfWork::PersistentStates]
         attr_reader :states
 
+        # @return [Entity, Hash, nil]
+        attr_reader :entity
+
+        # @return [Entity, Hash, nil]
+        attr_reader :criteria
+
         # @param options [Hash]
         #   a hash containing required items like data_mapper and states
         #
-        # @param entity [Entity]
+        # @param entity_or_criteria [Entity, Hash]
         #
         # @param args [any]
-        def initialize(options, entity = nil, *args)
+        def initialize(options, entity_or_criteria = nil, *args)
           @data_mapper = options[:data_mapper]
           @states      = options[:states]
           @lazy_load   = options[:lazy_load?]
-          @entity      = entity
+
+          @entity = @criteria = entity_or_criteria
         end
 
         # Should the method be aware of the dirty state?
@@ -52,8 +59,6 @@ module Datamappify
           false
         end
 
-        private
-
         # Dispatches a {Criteria} according to
         # the {Data::Mapper data mapper}'s default provider and default source class
         #
@@ -74,10 +79,28 @@ module Datamappify
         #
         # @return [void]
         def dispatch_criteria_to_providers(criteria_name, entity)
+          UnitOfWork::Transaction.new(data_mapper) do
+            walk_attributes(criteria_name, entity)
+            walk_references(criteria_name, entity)
+          end
+        end
+
+        # Walks through the references and performs actions on them
+        #
+        # @param (see #dispatch_criteria_to_providers)
+        #
+        # @return [void]
+        def walk_attributes(criteria_name, entity)
           _primary_record = nil
 
           attributes_walker(entity) do |provider_name, source_class, attributes|
-            attributes.classify { |attr| attr.options[:via] }.each do |via, attrs|
+            walk_path = if reader?
+              { nil => attributes }
+            else
+              attributes.classify { |attr| attr.options[:via] }
+            end
+
+            walk_path.each do |via, attrs|
               record = data_mapper.provider(provider_name).build_criteria(
                 criteria_name,
                 source_class,
@@ -106,20 +129,38 @@ module Datamappify
         #
         # @see SourceAttributesWalker#execute
         def attributes_walker(entity, &block)
-          UnitOfWork::Transaction.new(data_mapper) do
-            data_mapper.classified_attributes.each do |provider_name, attributes|
-              source_attributes_walker.new({
-                :entity           => entity,
-                :provider_name    => provider_name,
-                :attributes       => attributes,
-                :dirty_aware?     => dirty_aware?,
-                :dirty_attributes => states.find(entity).changed,
-                :query_method     => self
-              }).execute(&block)
-            end
+          data_mapper.classified_attributes.each do |provider_name, attributes|
+            source_attributes_walker.new({
+              :entity           => entity,
+              :provider_name    => provider_name,
+              :attributes       => attributes,
+              :dirty_aware?     => dirty_aware?,
+              :dirty_attributes => states.find(entity).changed,
+              :query_method     => self
+            }).execute(&block)
+          end
+        end
+
+        # Walks through the references and performs actions on them
+        #
+        # @param (see #dispatch_criteria_to_providers)
+        #
+        # @return [void]
+        def walk_references(criteria_name, entity)
+          data_mapper.references.each do |reference_name, options|
+            ReferenceHandler.new({
+              :entity            => entity,
+              :criteria_name     => criteria_name,
+              :reference_name    => reference_name,
+              :reference_options => options,
+              :query_method      => self
+            }).execute
           end
         end
 
+        private
+
+        # return [Class]
         def source_attributes_walker
           if @lazy_load
             Lazy::SourceAttributesWalker

data/lib/datamappify/repository/query_method/save.rb

@@ -4,11 +4,11 @@ module Datamappify
       class Save < Method
         # @return [Entity, false]
         def perform
-          states.update(@entity) do
-            create_or_update(@entity)
+          states.update(entity) do
+            create_or_update(entity)
           end
 
-          @entity
+          entity
         rescue Data::EntityInvalid
           false
         end
@@ -31,7 +31,7 @@ module Datamappify
         #
         # @return [Entity]
         def create_or_update(entity)
-          raise Data::EntityInvalid.new(entity) if entity.invalid?(context)
+          raise Data::EntityInvalid.new(entity.errors) if entity.invalid?(context)
 
           dispatch_criteria_to_providers(:SaveByKey, entity)
 

data/lib/datamappify/repository/query_method/where_or_match.rb

@@ -0,0 +1,24 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      class WhereOrMatch < Method
+        # @return [Array<Entity>]
+        def perform
+          results = dispatch_criteria_to_default_source(
+            self.class.name.demodulize.to_sym, data_mapper.entity_class, criteria, data_mapper.attributes
+          )
+
+          MultiResultBlender.new(self).blend(results)
+        end
+
+        # @see Method#reader?
+        def reader?
+          true
+        end
+      end
+
+      class Where < WhereOrMatch; end
+      class Match < WhereOrMatch; end
+    end
+  end
+end