all_futures 1.0.2 → 2.0.0

data/lib/vendor/active_entity/associations/embeds/collection_proxy.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Associations
+    module Embeds
+      # 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, :size, 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

data/lib/vendor/active_entity/associations/embeds/embedded_in_association.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Associations
+    module Embeds
+      # = Active Entity Belongs To Association
+      class EmbeddedInAssociation < SingularAssociation #:nodoc:
+        def default(&block)
+          writer(owner.instance_exec(&block)) if reader.nil?
+        end
+
+        private
+
+          def replace(record)
+            if record
+              raise_on_type_mismatch!(record)
+              set_inverse_instance(record)
+            end
+
+            self.target = record
+          end
+          # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
+          # has_one associations.
+          def invertible_for?(record)
+            inverse = inverse_reflection_for(record)
+            inverse&.embeds_one?
+          end
+      end
+    end
+  end
+end

data/lib/vendor/active_entity/associations/embeds/embeds_many_association.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Associations
+    module Embeds
+      # = Active Entity Has Many Association
+      # This is the proxy that handles a has many association.
+      #
+      # If the association has a <tt>:through</tt> option further specialization
+      # is provided by its child HasManyThroughAssociation.
+      class EmbedsManyAssociation < CollectionAssociation #:nodoc:
+      end
+    end
+  end
+end

data/lib/vendor/active_entity/associations/embeds/embeds_one_association.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Associations
+    module Embeds
+      # = Active Entity Has One Association
+      class EmbedsOneAssociation < SingularAssociation #:nodoc:
+        private
+
+          def replace(record)
+            self.target =
+              if record.is_a? reflection.klass
+                record
+              elsif record.nil?
+                nil
+              elsif record.respond_to?(:to_h)
+                build_record(record.to_h)
+              end
+          rescue => ex
+            raise_on_type_mismatch!(record)
+            raise ex
+          end
+      end
+    end
+  end
+end

data/lib/vendor/active_entity/associations/embeds/singular_association.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Associations
+    module Embeds
+      class SingularAssociation < Association #:nodoc:
+        # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
+        def reader
+          target
+        end
+
+        # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
+        def writer(record)
+          replace(record)
+        end
+
+        def build(attributes = {}, &block)
+          record = build_record(attributes, &block)
+          set_new_record(record)
+          record
+        end
+
+        private
+
+          def replace(_record)
+            raise NotImplementedError, "Subclasses must implement a replace(record) method"
+          end
+
+          def set_new_record(record)
+            replace(record)
+          end
+      end
+    end
+  end
+end

data/lib/vendor/active_entity/associations.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/string/conversions"
+
+module ActiveEntity
+  class AssociationNotFoundError < ConfigurationError #:nodoc:
+    def initialize(record = nil, association_name = nil)
+      if record && association_name
+        super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
+      else
+        super("Association was not found.")
+      end
+    end
+  end
+
+  class InverseOfAssociationNotFoundError < ActiveEntityError #:nodoc:
+    def initialize(reflection = nil, associated_class = nil)
+      if reflection
+        super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
+      else
+        super("Could not find the inverse association.")
+      end
+    end
+  end
+
+  # See ActiveEntity::Associations::ClassMethods for documentation.
+  module Associations # :nodoc:
+    extend ActiveSupport::Autoload
+    extend ActiveSupport::Concern
+    # These classes will be loaded when associations are created.
+    # So there is no need to eager load them.
+    module Embeds
+      extend ActiveSupport::Autoload
+
+      autoload :Association, "active_entity/associations/embeds/association"
+      autoload :SingularAssociation, "active_entity/associations/embeds/singular_association"
+      autoload :CollectionAssociation, "active_entity/associations/embeds/collection_association"
+      autoload :CollectionProxy, "active_entity/associations/embeds/collection_proxy"
+
+      module Builder #:nodoc:
+        autoload :Association,             "active_entity/associations/embeds/builder/association"
+        autoload :SingularAssociation,     "active_entity/associations/embeds/builder/singular_association"
+        autoload :CollectionAssociation,   "active_entity/associations/embeds/builder/collection_association"
+
+        autoload :EmbeddedIn,              "active_entity/associations/embeds/builder/embedded_in"
+        autoload :EmbedsOne,               "active_entity/associations/embeds/builder/embeds_one"
+        autoload :EmbedsMany,              "active_entity/associations/embeds/builder/embeds_many"
+      end
+
+      eager_autoload do
+        autoload :EmbeddedInAssociation
+        autoload :EmbedsOneAssociation
+        autoload :EmbedsManyAssociation
+      end
+    end
+
+    def self.eager_load!
+      super
+      Embeds.eager_load!
+    end
+    # Returns the association instance for the given name, instantiating it if it doesn't already exist
+    def association(name) #:nodoc:
+      association = association_instance_get(name)
+
+      if association.nil?
+        unless reflection = self.class._reflect_on_association(name)
+          raise AssociationNotFoundError.new(self, name)
+        end
+        association = reflection.association_class.new(self, reflection)
+        association_instance_set(name, association)
+      end
+
+      association
+    end
+
+    def association_cached?(name) # :nodoc:
+      @association_cache.key?(name)
+    end
+
+    def initialize_dup(*) # :nodoc:
+      @association_cache = {}
+      super
+    end
+
+    private
+
+      def init_internals
+        @association_cache = {}
+        super
+      end
+
+      # Returns the specified association instance if it exists, +nil+ otherwise.
+      def association_instance_get(name)
+        @association_cache[name]
+      end
+
+      # Set the specified association instance.
+      def association_instance_set(name, association)
+        @association_cache[name] = association
+      end
+
+      # \Associations are a set of macro-like class methods for tying objects together through
+      # foreign keys. They express relationships like "Project has one Project Manager"
+      # or "Project belongs to a Portfolio". Each macro adds a number of methods to the
+      # class which are specialized according to the collection or association symbol and the
+      # options hash. It works much the same way as Ruby's own <tt>attr*</tt>
+      # methods.
+      #
+      #   class Project < ActiveEntity::Base
+      #     belongs_to              :portfolio
+      #     has_one                 :project_manager
+      #     has_many                :milestones
+      #     has_and_belongs_to_many :categories
+      #   end
+      #
+      # The project class now has the following methods (and more) to ease the traversal and
+      # manipulation of its relationships:
+      # * <tt>Project#portfolio</tt>, <tt>Project#portfolio=(portfolio)</tt>, <tt>Project#reload_portfolio</tt>
+      # * <tt>Project#project_manager</tt>, <tt>Project#project_manager=(project_manager)</tt>, <tt>Project#reload_project_manager</tt>
+      # * <tt>Project#milestones.empty?</tt>, <tt>Project#milestones.size</tt>, <tt>Project#milestones</tt>, <tt>Project#milestones<<(milestone)</tt>,
+      #   <tt>Project#milestones.delete(milestone)</tt>, <tt>Project#milestones.destroy(milestone)</tt>, <tt>Project#milestones.find(milestone_id)</tt>,
+      #   <tt>Project#milestones.build</tt>, <tt>Project#milestones.create</tt>
+      # * <tt>Project#categories.empty?</tt>, <tt>Project#categories.size</tt>, <tt>Project#categories</tt>, <tt>Project#categories<<(category1)</tt>,
+      #   <tt>Project#categories.delete(category1)</tt>, <tt>Project#categories.destroy(category1)</tt>
+      #
+      # === A word of warning
+      #
+      # Don't create associations that have the same name as {instance methods}[rdoc-ref:ActiveEntity::Core] of
+      # <tt>ActiveEntity::Base</tt>. Since the association adds a method with that name to
+      # its model, using an association with the same name as one provided by <tt>ActiveEntity::Base</tt> will override the method inherited through <tt>ActiveEntity::Base</tt> and will break things.
+      # For instance, +attributes+ and +connection+ would be bad choices for association names, because those names already exist in the list of <tt>ActiveEntity::Base</tt> instance methods.
+      module ClassMethods
+        def embedded_in(name, **options)
+          reflection = Embeds::Builder::EmbeddedIn.build(self, name, options)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def embeds_one(name, **options)
+          reflection = Embeds::Builder::EmbedsOne.build(self, name, options)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def embeds_many(name, **options)
+          reflection = Embeds::Builder::EmbedsMany.build(self, name, options)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def association_names
+          @association_names ||=
+            if !abstract_class?
+              reflections.keys.map(&:to_sym)
+            else
+              []
+            end
+        end
+
+        def embeds_association_names
+          @association_names ||=
+            if !abstract_class?
+              reflections.select { |_, r| r.embedded? }.keys.map(&:to_sym)
+            else
+              []
+            end
+        end
+      end
+  end
+end

data/lib/vendor/active_entity/attribute_assignment.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "active_model/forbidden_attributes_protection"
+
+module ActiveEntity
+  module AttributeAssignment
+    include ActiveModel::AttributeAssignment
+
+    private
+
+      def _assign_attributes(attributes)
+        multi_parameter_attributes = nested_parameter_attributes = nil
+
+        attributes.each do |k, v|
+          key = k.to_s
+
+          if key.include?("(")
+            (multi_parameter_attributes ||= {})[key] = v
+          elsif v.is_a?(Hash)
+            (nested_parameter_attributes ||= {})[key] = v
+          else
+            _assign_attribute(key, v)
+          end
+        end
+
+        assign_nested_parameter_attributes(nested_parameter_attributes) if nested_parameter_attributes
+        assign_multiparameter_attributes(multi_parameter_attributes) if multi_parameter_attributes
+      end
+
+      # Assign any deferred nested attributes after the base attributes have been set.
+      def assign_nested_parameter_attributes(pairs)
+        pairs.each { |k, v| _assign_attribute(k, v) }
+      end
+
+      # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
+      # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
+      # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
+      # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
+      # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Integer and
+      # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
+      def assign_multiparameter_attributes(pairs)
+        execute_callstack_for_multiparameter_attributes(
+          extract_callstack_for_multiparameter_attributes(pairs)
+        )
+      end
+
+      def execute_callstack_for_multiparameter_attributes(callstack)
+        errors = []
+        callstack.each do |name, values_with_empty_parameters|
+          if values_with_empty_parameters.each_value.all?(&:nil?)
+            values = nil
+          else
+            values = values_with_empty_parameters
+          end
+          send("#{name}=", values)
+        rescue => ex
+          errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
+        end
+        unless errors.empty?
+          error_descriptions = errors.map(&:message).join(",")
+          raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
+        end
+      end
+
+      def extract_callstack_for_multiparameter_attributes(pairs)
+        attributes = {}
+
+        pairs.each do |(multiparameter_name, value)|
+          attribute_name = multiparameter_name.split("(").first
+          attributes[attribute_name] ||= {}
+
+          parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
+          attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
+        end
+
+        attributes
+      end
+
+      def type_cast_attribute_value(multiparameter_name, value)
+        multiparameter_name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
+      end
+
+      def find_parameter_position(multiparameter_name)
+        multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
+      end
+  end
+end