activeentity 0.0.1.beta1

data/lib/active_entity/associations/embedded/builder/embedded_in.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveEntity::Associations::Embedded::Builder # :nodoc:
+  class EmbeddedIn < SingularAssociation #:nodoc:
+    def self.macro
+      :embedded_in
+    end
+
+    def self.valid_options(options)
+      super + [:default]
+    end
+
+    def self.define_callbacks(model, reflection)
+      super
+      add_default_callbacks(model, reflection) if reflection.options[:default]
+    end
+
+    def self.add_default_callbacks(model, reflection)
+      model.before_validation lambda { |o|
+        o.association(reflection.name).default(&reflection.options[:default])
+      }
+    end
+
+    def self.define_validations(model, reflection)
+      if reflection.options.key?(:required)
+        reflection.options[:optional] = !reflection.options.delete(:required)
+      end
+
+      required = !reflection.options[:optional]
+
+      super
+
+      if required
+        model.validates_presence_of reflection.name, message: :required
+      end
+    end
+  end
+end

data/lib/active_entity/associations/embedded/builder/embeds_many.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveEntity::Associations::Embedded::Builder # :nodoc:
+  class EmbedsMany < CollectionAssociation #:nodoc:
+    def self.macro
+      :embeds_many
+    end
+
+    def self.valid_options(options)
+      super + [:inverse_of, :index_errors]
+    end
+  end
+end

data/lib/active_entity/associations/embedded/builder/embeds_one.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveEntity::Associations::Embedded::Builder # :nodoc:
+  class EmbedsOne < SingularAssociation #:nodoc:
+    def self.macro
+      :embeds_one
+    end
+
+    def self.define_validations(model, reflection)
+      super
+      if reflection.options[:required]
+        model.validates_presence_of reflection.name, message: :required
+      end
+    end
+  end
+end

data/lib/active_entity/associations/embedded/builder/singular_association.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# This class is inherited by the has_one and belongs_to association classes
+
+module ActiveEntity::Associations::Embedded::Builder # :nodoc:
+  class SingularAssociation < Association #:nodoc:
+    def self.valid_options(options)
+      super + [:inverse_of, :required]
+    end
+
+    def self.define_accessors(model, reflection)
+      super
+      mixin = model.generated_association_methods
+      name = reflection.name
+
+      define_constructors(mixin, name) if reflection.constructable?
+    end
+
+    # Defines the (build|create)_association methods for belongs_to or has_one association
+    def self.define_constructors(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def build_#{name}(*args, &block)
+          association(:#{name}).build(*args, &block)
+        end
+      CODE
+    end
+  end
+end

data/lib/active_entity/associations/embedded/collection_association.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Associations
+    module Embedded
+      # = Active Entity Association Collection
+      #
+      # CollectionAssociation is an abstract class that provides common stuff to
+      # ease the implementation of association proxies that represent
+      # collections. See the class hierarchy in Association.
+      #
+      #   CollectionAssociation:
+      #     HasManyAssociation => has_many
+      #       HasManyThroughAssociation + ThroughAssociation => has_many :through
+      #
+      # The CollectionAssociation class provides common methods to the collections
+      # defined by +has_and_belongs_to_many+, +has_many+ or +has_many+ with
+      # the +:through association+ option.
+      #
+      # You need to be careful with assumptions regarding the target: The proxy
+      # does not fetch records from the database until it needs them, but new
+      # ones created with +build+ are added to the target. So, the target may be
+      # non-empty and still lack children waiting to be read from the database.
+      # If you look directly to the database you cannot assume that's the entire
+      # collection because new records may have been added to the target, etc.
+      #
+      # If you need to work on all current children, new and existing records,
+      # +load_target+ and the +loaded+ flag are your friends.
+      class CollectionAssociation < Association #:nodoc:
+        def initialize(owner, reflection)
+          super
+
+          @target = []
+        end
+
+        # Implements the reader method, e.g. foo.items for Foo.has_many :items
+        def reader
+          @proxy ||= CollectionProxy.new(klass, self)
+        end
+
+        # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+        def writer(records)
+          replace(records)
+        end
+
+        def find(&block)
+          target.find(&block)
+        end
+
+        def build(attributes = {}, &block)
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| build(attr, &block) }
+          else
+            add_to_target(build_record(attributes, &block))
+          end
+        end
+
+        # Add +records+ to this association. Returns +self+ so method calls may
+        # be chained. Since << flattens its argument list and inserts each record,
+        # +push+ and +concat+ behave identically.
+        def concat(*records)
+          records = records.flatten
+          concat_records(records)
+        end
+
+        # Removes all records from the association without calling callbacks
+        # on the associated records. It honors the +:dependent+ option. However
+        # if the +:dependent+ value is +:destroy+ then in that case the +:delete_all+
+        # deletion strategy for the association is applied.
+        #
+        # You can force a particular deletion strategy by passing a parameter.
+        #
+        # Example:
+        #
+        # @author.books.delete_all(:nullify)
+        # @author.books.delete_all(:delete_all)
+        #
+        # See delete for more info.
+        def delete_all
+          target.clear
+        end
+        alias destroy_all delete_all
+
+        # Removes +records+ from this association calling +before_remove+ and
+        # +after_remove+ callbacks.
+        #
+        # This method is abstract in the sense that +delete_records+ has to be
+        # provided by descendants. Note this method does not imply the records
+        # are actually removed from the database, that depends precisely on
+        # +delete_records+. They are in any case removed from the collection.
+        def delete(*records)
+          records.each do |record|
+            target.delete(record)
+          end
+        end
+        alias destroy delete
+
+        # Returns the size of the collection by executing a SELECT COUNT(*)
+        # query if the collection hasn't been loaded, and calling
+        # <tt>collection.size</tt> if it has.
+        #
+        # If the collection has been already loaded +size+ and +length+ are
+        # equivalent. If not and you are going to need the records anyway
+        # +length+ will take one less query. Otherwise +size+ is more efficient.
+        #
+        # This method is abstract in the sense that it relies on
+        # +count_records+, which is a method descendants have to provide.
+        def size
+          target.size
+        end
+
+        # Returns true if the collection is empty.
+        #
+        # If the collection has been loaded
+        # it is equivalent to <tt>collection.size.zero?</tt>. If the
+        # collection has not been loaded, it is equivalent to
+        # <tt>collection.exists?</tt>. If the collection has not already been
+        # loaded and you are going to fetch the records anyway it is better to
+        # check <tt>collection.length.zero?</tt>.
+        def empty?
+          size.zero?
+        end
+
+        # Replace this collection with +other_array+. This will perform a diff
+        # and delete/add only records that have changed.
+        def replace(other_array)
+          other_array.each { |val| raise_on_type_mismatch!(val) }
+
+          target.replace other_array
+        end
+
+        def include?(record)
+          if record.is_a?(reflection.klass)
+            target.include?(record)
+          else
+            false
+          end
+        end
+
+        def add_to_target(record, skip_callbacks = false, &block)
+          # index = @target.index(record)
+          # replace_on_target(record, index, skip_callbacks, &block)
+          replace_on_target(record, nil, skip_callbacks, &block)
+        end
+
+        private
+
+          def concat_records(records)
+            records.each do |record|
+              raise_on_type_mismatch!(record)
+              add_to_target(record)
+            end
+
+            records
+          end
+
+          def replace_on_target(record, index, skip_callbacks)
+            callback(:before_add, record) unless skip_callbacks
+
+            set_inverse_instance(record)
+
+            yield(record) if block_given?
+
+            if index
+              target[index] = record
+            else
+              target << record
+            end
+
+            callback(:after_add, record) unless skip_callbacks
+
+            record
+          end
+
+          def callback(method, record)
+            callbacks_for(method).each do |callback|
+              callback.call(method, owner, record)
+            end
+          end
+
+          def callbacks_for(callback_name)
+            full_callback_name = "#{callback_name}_for_#{reflection.name}"
+            owner.class.send(full_callback_name)
+          end
+      end
+    end
+  end
+end

data/lib/active_entity/associations/embedded/collection_proxy.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Associations
+    module Embedded
+      # Association proxies in Active Entity are middlemen between the object that
+      # holds the association, known as the <tt>@owner</tt>, and the actual associated
+      # object, known as the <tt>@target</tt>. The kind of association any proxy is
+      # about is available in <tt>@reflection</tt>. That's an instance of the class
+      # ActiveEntity::Reflection::AssociationReflection.
+      #
+      # For example, given
+      #
+      #   class Blog < ActiveEntity::Base
+      #     has_many :posts
+      #   end
+      #
+      #   blog = Blog.first
+      #
+      # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
+      # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
+      # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
+      #
+      # This class delegates unknown methods to <tt>@target</tt> via
+      # <tt>method_missing</tt>.
+      #
+      # The <tt>@target</tt> object is not \loaded until needed. For example,
+      #
+      #   blog.posts.count
+      #
+      # is computed directly through SQL and does not trigger by itself the
+      # instantiation of the actual post records.
+      class CollectionProxy
+        include Enumerable
+
+        attr_reader :klass
+        alias :model :klass
+
+        delegate :to_xml, :encode_with, :length, :each, :join,
+                 :[], :&, :|, :+, :-, :sample, :reverse, :rotate, :compact, :in_groups, :in_groups_of,
+                 :find, :last, :take, :blank?, :present?, :empty?, :any?, :one?, :many?, :include?,
+                 :to_sentence, :to_formatted_s, :as_json,
+                 :shuffle, :split, :slice, :index, :rindex, to: :records
+
+        def initialize(klass, association)
+          @klass = klass
+
+          @association = association
+
+          extensions = association.extensions
+          extend(*extensions) if extensions.any?
+        end
+
+        # Initializes new record from relation while maintaining the current
+        # scope.
+        #
+        # Expects arguments in the same format as {ActiveEntity::Base.new}[rdoc-ref:Core.new].
+        #
+        #   users = User.where(name: 'DHH')
+        #   user = users.new # => #<User id: nil, name: "DHH", created_at: nil, updated_at: nil>
+        #
+        # You can also pass a block to new with the new record as argument:
+        #
+        #   user = users.new { |user| user.name = 'Oscar' }
+        #   user.name # => Oscar
+        def new(attributes = nil, &block)
+          klass.new(attributes, &block)
+        end
+
+        alias build new
+
+        def pretty_print(q)
+          q.pp(records)
+        end
+
+        def inspect
+          entries = records.take([size, 11].compact.min).map!(&:inspect)
+
+          entries[10] = "..." if entries.size == 11
+
+          "#<#{self.class.name} [#{entries.join(', ')}]>"
+        end
+
+        # Returns +true+ if the association has been loaded, otherwise +false+.
+        #
+        #   person.pets.loaded? # => false
+        #   person.pets
+        #   person.pets.loaded? # => true
+        def loaded?
+          @association.loaded?
+        end
+
+        # Returns a new object of the collection type that has been instantiated
+        # with +attributes+ and linked to this object, but have not yet been saved.
+        # You can pass an array of attributes hashes, this will return an array
+        # with the new objects.
+        #
+        #   class Person
+        #     has_many :pets
+        #   end
+        #
+        #   person.pets.build
+        #   # => #<Pet id: nil, name: nil, person_id: 1>
+        #
+        #   person.pets.build(name: 'Fancy-Fancy')
+        #   # => #<Pet id: nil, name: "Fancy-Fancy", person_id: 1>
+        #
+        #   person.pets.build([{name: 'Spook'}, {name: 'Choo-Choo'}, {name: 'Brain'}])
+        #   # => [
+        #   #      #<Pet id: nil, name: "Spook", person_id: 1>,
+        #   #      #<Pet id: nil, name: "Choo-Choo", person_id: 1>,
+        #   #      #<Pet id: nil, name: "Brain", person_id: 1>
+        #   #    ]
+        #
+        #   person.pets.size  # => 5 # size of the collection
+        #   person.pets.count # => 0 # count from database
+        def build(attributes = {}, &block)
+          @association.build(attributes, &block)
+        end
+        alias_method :new, :build
+
+        # Add one or more records to the collection by setting their foreign keys
+        # to the association's primary key. Since #<< flattens its argument list and
+        # inserts each record, +push+ and #concat behave identically. Returns +self+
+        # so method calls may be chained.
+        #
+        #   class Person < ActiveEntity::Base
+        #     has_many :pets
+        #   end
+        #
+        #   person.pets.size # => 0
+        #   person.pets.concat(Pet.new(name: 'Fancy-Fancy'))
+        #   person.pets.concat(Pet.new(name: 'Spook'), Pet.new(name: 'Choo-Choo'))
+        #   person.pets.size # => 3
+        #
+        #   person.id # => 1
+        #   person.pets
+        #   # => [
+        #   #       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
+        #   #       #<Pet id: 2, name: "Spook", person_id: 1>,
+        #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
+        #   #    ]
+        #
+        #   person.pets.concat([Pet.new(name: 'Brain'), Pet.new(name: 'Benny')])
+        #   person.pets.size # => 5
+        def concat(*records)
+          @association.concat(*records)
+        end
+
+        # Replaces this collection with +other_array+. This will perform a diff
+        # and delete/add only records that have changed.
+        #
+        #   class Person < ActiveEntity::Base
+        #     has_many :pets
+        #   end
+        #
+        #   person.pets
+        #   # => [#<Pet id: 1, name: "Gorby", group: "cats", person_id: 1>]
+        #
+        #   other_pets = [Pet.new(name: 'Puff', group: 'celebrities']
+        #
+        #   person.pets.replace(other_pets)
+        #
+        #   person.pets
+        #   # => [#<Pet id: 2, name: "Puff", group: "celebrities", person_id: 1>]
+        #
+        # If the supplied array has an incorrect association type, it raises
+        # an <tt>ActiveEntity::AssociationTypeMismatch</tt> error:
+        #
+        #   person.pets.replace(["doo", "ggie", "gaga"])
+        #   # => ActiveEntity::AssociationTypeMismatch: Pet expected, got String
+        def replace(other_array)
+          @association.replace(other_array)
+        end
+
+        def delete_all
+          @association.delete_all
+        end
+        alias destroy_all delete_all
+
+        def delete(*records)
+          @association.delete(*records)
+        end
+        alias destroy delete
+
+        # Equivalent to +delete_all+. The difference is that returns +self+, instead
+        # of an array with the deleted objects, so methods can be chained. See
+        # +delete_all+ for more information.
+        # Note that because +delete_all+ removes records by directly
+        # running an SQL query into the database, the +updated_at+ column of
+        # the object is not changed.
+        def clear
+          delete_all
+          self
+        end
+
+        def proxy_association
+          @association
+        end
+
+        # Equivalent to <tt>Array#==</tt>. Returns +true+ if the two arrays
+        # contain the same number of elements and if each element is equal
+        # to the corresponding element in the +other+ array, otherwise returns
+        # +false+.
+        #
+        #   class Person < ActiveEntity::Base
+        #     has_many :pets
+        #   end
+        #
+        #   person.pets
+        #   # => [
+        #   #      #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
+        #   #      #<Pet id: 2, name: "Spook", person_id: 1>
+        #   #    ]
+        #
+        #   other = person.pets.to_ary
+        #
+        #   person.pets == other
+        #   # => true
+        #
+        #   other = [Pet.new(id: 1), Pet.new(id: 2)]
+        #
+        #   person.pets == other
+        #   # => false
+        def ==(other)
+          records == other
+        end
+
+        ##
+        # :method: to_ary
+        #
+        # :call-seq:
+        #   to_ary()
+        #
+        # Returns a new array of objects from the collection. If the collection
+        # hasn't been loaded, it fetches the records from the database.
+        #
+        #   class Person < ActiveEntity::Base
+        #     has_many :pets
+        #   end
+        #
+        #   person.pets
+        #   # => [
+        #   #       #<Pet id: 4, name: "Benny", person_id: 1>,
+        #   #       #<Pet id: 5, name: "Brain", person_id: 1>,
+        #   #       #<Pet id: 6, name: "Boss",  person_id: 1>
+        #   #    ]
+        #
+        #   other_pets = person.pets.to_ary
+        #   # => [
+        #   #       #<Pet id: 4, name: "Benny", person_id: 1>,
+        #   #       #<Pet id: 5, name: "Brain", person_id: 1>,
+        #   #       #<Pet id: 6, name: "Boss",  person_id: 1>
+        #   #    ]
+        #
+        #   other_pets.replace([Pet.new(name: 'BooGoo')])
+        #
+        #   other_pets
+        #   # => [#<Pet id: nil, name: "BooGoo", person_id: 1>]
+        #
+        #   person.pets
+        #   # This is not affected by replace
+        #   # => [
+        #   #       #<Pet id: 4, name: "Benny", person_id: 1>,
+        #   #       #<Pet id: 5, name: "Brain", person_id: 1>,
+        #   #       #<Pet id: 6, name: "Boss",  person_id: 1>
+        #   #    ]
+        # Converts relation objects to Array.
+        def to_ary
+          records.dup
+        end
+        alias to_a to_ary
+
+        def records # :nodoc:
+          @association.target
+        end
+
+        # Adds one or more +records+ to the collection by setting their foreign keys
+        # to the association's primary key. Returns +self+, so several appends may be
+        # chained together.
+        #
+        #   class Person < ActiveEntity::Base
+        #     has_many :pets
+        #   end
+        #
+        #   person.pets.size # => 0
+        #   person.pets << Pet.new(name: 'Fancy-Fancy')
+        #   person.pets << [Pet.new(name: 'Spook'), Pet.new(name: 'Choo-Choo')]
+        #   person.pets.size # => 3
+        #
+        #   person.id # => 1
+        #   person.pets
+        #   # => [
+        #   #      #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
+        #   #      #<Pet id: 2, name: "Spook", person_id: 1>,
+        #   #      #<Pet id: 3, name: "Choo-Choo", person_id: 1>
+        #   #    ]
+        def <<(*records)
+          proxy_association.concat(records) && self
+        end
+        alias_method :push, :<<
+        alias_method :append, :<<
+
+        def prepend(*_args)
+          raise NoMethodError, "prepend on association is not defined. Please use <<, push or append"
+        end
+      end
+    end
+  end
+end