dynamoid 3.8.0 → 3.10.0

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 = value.duplicable? ? value.clone : value
+        value = read_attribute(name)
+        value = value.clone if value.duplicable?
       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
@@ -244,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.
@@ -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/dumping.rb

@@ -210,7 +210,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 +237,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

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/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
@@ -293,7 +291,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 +352,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]
 
@@ -379,23 +360,24 @@ 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
 
     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
 
     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.
       #
@@ -118,7 +107,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 +140,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 +164,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}"
@@ -249,7 +242,6 @@ module Dynamoid
         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
@@ -257,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
@@ -294,7 +289,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
@@ -303,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
@@ -169,10 +168,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 +297,6 @@ module Dynamoid
         end
       end
 
-
       def validate_hash_key
         validate_index_key(:hash_key, @hash_key)
       end
@@ -319,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)
-          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/loadable.rb

@@ -6,7 +6,7 @@ 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
@@ -27,7 +27,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/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