all_futures 1.0.2 → 2.0.0

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

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+
+module ActiveEntity
+  module AttributeMethods
+    module Dirty
+      extend ActiveSupport::Concern
+      include ActiveEntity::AMAttributeMethods
+
+      included do
+        attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
+        attribute_method_suffix "_previously_changed?", "_previous_change", "_previously_was"
+        attribute_method_affix prefix: "restore_", suffix: "!"
+        attribute_method_affix prefix: "clear_", suffix: "_change"
+      end
+
+      def initialize_dup(other) # :nodoc:
+        super
+        if self.class.respond_to?(:_default_attributes)
+          @attributes = self.class._default_attributes.map do |attr|
+            attr.with_value_from_user(@attributes.fetch_value(attr.name))
+          end
+        end
+        @mutations_from_database = nil
+      end
+
+      def as_json(options = {}) # :nodoc:
+        options[:except] = [*options[:except], "mutations_from_database", "mutations_before_last_save"]
+        super(options)
+      end
+
+      # Clears dirty data and moves +changes+ to +previous_changes+ and
+      # +mutations_from_database+ to +mutations_before_last_save+ respectively.
+      def changes_applied
+        unless defined?(@attributes)
+          mutations_from_database.finalize_changes
+        end
+        @mutations_before_last_save = mutations_from_database
+        forget_attribute_assignments
+        @mutations_from_database = nil
+      end
+
+      # Returns +true+ if any of the attributes has unsaved changes, +false+ otherwise.
+      #
+      #   person.changed? # => false
+      #   person.name = 'bob'
+      #   person.changed? # => true
+      def changed?
+        mutations_from_database.any_changes?
+      end
+
+      # Returns an array with the name of the attributes with unsaved changes.
+      #
+      #   person.changed # => []
+      #   person.name = 'bob'
+      #   person.changed # => ["name"]
+      def changed
+        mutations_from_database.changed_attribute_names
+      end
+
+      # Dispatch target for <tt>*_changed?</tt> attribute methods.
+      def attribute_changed?(attr_name, **options) # :nodoc:
+        mutations_from_database.changed?(attr_name.to_s, **options)
+      end
+
+      # Dispatch target for <tt>*_was</tt> attribute methods.
+      def attribute_was(attr_name) # :nodoc:
+        mutations_from_database.original_value(attr_name.to_s)
+      end
+
+      # Dispatch target for <tt>*_previously_changed?</tt> attribute methods.
+      def attribute_previously_changed?(attr_name, **options) # :nodoc:
+        mutations_before_last_save.changed?(attr_name.to_s, **options)
+      end
+
+      # Dispatch target for <tt>*_previously_was</tt> attribute methods.
+      def attribute_previously_was(attr_name) # :nodoc:
+        mutations_before_last_save.original_value(attr_name.to_s)
+      end
+
+      # Restore all previous data of the provided attributes.
+      def restore_attributes(attr_names = changed)
+        attr_names.each { |attr_name| restore_attribute!(attr_name) }
+      end
+
+      # Clears all dirty data: current changes and previous changes.
+      def clear_changes_information
+        @mutations_before_last_save = nil
+        forget_attribute_assignments
+        @mutations_from_database = nil
+      end
+
+      def clear_attribute_changes(attr_names)
+        attr_names.each do |attr_name|
+          clear_attribute_change(attr_name)
+        end
+      end
+
+      # Returns a hash of the attributes with unsaved changes indicating their original
+      # values like <tt>attr => original value</tt>.
+      #
+      #   person.name # => "bob"
+      #   person.name = 'robert'
+      #   person.changed_attributes # => {"name" => "bob"}
+      def changed_attributes
+        mutations_from_database.changed_values
+      end
+
+      # Returns a hash of changed attributes indicating their original
+      # and new values like <tt>attr => [original value, new value]</tt>.
+      #
+      #   person.changes # => {}
+      #   person.name = 'bob'
+      #   person.changes # => { "name" => ["bill", "bob"] }
+      def changes
+        mutations_from_database.changes
+      end
+
+      # Returns a hash of attributes that were changed before the model was saved.
+      #
+      #   person.name # => "bob"
+      #   person.name = 'robert'
+      #   person.save
+      #   person.previous_changes # => {"name" => ["bob", "robert"]}
+      def previous_changes
+        mutations_before_last_save.changes
+      end
+
+      def attribute_changed_in_place?(attr_name) # :nodoc:
+        mutations_from_database.changed_in_place?(attr_name.to_s)
+      end
+
+      private
+        def clear_attribute_change(attr_name)
+          mutations_from_database.forget_change(attr_name.to_s)
+        end
+
+        def mutations_from_database
+          @mutations_from_database ||= if defined?(@attributes)
+                                         ActiveModel::AttributeMutationTracker.new(@attributes)
+                                       else
+                                         ActiveModel::ForcedMutationTracker.new(self)
+                                       end
+        end
+
+        def forget_attribute_assignments
+          @attributes = @attributes.map(&:forgetting_assignment) if defined?(@attributes)
+        end
+
+        def mutations_before_last_save
+          @mutations_before_last_save ||= ActiveModel::NullMutationTracker.instance
+        end
+
+        # Dispatch target for <tt>*_change</tt> attribute methods.
+        def attribute_change(attr_name)
+          mutations_from_database.change_to_attribute(attr_name.to_s)
+        end
+
+        # Dispatch target for <tt>*_previous_change</tt> attribute methods.
+        def attribute_previous_change(attr_name)
+          mutations_before_last_save.change_to_attribute(attr_name.to_s)
+        end
+
+        # Dispatch target for <tt>*_will_change!</tt> attribute methods.
+        def attribute_will_change!(attr_name)
+          mutations_from_database.force_change(attr_name.to_s)
+        end
+
+        # Dispatch target for <tt>restore_*!</tt> attribute methods.
+        def restore_attribute!(attr_name)
+          attr_name = attr_name.to_s
+          if attribute_changed?(attr_name)
+            __send__("#{attr_name}=", attribute_was(attr_name))
+            clear_attribute_change(attr_name)
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "set"
+
+module ActiveEntity
+  module AttributeMethods
+    module PrimaryKey
+      extend ActiveSupport::Concern
+
+      # Returns this record's primary key value wrapped in an array if one is
+      # available.
+      def to_key
+        key = id
+        [key] if key
+      end
+
+      # Returns the primary key column's value.
+      def id
+        _read_attribute(@primary_key)
+      end
+
+      # Sets the primary key column's value.
+      def id=(value)
+        _write_attribute(@primary_key, value)
+      end
+
+      # Queries the primary key column's value.
+      def id?
+        query_attribute(@primary_key)
+      end
+
+      # Returns the primary key column's value before type cast.
+      def id_before_type_cast
+        read_attribute_before_type_cast(@primary_key)
+      end
+
+      # Returns the primary key column's previous value.
+      def id_was
+        attribute_was(@primary_key)
+      end
+
+      private
+
+        def attribute_method?(attr_name)
+          attr_name == "id" || super
+        end
+
+        module ClassMethods
+          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was).to_set
+
+          def instance_method_already_implemented?(method_name)
+            super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)
+          end
+
+          def dangerous_attribute_method?(method_name)
+            super && !ID_ATTRIBUTE_METHODS.include?(method_name)
+          end
+
+          # Defines the primary key field -- can be overridden in subclasses.
+          # Overwriting will negate any effect of the +primary_key_prefix_type+
+          # setting, though.
+          def primary_key
+            unless defined? @primary_key
+              @primary_key =
+                if has_attribute?("id")
+                  "id"
+                else
+                  nil
+                end
+            end
+
+            @primary_key
+          end
+
+          # Sets the name of the primary key column.
+          #
+          #   class Project < ActiveEntity::Base
+          #     self.primary_key = 'sysid'
+          #   end
+          #
+          # You can also define the #primary_key method yourself:
+          #
+          #   class Project < ActiveEntity::Base
+          #     def self.primary_key
+          #       'foo_' + super
+          #     end
+          #   end
+          #
+          #   Project.primary_key # => "foo_id"
+          def primary_key=(value)
+            @primary_key = value && -value.to_s
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module AttributeMethods
+    module Query
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "?"
+      end
+
+      def query_attribute(attr_name)
+        value = self[attr_name]
+
+        case value
+        when true        then true
+        when false, nil  then false
+        else
+          if !type_for_attribute(attr_name) { false }
+            if Numeric === value || !value.match?(/[^0-9]/)
+              !value.to_i.zero?
+            else
+              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
+              !value.blank?
+            end
+          elsif value.respond_to?(:zero?)
+            !value.zero?
+          else
+            !value.blank?
+          end
+        end
+      end
+
+      alias :attribute? :query_attribute
+      private :attribute?
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+      module ClassMethods # :nodoc:
+        private
+
+          def define_method_attribute(name, owner:)
+            ActiveEntity::AMAttributeMethods::AttrNames.define_attribute_accessor_method(
+              owner, name
+            ) do |temp_method_name, attr_name_expr|
+              owner <<
+                "def #{temp_method_name}" <<
+                "  _read_attribute(#{attr_name_expr}) { |n| missing_attribute(n, caller) }" <<
+                "end"
+            end
+          end
+      end
+
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after
+      # it has been typecast (for example, "2004-12-12" in a date column is cast
+      # to a date object, like Date.new(2004, 12, 12)).
+      def read_attribute(attr_name, &block)
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
+
+        name = @primary_key if name == "id" && @primary_key
+        @attributes.fetch_value(name, &block)
+      end
+
+      # This method exists to avoid the expensive primary_key check internally, without
+      # breaking compatibility with the read_attribute API
+      def _read_attribute(attr_name, &block) # :nodoc
+        @attributes.fetch_value(attr_name, &block)
+      end
+
+      alias :attribute :_read_attribute
+      private :attribute
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module AttributeMethods
+    module Serialization
+      extend ActiveSupport::Concern
+
+      class ColumnNotSerializableError < StandardError
+        def initialize(name, type)
+          super <<~EOS
+            Column `#{name}` of type #{type.class} does not support `serialize` feature.
+            Usually it means that you are trying to use `serialize`
+            on a column that already implements serialization natively.
+          EOS
+        end
+      end
+
+      module ClassMethods
+        # If you have an attribute that needs to be saved to the database as an
+        # object, and retrieved as the same object, then specify the name of that
+        # attribute using this method and it will be handled automatically. The
+        # serialization is done through YAML. If +class_name+ is specified, the
+        # serialized object must be of that class on assignment and retrieval.
+        # Otherwise SerializationTypeMismatch will be raised.
+        #
+        # Empty objects as <tt>{}</tt>, in the case of +Hash+, or <tt>[]</tt>, in the case of
+        # +Array+, will always be persisted as null.
+        #
+        # Keep in mind that database adapters handle certain serialization tasks
+        # for you. For instance: +json+ and +jsonb+ types in PostgreSQL will be
+        # converted between JSON object/array syntax and Ruby +Hash+ or +Array+
+        # objects transparently. There is no need to use #serialize in this
+        # case.
+        #
+        # For more complex cases, such as conversion to or from your application
+        # domain objects, consider using the ActiveEntity::Attributes API.
+        #
+        # ==== Parameters
+        #
+        # * +attr_name+ - The field name that should be serialized.
+        # * +class_name_or_coder+ - Optional, a coder object, which responds to +.load+ and +.dump+
+        #   or a class name that the object type should be equal to.
+        #
+        # ==== Example
+        #
+        #   # Serialize a preferences attribute.
+        #   class User < ActiveEntity::Base
+        #     serialize :preferences
+        #   end
+        #
+        #   # Serialize preferences using JSON as coder.
+        #   class User < ActiveEntity::Base
+        #     serialize :preferences, JSON
+        #   end
+        #
+        #   # Serialize preferences as Hash using YAML coder.
+        #   class User < ActiveEntity::Base
+        #     serialize :preferences, Hash
+        #   end
+        def serialize(attr_name, class_name_or_coder = Object)
+          # When ::JSON is used, force it to go through the Active Support JSON encoder
+          # to ensure special objects (e.g. Active Entity models) are dumped correctly
+          # using the #as_json hook.
+          coder = if class_name_or_coder == ::JSON
+            Coders::JSON
+          elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+            class_name_or_coder
+          else
+            Coders::YAMLColumn.new(attr_name, class_name_or_coder)
+          end
+
+          decorate_attribute_type(attr_name, :serialize) do |type|
+            if type_incompatible_with_serialize?(type, class_name_or_coder)
+              raise ColumnNotSerializableError.new(attr_name, type)
+            end
+
+            Type::Serialized.new(type, coder)
+          end
+        end
+
+        private
+
+          def type_incompatible_with_serialize?(type, class_name)
+            type.is_a?(ActiveEntity::Type::Json) && class_name == ::JSON ||
+              type.respond_to?(:type_cast_array, true) && class_name == ::Array
+          end
+      end
+    end
+  end
+end