active_data 1.0.0 → 1.1.0

data/lib/active_data/model/associations/reflections/base.rb

@@ -11,27 +11,17 @@ module ActiveData
           attr_accessor :parent_reflection
           delegate :association_class, to: 'self.class'
 
-          def self.build target, generated_methods, name, options = {}, &block
-            if block
-              options[:class] = proc do |reflection|
-                superclass = reflection.options[:class_name].to_s.presence.try(:constantize)
-                klass = Class.new(superclass || Object) do
-                  include ActiveData::Model
-                  include ActiveData::Model::Associations
-                  include ActiveData::Model::Lifecycle
-                  include ActiveData::Model::Primary
-                end
-                target.const_set(name.to_s.classify, klass)
-                klass.class_eval(&block)
-                klass
-              end
-            end
+          def self.build(target, generated_methods, name, options = {}, &_block)
             generate_methods name, generated_methods
-            target.validates_nested name if options.delete(:validate) && target.respond_to?(:validates_nested)
+            if options.delete(:validate) &&
+                target.respond_to?(:validates_nested) &&
+                !target.validates_nested?(name)
+              target.validates_nested name
+            end
             new(name, options)
           end
 
-          def self.generate_methods name, target
+          def self.generate_methods(name, target)
             target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{name} force_reload = false
                 association(:#{name}).reader(force_reload)
@@ -47,8 +37,9 @@ module ActiveData
             @association_class ||= "ActiveData::Model::Associations::#{name.demodulize}".constantize
           end
 
-          def initialize name, options = {}
-            @name, @options = name.to_sym, options
+          def initialize(name, options = {})
+            @name = name.to_sym
+            @options = options
           end
 
           def macro
@@ -56,31 +47,30 @@ module ActiveData
           end
 
           def klass
-            @klass ||= options[:class] ?
-              options[:class].call(self) :
-              (options[:class_name].presence || name.to_s.classify).to_s.constantize
+            @klass ||= (options[:class_name].presence || name.to_s.classify).to_s.constantize
           end
 
+          # AR compatibility
           def belongs_to?
             false
           end
 
-          def build_association object
+          def build_association(object)
             self.class.association_class.new object, self
           end
 
-          def read_source object
+          def read_source(object)
             (options[:read] || READ).call(self, object)
           end
 
-          def write_source object, value
+          def write_source(object, value)
             (options[:write] || WRITE).call(self, object, value)
           end
 
-          def default object
+          def default(object)
             defaultizer = options[:default]
             if defaultizer.is_a?(Proc)
-              if defaultizer.arity != 0
+              if defaultizer.arity.nonzero?
                 defaultizer.call(object)
               else
                 object.instance_exec(&defaultizer)
@@ -90,8 +80,8 @@ module ActiveData
             end
           end
 
-          def inspect
-            "#{self.class.name.demodulize}(#{klass})"
+          def collection?
+            true
           end
         end
       end

data/lib/active_data/model/associations/reflections/embeds_any.rb

@@ -0,0 +1,43 @@
+module ActiveData
+  module Model
+    module Associations
+      module Reflections
+        class EmbedsAny < Base
+          def self.build(target, generated_methods, name, options = {}, &block)
+            if block
+              options[:class] = proc do |reflection|
+                superclass = reflection.options[:class_name].to_s.presence.try(:constantize)
+                klass = Class.new(superclass || ActiveData::Base) do
+                  include ActiveData::Model
+                  include ActiveData::Model::Associations
+                  include ActiveData::Model::Lifecycle
+                  include ActiveData::Model::Primary
+                end
+                target.const_set(name.to_s.classify, klass)
+                klass.class_eval(&block)
+                klass
+              end
+            end
+            super
+          end
+
+          def klass
+            @klass ||= if options[:class]
+              options[:class].call(self)
+            else
+              super
+            end
+          end
+
+          def inspect
+            "#{self.class.name.demodulize}(#{klass})"
+          end
+
+          def embedded?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/reflections/embeds_many.rb

@@ -2,22 +2,12 @@ module ActiveData
   module Model
     module Associations
       module Reflections
-        class EmbedsMany < Base
-          def self.build target, generated_methods, name, options = {}, &block
-            if target < ActiveData::Model::Attributes
-              target.add_attribute(ActiveData::Model::Attributes::Reflections::Base, name)
-            end
+        class EmbedsMany < EmbedsAny
+          def self.build(target, generated_methods, name, options = {}, &block)
+            target.add_attribute(ActiveData::Model::Attributes::Reflections::Base, name) if target < ActiveData::Model::Attributes
             options[:validate] = true unless options.key?(:validate)
             super
           end
-
-          def collection?
-            true
-          end
-
-          def embedded?
-            true
-          end
         end
       end
     end

data/lib/active_data/model/associations/reflections/embeds_one.rb

@@ -2,46 +2,14 @@ module ActiveData
   module Model
     module Associations
       module Reflections
-        class EmbedsOne < Base
-          def self.build target, generated_methods, name, options = {}, &block
-            if target < ActiveData::Model::Attributes
-              target.add_attribute(ActiveData::Model::Attributes::Reflections::Base, name)
-            end
+        class EmbedsOne < EmbedsAny
+          include Singular
+
+          def self.build(target, generated_methods, name, options = {}, &block)
+            target.add_attribute(ActiveData::Model::Attributes::Reflections::Base, name) if target < ActiveData::Model::Attributes
             options[:validate] = true unless options.key?(:validate)
             super
           end
-
-          def self.generate_methods name, target
-            target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name} force_reload = false
-                association(:#{name}).reader(force_reload)
-              end
-
-              def #{name}= value
-                association(:#{name}).writer(value)
-              end
-
-              def build_#{name} attributes = {}
-                association(:#{name}).build(attributes)
-              end
-
-              def create_#{name} attributes = {}
-                association(:#{name}).create(attributes)
-              end
-
-              def create_#{name}! attributes = {}
-                association(:#{name}).create!(attributes)
-              end
-            RUBY
-          end
-
-          def collection?
-            false
-          end
-
-          def embedded?
-            true
-          end
         end
       end
     end

data/lib/active_data/model/associations/reflections/references_any.rb

@@ -0,0 +1,62 @@
+module ActiveData
+  module Model
+    module Associations
+      module Reflections
+        class ReferencesAny < Base
+          def self.build(_target, generated_methods, name, *args)
+            reflection = new(name, *args)
+            generate_methods name, generated_methods
+            reflection
+          end
+
+          def self.persistence_adapter(klass)
+            adapter = klass.active_data_persistence_adapter if klass.respond_to?(:active_data_persistence_adapter)
+            adapter or raise PersistenceAdapterMissing, klass
+          end
+
+          delegate :primary_key, to: :persistence_adapter
+
+          def initialize(name, *args)
+            @options = args.extract_options!
+            @scope_proc = args.first
+            @name = name.to_sym
+          end
+
+          def klass
+            @klass ||= if options[:data_source].present?
+              options[:data_source].to_s.constantize
+            else
+              super
+            end
+          end
+          alias_method :data_source, :klass
+
+          def persistence_adapter
+            @persistence_adapter ||= self.class.persistence_adapter(klass)
+              .new(data_source, options[:primary_key], @scope_proc)
+          end
+
+          def read_source(object)
+            object.read_attribute(reference_key)
+          end
+
+          def write_source(object, value)
+            object.write_attribute(reference_key, value)
+          end
+
+          def embedded?
+            false
+          end
+
+          def inspect
+            "#{self.class.name.demodulize}(#{persistence_adapter.data_type})"
+          end
+
+          def autosave?
+            !!options[:autosave]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/reflections/references_many.rb

@@ -1,22 +1,22 @@
+require 'active_data/model/attributes/reflections/reference_many'
+require 'active_data/model/attributes/reference_many'
+
 module ActiveData
   module Model
     module Associations
       module Reflections
-        class ReferencesMany < ReferenceReflection
-          def self.build target, generated_methods, name, *args, &block
+        class ReferencesMany < ReferencesAny
+          def self.build(target, generated_methods, name, *args, &block)
             reflection = super
 
             target.add_attribute(
               ActiveData::Model::Attributes::Reflections::ReferenceMany,
-              reflection.reference_key, association: name)
+              reflection.reference_key, association: name
+            )
 
             reflection
           end
 
-          def collection?
-            true
-          end
-
           def reference_key
             @reference_key ||= options[:reference_key].presence.try(:to_sym) ||
               :"#{name.to_s.singularize}_#{primary_key.to_s.pluralize}"

data/lib/active_data/model/associations/reflections/references_one.rb

@@ -1,22 +1,24 @@
+require 'active_data/model/attributes/reflections/reference_one'
+require 'active_data/model/attributes/reference_one'
+
 module ActiveData
   module Model
     module Associations
       module Reflections
-        class ReferencesOne < ReferenceReflection
-          def self.build target, generated_methods, name, *args, &block
+        class ReferencesOne < ReferencesAny
+          include Singular
+
+          def self.build(target, generated_methods, name, *args, &block)
             reflection = super
 
             target.add_attribute(
               ActiveData::Model::Attributes::Reflections::ReferenceOne,
-              reflection.reference_key, association: name)
+              reflection.reference_key, association: name
+            )
 
             reflection
           end
 
-          def collection?
-            false
-          end
-
           def reference_key
             @reference_key ||= options[:reference_key].presence.try(:to_sym) ||
               :"#{name}_#{primary_key}"

data/lib/active_data/model/associations/reflections/singular.rb

@@ -0,0 +1,35 @@
+module ActiveData
+  module Model
+    module Associations
+      module Reflections
+        module Singular
+          extend ActiveSupport::Concern
+
+          module ClassMethods
+            def generate_methods(name, target)
+              super
+
+              target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def build_#{name} attributes = {}
+                  association(:#{name}).build(attributes)
+                end
+
+                def create_#{name} attributes = {}
+                  association(:#{name}).create(attributes)
+                end
+
+                def create_#{name}! attributes = {}
+                  association(:#{name}).create!(attributes)
+                end
+              RUBY
+            end
+          end
+
+          def collection?
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,44 +19,19 @@ module ActiveData
 
       private
 
-        def run_validations! #:nodoc:
-          super
-          emerge_represented_attributes_errors!
-          errors.empty?
-        end
-
         def validate_nested!
           association_names.each do |name|
             association = association(name)
             invalid_block = if association.reflection.klass.method_defined?(:invalid_ansestry?)
-              lambda { |object| object.invalid_ansestry? }
+              ->(object) { object.invalid_ansestry? }
             else
-              lambda { |object| object.invalid? }
+              ->(object) { object.invalid? }
             end
 
             ActiveData::Model::Validations::NestedValidator
               .validate_nested(self, name, association.target, &invalid_block)
           end
         end
-
-        # Move represent attribute errors to the top level:
-        #
-        #   {:'role.email' => ['Some error']}
-        #
-        # to:
-        #
-        #   {email: ['Some error']}
-        #
-        def emerge_represented_attributes_errors!
-          self.class.represented_attributes.each do |attribute|
-            key = :"#{attribute.reference}.#{attribute.column}"
-            messages = errors.messages[key]
-            if messages.present?
-              errors[attribute.column].concat(messages)
-              errors.delete(key)
-            end
-          end
-        end
       end
     end
   end

data/lib/active_data/model/associations.rb

@@ -1,17 +1,20 @@
 require 'active_data/model/associations/collection/proxy'
 require 'active_data/model/associations/collection/embedded'
-require 'active_data/model/associations/collection/referenced'
 
 require 'active_data/model/associations/reflections/base'
+require 'active_data/model/associations/reflections/singular'
+require 'active_data/model/associations/reflections/embeds_any'
 require 'active_data/model/associations/reflections/embeds_one'
 require 'active_data/model/associations/reflections/embeds_many'
-require 'active_data/model/associations/reflections/reference_reflection'
+require 'active_data/model/associations/reflections/references_any'
 require 'active_data/model/associations/reflections/references_one'
 require 'active_data/model/associations/reflections/references_many'
 
 require 'active_data/model/associations/base'
+require 'active_data/model/associations/embeds_any'
 require 'active_data/model/associations/embeds_one'
 require 'active_data/model/associations/embeds_many'
+require 'active_data/model/associations/references_any'
 require 'active_data/model/associations/references_one'
 require 'active_data/model/associations/references_many'
 
@@ -25,7 +28,6 @@ module ActiveData
 
       included do
         include NestedAttributes
-        include Validations
 
         class_attribute :_associations, :_association_aliases, instance_reader: false, instance_writer: false
         self._associations = {}
@@ -54,13 +56,13 @@ module ActiveData
 
         def alias_association(alias_name, association_name)
           reflection = reflect_on_association(association_name)
-          raise ArgumentError.new("Can't alias undefined association `#{attribute_name}` on #{self}") unless reflection
+          raise ArgumentError, "Can't alias undefined association `#{attribute_name}` on #{self}" unless reflection
           reflection.class.generate_methods alias_name, generated_associations_methods
           self._association_aliases = _association_aliases.merge(alias_name.to_sym => reflection.name)
           reflection
         end
 
-        def reflect_on_association name
+        def reflect_on_association(name)
           name = name.to_sym
           _associations[_association_aliases[name] || name]
         end
@@ -83,17 +85,17 @@ module ActiveData
         end
       end
 
-      def == other
+      def ==(other)
         super && association_names.all? do |association|
           public_send(association) == other.public_send(association)
         end
       end
       alias_method :eql?, :==
 
-      def association name
-        if reflection = self.class.reflect_on_association(name)
-          (@_associations ||= {})[reflection.name] ||= reflection.build_association(self)
-        end
+      def association(name)
+        reflection = self.class.reflect_on_association(name)
+        return unless reflection
+        (@_associations ||= {})[reflection.name] ||= reflection.build_association(self)
       end
 
       def apply_association_changes!

data/lib/active_data/model/attributes/attribute.rb

@@ -4,7 +4,7 @@ module ActiveData
       class Attribute < Base
         delegate :defaultizer, :enumerizer, :normalizers, to: :reflection
 
-        def write value
+        def write(value)
           return if readonly?
           pollute do
             write_value value
@@ -27,8 +27,8 @@ module ActiveData
           defaultizer.is_a?(Proc) ? evaluate(&defaultizer) : defaultizer
         end
 
-        def defaultize value, default_value = nil
-          defaultizer && value.nil? ? default_value || default : value
+        def defaultize(value, default_value = nil)
+          !defaultizer.nil? && value.nil? ? default_value || default : value
         end
 
         def enum
@@ -44,25 +44,25 @@ module ActiveData
           end.to_set
         end
 
-        def enumerize value
+        def enumerize(value)
           set = enum if enumerizer
           value if !set || (set.none? || set.include?(value))
         end
 
-        def normalize value
+        def normalize(value)
           if normalizers.none?
             value
           else
-            normalizers.inject(value) do |value, normalizer|
+            normalizers.inject(value) do |val, normalizer|
               case normalizer
               when Proc
-                evaluate(value, &normalizer)
+                evaluate(val, &normalizer)
               when Hash
-                normalizer.inject(value) do |value, (name, options)|
-                  ActiveData.normalizer(name).call(value, options, self)
+                normalizer.inject(val) do |v, (name, options)|
+                  ActiveData.normalizer(name).call(v, options, self)
                 end
               else
-                ActiveData.normalizer(normalizer).call(value, {}, self)
+                ActiveData.normalizer(normalizer).call(val, {}, self)
               end
             end
           end

data/lib/active_data/model/attributes/base.rb

@@ -5,20 +5,21 @@ module ActiveData
         attr_reader :name, :owner
         delegate :type, :typecaster, :readonly, to: :reflection
 
-        def initialize name, owner
-          @name, @owner = name, owner
+        def initialize(name, owner)
+          @name = name
+          @owner = owner
         end
 
         def reflection
           @owner.class._attributes[name]
         end
 
-        def write_value value
+        def write_value(value)
           reset
           @value_cache = value
         end
 
-        def write value
+        def write(value)
           return if readonly?
           write_value value
         end
@@ -43,7 +44,7 @@ module ActiveData
           !(read.respond_to?(:zero?) ? read.zero? : read.blank?)
         end
 
-        def typecast value
+        def typecast(value)
           if value.instance_of?(type)
             value
           else
@@ -86,12 +87,12 @@ module ActiveData
 
       private
 
-        def evaluate *args, &block
+        def evaluate(*args, &block)
           if block.arity >= 0 && block.arity <= args.length
             owner.instance_exec(*args.first(block.arity), &block)
           else
             args = block.arity < 0 ? args : args.first(block.arity)
-            block.call(*args, owner)
+            yield(*args, owner)
           end
         end
 

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

@@ -14,25 +14,25 @@ module ActiveData
           end]
         end
 
-        def write_locale value, locale
+        def write_locale(value, locale)
           pollute do
             write(read.merge(locale.to_s => value))
           end
         end
 
-        def read_locale locale
+        def read_locale(locale)
           read[owner.class.fallbacks(locale).detect do |fallback|
             read[fallback.to_s]
           end.to_s]
         end
 
-        def read_locale_before_type_cast locale
+        def read_locale_before_type_cast(locale)
           read_before_type_cast[owner.class.fallbacks(locale).detect do |fallback|
             read_before_type_cast[fallback.to_s]
           end.to_s]
         end
 
-        def locale_query locale
+        def locale_query(locale)
           value = read_locale(locale)
           !(value.respond_to?(:zero?) ? value.zero? : value.blank?)
         end

data/lib/active_data/model/attributes/reference_many.rb

@@ -2,19 +2,17 @@ module ActiveData
   module Model
     module Attributes
       class ReferenceMany < ReferenceOne
-        def read_before_type_cast
-          variable_cache(:value_before_type_cast) do
-            Array.wrap(@value_cache)
-          end
-        end
-
-      private
-
         def type_casted_value
           variable_cache(:value) do
             read_before_type_cast.map { |id| typecast(id) }
           end
         end
+
+        def read_before_type_cast
+          variable_cache(:value_before_type_cast) do
+            Array.wrap(@value_cache)
+          end
+        end
       end
     end
   end