all_futures 1.0.3 → 2.0.0

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

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
+
+module ActiveEntity
+  module AttributeMethods
+    module TimeZoneConversion
+      class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
+        def deserialize(value)
+          convert_time_to_time_zone(super)
+        end
+
+        def cast(value)
+          return if value.nil?
+
+          if value.is_a?(Hash)
+            set_time_zone_without_conversion(super)
+          elsif value.respond_to?(:in_time_zone)
+            begin
+              super(user_input_in_time_zone(value)) || super
+            rescue ArgumentError
+              nil
+            end
+          else
+            map_avoiding_infinite_recursion(super) { |v| cast(v) }
+          end
+        end
+
+        private
+
+          def convert_time_to_time_zone(value)
+            return if value.nil?
+
+            if value.acts_like?(:time)
+              value.in_time_zone
+            elsif value.is_a?(::Float)
+              value
+            else
+              map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
+            end
+          end
+
+          def set_time_zone_without_conversion(value)
+            ::Time.zone.local_to_utc(value).try(:in_time_zone) if value
+          end
+
+          def map_avoiding_infinite_recursion(value)
+            map(value) do |v|
+              if value.equal?(v)
+                nil
+              else
+                yield(v)
+              end
+            end
+          end
+      end
+
+      extend ActiveSupport::Concern
+
+      included do
+        mattr_accessor :time_zone_aware_attributes, instance_writer: false, default: false
+
+        class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false, default: []
+        class_attribute :time_zone_aware_types, instance_writer: false, default: [ :datetime, :time ]
+      end
+
+      module ClassMethods # :nodoc:
+        private
+
+          def inherited(subclass)
+            super
+            # We need to apply this decorator here, rather than on module inclusion. The closure
+            # created by the matcher would otherwise evaluate for `ActiveEntity::Base`, not the
+            # sub class being decorated. As such, changes to `time_zone_aware_attributes`, or
+            # `skip_time_zone_conversion_for_attributes` would not be picked up.
+            subclass.class_eval do
+              matcher = ->(name, type) { create_time_zone_conversion_attribute?(name, type) }
+              decorate_matching_attribute_types(matcher, "_time_zone_conversion") do |type|
+                TimeZoneConverter.new(type)
+              end
+            end
+          end
+
+          def create_time_zone_conversion_attribute?(name, cast_type)
+            enabled_for_column = time_zone_aware_attributes &&
+              !skip_time_zone_conversion_for_attributes.include?(name.to_sym)
+
+            enabled_for_column && time_zone_aware_types.include?(cast_type.type)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module AttributeMethods
+    module Write
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "="
+      end
+
+      module ClassMethods # :nodoc:
+        private
+
+          def define_method_attribute=(name, owner:)
+            ActiveEntity::AMAttributeMethods::AttrNames.define_attribute_accessor_method(
+              owner, name, writer: true,
+              ) do |temp_method_name, attr_name_expr|
+              owner <<
+                "def #{temp_method_name}(value)" <<
+                "  _write_attribute(#{attr_name_expr}, value)" <<
+                "end"
+            end
+          end
+      end
+
+      # Updates the attribute identified by <tt>attr_name</tt> with the
+      # specified +value+. Empty strings for Integer and Float columns are
+      # turned into +nil+.
+      def write_attribute(attr_name, value)
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
+
+        name = @primary_key if name == "id" && @primary_key
+        @attributes.write_from_user(name, value)
+      end
+
+      # This method exists to avoid the expensive primary_key check internally, without
+      # breaking compatibility with the write_attribute API
+      def _write_attribute(attr_name, value) # :nodoc:
+        @attributes.write_from_user(attr_name, value)
+      end
+
+      alias :attribute= :_write_attribute
+      private :attribute=
+
+      private
+
+        def write_attribute_without_type_cast(attr_name, value)
+          @attributes.write_cast_value(attr_name, value)
+        end
+    end
+  end
+end