dynamoid 3.8.0 → 3.9.0

data/lib/dynamoid/criteria/chain.rb

@@ -187,10 +187,10 @@ module Dynamoid
       def first(*args)
         n = args.first || 1
 
-        return self.dup.scan_limit(n).to_a.first(*args) if @query.blank?
+        return dup.scan_limit(n).to_a.first(*args) if @query.blank?
         return super if @key_fields_detector.non_key_present?
 
-        self.dup.record_limit(n).to_a.first(*args)
+        dup.record_limit(n).to_a.first(*args)
       end
 
       # Returns the last item matching the criteria.
@@ -487,7 +487,7 @@ module Dynamoid
       def pluck(*args)
         fields = args.map(&:to_sym)
 
-        scope = self.dup
+        scope = dup
         scope.project(*fields)
 
         if fields.many?
@@ -525,6 +525,7 @@ module Dynamoid
       def pages
         raw_pages.lazy.map do |items, options|
           models = items.map { |i| source.from_database(i) }
+          models.each { |m| m.run_callbacks :find }
           [models, options]
         end.each
       end
@@ -787,9 +788,9 @@ module Dynamoid
         condition = {}
         type = @source.inheritance_field
 
-        if @source.attributes.key?(type)
-          class_names = @source.deep_subclasses.map(&:name) << @source.name
-          condition[:"#{type}.in"] = class_names
+        if @source.attributes.key?(type) && !@source.abstract_class?
+          sti_names = @source.deep_subclasses.map(&:sti_name) << @source.sti_name
+          condition[:"#{type}.in"] = sti_names
         end
 
         condition

data/lib/dynamoid/dirty.rb

@@ -26,20 +26,18 @@ module Dynamoid
     module ClassMethods
       def update_fields(*)
         super.tap do |model|
-          model.send(:clear_changes_information) if model
+          model.clear_changes_information if model
         end
       end
 
       def upsert(*)
         super.tap do |model|
-          model.send(:clear_changes_information) if model
+          model.clear_changes_information if model
         end
       end
 
       def from_database(*)
-        super.tap do |m|
-          m.send(:clear_changes_information)
-        end
+        super.tap(&:clear_changes_information)
       end
     end
 
@@ -110,7 +108,7 @@ module Dynamoid
     #
     # @return [ActiveSupport::HashWithIndifferentAccess]
     def changes
-      ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
+      ActiveSupport::HashWithIndifferentAccess[changed.map { |name| [name, attribute_change(name)] }]
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
@@ -137,6 +135,25 @@ module Dynamoid
       @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
     end
 
+    # Clear all dirty data: current changes and previous changes.
+    def clear_changes_information
+      @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    # Clears dirty data and moves +changes+ to +previous_changes+.
+    def changes_applied
+      @previously_changed = changes
+      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    # Remove changes information for the provided attributes.
+    #
+    # @param attributes [Array[String]] - a list of attributes to clear changes for
+    def clear_attribute_changes(names)
+      attributes_changed_by_setter.except!(*names)
+    end
+
     # Handle <tt>*_changed?</tt> for +method_missing+.
     #
     #  person.attribute_changed?(:name) # => true
@@ -145,14 +162,14 @@ module Dynamoid
     #  person.attribute_changed?(:name, from: 'Alice', to: 'Bod')
     #
     # @private
-    # @param attr [Symbol] attribute name
+    # @param name [Symbol] attribute name
     # @param options [Hash] conditions on +from+ and +to+ value (optional)
     # @option options [Symbol] :from previous attribute value
     # @option options [Symbol] :to current attribute value
-    def attribute_changed?(attr, options = {})
-      result = changes_include?(attr)
-      result &&= options[:to] == __send__(attr) if options.key?(:to)
-      result &&= options[:from] == changed_attributes[attr] if options.key?(:from)
+    def attribute_changed?(name, options = {})
+      result = changes_include?(name)
+      result &&= options[:to] == read_attribute(name) if options.key?(:to)
+      result &&= options[:from] == changed_attributes[name] if options.key?(:from)
       result
     end
 
@@ -163,16 +180,16 @@ module Dynamoid
     #  person.attribute_was(:name) # => "Alice"
     #
     # @private
-    # @param attr [Symbol] attribute name
-    def attribute_was(attr)
-      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+    # @param name [Symbol] attribute name
+    def attribute_was(name)
+      attribute_changed?(name) ? changed_attributes[name] : read_attribute(name)
     end
 
     # Restore all previous data of the provided attributes.
     #
     # @param attributes [Array[Symbol]] a list of attribute names
-    def restore_attributes(attributes = changed)
-      attributes.each { |attr| restore_attribute! attr }
+    def restore_attributes(names = changed)
+      names.each { |name| restore_attribute! name }
     end
 
     # Handles <tt>*_previously_changed?</tt> for +method_missing+.
@@ -183,10 +200,10 @@ module Dynamoid
     #  person.attribute_changed?(:name) # => true
     #
     # @private
-    # @param attr [Symbol] attribute name
+    # @param name [Symbol] attribute name
     # @return [true|false]
-    def attribute_previously_changed?(attr)
-      previous_changes_include?(attr)
+    def attribute_previously_changed?(name)
+      previous_changes_include?(name)
     end
 
     # Handles <tt>*_previous_change</tt> for +method_missing+.
@@ -197,61 +214,49 @@ module Dynamoid
     #  person.attribute_previously_changed(:name) # => ["Alice", "Bob"]
     #
     # @private
-    # @param attr [Symbol]
+    # @param name [Symbol]
     # @return [Array]
-    def attribute_previous_change(attr)
-      previous_changes[attr] if attribute_previously_changed?(attr)
+    def attribute_previous_change(name)
+      previous_changes[name] if attribute_previously_changed?(name)
     end
 
     private
 
-    def changes_include?(attr_name)
-      attributes_changed_by_setter.include?(attr_name)
+    def changes_include?(name)
+      attributes_changed_by_setter.include?(name)
     end
     alias attribute_changed_by_setter? changes_include?
 
-    # Removes current changes and makes them accessible through +previous_changes+.
-    def changes_applied # :doc:
-      @previously_changed = changes
-      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-    end
-
-    # Clear all dirty data: current changes and previous changes.
-    def clear_changes_information # :doc:
-      @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-    end
-
     # Handle <tt>*_change</tt> for +method_missing+.
-    def attribute_change(attr)
-      [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+    def attribute_change(name)
+      [changed_attributes[name], read_attribute(name)] if attribute_changed?(name)
     end
 
     # Handle <tt>*_will_change!</tt> for +method_missing+.
-    def attribute_will_change!(attr)
-      return if attribute_changed?(attr)
+    def attribute_will_change!(name)
+      return if attribute_changed?(name)
 
       begin
-        value = __send__(attr)
+        value = read_attribute(name)
         value = value.duplicable? ? value.clone : value
       rescue TypeError, NoMethodError
       end
 
-      set_attribute_was(attr, value)
+      set_attribute_was(name, value)
     end
 
     # Handle <tt>restore_*!</tt> for +method_missing+.
-    def restore_attribute!(attr)
-      if attribute_changed?(attr)
-        __send__("#{attr}=", changed_attributes[attr])
-        clear_attribute_changes([attr])
+    def restore_attribute!(name)
+      if attribute_changed?(name)
+        write_attribute(name, changed_attributes[name])
+        clear_attribute_changes([name])
       end
     end
 
-    # Returns +true+ if attr_name were changed before the model was saved,
+    # Returns +true+ if name were changed before the model was saved,
     # +false+ otherwise.
-    def previous_changes_include?(attr_name)
-      previous_changes.include?(attr_name)
+    def previous_changes_include?(name)
+      previous_changes.include?(name)
     end
 
     # This is necessary because `changed_attributes` might be overridden in
@@ -259,13 +264,8 @@ module Dynamoid
     alias attributes_changed_by_setter changed_attributes
 
     # Force an attribute to have a particular "before" value
-    def set_attribute_was(attr, old_value)
-      attributes_changed_by_setter[attr] = old_value
-    end
-
-    # Remove changes information for the provided attributes.
-    def clear_attribute_changes(attributes)
-      attributes_changed_by_setter.except!(*attributes)
+    def set_attribute_was(name, old_value)
+      attributes_changed_by_setter[name] = old_value
     end
   end
 end

data/lib/dynamoid/document.rb

@@ -160,6 +160,22 @@ module Dynamoid
         end
       end
 
+      attr_accessor :abstract_class
+
+      def abstract_class?
+        defined?(@abstract_class) && @abstract_class == true
+      end
+
+      def sti_name
+        name
+      end
+
+      def sti_class_for(type_name)
+        type_name.constantize
+      rescue NameError
+        raise Errors::SubclassNotFound, "STI subclass does not found. Subclass: '#{type_name}'"
+      end
+
       # @private
       def deep_subclasses
         subclasses + subclasses.map(&:deep_subclasses).flatten
@@ -167,7 +183,7 @@ module Dynamoid
 
       # @private
       def choose_right_class(attrs)
-        attrs[inheritance_field] ? attrs[inheritance_field].constantize : self
+        attrs[inheritance_field] ? sti_class_for(attrs[inheritance_field]) : self
       end
     end
 
@@ -206,7 +222,7 @@ module Dynamoid
         load(attrs_with_defaults.merge(attrs_virtual))
 
         if block
-          block.call(self)
+          yield(self)
         end
       end
     end
@@ -278,6 +294,26 @@ module Dynamoid
       end
     end
 
+    def inspect
+      # attributes order is:
+      # - partition key
+      # - sort key
+      # - user defined attributes
+      # - timestamps - created_at/updated_at
+      names = [self.class.hash_key]
+      names << self.class.range_key if self.class.range_key
+      names += self.class.attributes.keys - names - %i[created_at updated_at]
+      names << :created_at if self.class.attributes.key?(:created_at)
+      names << :updated_at if self.class.attributes.key?(:updated_at)
+
+      inspection = names.map do |name|
+        value = read_attribute(name)
+        "#{name}: #{value.inspect}"
+      end.join(', ')
+
+      "#<#{self.class.name} #{inspection}>"
+    end
+
     private
 
     def dumped_range_value

data/lib/dynamoid/errors.rb

@@ -77,5 +77,7 @@ module Dynamoid
     class UnsupportedKeyType < Error; end
 
     class UnknownAttribute < Error; end
+
+    class SubclassNotFound < Error; end
   end
 end

data/lib/dynamoid/fields.rb

@@ -293,7 +293,7 @@ module Dynamoid
       old_value = read_attribute(name)
 
       unless attribute_is_present_on_model?(name)
-        raise Dynamoid::Errors::UnknownAttribute.new("Attribute #{name} is not part of the model")
+        raise Dynamoid::Errors::UnknownAttribute, "Attribute #{name} is not part of the model"
       end
 
       if association = @associations[name]
@@ -354,23 +354,6 @@ module Dynamoid
 
     private
 
-    # Automatically called during the created callback to set the created_at time.
-    #
-    # @since 0.2.0
-    def set_created_at
-      self.created_at ||= DateTime.now.in_time_zone(Time.zone) if self.class.timestamps_enabled?
-    end
-
-    # Automatically called during the save callback to set the updated_at time.
-    #
-    # @since 0.2.0
-    def set_updated_at
-      # @_touch_record=false means explicit disabling
-      if self.class.timestamps_enabled? && changed? && !updated_at_changed? && @_touch_record != false
-        self.updated_at = DateTime.now.in_time_zone(Time.zone)
-      end
-    end
-
     def set_expires_field
       options = self.class.options[:expires]
 
@@ -386,11 +369,12 @@ module Dynamoid
 
     def set_inheritance_field
       # actually it does only following logic:
-      # self.type ||= self.class.name if self.class.attributes[:type]
+      # self.type ||= self.class.sti_name if self.class.attributes[:type]
+      return if self.class.abstract_class?
 
       type = self.class.inheritance_field
       if self.class.attributes[type] && send(type).nil?
-        send("#{type}=", self.class.name)
+        send("#{type}=", self.class.sti_name)
       end
     end
 

data/lib/dynamoid/finders.rb

@@ -118,7 +118,7 @@ module Dynamoid
 
       # @private
       def _find_all(ids, options = {})
-        raise Errors::MissingRangeKey if range_key && ids.any? { |pk, sk| sk.nil? }
+        raise Errors::MissingRangeKey if range_key && ids.any? { |_pk, sk| sk.nil? }
 
         if range_key
           ids = ids.map do |pk, sk|
@@ -151,7 +151,9 @@ module Dynamoid
                 end
 
         if items.size == ids.size || !options[:raise_error]
-          items ? items.map { |i| from_database(i) } : []
+          models = items ? items.map { |i| from_database(i) } : []
+          models.each { |m| m.run_callbacks :find }
+          models
         else
           ids_list = range_key ? ids.map { |pk, sk| "(#{pk},#{sk})" } : ids.map(&:to_s)
           message = "Couldn't find all #{name.pluralize} with primary keys [#{ids_list.join(', ')}] "
@@ -173,7 +175,9 @@ module Dynamoid
         end
 
         if item = Dynamoid.adapter.read(table_name, id, options.slice(:range_key, :consistent_read))
-          from_database(item)
+          model = from_database(item)
+          model.run_callbacks :find
+          model
         elsif options[:raise_error]
           primary_key = range_key ? "(#{id},#{options[:range_key]})" : id
           message = "Couldn't find #{name} with primary key #{primary_key}"
@@ -294,7 +298,8 @@ module Dynamoid
       # @private
       # @since 0.2.0
       def method_missing(method, *args)
-        if method =~ /find/
+        # 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")
 
           finder = method.to_s.split('_by_').first

data/lib/dynamoid/indexes.rb

@@ -169,10 +169,9 @@ module Dynamoid
       # @return [Dynamoid::Indexes::Index, nil] index object or nil if it isn't found
       def find_index_by_name(name)
         string_name = name.to_s
-        indexes.each_value.detect{ |i| i.name.to_s == string_name }
+        indexes.each_value.detect { |i| i.name.to_s == string_name }
       end
 
-
       # Returns true iff the provided hash[,range] key combo is a local
       # secondary index.
       #
@@ -299,7 +298,6 @@ module Dynamoid
         end
       end
 
-
       def validate_hash_key
         validate_index_key(:hash_key, @hash_key)
       end
@@ -319,7 +317,7 @@ module Dynamoid
 
         key_dynamodb_type = dynamodb_type(key_field_attributes[:type], key_field_attributes)
         if PERMITTED_KEY_DYNAMODB_TYPES.include?(key_dynamodb_type)
-          self.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/log/formatter.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Dynamoid
   module Log
+    # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Log/Formatter.html
+    # https://docs.aws.amazon.com/sdk-for-ruby/v2/api/Seahorse/Client/Response.html
+    # https://aws.amazon.com/ru/blogs/developer/logging-requests/
     module Formatter
-
-      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Log/Formatter.html
-      # https://docs.aws.amazon.com/sdk-for-ruby/v2/api/Seahorse/Client/Response.html
-      # https://aws.amazon.com/ru/blogs/developer/logging-requests/
       class Debug
         def format(response)
           bold = "\x1b[1m"
@@ -21,6 +22,20 @@ module Dynamoid
           ].join("\n")
         end
       end
+
+      class Compact
+        def format(response)
+          bold = "\x1b[1m"
+          reset = "\x1b[0m"
+
+          [
+            response.context.operation.name,
+            bold,
+            response.context.http_request.body.string,
+            reset
+          ].join(' ')
+        end
+      end
     end
   end
 end

data/lib/dynamoid/persistence/import.rb

@@ -24,7 +24,10 @@ module Dynamoid
           import_with_backoff(models)
         end
 
-        models.each { |d| d.new_record = false }
+        models.each do |m|
+          m.new_record = false
+          m.clear_changes_information
+        end
         models
       end
 

data/lib/dynamoid/persistence/inc.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Persistence
+    # @private
+    class Inc
+      def self.call(model_class, hash_key, range_key = nil, counters)
+        new(model_class, hash_key, range_key, counters).call
+      end
+
+      # rubocop:disable Style/OptionalArguments
+      def initialize(model_class, hash_key, range_key = nil, counters)
+        @model_class = model_class
+        @hash_key = hash_key
+        @range_key = range_key
+        @counters = counters
+      end
+      # rubocop:enable Style/OptionalArguments
+
+      def call
+        touch = @counters.delete(:touch)
+
+        Dynamoid.adapter.update_item(@model_class.table_name, @hash_key, update_item_options) do |t|
+          @counters.each do |name, value|
+            t.add(name => cast_and_dump_attribute_value(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))
+            end
+          end
+        end
+      end
+
+      private
+
+      def update_item_options
+        if @model_class.range_key
+          range_key_options = @model_class.attributes[@model_class.range_key]
+          value_casted = TypeCasting.cast_field(@range_key, range_key_options)
+          value_dumped = Dumping.dump_field(value_casted, range_key_options)
+          { range_key: value_dumped }
+        else
+          {}
+        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
+
+        names = []
+        names << :updated_at if @model_class.timestamps_enabled?
+        names += Array.wrap(touch) if touch != true
+        names
+      end
+    end
+  end
+end

data/lib/dynamoid/persistence/save.rb

@@ -4,24 +4,44 @@ module Dynamoid
   module Persistence
     # @private
     class Save
-      def self.call(model)
-        new(model).call
+      def self.call(model, **options)
+        new(model, **options).call
       end
 
-      def initialize(model)
+      def initialize(model, touch: nil)
         @model = model
+        @touch = touch # touch=false means explicit disabling of updating the `updated_at` attribute
       end
 
       def call
         @model.hash_key = SecureRandom.uuid if @model.hash_key.blank?
 
+        return true unless @model.changed?
+
+        @model.created_at ||= DateTime.now.in_time_zone(Time.zone) if @model.class.timestamps_enabled?
+
+        if @model.class.timestamps_enabled? && !@model.updated_at_changed? && !(@touch == false && @model.persisted?)
+          @model.updated_at = DateTime.now.in_time_zone(Time.zone)
+        end
+
         # Add an optimistic locking check if the lock_version column exists
         if @model.class.attributes[:lock_version]
           @model.lock_version = (@model.lock_version || 0) + 1
         end
 
-        attributes_dumped = Dumping.dump_attributes(@model.attributes, @model.class.attributes)
-        Dynamoid.adapter.write(@model.class.table_name, attributes_dumped, conditions_for_write)
+        if @model.new_record?
+          attributes_dumped = Dumping.dump_attributes(@model.attributes, @model.class.attributes)
+          Dynamoid.adapter.write(@model.class.table_name, attributes_dumped, conditions_for_write)
+        else
+          attributes_to_persist = @model.attributes.slice(*@model.changed.map(&:to_sym))
+
+          Dynamoid.adapter.update_item(@model.class.table_name, @model.hash_key, options_to_update_item) do |t|
+            attributes_to_persist.each do |name, value|
+              value_dumped = Dumping.dump_field(value, @model.class.attributes[name])
+              t.set(name => value_dumped)
+            end
+          end
+        end
 
         @model.new_record = false
         true
@@ -59,6 +79,33 @@ module Dynamoid
 
         conditions
       end
+
+      def options_to_update_item
+        options = {}
+
+        if @model.class.range_key
+          value_dumped = Dumping.dump_field(@model.range_value, @model.class.attributes[@model.class.range_key])
+          options[:range_key] = value_dumped
+        end
+
+        conditions = {}
+        conditions[:if_exists] ||= {}
+        conditions[:if_exists][@model.class.hash_key] = @model.hash_key
+
+        # Add an optimistic locking check if the lock_version column exists
+        if @model.class.attributes[:lock_version]
+          # Uses the original lock_version value from Dirty API
+          # in case user changed 'lock_version' manually
+          if @model.changes[:lock_version][0]
+            conditions[:if] ||= {}
+            conditions[:if][:lock_version] = @model.changes[:lock_version][0]
+          end
+        end
+
+        options[:conditions] = conditions
+
+        options
+      end
     end
   end
 end

data/lib/dynamoid/persistence/update_validations.rb

@@ -9,7 +9,7 @@ module Dynamoid
 
         attributes.each do |attr_name, _|
           unless model_attributes.include?(attr_name)
-            raise Dynamoid::Errors::UnknownAttribute.new("Attribute #{attr_name} does not exist in #{model_class}")
+            raise Dynamoid::Errors::UnknownAttribute, "Attribute #{attr_name} does not exist in #{model_class}"
           end
         end
       end