all_futures 1.0.2 → 2.0.0

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