duck_record 0.0.3 → 0.0.5

data/lib/duck_record/nested_validate_association.rb

@@ -0,0 +1,262 @@
+module DuckRecord
+  # = Active Record Autosave Association
+  #
+  # AutosaveAssociation is a module that takes care of automatically saving
+  # associated records when their parent is saved. In addition to saving, it
+  # also destroys any associated records that were marked for destruction.
+  # (See #mark_for_destruction and #marked_for_destruction?).
+  #
+  # Saving of the parent, its associations, and the destruction of marked
+  # associations, all happen inside a transaction. This should never leave the
+  # database in an inconsistent state.
+  #
+  # If validations for any of the associations fail, their error messages will
+  # be applied to the parent.
+  #
+  # Note that it also means that associations marked for destruction won't
+  # be destroyed directly. They will however still be marked for destruction.
+  #
+  # Note that <tt>autosave: false</tt> is not same as not declaring <tt>:autosave</tt>.
+  # When the <tt>:autosave</tt> option is not present then new association records are
+  # saved but the updated association records are not saved.
+  #
+  # == Validation
+  #
+  # Child records are validated unless <tt>:validate</tt> is +false+.
+  #
+  # == Callbacks
+  #
+  # Association with autosave option defines several callbacks on your
+  # model (before_save, after_create, after_update). Please note that
+  # callbacks are executed in the order they were defined in
+  # model. You should avoid modifying the association content, before
+  # autosave callbacks are executed. Placing your callbacks after
+  # associations is usually a good practice.
+  #
+  # === One-to-one Example
+  #
+  #   class Post < ActiveRecord::Base
+  #     has_one :author, autosave: true
+  #   end
+  #
+  # Saving changes to the parent and its associated model can now be performed
+  # automatically _and_ atomically:
+  #
+  #   post = Post.find(1)
+  #   post.title       # => "The current global position of migrating ducks"
+  #   post.author.name # => "alloy"
+  #
+  #   post.title = "On the migration of ducks"
+  #   post.author.name = "Eloy Duran"
+  #
+  #   post.save
+  #   post.reload
+  #   post.title       # => "On the migration of ducks"
+  #   post.author.name # => "Eloy Duran"
+  #
+  # Destroying an associated model, as part of the parent's save action, is as
+  # simple as marking it for destruction:
+  #
+  #   post.author.mark_for_destruction
+  #   post.author.marked_for_destruction? # => true
+  #
+  # Note that the model is _not_ yet removed from the database:
+  #
+  #   id = post.author.id
+  #   Author.find_by(id: id).nil? # => false
+  #
+  #   post.save
+  #   post.reload.author # => nil
+  #
+  # Now it _is_ removed from the database:
+  #
+  #   Author.find_by(id: id).nil? # => true
+  #
+  # === One-to-many Example
+  #
+  # When <tt>:autosave</tt> is not declared new children are saved when their parent is saved:
+  #
+  #   class Post < ActiveRecord::Base
+  #     has_many :comments # :autosave option is not declared
+  #   end
+  #
+  #   post = Post.new(title: 'ruby rocks')
+  #   post.comments.build(body: 'hello world')
+  #   post.save # => saves both post and comment
+  #
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.build(body: 'hello world')
+  #   post.save # => saves both post and comment
+  #
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.create(body: 'hello world')
+  #   post.save # => saves both post and comment
+  #
+  # When <tt>:autosave</tt> is true all children are saved, no matter whether they
+  # are new records or not:
+  #
+  #   class Post < ActiveRecord::Base
+  #     has_many :comments, autosave: true
+  #   end
+  #
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.create(body: 'hello world')
+  #   post.comments[0].body = 'hi everyone'
+  #   post.comments.build(body: "good morning.")
+  #   post.title += "!"
+  #   post.save # => saves both post and comments.
+  #
+  # Destroying one of the associated models as part of the parent's save action
+  # is as simple as marking it for destruction:
+  #
+  #   post.comments # => [#<Comment id: 1, ...>, #<Comment id: 2, ...]>
+  #   post.comments[1].mark_for_destruction
+  #   post.comments[1].marked_for_destruction? # => true
+  #   post.comments.length # => 2
+  #
+  # Note that the model is _not_ yet removed from the database:
+  #
+  #   id = post.comments.last.id
+  #   Comment.find_by(id: id).nil? # => false
+  #
+  #   post.save
+  #   post.reload.comments.length # => 1
+  #
+  # Now it _is_ removed from the database:
+  #
+  #   Comment.find_by(id: id).nil? # => true
+  module NestedValidateAssociation
+    extend ActiveSupport::Concern
+
+    module AssociationBuilderExtension #:nodoc:
+      def self.build(model, reflection)
+        model.send(:add_nested_validate_association_callbacks, reflection)
+      end
+
+      def self.valid_options
+        []
+      end
+    end
+
+    included do
+      Associations::Builder::Association.extensions << AssociationBuilderExtension
+      mattr_accessor :index_nested_attribute_errors, instance_writer: false
+      self.index_nested_attribute_errors = false
+    end
+
+    module ClassMethods # :nodoc:
+      private
+
+      def define_non_cyclic_method(name, &block)
+        return if method_defined?(name)
+        define_method(name) do |*args|
+          result = true; @_already_called ||= {}
+          # Loop prevention for validation of associations
+          unless @_already_called[name]
+            begin
+              @_already_called[name] = true
+              result = instance_eval(&block)
+            ensure
+              @_already_called[name] = false
+            end
+          end
+
+          result
+        end
+      end
+
+      # Adds validation and save callbacks for the association as specified by
+      # the +reflection+.
+      #
+      # For performance reasons, we don't check whether to validate at runtime.
+      # However the validation and callback methods are lazy and those methods
+      # get created when they are invoked for the very first time. However,
+      # this can change, for instance, when using nested attributes, which is
+      # called _after_ the association has been defined. Since we don't want
+      # the callbacks to get defined multiple times, there are guards that
+      # check if the save or validation methods have already been defined
+      # before actually defining them.
+      def add_nested_validate_association_callbacks(reflection)
+        validation_method = :"validate_associated_records_for_#{reflection.name}"
+        if reflection.validate? && !method_defined?(validation_method)
+          if reflection.collection?
+            method = :validate_collection_association
+          else
+            method = :validate_single_association
+          end
+
+          define_non_cyclic_method(validation_method) do
+            send(method, reflection)
+            # TODO: remove the following line as soon as the return value of
+            # callbacks is ignored, that is, returning `false` does not
+            # display a deprecation warning or halts the callback chain.
+            true
+          end
+          validate validation_method
+          after_validation :_ensure_no_duplicate_errors
+        end
+      end
+    end
+
+    private
+
+    # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
+    # turned on for the association.
+    def validate_single_association(reflection)
+      association = association_instance_get(reflection.name)
+      record      = association&.reader
+      association_valid?(reflection, record) if record
+    end
+
+    # Validate the associated records if <tt>:validate</tt> or
+    # <tt>:autosave</tt> is turned on for the association specified by
+    # +reflection+.
+    def validate_collection_association(reflection)
+      if association = association_instance_get(reflection.name)
+        if records = association.target
+          records.each_with_index { |record, index| association_valid?(reflection, record, index) }
+        end
+      end
+    end
+
+    # Returns whether or not the association is valid and applies any errors to
+    # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
+    # enabled records if they're marked_for_destruction? or destroyed.
+    def association_valid?(reflection, record, index = nil)
+      unless valid = record.valid?
+        indexed_attribute = !index.nil? && (reflection.options[:index_errors] || DuckRecord::Base.index_nested_attribute_errors)
+
+        record.errors.each do |attribute, message|
+          attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
+          errors[attribute] << message
+          errors[attribute].uniq!
+        end
+
+        record.errors.details.each_key do |attribute|
+          reflection_attribute =
+            normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym
+
+          record.errors.details[attribute].each do |error|
+            errors.details[reflection_attribute] << error
+            errors.details[reflection_attribute].uniq!
+          end
+        end
+      end
+      valid
+    end
+
+    def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
+      if indexed_attribute
+        "#{reflection.name}[#{index}].#{attribute}"
+      else
+        "#{reflection.name}.#{attribute}"
+      end
+    end
+
+    def _ensure_no_duplicate_errors
+      errors.messages.each_key do |attribute|
+        errors[attribute].uniq!
+      end
+    end
+  end
+end

data/lib/duck_record/reflection.rb

@@ -0,0 +1,309 @@
+require "thread"
+require "active_support/core_ext/string/filters"
+require "active_support/deprecation"
+
+module DuckRecord
+  # = Active Record Reflection
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_reflections, instance_writer: false
+      self._reflections = {}
+    end
+
+    def self.create(macro, name, options, ar)
+      klass = \
+        case macro
+        when :has_many
+          HasManyReflection
+        when :has_one
+          HasOneReflection
+        else
+          raise "Unsupported Macro: #{macro}"
+        end
+
+      klass.new(name, options, ar)
+    end
+
+    def self.add_reflection(ar, name, reflection)
+      ar.clear_reflections_cache
+      ar._reflections = ar._reflections.merge(name.to_s => reflection)
+    end
+
+    # \Reflection enables the ability to examine the associations and aggregations of
+    # Active Record classes and objects. This information, for example,
+    # can be used in a form builder that takes an Active Record object
+    # and creates input fields for all of the attributes depending on their type
+    # and displays the associations to other objects.
+    #
+    # MacroReflection class has info for AggregateReflection and AssociationReflection
+    # classes.
+    module ClassMethods
+      # Returns a Hash of name of the reflection as the key and an AssociationReflection as the value.
+      #
+      #   Account.reflections # => {"balance" => AggregateReflection}
+      #
+      def reflections
+        @__reflections ||= begin
+          ref = {}
+
+          _reflections.each do |name, reflection|
+            parent_reflection = reflection.parent_reflection
+
+            if parent_reflection
+              parent_name = parent_reflection.name
+              ref[parent_name.to_s] = parent_reflection
+            else
+              ref[name] = reflection
+            end
+          end
+
+          ref
+        end
+      end
+
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
+      # Example:
+      #
+      #   Account.reflect_on_all_associations             # returns an array of all associations
+      #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      #
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values
+        association_reflections.select! { |reflection| reflection.macro == macro } if macro
+        association_reflections
+      end
+
+      # Returns the AssociationReflection object for the +association+ (use the symbol).
+      #
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #
+      def reflect_on_association(association)
+        reflections[association.to_s]
+      end
+
+      def _reflect_on_association(association) #:nodoc:
+        _reflections[association.to_s]
+      end
+
+      def clear_reflections_cache # :nodoc:
+        @__reflections = nil
+      end
+    end
+
+    # Holds all the methods that are shared between MacroReflection and ThroughReflection.
+    #
+    #   AbstractReflection
+    #     MacroReflection
+    #       AggregateReflection
+    #       AssociationReflection
+    #         HasManyReflection
+    #         HasOneReflection
+    #         BelongsToReflection
+    #         HasAndBelongsToManyReflection
+    #     ThroughReflection
+    #     PolymorphicReflection
+    #       RuntimeReflection
+    class AbstractReflection # :nodoc:
+      # Returns a new, unsaved instance of the associated class. +attributes+ will
+      # be passed to the class's constructor.
+      def build_association(attributes, &block)
+        klass.new(attributes, &block)
+      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      end
+
+      def check_validity!
+        true
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}"
+      end
+    end
+
+    # Base class for AggregateReflection and AssociationReflection. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    class MacroReflection < AbstractReflection
+      # Returns the name of the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>{ class_name: "Money" }</tt>
+      # <tt>has_many :clients</tt> returns <tt>{}</tt>
+      attr_reader :options
+
+      attr_reader :active_record
+
+      attr_reader :plural_name # :nodoc:
+
+      def initialize(name, options, active_record)
+        @name          = name
+        @options       = options
+        @active_record = active_record
+        @klass         = options[:anonymous_class]
+        @plural_name   = name.to_s.pluralize
+      end
+
+      # Returns the class for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns the Money class
+      # <tt>has_many :clients</tt> returns the Client class
+      def klass
+        @klass ||= compute_class(class_name)
+      end
+
+      def compute_class(name)
+        name.constantize
+      end
+
+      private
+
+      def derive_class_name
+        name.to_s.camelize
+      end
+    end
+
+    # Holds all the metadata about an association as it was specified in the
+    # Active Record class.
+    class AssociationReflection < MacroReflection #:nodoc:
+      # Returns the target association's class.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
+      def klass
+        @klass ||= compute_class(class_name)
+      end
+
+      def compute_class(name)
+        active_record.send(:compute_type, name)
+      end
+
+      attr_accessor :parent_reflection # Reflection
+
+      def initialize(name, options, active_record)
+        super
+        @constructable = calculate_constructable(macro, options)
+
+        if options[:class_name] && options[:class_name].class == Class
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing a class to the `class_name` is deprecated and will raise
+            an ArgumentError in Rails 5.2. It eagerloads more classes than
+            necessary and potentially creates circular dependencies.
+
+            Please pass the class name as a string:
+            `#{macro} :#{name}, class_name: '#{options[:class_name]}'`
+          MSG
+        end
+      end
+
+      def constructable? # :nodoc:
+        @constructable
+      end
+
+      def source_reflection
+        self
+      end
+
+      def nested?
+        false
+      end
+
+      # Returns the macro type.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      def macro; raise NotImplementedError; end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        false
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>validate: false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>validate: true</tt>
+      # * you use autosave; <tt>autosave: true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : collection?
+      end
+
+      # Returns +true+ if +self+ is a +has_one+ reflection.
+      def has_one?; false; end
+
+      def association_class; raise NotImplementedError; end
+
+      def add_as_source(seed)
+        seed
+      end
+
+      protected
+
+      def actual_source_reflection # FIXME: this is a horrible name
+        self
+      end
+
+      private
+
+      def calculate_constructable(macro, options)
+        true
+      end
+
+      def derive_class_name
+        class_name = name.to_s
+        class_name = class_name.singularize if collection?
+        class_name.camelize
+      end
+    end
+
+    class HasManyReflection < AssociationReflection # :nodoc:
+      def macro; :has_many; end
+
+      def collection?; true; end
+
+      def association_class
+        Associations::HasManyAssociation
+      end
+    end
+
+    class HasOneReflection < AssociationReflection # :nodoc:
+      def macro; :has_one; end
+
+      def has_one?; true; end
+
+      def association_class
+        Associations::HasOneAssociation
+      end
+    end
+  end
+end

data/lib/duck_record/version.rb

@@ -1,3 +1,3 @@
 module DuckRecord
-  VERSION = '0.0.3'
+  VERSION = '0.0.5'
 end

data/lib/duck_record.rb

@@ -14,6 +14,8 @@ module DuckRecord
   autoload :Core
   autoload :Inheritance
   autoload :ModelSchema
+  autoload :NestedAttributes
+  autoload :Reflection
   autoload :Serialization
   autoload :Translation
   autoload :Validations
@@ -21,8 +23,10 @@ module DuckRecord
   eager_autoload do
     autoload :DuckRecordError, 'duck_record/errors'
 
+    autoload :Associations
     autoload :AttributeAssignment
     autoload :AttributeMethods
+    autoload :NestedValidateAssociation
   end
 
   module AttributeMethods
@@ -38,10 +42,12 @@ module DuckRecord
 
   def self.eager_load!
     super
-    ActiveRecord::AttributeMethods.eager_load!
+
+    DuckRecord::Associations.eager_load!
+    DuckRecord::AttributeMethods.eager_load!
   end
 end
 
-# ActiveSupport.on_load(:i18n) do
-#   I18n.load_path << File.dirname(__FILE__) + '/duck_record/locale/en.yml'
-# end
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.dirname(__FILE__) + '/duck_record/locale/en.yml'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_record
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - jasl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-11 00:00:00.000000000 Z
+date: 2017-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,6 +66,18 @@ files:
 - README.md
 - Rakefile
 - lib/duck_record.rb
+- lib/duck_record/associations.rb
+- lib/duck_record/associations/association.rb
+- lib/duck_record/associations/builder/association.rb
+- lib/duck_record/associations/builder/collection_association.rb
+- lib/duck_record/associations/builder/has_many.rb
+- lib/duck_record/associations/builder/has_one.rb
+- lib/duck_record/associations/builder/singular_association.rb
+- lib/duck_record/associations/collection_association.rb
+- lib/duck_record/associations/collection_proxy.rb
+- lib/duck_record/associations/has_many_association.rb
+- lib/duck_record/associations/has_one_association.rb
+- lib/duck_record/associations/singular_association.rb
 - lib/duck_record/attribute.rb
 - lib/duck_record/attribute/user_provided_default.rb
 - lib/duck_record/attribute_assignment.rb
@@ -86,6 +98,9 @@ files:
 - lib/duck_record/inheritance.rb
 - lib/duck_record/locale/en.yml
 - lib/duck_record/model_schema.rb
+- lib/duck_record/nested_attributes.rb
+- lib/duck_record/nested_validate_association.rb
+- lib/duck_record/reflection.rb
 - lib/duck_record/serialization.rb
 - lib/duck_record/translation.rb
 - lib/duck_record/type.rb