active_data 1.0.0 → 1.1.0

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

@@ -2,13 +2,13 @@ module ActiveData
   module Model
     module Attributes
       class ReferenceOne < Base
-        def write value
+        def write(value)
           pollute do
             previous = type_casted_value
             result = write_value value
-            if (!value.nil? && type_casted_value.nil?) || type_casted_value != previous
-              association.reset
-            end
+            changed = (!value.nil? && type_casted_value.nil?) || type_casted_value != previous
+
+            association.reset if changed
             result
           end
         end
@@ -21,18 +21,26 @@ module ActiveData
           end
         end
 
+        def type_casted_value
+          variable_cache(:value) do
+            typecast(read_before_type_cast)
+          end
+        end
+
         def read_before_type_cast
           @value_cache
         end
 
-      private
+        def type
+          @type ||= association.reflection.persistence_adapter.primary_key_type
+        end
 
-        def type_casted_value
-          variable_cache(:value) do
-            typecast(read_before_type_cast)
-          end
+        def typecaster
+          @typecaster ||= ActiveData.typecaster(type.ancestors.grep(Class))
         end
 
+      private
+
         def association
           @association ||= owner.association(reflection.association)
         end

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

@@ -3,13 +3,13 @@ module ActiveData
     module Attributes
       module Reflections
         class Attribute < Base
-          def self.build target, generated_methods, name, *args, &block
+          def self.build(target, generated_methods, name, *args, &block)
             attribute = super(target, generated_methods, name, *args, &block)
             generate_methods name, generated_methods
             attribute
           end
 
-          def self.generate_methods name, target
+          def self.generate_methods(name, target)
             target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{name}
                 attribute('#{name}').read

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

@@ -5,37 +5,34 @@ module ActiveData
         class Base
           attr_reader :name, :options
           class << self
-            def build target, generated_methods, name, *args, &block
+            def build(_target, _generated_methods, name, *args, &block)
               options = args.extract_options!
-              options.merge!(type: args.first) if args.first
-              options.merge!(default: block) if block
+              options[:type] = args.first if args.first
+              options[:default] = block if block
               new(name, options)
             end
 
-            def generate_methods name, target
-            end
+            def generate_methods(name, target) end
 
             def attribute_class
               @attribute_class ||= "ActiveData::Model::Attributes::#{name.demodulize}".constantize
             end
           end
 
-          def initialize name, options = {}
+          def initialize(name, options = {})
             @name = name.to_s
             @options = options
           end
 
-          def build_attribute owner, raw_value = nil
+          def build_attribute(owner, raw_value = ActiveData::UNDEFINED)
             attribute = self.class.attribute_class.new(name, owner)
-            attribute.write_value(raw_value) if raw_value
+            attribute.write_value(raw_value) unless raw_value == ActiveData::UNDEFINED
             attribute
           end
 
           def type
             @type ||= case options[:type]
-            when Proc
-              options[:type].call
-            when Class
+            when Class, Module
               options[:type]
             when nil
               raise "Type is not specified for `#{name}`"

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

@@ -3,13 +3,13 @@ module ActiveData
     module Attributes
       module Reflections
         class Localized < Attribute
-          def self.build target, generated_methods, name, *args, &block
+          def self.build(target, generated_methods, name, *args, &block)
             attribute = super(target, generated_methods, name, *args, &block)
             generate_methods name, generated_methods
             attribute
           end
 
-          def self.generate_methods name, target
+          def self.generate_methods(name, target)
             target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{name}_translations
                 attribute('#{name}').read

data/lib/active_data/model/attributes/reflections/reference_one.rb

@@ -3,32 +3,13 @@ module ActiveData
     module Attributes
       module Reflections
         class ReferenceOne < Base
-          TYPES = {
-            integer: Integer,
-            float: Float,
-            decimal: BigDecimal,
-            datetime: Time,
-            timestamp: Time,
-            time: Time,
-            date: Date,
-            text: String,
-            string: String,
-            binary: String,
-            boolean: Boolean
-          }
-
-          def self.build target, generated_methods, name, *args, &block
+          def self.build(_target, generated_methods, name, *args)
             options = args.extract_options!
             generate_methods name, generated_methods
-            type_proc = -> {
-              reflection = target.reflect_on_association(options[:association])
-              column = reflection.klass.columns_hash[reflection.primary_key.to_s]
-              TYPES[column.type]
-            }
-            new(name, options.reverse_merge(type: type_proc))
+            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}
                 attribute('#{name}').read
@@ -48,6 +29,14 @@ module ActiveData
             RUBY
           end
 
+          def type
+            Object
+          end
+
+          def inspect_reflection
+            "#{name}: (reference)"
+          end
+
           def association
             @association ||= options[:association].to_s
           end

data/lib/active_data/model/attributes/reflections/represents.rb

@@ -3,20 +3,19 @@ module ActiveData
     module Attributes
       module Reflections
         class Represents < Attribute
-          def self.build target, generated_methods, name, *args, &block
+          def self.build(target, generated_methods, name, *args, &block)
             options = args.extract_options!
 
             reference = target.reflect_on_association(options[:of]) if target.respond_to?(:reflect_on_association)
             reference ||= target.reflect_on_attribute(options[:of]) if target.respond_to?(:reflect_on_attribute)
-            if reference
-              options[:of] = reference.name
-              target.validates_nested options[:of]
-            end
+            options[:of] = reference.name if reference
+            validates_nested = target.respond_to?(:validates_nested) && !target.validates_nested?(options[:of])
+            target.validates_nested(options[:of]) if validates_nested
 
             super(target, generated_methods, name, *args, options, &block)
           end
 
-          def initialize name, options
+          def initialize(name, options)
             super
             raise ArgumentError, "Undefined reference for `#{name}`" if reference.blank?
           end

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

@@ -4,7 +4,7 @@ module ActiveData
       class Represents < Attribute
         delegate :reader, :reader_before_type_cast, :writer, to: :reflection
 
-        def write value
+        def write(value)
           return if readonly?
           pollute do
             reset
@@ -48,10 +48,11 @@ module ActiveData
 
         def read_value_before_type_cast
           ref = reference
-          if ref
-            ref.respond_to?(reader_before_type_cast) ?
-              ref.public_send(reader_before_type_cast) :
-              ref.public_send(reader)
+          return unless ref
+          if ref.respond_to?(reader_before_type_cast)
+            ref.public_send(reader_before_type_cast)
+          else
+            ref.public_send(reader)
           end
         end
 

data/lib/active_data/model/attributes.rb

@@ -1,20 +1,12 @@
 require 'active_data/model/attributes/reflections/base'
-require 'active_data/model/attributes/reflections/reference_one'
-require 'active_data/model/attributes/reflections/reference_many'
 require 'active_data/model/attributes/reflections/attribute'
 require 'active_data/model/attributes/reflections/collection'
 require 'active_data/model/attributes/reflections/dictionary'
-require 'active_data/model/attributes/reflections/localized'
-require 'active_data/model/attributes/reflections/represents'
 
 require 'active_data/model/attributes/base'
-require 'active_data/model/attributes/reference_one'
-require 'active_data/model/attributes/reference_many'
 require 'active_data/model/attributes/attribute'
 require 'active_data/model/attributes/collection'
 require 'active_data/model/attributes/dictionary'
-require 'active_data/model/attributes/localized'
-require 'active_data/model/attributes/represents'
 
 module ActiveData
   module Model
@@ -37,31 +29,21 @@ module ActiveData
       end
 
       module ClassMethods
-        def represents(*names, &block)
-          options = names.extract_options!
-          names.each do |name|
-            add_attribute(Reflections::Represents, name, options, &block)
-          end
-        end
-
         def add_attribute(reflection_class, *args, &block)
           reflection = reflection_class.build(self, generated_attributes_methods, *args, &block)
           self._attributes = _attributes.merge(reflection.name => reflection)
-          if dirty? && reflection_class != ActiveData::Model::Attributes::Reflections::Base
-            define_dirty reflection.name, generated_attributes_methods
-          end
+          should_define_dirty = (dirty? && reflection_class != ActiveData::Model::Attributes::Reflections::Base)
+          define_dirty(reflection.name, generated_attributes_methods) if should_define_dirty
           reflection
         end
 
         def alias_attribute(alias_name, attribute_name)
           reflection = reflect_on_attribute(attribute_name)
-          raise ArgumentError.new("Unable to alias undefined attribute `#{attribute_name}` on #{self}") unless reflection
-          raise ArgumentError.new("Unable to alias base attribute `#{attribute_name}`") if reflection.class == ActiveData::Model::Attributes::Reflections::Base
+          raise ArgumentError, "Unable to alias undefined attribute `#{attribute_name}` on #{self}" unless reflection
+          raise ArgumentError, "Unable to alias base attribute `#{attribute_name}`" if reflection.class == ActiveData::Model::Attributes::Reflections::Base
           reflection.class.generate_methods alias_name, generated_attributes_methods
           self._attribute_aliases = _attribute_aliases.merge(alias_name.to_s => reflection.name)
-          if dirty?
-            define_dirty alias_name, generated_attributes_methods
-          end
+          define_dirty alias_name, generated_attributes_methods if dirty?
           reflection
         end
 
@@ -70,7 +52,7 @@ module ActiveData
           _attributes[_attribute_aliases[name] || name]
         end
 
-        def has_attribute? name
+        def has_attribute?(name) # rubocop:disable Naming/PredicateName
           name = name.to_s
           _attributes.key?(_attribute_aliases[name] || name)
         end
@@ -89,24 +71,13 @@ module ActiveData
           "#{original_inspect}(#{attributes_for_inspect.presence || 'no attributes'})"
         end
 
-        def represented_attributes
-          @represented_attributes ||= _attributes.values.select do |attribute|
-            attribute.is_a? ActiveData::Model::Attributes::Reflections::Represents
-          end
-        end
-
-        def represented_names_and_aliases
-          @represented_names_and_aliases ||= represented_attributes.flat_map do |attribute|
-            [attribute.name, *inverted_attribute_aliases[attribute.name]]
-          end
-        end
-
         def dirty?
           false
         end
 
         def with_sanitize(value)
-          previous_sanitize, self._sanitize = _sanitize, value
+          previous_sanitize = _sanitize
+          self._sanitize = value
           yield
         ensure
           self._sanitize = previous_sanitize
@@ -120,7 +91,7 @@ module ActiveData
 
         def attributes_for_inspect
           attribute_names(false).map do |name|
-            prefix = respond_to?(:_primary_name) && _primary_name == name ? ?* : ''
+            prefix = respond_to?(:_primary_name) && _primary_name == name ? '*' : ''
             "#{prefix}#{_attributes[name].inspect_reflection}"
           end.join(', ')
         end
@@ -128,7 +99,7 @@ module ActiveData
         def generated_attributes_methods
           @generated_attributes_methods ||=
             const_set(:GeneratedAttributesMethods, Module.new)
-            .tap { |proxy| include proxy }
+              .tap { |proxy| include proxy }
         end
 
         def inverted_attribute_aliases
@@ -139,37 +110,38 @@ module ActiveData
         end
       end
 
-      def initialize attrs = {}
+      def initialize(attrs = {})
         assign_attributes attrs
       end
 
-      def == other
+      def ==(other)
         super || other.instance_of?(self.class) && other.attributes(false) == attributes(false)
       end
       alias_method :eql?, :==
 
       def attribute(name)
-        if reflection = self.class.reflect_on_attribute(name)
-          (@_attributes ||= {})[reflection.name] ||= reflection
-            .build_attribute(self, @initial_attributes.try(:[], reflection.name))
-        end
+        reflection = self.class.reflect_on_attribute(name)
+        return unless reflection
+        initial_value = @initial_attributes.to_h.fetch(reflection.name, ActiveData::UNDEFINED)
+        @_attributes ||= {}
+        @_attributes[reflection.name] ||= reflection.build_attribute(self, initial_value)
       end
 
-      def write_attribute name, value
+      def write_attribute(name, value)
         attribute(name).write(value)
       end
       alias_method :[]=, :write_attribute
 
-      def read_attribute name
+      def read_attribute(name)
         attribute(name).read
       end
       alias_method :[], :read_attribute
 
-      def read_attribute_before_type_cast name
+      def read_attribute_before_type_cast(name)
         attribute(name).read_before_type_cast
       end
 
-      def attribute_present? name
+      def attribute_present?(name)
         attribute(name).value_present?
       end
 
@@ -177,35 +149,22 @@ module ActiveData
         Hash[attribute_names(include_associations).map { |name| [name, read_attribute(name)] }]
       end
 
-      def update attrs
+      def update(attrs)
         assign_attributes(attrs)
       end
       alias_method :update_attributes, :update
 
-      def assign_attributes attrs
-        if self.class.represented_attributes.present? ||
-            (self.class.is_a?(ActiveData::Model::Associations::NestedAttributes) &&
-            self.class.nested_attributes_options.present?)
-          attrs.stringify_keys!
-          represented_attrs = self.class.represented_names_and_aliases
-            .each_with_object({}) do |name, result|
-              result[name] = attrs.delete(name) if attrs.has_key?(name)
-            end
-          if self.class.is_a?(ActiveData::Model::Associations::NestedAttributes)
-            nested_attrs = self.class.nested_attributes_options.keys
-              .each_with_object({}) do |association_name, result|
-                name = "#{association_name}_attributes"
-                result[name] = attrs.delete(name) if attrs.has_key?(name)
-              end
-          end
+      def assign_attributes(attrs)
+        attrs.each do |name, value|
+          name = name.to_s
+          sanitize_value = self.class._sanitize && name == self.class.primary_name
 
-          _assign_attributes(attrs)
-          _assign_attributes(represented_attrs)
-          _assign_attributes(nested_attrs) if nested_attrs
-        else
-          _assign_attributes(attrs)
+          if respond_to?("#{name}=") && !sanitize_value
+            public_send("#{name}=", value)
+          else
+            logger.info("Ignoring #{sanitize_value ? 'primary' : 'undefined'} `#{name}` attribute value for #{self} during mass-assignment")
+          end
         end
-        true
       end
       alias_method :attributes=, :assign_attributes
 
@@ -213,7 +172,7 @@ module ActiveData
         "#<#{self.class.send(:original_inspect)} #{attributes_for_inspect.presence || '(no attributes)'}>"
       end
 
-      def initialize_copy _
+      def initialize_copy(_)
         @initial_attributes = Hash[attribute_names.map do |name|
           [name, read_attribute_before_type_cast(name)]
         end]
@@ -223,22 +182,9 @@ module ActiveData
 
     private
 
-      def _assign_attributes attrs
-        attrs.each do |name, value|
-          name = name.to_s
-          sanitize_value = self.class._sanitize && name == self.class.primary_name
-
-          if respond_to?("#{name}=") && !sanitize_value
-            public_send("#{name}=", value)
-          else
-            logger.info("Ignoring #{sanitize_value ? 'primary' : 'undefined'} `#{name}` attribute value for #{self} during mass-assignment")
-          end
-        end
-      end
-
       def attributes_for_inspect
         attribute_names(false).map do |name|
-          prefix = self.class.primary_name == name ? ?* : ''
+          prefix = self.class.primary_name == name ? '*' : ''
           "#{prefix}#{attribute(name).inspect_attribute}"
         end.join(', ')
       end

data/lib/active_data/model/callbacks.rb

@@ -1,6 +1,5 @@
 module ActiveData
   module Model
-
     # == Callbacks for ActiveData::Model lifecycle
     #
     # Provides ActiveModel callbacks support for lifecycle
@@ -45,24 +44,24 @@ module ActiveData
       end
 
       module PrependMethods
-        def initialize *_
-          super(*_)
+        def initialize(*_)
+          super
           run_callbacks :initialize
         end
 
-        def save_object &block
+        def save_object(&block)
           run_callbacks(:save) { super(&block) }
         end
 
-        def create_object &block
+        def create_object(&block)
           run_callbacks(:create) { super(&block) }
         end
 
-        def update_object &block
+        def update_object(&block)
           run_callbacks(:update) { super(&block) }
         end
 
-        def destroy_object &block
+        def destroy_object(&block)
           run_callbacks(:destroy) { super(&block) }
         end
       end

data/lib/active_data/model/conventions.rb

@@ -4,6 +4,8 @@ module ActiveData
       extend ActiveSupport::Concern
 
       included do
+        attr_reader :embedder
+
         delegate :logger, to: ActiveData
         self.include_root_in_json = ActiveData.include_root_in_json
       end

data/lib/active_data/model/dirty.rb

@@ -12,8 +12,8 @@ module ActiveData
         def self.append_features(base)
           unconcerned_append_features(base)
         end
-        def self.included(base)
-        end
+
+        def self.included(_base); end
       end
 
       included do
@@ -42,13 +42,13 @@ module ActiveData
         attribute_names(false).each do |name|
           define_dirty name, generated_attributes_methods
         end
-        _attribute_aliases.keys.each do |name|
+        _attribute_aliases.each_key do |name|
           define_dirty name, generated_attributes_methods
         end
       end
 
       module ClassMethods
-        def define_dirty method, target = self
+        def define_dirty(method, target = self)
           reflection = reflect_on_attribute(method)
           name = reflection ? reflection.name : method