dynamoid 3.9.0 → 3.11.0

data/lib/dynamoid/dirty.rb

@@ -36,8 +36,11 @@ module Dynamoid
         end
       end
 
-      def from_database(*)
-        super.tap(&:clear_changes_information)
+      def from_database(attributes_from_database)
+        super.tap do |model|
+          model.clear_changes_information
+          model.assign_attributes_from_database(DeepDupper.dup_attributes(model.attributes, model.class))
+        end
       end
     end
 
@@ -108,7 +111,7 @@ module Dynamoid
     #
     # @return [ActiveSupport::HashWithIndifferentAccess]
     def changes
-      ActiveSupport::HashWithIndifferentAccess[changed.map { |name| [name, attribute_change(name)] }]
+      ActiveSupport::HashWithIndifferentAccess[changed_attributes.map { |name, old_value| [name, [old_value, read_attribute(name)]] }]
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
@@ -132,19 +135,21 @@ module Dynamoid
     #
     # @return [ActiveSupport::HashWithIndifferentAccess]
     def changed_attributes
-      @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      attributes_changed_by_setter.merge(attributes_changed_in_place)
     end
 
     # Clear all dirty data: current changes and previous changes.
     def clear_changes_information
       @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_from_database = HashWithIndifferentAccess.new(DeepDupper.dup_attributes(@attributes, self.class))
     end
 
     # Clears dirty data and moves +changes+ to +previous_changes+.
     def changes_applied
       @previously_changed = changes
-      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_from_database = HashWithIndifferentAccess.new(DeepDupper.dup_attributes(@attributes, self.class))
     end
 
     # Remove changes information for the provided attributes.
@@ -152,6 +157,9 @@ module Dynamoid
     # @param attributes [Array[String]] - a list of attributes to clear changes for
     def clear_attribute_changes(names)
       attributes_changed_by_setter.except!(*names)
+
+      slice = HashWithIndifferentAccess.new(@attributes).slice(*names)
+      attributes_from_database.merge!(DeepDupper.dup_attributes(slice, self.class))
     end
 
     # Handle <tt>*_changed?</tt> for +method_missing+.
@@ -220,12 +228,16 @@ module Dynamoid
       previous_changes[name] if attribute_previously_changed?(name)
     end
 
+    # @private
+    def assign_attributes_from_database(attributes_from_database)
+      @attributes_from_database = HashWithIndifferentAccess.new(attributes_from_database)
+    end
+
     private
 
     def changes_include?(name)
-      attributes_changed_by_setter.include?(name)
+      attribute_changed_by_setter?(name) || attribute_changed_in_place?(name)
     end
-    alias attribute_changed_by_setter? changes_include?
 
     # Handle <tt>*_change</tt> for +method_missing+.
     def attribute_change(name)
@@ -238,7 +250,7 @@ module Dynamoid
 
       begin
         value = read_attribute(name)
-        value = value.duplicable? ? value.clone : value
+        value = value.clone if value.duplicable?
       rescue TypeError, NoMethodError
       end
 
@@ -259,13 +271,76 @@ module Dynamoid
       previous_changes.include?(name)
     end
 
-    # This is necessary because `changed_attributes` might be overridden in
-    # other implemntations (e.g. in `ActiveRecord`)
-    alias attributes_changed_by_setter changed_attributes
+    def attributes_changed_by_setter
+      @attributes_changed_by_setter ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def attribute_changed_by_setter?(name)
+      attributes_changed_by_setter.include?(name)
+    end
+
+    def attributes_from_database
+      @attributes_from_database ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
 
     # Force an attribute to have a particular "before" value
     def set_attribute_was(name, old_value)
       attributes_changed_by_setter[name] = old_value
     end
+
+    def attributes_changed_in_place
+      attributes_from_database.select do |name, _|
+        attribute_changed_in_place?(name)
+      end
+    end
+
+    def attribute_changed_in_place?(name)
+      return false if attribute_changed_by_setter?(name)
+
+      value_from_database = attributes_from_database[name]
+      return false if value_from_database.nil?
+
+      value = read_attribute(name)
+      value != value_from_database
+    end
+
+    module DeepDupper
+      def self.dup_attributes(attributes, klass)
+        attributes.map do |name, value|
+          type_options = klass.attributes[name.to_sym]
+          value_duplicate = dup_attribute(value, type_options)
+          [name, value_duplicate]
+        end.to_h
+      end
+
+      def self.dup_attribute(value, type_options)
+        type, of = type_options.values_at(:type, :of)
+
+        case value
+        when NilClass, TrueClass, FalseClass, Numeric, Symbol, IO
+          # till Ruby 2.4 these immutable objects could not be duplicated
+          # IO objects cannot be duplicated - is used for binary fields
+          value
+        when String
+          value.dup
+        when Array
+          if of.is_a? Class # custom type
+            value.map { |e| dup_attribute(e, type: of) }
+          else
+            value.deep_dup
+          end
+        when Set
+          Set.new(value.map { |e| dup_attribute(e, type: of) })
+        when Hash
+          value.deep_dup
+        else
+          if type.is_a? Class # custom type
+            Marshal.load(Marshal.dump(value)) # dup instance variables
+          else
+            value.dup # date, datetime
+          end
+        end
+      end
+    end
   end
 end

data/lib/dynamoid/document.rb

@@ -260,7 +260,7 @@ module Dynamoid
     #
     # @return [Integer]
     def hash
-      hash_key.hash ^ range_value.hash
+      [hash_key, range_value].hash
     end
 
     # Return a model's hash key value.

data/lib/dynamoid/dumping.rb

@@ -70,7 +70,8 @@ module Dynamoid
       end
 
       def invalid_value?(value)
-        (value.is_a?(Set) || value.is_a?(String)) && value.empty?
+        (value.is_a?(Set) && value.empty?) ||
+          (value.is_a?(String) && value.empty? && Config.store_empty_string_as_nil)
       end
     end
 
@@ -86,6 +87,12 @@ module Dynamoid
 
     # string -> string
     class StringDumper < Base
+      def process(string)
+        return nil if string.nil?
+        return nil if string.empty? && Config.store_empty_string_as_nil
+
+        string
+      end
     end
 
     # integer -> number
@@ -101,6 +108,8 @@ module Dynamoid
       ALLOWED_TYPES = %i[string integer number date datetime serialized].freeze
 
       def process(set)
+        return nil if set.is_a?(Set) && set.empty?
+
         if @options.key?(:of)
           process_typed_collection(set)
         else
@@ -112,13 +121,13 @@ module Dynamoid
 
       def process_typed_collection(set)
         if allowed_type?
-          dumper = Dumping.find_dumper(element_options)
-          result = set.map { |el| dumper.process(el) }
-
-          if element_type == :string
-            result.reject!(&:empty?)
+          # StringDumper may replace "" with nil so we cannot distinguish it from an explicit nil
+          if element_type == :string && Config.store_empty_string_as_nil
+            set.reject! { |s| s && s.empty? }
           end
 
+          dumper = Dumping.find_dumper(element_options)
+          result = set.map { |el| dumper.process(el) }
           result.to_set
         else
           raise ArgumentError, "Set element type #{element_type} isn't supported"
@@ -164,14 +173,13 @@ module Dynamoid
 
       def process_typed_collection(array)
         if allowed_type?
-          dumper = Dumping.find_dumper(element_options)
-          result = array.map { |el| dumper.process(el) }
-
-          if element_type == :string
-            result.reject!(&:empty?)
+          # StringDumper may replace "" with nil so we cannot distinguish it from an explicit nil
+          if element_type == :string && Config.store_empty_string_as_nil
+            array.reject! { |s| s && s.empty? }
           end
 
-          result
+          dumper = Dumping.find_dumper(element_options)
+          array.map { |el| dumper.process(el) }
         else
           raise ArgumentError, "Array element type #{element_type} isn't supported"
         end
@@ -210,7 +218,7 @@ module Dynamoid
     # datetime -> integer/string
     class DateTimeDumper < Base
       def process(value)
-        !value.nil? ? format_datetime(value, @options) : nil
+        value.nil? ? nil : format_datetime(value, @options)
       end
 
       private
@@ -237,7 +245,7 @@ module Dynamoid
     # date -> integer/string
     class DateDumper < Base
       def process(value)
-        !value.nil? ? format_date(value, @options) : nil
+        value.nil? ? nil : format_date(value, @options)
       end
 
       private
@@ -289,10 +297,24 @@ module Dynamoid
       end
     end
 
-    # string -> string
+    # string -> StringIO
     class BinaryDumper < Base
       def process(value)
-        Base64.strict_encode64(value)
+        store_as_binary = if @options[:store_as_native_binary].nil?
+                            Dynamoid.config.store_binary_as_native
+                          else
+                            @options[:store_as_native_binary]
+                          end
+
+        if store_as_binary
+          if value.is_a?(StringIO) || value.is_a?(IO)
+            value
+          else
+            StringIO.new(value)
+          end
+        else
+          Base64.strict_encode64(value)
+        end
       end
     end
 

data/lib/dynamoid/errors.rb

@@ -6,6 +6,7 @@ module Dynamoid
     # Generic Dynamoid error
     class Error < StandardError; end
 
+    class MissingHashKey < Error; end
     class MissingRangeKey < Error; end
 
     class MissingIndex < Error; end
@@ -15,18 +16,27 @@ module Dynamoid
     class InvalidIndex < Error
       def initialize(item)
         if item.is_a? String
-          super(item)
+          super
         else
           super("Validation failed: #{item.errors.full_messages.join(', ')}")
         end
       end
     end
 
+    class RecordNotSaved < Error
+      attr_reader :record
+
+      def initialize(record)
+        super('Failed to save the item')
+        @record = record
+      end
+    end
+
     class RecordNotDestroyed < Error
       attr_reader :record
 
       def initialize(record)
-        super('Failed to destroy item')
+        super('Failed to destroy the item')
         @record = record
       end
     end
@@ -79,5 +89,7 @@ module Dynamoid
     class UnknownAttribute < Error; end
 
     class SubclassNotFound < Error; end
+
+    class Rollback < Error; end
   end
 end

data/lib/dynamoid/fields/declare.rb

@@ -48,7 +48,7 @@ module Dynamoid
 
         @source.generated_methods.module_eval do
           define_method(name) { read_attribute(name) }
-          define_method("#{name}?") do
+          define_method(:"#{name}?") do
             value = read_attribute(name)
             case value
             when true        then true
@@ -57,8 +57,8 @@ module Dynamoid
               !value.nil?
             end
           end
-          define_method("#{name}=") { |value| write_attribute(name, value) }
-          define_method("#{name}_before_type_cast") { read_attribute_before_type_cast(name) }
+          define_method(:"#{name}=") { |value| write_attribute(name, value) }
+          define_method(:"#{name}_before_type_cast") { read_attribute_before_type_cast(name) }
         end
       end
 
@@ -70,9 +70,9 @@ module Dynamoid
 
         @source.generated_methods.module_eval do
           alias_method alias_name, name
-          alias_method "#{alias_name}=", "#{name}="
-          alias_method "#{alias_name}?", "#{name}?"
-          alias_method "#{alias_name}_before_type_cast", "#{name}_before_type_cast"
+          alias_method :"#{alias_name}=", :"#{name}="
+          alias_method :"#{alias_name}?", :"#{name}?"
+          alias_method :"#{alias_name}_before_type_cast", :"#{name}_before_type_cast"
         end
       end
 

data/lib/dynamoid/fields.rb

@@ -164,7 +164,7 @@ module Dynamoid
       #
       # @param name [Symbol] a range key attribute name
       # @param type [Symbol] a range key type (optional)
-      # @param options [Symbol] type options (optional)
+      # @param options [Hash] type options (optional)
       def range(name, type = :string, options = {})
         field(name, type, options)
         self.range_key = name
@@ -263,10 +263,8 @@ module Dynamoid
 
       # @private
       def generated_methods
-        @generated_methods ||= begin
-          Module.new.tap do |mod|
-            include(mod)
-          end
+        @generated_methods ||= Module.new.tap do |mod|
+          include(mod)
         end
       end
     end
@@ -362,7 +360,7 @@ module Dynamoid
         seconds = options[:after]
 
         if self[name].blank?
-          send("#{name}=", Time.now.to_i + seconds)
+          send(:"#{name}=", Time.now.to_i + seconds)
         end
       end
     end
@@ -374,12 +372,12 @@ module Dynamoid
 
       type = self.class.inheritance_field
       if self.class.attributes[type] && send(type).nil?
-        send("#{type}=", self.class.sti_name)
+        send(:"#{type}=", self.class.sti_name)
       end
     end
 
     def attribute_is_present_on_model?(attribute_name)
-      setter = "#{attribute_name}=".to_sym
+      setter = :"#{attribute_name}="
       respond_to?(setter)
     end
   end

data/lib/dynamoid/finders.rb

@@ -6,17 +6,6 @@ module Dynamoid
   module Finders
     extend ActiveSupport::Concern
 
-    # @private
-    RANGE_MAP = {
-      'gt'            => :range_greater_than,
-      'lt'            => :range_less_than,
-      'gte'           => :range_gte,
-      'lte'           => :range_lte,
-      'begins_with'   => :range_begins_with,
-      'between'       => :range_between,
-      'eq'            => :range_eq
-    }.freeze
-
     module ClassMethods
       # Find one or many objects, specified by one id or an array of ids.
       #
@@ -89,7 +78,7 @@ module Dynamoid
       #   # Find all the tweets using hash key and range key with consistent read
       #   Tweet.find_all([['1', 'red'], ['1', 'green']], consistent_read: true)
       def find_all(ids, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_all is deprecated! Call .find instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_all is deprecated! Call .find instead of')
 
         _find_all(ids, options)
       end
@@ -111,7 +100,7 @@ module Dynamoid
       #
       # @since 0.2.0
       def find_by_id(id, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_by_id is deprecated! Call .find instead of', caller[1..-1])
+        Dynamoid.deprecator.warn('[Dynamoid] .find_by_id is deprecated! Call .find instead of')
 
         _find_by_id(id, options)
       end
@@ -191,7 +180,7 @@ module Dynamoid
       # @param range_key [Scalar value] range key of the object to find
       #
       def find_by_composite_key(hash_key, range_key, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_by_composite_key is deprecated! Call .find instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_by_composite_key is deprecated! Call .find instead of')
 
         _find_by_id(hash_key, options.merge(range_key: range_key))
       end
@@ -218,7 +207,7 @@ module Dynamoid
       #
       # @return [Array] an array of all matching items
       def find_all_by_composite_key(hash_key, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_all_composite_key is deprecated! Call .where instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_all_composite_key is deprecated! Call .where instead of')
 
         Dynamoid.adapter.query(table_name, options.merge(hash_value: hash_key)).flat_map { |i| i }.collect do |item|
           from_database(item)
@@ -248,12 +237,11 @@ module Dynamoid
       # @param options [Hash] conditions on range key e.g. +{ "rank.lte": 10 }, query filter, projected keys, scan_index_forward etc.
       # @return [Array] an array of all matching items
       def find_all_by_secondary_index(hash, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_all_by_secondary_index is deprecated! Call .where instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_all_by_secondary_index is deprecated! Call .where instead of')
 
         range = options[:range] || {}
         hash_key_field, hash_key_value = hash.first
         range_key_field, range_key_value = range.first
-        range_op_mapped = nil
 
         if range_key_field
           range_key_field = range_key_field.to_s
@@ -261,27 +249,30 @@ module Dynamoid
           if range_key_field.include?('.')
             range_key_field, range_key_op = range_key_field.split('.', 2)
           end
-          range_op_mapped = RANGE_MAP.fetch(range_key_op)
         end
 
         # Find the index
         index = find_index(hash_key_field, range_key_field)
         raise Dynamoid::Errors::MissingIndex, "attempted to find #{[hash_key_field, range_key_field]}" if index.nil?
 
-        # query
-        opts = {
-          hash_key: hash_key_field.to_s,
-          hash_value: hash_key_value,
-          index_name: index.name
-        }
+        # Query
+        query_key_conditions = {}
+        query_key_conditions[hash_key_field.to_sym] = [[:eq, hash_key_value]]
         if range_key_field
-          opts[:range_key] = range_key_field
-          opts[range_op_mapped] = range_key_value
-        end
-        dynamo_options = opts.merge(options.reject { |key, _| key == :range })
-        Dynamoid.adapter.query(table_name, dynamo_options).flat_map { |i| i }.map do |item|
-          from_database(item)
+          query_key_conditions[range_key_field.to_sym] = [[range_key_op.to_sym, range_key_value]]
         end
+
+        query_non_key_conditions = options
+          .except(*Dynamoid::AdapterPlugin::AwsSdkV3::Query::OPTIONS_KEYS)
+          .except(:range)
+          .symbolize_keys
+
+        query_options = options.slice(*Dynamoid::AdapterPlugin::AwsSdkV3::Query::OPTIONS_KEYS)
+        query_options[:index_name] = index.name
+
+        Dynamoid.adapter.query(table_name, query_key_conditions, query_non_key_conditions, query_options)
+          .flat_map { |i| i }
+          .map { |item| from_database(item) }
       end
 
       # Find using exciting method_missing finders attributes. Uses criteria
@@ -300,7 +291,7 @@ module Dynamoid
       def method_missing(method, *args)
         # Cannot use Symbol#start_with? because it was introduced in Ruby 2.7, but we support Ruby >= 2.3
         if method.to_s.start_with?('find')
-          ActiveSupport::Deprecation.warn("[Dynamoid] .#{method} is deprecated! Call .where instead of")
+          Dynamoid.deprecator.warn("[Dynamoid] .#{method} is deprecated! Call .where instead of")
 
           finder = method.to_s.split('_by_').first
           attributes = method.to_s.split('_by_').last.split('_and_')
@@ -308,7 +299,7 @@ module Dynamoid
           chain = Dynamoid::Criteria::Chain.new(self)
           chain = chain.where({}.tap { |h| attributes.each_with_index { |attr, index| h[attr.to_sym] = args[index] } })
 
-          if finder =~ /all/
+          if finder.include?('all')
             chain.all
           else
             chain.first

data/lib/dynamoid/indexes.rb

@@ -130,13 +130,13 @@ module Dynamoid
         index_range_key = options[:range_key]
 
         unless index_range_key.present?
-          raise Dynamoid::Errors::InvalidIndex, 'A local secondary index '\
-            'requires a :range_key to be specified'
+          raise Dynamoid::Errors::InvalidIndex, 'A local secondary index ' \
+                                                'requires a :range_key to be specified'
         end
 
         if primary_range_key.present? && index_range_key == primary_range_key
-          raise Dynamoid::Errors::InvalidIndex, 'A local secondary index'\
-            ' must use a different :range_key than the primary key'
+          raise Dynamoid::Errors::InvalidIndex, 'A local secondary index ' \
+                                                'must use a different :range_key than the primary key'
         end
 
         index_opts = options.merge(
@@ -159,8 +159,7 @@ module Dynamoid
       # @param range [scalar] the range key used to declare an index (optional)
       # @return [Dynamoid::Indexes::Index, nil] index object or nil if it isn't found
       def find_index(hash, range = nil)
-        index = indexes[index_key(hash, range)]
-        index
+        indexes[index_key(hash, range)]
       end
 
       # Returns an index by its name
@@ -317,7 +316,7 @@ module Dynamoid
 
         key_dynamodb_type = dynamodb_type(key_field_attributes[:type], key_field_attributes)
         if PERMITTED_KEY_DYNAMODB_TYPES.include?(key_dynamodb_type)
-          send("#{key_param}_schema=", { key_val => key_dynamodb_type })
+          send(:"#{key_param}_schema=", { key_val => key_dynamodb_type })
         else
           errors.add(key_param, "Index :#{key_param} is not a valid key type")
         end

data/lib/dynamoid/loadable.rb

@@ -6,11 +6,12 @@ module Dynamoid
 
     def load(attrs)
       attrs.each do |key, value|
-        send("#{key}=", value) if respond_to?("#{key}=")
+        send(:"#{key}=", value) if respond_to?(:"#{key}=")
       end
 
       self
     end
+    alias assign_attributes load
 
     # Reload an object from the database -- if you suspect the object has changed in the data store and you need those
     # changes to be reflected immediately, you would call this method. This is a consistent read.
@@ -27,7 +28,7 @@ module Dynamoid
 
       self.attributes = self.class.find(hash_key, **options).attributes
 
-      @associations.values.each(&:reset)
+      @associations.each_value(&:reset)
       @new_record = false
 
       self

data/lib/dynamoid/persistence/inc.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'item_updater_with_casting_and_dumping'
+
 module Dynamoid
   module Persistence
     # @private
@@ -21,15 +23,17 @@ module Dynamoid
         touch = @counters.delete(:touch)
 
         Dynamoid.adapter.update_item(@model_class.table_name, @hash_key, update_item_options) do |t|
+          item_updater = ItemUpdaterWithCastingAndDumping.new(@model_class, t)
+
           @counters.each do |name, value|
-            t.add(name => cast_and_dump_attribute_value(name, value))
+            item_updater.add(name => value)
           end
 
           if touch
             value = DateTime.now.in_time_zone(Time.zone)
 
             timestamp_attributes_to_touch(touch).each do |name|
-              t.set(name => cast_and_dump_attribute_value(name, value))
+              item_updater.set(name => value)
             end
           end
         end
@@ -48,11 +52,6 @@ module Dynamoid
         end
       end
 
-      def cast_and_dump_attribute_value(name, value)
-        value_casted = TypeCasting.cast_field(value, @model_class.attributes[name])
-        Dumping.dump_field(value_casted, @model_class.attributes[name])
-      end
-
       def timestamp_attributes_to_touch(touch)
         return [] unless touch
 

data/lib/dynamoid/persistence/item_updater_with_casting_and_dumping.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Persistence
+    # @private
+    class ItemUpdaterWithCastingAndDumping
+      def initialize(model_class, item_updater)
+        @model_class = model_class
+        @item_updater = item_updater
+      end
+
+      def add(attributes)
+        @item_updater.add(cast_and_dump(attributes))
+      end
+
+      def set(attributes)
+        @item_updater.set(cast_and_dump(attributes))
+      end
+
+      private
+
+      def cast_and_dump(attributes)
+        casted_and_dumped = {}
+
+        attributes.each do |name, value|
+          value_casted = TypeCasting.cast_field(value, @model_class.attributes[name])
+          value_dumped = Dumping.dump_field(value_casted, @model_class.attributes[name])
+
+          casted_and_dumped[name] = value_dumped
+        end
+
+        casted_and_dumped
+      end
+    end
+  end
+end