active_data 0.3.0 → 1.0.0

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

@@ -0,0 +1,63 @@
+module ActiveData
+  module Model
+    module Associations
+      module Validations
+        def valid_ancestry?
+          errors.clear
+          validate_nested!
+          run_validations!
+        end
+        alias_method :validate_ancestry, :valid_ancestry?
+
+        def invalid_ancestry?
+          !valid_ancestry?
+        end
+
+        def validate_ancestry!
+          valid_ancestry? || raise_validation_error
+        end
+
+      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? }
+            else
+              lambda { |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
+end

data/lib/active_data/model/attributes.rb

@@ -0,0 +1,247 @@
+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
+    module Attributes
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_attributes, :_attribute_aliases, :_sanitize, instance_reader: false, instance_writer: false
+        self._attributes = {}
+        self._attribute_aliases = {}
+        self._sanitize = true
+
+        delegate :attribute_names, :has_attribute?, to: 'self.class'
+
+        %w[attribute collection dictionary].each do |kind|
+          define_singleton_method kind do |*args, &block|
+            add_attribute("ActiveData::Model::Attributes::Reflections::#{kind.camelize}".constantize, *args, &block)
+          end
+        end
+      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
+          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
+          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
+          reflection
+        end
+
+        def reflect_on_attribute(name)
+          name = name.to_s
+          _attributes[_attribute_aliases[name] || name]
+        end
+
+        def has_attribute? name
+          name = name.to_s
+          _attributes.key?(_attribute_aliases[name] || name)
+        end
+
+        def attribute_names(include_associations = true)
+          if include_associations
+            _attributes.keys
+          else
+            _attributes.map do |name, attribute|
+              name unless attribute.class == ActiveData::Model::Attributes::Reflections::Base
+            end.compact
+          end
+        end
+
+        def inspect
+          "#{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
+          yield
+        ensure
+          self._sanitize = previous_sanitize
+        end
+
+      private
+
+        def original_inspect
+          Object.method(:inspect).unbind.bind(self).call
+        end
+
+        def attributes_for_inspect
+          attribute_names(false).map do |name|
+            prefix = respond_to?(:_primary_name) && _primary_name == name ? ?* : ''
+            "#{prefix}#{_attributes[name].inspect_reflection}"
+          end.join(', ')
+        end
+
+        def generated_attributes_methods
+          @generated_attributes_methods ||=
+            const_set(:GeneratedAttributesMethods, Module.new)
+            .tap { |proxy| include proxy }
+        end
+
+        def inverted_attribute_aliases
+          @inverted_attribute_aliases ||=
+            _attribute_aliases.each.with_object({}) do |(alias_name, attribute_name), result|
+              (result[attribute_name] ||= []).push(alias_name)
+            end
+        end
+      end
+
+      def initialize attrs = {}
+        assign_attributes attrs
+      end
+
+      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
+      end
+
+      def write_attribute name, value
+        attribute(name).write(value)
+      end
+      alias_method :[]=, :write_attribute
+
+      def read_attribute name
+        attribute(name).read
+      end
+      alias_method :[], :read_attribute
+
+      def read_attribute_before_type_cast name
+        attribute(name).read_before_type_cast
+      end
+
+      def attribute_present? name
+        attribute(name).value_present?
+      end
+
+      def attributes(include_associations = true)
+        Hash[attribute_names(include_associations).map { |name| [name, read_attribute(name)] }]
+      end
+
+      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
+
+          _assign_attributes(attrs)
+          _assign_attributes(represented_attrs)
+          _assign_attributes(nested_attrs) if nested_attrs
+        else
+          _assign_attributes(attrs)
+        end
+        true
+      end
+      alias_method :attributes=, :assign_attributes
+
+      def inspect
+        "#<#{self.class.send(:original_inspect)} #{attributes_for_inspect.presence || '(no attributes)'}>"
+      end
+
+      def initialize_copy _
+        @initial_attributes = Hash[attribute_names.map do |name|
+          [name, read_attribute_before_type_cast(name)]
+        end]
+        @_attributes = nil
+        super
+      end
+
+    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}#{attribute(name).inspect_attribute}"
+        end.join(', ')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module ActiveData
+  module Model
+    module Attributes
+      class Attribute < Base
+        delegate :defaultizer, :enumerizer, :normalizers, to: :reflection
+
+        def write value
+          return if readonly?
+          pollute do
+            write_value value
+          end
+        end
+
+        def read
+          variable_cache(:value) do
+            normalize(enumerize(typecast(read_before_type_cast)))
+          end
+        end
+
+        def read_before_type_cast
+          variable_cache(:value_before_type_cast) do
+            defaultize(@value_cache)
+          end
+        end
+
+        def default
+          defaultizer.is_a?(Proc) ? evaluate(&defaultizer) : defaultizer
+        end
+
+        def defaultize value, default_value = nil
+          defaultizer && value.nil? ? default_value || default : value
+        end
+
+        def enum
+          source = enumerizer.is_a?(Proc) ? evaluate(&enumerizer) : enumerizer
+
+          case source
+          when Range
+            source.to_a
+          when Set
+            source
+          else
+            Array.wrap(source)
+          end.to_set
+        end
+
+        def enumerize value
+          set = enum if enumerizer
+          value if !set || (set.none? || set.include?(value))
+        end
+
+        def normalize value
+          if normalizers.none?
+            value
+          else
+            normalizers.inject(value) do |value, normalizer|
+              case normalizer
+              when Proc
+                evaluate(value, &normalizer)
+              when Hash
+                normalizer.inject(value) do |value, (name, options)|
+                  ActiveData.normalizer(name).call(value, options, self)
+                end
+              else
+                ActiveData.normalizer(normalizer).call(value, {}, self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module ActiveData
+  module Model
+    module Attributes
+      class Base
+        attr_reader :name, :owner
+        delegate :type, :typecaster, :readonly, to: :reflection
+
+        def initialize name, owner
+          @name, @owner = name, owner
+        end
+
+        def reflection
+          @owner.class._attributes[name]
+        end
+
+        def write_value value
+          reset
+          @value_cache = value
+        end
+
+        def write value
+          return if readonly?
+          write_value value
+        end
+
+        def reset
+          remove_variable(:value, :value_before_type_cast)
+        end
+
+        def read
+          @value_cache
+        end
+
+        def read_before_type_cast
+          @value_cache
+        end
+
+        def value_present?
+          !read.nil? && !(read.respond_to?(:empty?) && read.empty?)
+        end
+
+        def query
+          !(read.respond_to?(:zero?) ? read.zero? : read.blank?)
+        end
+
+        def typecast value
+          if value.instance_of?(type)
+            value
+          else
+            typecaster.call(value, self) unless value.nil?
+          end
+        end
+
+        def readonly?
+          !!(readonly.is_a?(Proc) ? evaluate(&readonly) : readonly)
+        end
+
+        def inspect_attribute
+          value = case read
+          when Date, Time, DateTime
+            %("#{read.to_s(:db)}")
+          else
+            inspection = read.inspect
+            inspection.size > 100 ? inspection.truncate(50) : inspection
+          end
+          "#{name}: #{value}"
+        end
+
+        def pollute
+          pollute = owner.class.dirty? && !owner.send(:attribute_changed?, name)
+
+          if pollute
+            previous_value = read
+            result = yield
+            if previous_value != read || (
+              read.respond_to?(:changed?) &&
+              read.changed?
+            )
+              owner.send(:set_attribute_was, name, previous_value)
+            end
+            result
+          else
+            yield
+          end
+        end
+
+      private
+
+        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)
+          end
+        end
+
+        def remove_variable(*names)
+          names.flatten.each do |name|
+            name = :"@#{name}"
+            remove_instance_variable(name) if instance_variable_defined?(name)
+          end
+        end
+
+        def variable_cache(name)
+          name = :"@#{name}"
+          if instance_variable_defined?(name)
+            instance_variable_get(name)
+          else
+            instance_variable_set(name, yield)
+          end
+        end
+      end
+    end
+  end
+end