all_futures 1.0.3 → 2.0.0

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

data/lib/vendor/active_entity/attribute_decorators.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module AttributeDecorators # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :attribute_type_decorations, instance_accessor: false, default: TypeDecorator.new # :internal:
+    end
+
+    module ClassMethods # :nodoc:
+      # This method is an internal API used to create class macros such as
+      # +serialize+, and features like time zone aware attributes.
+      #
+      # Used to wrap the type of an attribute in a new type.
+      # When the schema for a model is loaded, attributes with the same name as
+      # +column_name+ will have their type yielded to the given block. The
+      # return value of that block will be used instead.
+      #
+      # Subsequent calls where +column_name+ and +decorator_name+ are the same
+      # will override the previous decorator, not decorate twice. This can be
+      # used to create idempotent class macros like +serialize+
+      def decorate_attribute_type(column_name, decorator_name, &block)
+        matcher = ->(name, _) { name == column_name.to_s }
+        key = "_#{column_name}_#{decorator_name}"
+        decorate_matching_attribute_types(matcher, key, &block)
+      end
+
+      # This method is an internal API used to create higher level features like
+      # time zone aware attributes.
+      #
+      # When the schema for a model is loaded, +matcher+ will be called for each
+      # attribute with its name and type. If the matcher returns a truthy value,
+      # the type will then be yielded to the given block, and the return value
+      # of that block will replace the type.
+      #
+      # Subsequent calls to this method with the same value for +decorator_name+
+      # will replace the previous decorator, not decorate twice. This can be
+      # used to ensure that class macros are idempotent.
+      def decorate_matching_attribute_types(matcher, decorator_name, &block)
+        reload_schema_from_cache
+        decorator_name = decorator_name.to_s
+
+        # Create new hashes so we don't modify parent classes
+        self.attribute_type_decorations = attribute_type_decorations.merge(decorator_name => [matcher, block])
+      end
+
+      private
+
+        def load_schema!
+          super
+          attribute_types.each do |name, type|
+            decorated_type = attribute_type_decorations.apply(name, type)
+            define_attribute(name, decorated_type)
+          end
+        end
+    end
+
+    class TypeDecorator # :nodoc:
+      delegate :clear, to: :@decorations
+
+      def initialize(decorations = {})
+        @decorations = decorations
+      end
+
+      def merge(*args)
+        TypeDecorator.new(@decorations.merge(*args))
+      end
+
+      def apply(name, type)
+        decorations = decorators_for(name, type)
+        decorations.inject(type) do |new_type, block|
+          block.call(new_type)
+        end
+      end
+
+      private
+
+        def decorators_for(name, type)
+          matching(name, type).map(&:last)
+        end
+
+        def matching(name, type)
+          @decorations.values.select do |(matcher, _)|
+            matcher.call(name, type)
+          end
+        end
+    end
+  end
+end

data/lib/vendor/active_entity/attribute_methods/before_type_cast.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module AttributeMethods
+    # = Active Entity Attribute Methods Before Type Cast
+    #
+    # ActiveEntity::AttributeMethods::BeforeTypeCast provides a way to
+    # read the value of the attributes before typecasting and deserialization.
+    #
+    #   class Task < ActiveEntity::Base
+    #   end
+    #
+    #   task = Task.new(id: '1', completed_on: '2012-10-21')
+    #   task.id           # => 1
+    #   task.completed_on # => Sun, 21 Oct 2012
+    #
+    #   task.attributes_before_type_cast
+    #   # => {"id"=>"1", "completed_on"=>"2012-10-21", ... }
+    #   task.read_attribute_before_type_cast('id')           # => "1"
+    #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+    #
+    # In addition to #read_attribute_before_type_cast and #attributes_before_type_cast,
+    # it declares a method for all attributes with the <tt>*_before_type_cast</tt>
+    # suffix.
+    #
+    #   task.id_before_type_cast           # => "1"
+    #   task.completed_on_before_type_cast # => "2012-10-21"
+    module BeforeTypeCast
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "_before_type_cast"
+        attribute_method_suffix "_came_from_user?"
+      end
+
+      # Returns the value of the attribute identified by +attr_name+ before
+      # typecasting and deserialization.
+      #
+      #   class Task < ActiveEntity::Base
+      #   end
+      #
+      #   task = Task.new(id: '1', completed_on: '2012-10-21')
+      #   task.read_attribute('id')                            # => 1
+      #   task.read_attribute_before_type_cast('id')           # => '1'
+      #   task.read_attribute('completed_on')                  # => Sun, 21 Oct 2012
+      #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+      #   task.read_attribute_before_type_cast(:completed_on)  # => "2012-10-21"
+      def read_attribute_before_type_cast(attr_name)
+        attribute_before_type_cast(attr_name.to_s)
+      end
+
+      # Returns a hash of attributes before typecasting and deserialization.
+      #
+      #   class Task < ActiveEntity::Base
+      #   end
+      #
+      #   task = Task.new(title: nil, is_done: true, completed_on: '2012-10-21')
+      #   task.attributes
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>Sun, 21 Oct 2012, "created_at"=>nil, "updated_at"=>nil}
+      #   task.attributes_before_type_cast
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>"2012-10-21", "created_at"=>nil, "updated_at"=>nil}
+      def attributes_before_type_cast
+        @attributes.values_before_type_cast
+      end
+
+      private
+
+        # Dispatch target for <tt>*_before_type_cast</tt> attribute methods.
+        def attribute_before_type_cast(attr_name)
+          @attributes[attr_name].value_before_type_cast
+        end
+
+        def attribute_came_from_user?(attr_name)
+          @attributes[attr_name].came_from_user?
+        end
+    end
+  end
+end