dynamoid 3.2.0 → 3.6.0

data/lib/dynamoid/criteria/ignored_conditions_detector.rb

@@ -2,6 +2,7 @@
 
 module Dynamoid
   module Criteria
+    # @private
     class IgnoredConditionsDetector
       def initialize(conditions)
         @conditions = conditions
@@ -24,8 +25,8 @@ module Dynamoid
       def ignored_keys
         @conditions.keys
           .group_by(&method(:key_to_field))
-          .select { |field, ary| ary.size > 1 }
-          .flat_map { |field, ary| ary[0 .. -2] }
+          .select { |_, ary| ary.size > 1 }
+          .flat_map { |_, ary| ary[0..-2] }
       end
 
       def key_to_field(key)
@@ -38,4 +39,3 @@ module Dynamoid
     end
   end
 end
-

data/lib/dynamoid/criteria/key_fields_detector.rb

@@ -1,59 +1,136 @@
 # frozen_string_literal: true
 
-module Dynamoid #:nodoc:
+module Dynamoid
   module Criteria
+    # @private
     class KeyFieldsDetector
-      attr_reader :hash_key, :range_key, :index_name
+      class Query
+        def initialize(query_hash)
+          @query_hash = query_hash
+          @fields_with_operator = query_hash.keys.map(&:to_s)
+          @fields = query_hash.keys.map(&:to_s).map { |s| s.split('.').first }
+        end
+
+        def contain_only?(field_names)
+          (@fields - field_names.map(&:to_s)).blank?
+        end
+
+        def contain?(field_name)
+          @fields.include?(field_name.to_s)
+        end
+
+        def contain_with_eq_operator?(field_name)
+          @fields_with_operator.include?(field_name.to_s)
+        end
+      end
 
       def initialize(query, source)
         @query = query
         @source = source
+        @query = Query.new(query)
+        @result = find_keys_in_query
+      end
 
-        detect_keys
+      def non_key_present?
+        !@query.contain_only?([hash_key, range_key].compact)
       end
 
       def key_present?
-        @hash_key.present?
+        @result.present?
+      end
+
+      def hash_key
+        @result && @result[:hash_key]
+      end
+
+      def range_key
+        @result && @result[:range_key]
+      end
+
+      def index_name
+        @result && @result[:index_name]
       end
 
       private
 
-      def detect_keys
-        query_keys = @query.keys.collect { |k| k.to_s.split('.').first }
+      def find_keys_in_query
+        match_table_and_sort_key ||
+          match_local_secondary_index ||
+          match_global_secondary_index_and_sort_key ||
+          match_table ||
+          match_global_secondary_index
+      end
+
+      # Use table's default range key
+      def match_table_and_sort_key
+        return unless @query.contain_with_eq_operator?(@source.hash_key)
+        return unless @source.range_key
 
-        # See if querying based on table hash key
-        if @query.keys.map(&:to_s).include?(@source.hash_key.to_s)
-          @hash_key = @source.hash_key
+        if @query.contain?(@source.range_key)
+          {
+            hash_key: @source.hash_key,
+            range_key: @source.range_key
+          }
+        end
+      end
 
-          # Use table's default range key
-          if query_keys.include?(@source.range_key.to_s)
-            @range_key = @source.range_key
-            return
-          end
+      # See if can use any local secondary index range key
+      # Chooses the first LSI found that can be utilized for the query
+      def match_local_secondary_index
+        return unless @query.contain_with_eq_operator?(@source.hash_key)
 
-          # See if can use any local secondary index range key
-          # Chooses the first LSI found that can be utilized for the query
-          @source.local_secondary_indexes.each do |_, lsi|
-            next unless query_keys.include?(lsi.range_key.to_s)
+        lsi = @source.local_secondary_indexes.values.find do |i|
+          @query.contain?(i.range_key)
+        end
+
+        if lsi.present?
+          {
+            hash_key: @source.hash_key,
+            range_key: lsi.range_key,
+            index_name: lsi.name,
+          }
+        end
+      end
 
-            @range_key = lsi.range_key
-            @index_name = lsi.name
-          end
+      # See if can use any global secondary index
+      # Chooses the first GSI found that can be utilized for the query
+      # GSI with range key involved into query conditions has higher priority
+      # But only do so if projects ALL attributes otherwise we won't
+      # get back full data
+      def match_global_secondary_index_and_sort_key
+        gsi = @source.global_secondary_indexes.values.find do |i|
+          @query.contain_with_eq_operator?(i.hash_key) && i.projected_attributes == :all &&
+            @query.contain?(i.range_key)
+        end
 
-          return
+        if gsi.present?
+          {
+            hash_key: gsi.hash_key,
+            range_key: gsi.range_key,
+            index_name: gsi.name,
+          }
         end
+      end
+
+      def match_table
+        return unless @query.contain_with_eq_operator?(@source.hash_key)
 
-        # See if can use any global secondary index
-        # Chooses the first GSI found that can be utilized for the query
-        # But only do so if projects ALL attributes otherwise we won't
-        # get back full data
-        @source.global_secondary_indexes.each do |_, gsi|
-          next unless @query.keys.map(&:to_s).include?(gsi.hash_key.to_s) && gsi.projected_attributes == :all
-          next if @range_key.present? && !query_keys.include?(gsi.range_key.to_s)
+        {
+          hash_key: @source.hash_key,
+        }
+      end
+
+      def match_global_secondary_index
+        gsi = @source.global_secondary_indexes.values.find do |i|
+          @query.contain_with_eq_operator?(i.hash_key) && i.projected_attributes == :all
+        end
 
-          @hash_key = gsi.hash_key
-          @range_key = gsi.range_key
-          @index_name = gsi.name
+        if gsi.present?
+          {
+            hash_key: gsi.hash_key,
+            range_key: gsi.range_key,
+            index_name: gsi.name,
+          }
         end
       end
     end

data/lib/dynamoid/criteria/nonexistent_fields_detector.rb

@@ -2,6 +2,7 @@
 
 module Dynamoid
   module Criteria
+    # @private
     class NonexistentFieldsDetector
       def initialize(conditions, source)
         @conditions = conditions
@@ -19,8 +20,8 @@ module Dynamoid
         fields_list = @nonexistent_fields.map { |s| "`#{s}`" }.join(', ')
         count = @nonexistent_fields.size
 
-        "where conditions contain nonexistent" \
-          " field #{ 'name'.pluralize(count) } #{ fields_list }"
+        'where conditions contain nonexistent' \
+          " field #{'name'.pluralize(count)} #{fields_list}"
       end
 
       private

data/lib/dynamoid/criteria/overwritten_conditions_detector.rb

@@ -2,6 +2,7 @@
 
 module Dynamoid
   module Criteria
+    # @private
     class OverwrittenConditionsDetector
       def initialize(conditions, conditions_new)
         @conditions = conditions
@@ -37,4 +38,3 @@ module Dynamoid
     end
   end
 end
-

data/lib/dynamoid/dirty.rb

@@ -1,67 +1,274 @@
 # frozen_string_literal: true
 
 module Dynamoid
+  # Support interface of Rails' ActiveModel::Dirty module
+  #
+  # The reason why not just include ActiveModel::Dirty -
+  # ActiveModel::Dirty conflicts either with @attributes or
+  # #attributes in different Rails versions.
+  #
+  # Separate implementation (or copy-pasting) is the best way to
+  # avoid endless monkey-patching
+  #
+  # Documentation:
+  # https://api.rubyonrails.org/v4.2/classes/ActiveModel/Dirty.html
   module Dirty
     extend ActiveSupport::Concern
-    include ActiveModel::Dirty
+    include ActiveModel::AttributeMethods
 
+    included do
+      attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
+      attribute_method_suffix '_previously_changed?', '_previous_change'
+      attribute_method_affix prefix: 'restore_', suffix: '!'
+    end
+
+    # @private
     module ClassMethods
+      def update_fields(*)
+        if model = super
+          model.send(:clear_changes_information)
+        end
+        model
+      end
+
+      def upsert(*)
+        if model = super
+          model.send(:clear_changes_information)
+        end
+        model
+      end
+
       def from_database(*)
-        super.tap { |d| d.send(:clear_changes_information) }
+        super.tap do |m|
+          m.send(:clear_changes_information)
+        end
       end
     end
 
+    # @private
     def save(*)
-      clear_changes { super }
+      if status = super
+        changes_applied
+      end
+      status
     end
 
-    def update!(*)
-      ret = super
-      clear_changes # update! completely reloads all fields on the class, so any extant changes are wiped out
-      ret
+    # @private
+    def save!(*)
+      super.tap do
+        changes_applied
+      end
     end
 
-    def reload
-      super.tap { clear_changes }
+    # @private
+    def update(*)
+      super.tap do
+        clear_changes_information
+      end
     end
 
-    def clear_changes
-      previous = changes
-      (block_given? ? yield : true).tap do |result|
-        unless result == false # failed validation; nil is OK.
-          @previously_changed = previous
-          clear_changes_information
-        end
+    # @private
+    def update!(*)
+      super.tap do
+        clear_changes_information
+      end
+    end
+
+    # @private
+    def reload(*)
+      super.tap do
+        clear_changes_information
       end
     end
 
-    def write_attribute(name, value)
-      attribute_will_change!(name) unless read_attribute(name) == value
-      super
+    # Returns +true+ if any attribute have unsaved changes, +false+ otherwise.
+    #
+    #   person.changed? # => false
+    #   person.name = 'Bob'
+    #   person.changed? # => true
+    #
+    # @return [true|false]
+    def changed?
+      changed_attributes.present?
+    end
+
+    # Returns an array with names of the attributes with unsaved changes.
+    #
+    #   person = Person.new
+    #   person.changed # => []
+    #   person.name = 'Bob'
+    #   person.changed # => ["name"]
+    #
+    # @return [Array[String]]
+    def changed
+      changed_attributes.keys
+    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"] }
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def changes
+      ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
     end
 
-    protected
+    # 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"]}
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def previous_changes
+      @previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
 
-    def attribute_method?(attr)
-      super || self.class.attributes.key?(attr.to_sym)
+    # 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"}
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def changed_attributes
+      @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
     end
 
-    if ActiveModel::VERSION::STRING >= '5.2.0'
-      # The ActiveModel::Dirty API was changed
-      # https://github.com/rails/rails/commit/c3675f50d2e59b7fc173d7b332860c4b1a24a726#diff-aaddd42c7feb0834b1b5c66af69814d3
-      # So we just try to disable new functionality
+    # Handle <tt>*_changed?</tt> for +method_missing+.
+    #
+    #  person.attribute_changed?(:name) # => true
+    #  person.attribute_changed?(:name, from: 'Alice')
+    #  person.attribute_changed?(:name, to: 'Bob')
+    #  person.attribute_changed?(:name, from: 'Alice', to: 'Bod')
+    #
+    # @private
+    # @param attr [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)
+      result
+    end
 
-      def mutations_from_database
-        @mutations_from_database ||= ActiveModel::NullMutationTracker.instance
+    # Handle <tt>*_was</tt> for +method_missing+.
+    #
+    #  person = Person.create(name: 'Alice')
+    #  person.name = 'Bob'
+    #  person.attribute_was(:name) # => "Alice"
+    #
+    # @private
+    # @param attr [Symbol] attribute name
+    def attribute_was(attr)
+      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+    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 }
+    end
+
+    # Handles <tt>*_previously_changed?</tt> for +method_missing+.
+    #
+    #  person = Person.create(name: 'Alice')
+    #  person.name = 'Bob'
+    #  person.save
+    #  person.attribute_changed?(:name) # => true
+    #
+    # @private
+    # @param attr [Symbol] attribute name
+    # @return [true|false]
+    def attribute_previously_changed?(attr)
+      previous_changes_include?(attr)
+    end
+
+    # Handles <tt>*_previous_change</tt> for +method_missing+.
+    #
+    #  person = Person.create(name: 'Alice')
+    #  person.name = 'Bob'
+    #  person.save
+    #  person.attribute_previously_changed(:name) # => ["Alice", "Bob"]
+    #
+    # @private
+    # @param attr [Symbol]
+    # @return [Array]
+    def attribute_previous_change(attr)
+      previous_changes[attr] if attribute_previously_changed?(attr)
+    end
+
+    private
+
+    def changes_include?(attr_name)
+      attributes_changed_by_setter.include?(attr_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)
+    end
+
+    # Handle <tt>*_will_change!</tt> for +method_missing+.
+    def attribute_will_change!(attr)
+      return if attribute_changed?(attr)
+
+      begin
+        value = __send__(attr)
+        value = value.duplicable? ? value.clone : value
+      rescue TypeError, NoMethodError
       end
 
-      def forget_attribute_assignments; end
+      set_attribute_was(attr, value)
     end
 
-    if ActiveModel::VERSION::STRING < '4.2.0'
-      def clear_changes_information
-        changed_attributes.clear
+    # Handle <tt>restore_*!</tt> for +method_missing+.
+    def restore_attribute!(attr)
+      if attribute_changed?(attr)
+        __send__("#{attr}=", changed_attributes[attr])
+        clear_attribute_changes([attr])
       end
     end
+
+    # Returns +true+ if attr_name were changed before the model was saved,
+    # +false+ otherwise.
+    def previous_changes_include?(attr_name)
+      previous_changes.include?(attr_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
+
+    # 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)
+    end
   end
 end