all_futures 1.0.2 → 2.0.0

data/lib/vendor/active_entity/associations/embeds/builder/association.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# This is the parent Association class which defines the variables
+# used by all associations.
+#
+# The hierarchy is defined as follows:
+#  Association
+#    - SingularAssociation
+#      - BelongsToAssociation
+#      - HasOneAssociation
+#    - CollectionAssociation
+#      - HasManyAssociation
+
+module ActiveEntity::Associations::Embeds::Builder # :nodoc:
+  class Association #:nodoc:
+    class << self
+      attr_accessor :extensions
+    end
+    self.extensions = []
+
+    VALID_OPTIONS = [:class_name, :anonymous_class, :validate] # :nodoc:
+
+    def self.build(model, name, options)
+      if model.dangerous_attribute_method?(name)
+        raise ArgumentError, "You tried to define an association named #{name} on the model #{model.name}, but " \
+                             "this will conflict with a method #{name} already defined by Active Entity. " \
+                             "Please choose a different association name."
+      end
+
+      reflection = create_reflection model, name, options
+      define_accessors model, reflection
+      define_callbacks model, reflection
+      define_validations model, reflection
+      reflection
+    end
+
+    def self.create_reflection(model, name, options, &block)
+      raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
+
+      validate_options(options)
+
+      extension = define_extensions(model, name, &block)
+      options[:extend] = [*options[:extend], extension] if extension
+
+      ActiveEntity::Reflection.create(macro, name, nil, options, model)
+    end
+
+    def self.macro
+      raise NotImplementedError
+    end
+
+    def self.valid_options(options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
+    end
+
+    def self.validate_options(options)
+      options.assert_valid_keys(valid_options(options))
+    end
+
+    def self.define_extensions(model, name)
+    end
+
+    def self.define_callbacks(model, reflection)
+      Association.extensions.each do |extension|
+        extension.build model, reflection
+      end
+    end
+
+    # Defines the setter and getter methods for the association
+    # class Post < ActiveEntity::Base
+    #   has_many :comments
+    # end
+    #
+    # Post.first.comments and Post.first.comments= methods are defined by this method...
+    def self.define_accessors(model, reflection)
+      mixin = model.generated_association_methods
+      name = reflection.name
+      define_readers(mixin, name)
+      define_writers(mixin, name)
+    end
+
+    def self.define_readers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}
+          association(:#{name}).reader
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          association(:#{name}).writer(value)
+        end
+      CODE
+    end
+
+    def self.define_validations(_model, _reflection)
+      # noop
+    end
+
+    private_class_method :macro, :valid_options, :validate_options, :define_extensions,
+                         :define_callbacks, :define_accessors, :define_readers, :define_writers, :define_validations
+  end
+end

data/lib/vendor/active_entity/associations/embeds/builder/collection_association.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "active_entity/associations"
+
+module ActiveEntity::Associations::Embeds::Builder # :nodoc:
+  class CollectionAssociation < Association #:nodoc:
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+
+    def self.valid_options(options)
+      super + [:before_add, :after_add, :before_remove, :after_remove, :extend]
+    end
+
+    def self.define_callbacks(model, reflection)
+      super
+      name    = reflection.name
+      options = reflection.options
+      CALLBACKS.each { |callback_name|
+        define_callback(model, callback_name, name, options)
+      }
+    end
+
+    def self.define_extensions(model, name, &block)
+      if block_given?
+        extension_module_name = "#{name.to_s.camelize}AssociationExtension"
+        extension = Module.new(&block)
+        model.const_set(extension_module_name, extension)
+      end
+    end
+
+    def self.define_callback(model, callback_name, name, options)
+      full_callback_name = "#{callback_name}_for_#{name}"
+
+      # TODO : why do i need method_defined? I think its because of the inheritance chain
+      model.class_attribute full_callback_name unless model.method_defined?(full_callback_name)
+      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+        case callback
+        when Symbol
+          ->(_method, owner, record) { owner.send(callback, record) }
+        when Proc
+          ->(_method, owner, record) { callback.call(owner, record) }
+        else
+          ->(method, owner, record) { callback.send(method, owner, record) }
+        end
+      end
+      model.send "#{full_callback_name}=", callbacks
+    end
+
+    # Defines the setter and getter methods for the collection_singular_ids.
+    def self.define_readers(mixin, name)
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids
+          association(:#{name}).ids_reader
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name)
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
+        end
+      CODE
+    end
+
+    private_class_method :valid_options, :define_callback, :define_extensions, :define_readers, :define_writers
+  end
+end

data/lib/vendor/active_entity/associations/embeds/builder/embedded_in.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveEntity::Associations::Embeds::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/vendor/active_entity/associations/embeds/builder/embeds_many.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveEntity::Associations::Embeds::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/vendor/active_entity/associations/embeds/builder/embeds_one.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveEntity::Associations::Embeds::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/vendor/active_entity/associations/embeds/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::Embeds::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/vendor/active_entity/associations/embeds/collection_association.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Associations
+    module Embeds
+      # = 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)
+          records = other_array.map do |val|
+            if val.is_a? reflection.klass
+              val
+            elsif val.nil?
+              next
+            elsif val.respond_to?(:to_h)
+              build_record(val.to_h)
+            end
+          rescue => ex
+            raise_on_type_mismatch!(val)
+            raise ex
+          end
+
+          target.replace records
+        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|
+              r =
+                if record.is_a? reflection.klass
+                  record
+                elsif record.nil?
+                  nil
+                elsif record.respond_to?(:to_h)
+                  build_record(record.to_h)
+                end
+              add_to_target(r)
+            rescue => ex
+              raise_on_type_mismatch!(record)
+              raise ex
+            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