dynamoid 3.3.0 → 3.7.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,9 +1,9 @@
 # frozen_string_literal: true
 
-module Dynamoid #:nodoc:
+module Dynamoid
   module Criteria
+    # @private
     class KeyFieldsDetector
-
       class Query
         def initialize(query_hash)
           @query_hash = query_hash
@@ -11,6 +11,10 @@ module Dynamoid #:nodoc:
           @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
@@ -20,13 +24,18 @@ module Dynamoid #:nodoc:
         end
       end
 
-      def initialize(query, source)
+      def initialize(query, source, forced_index_name: nil)
         @query = query
         @source = source
         @query = Query.new(query)
+        @forced_index_name = forced_index_name
         @result = find_keys_in_query
       end
 
+      def non_key_present?
+        !@query.contain_only?([hash_key, range_key].compact)
+      end
+
       def key_present?
         @result.present?
       end
@@ -46,6 +55,8 @@ module Dynamoid #:nodoc:
       private
 
       def find_keys_in_query
+        return match_forced_index if @forced_index_name
+
         match_table_and_sort_key ||
           match_local_secondary_index ||
           match_global_secondary_index_and_sort_key ||
@@ -71,8 +82,8 @@ module Dynamoid #:nodoc:
       def match_local_secondary_index
         return unless @query.contain_with_eq_operator?(@source.hash_key)
 
-        lsi = @source.local_secondary_indexes.values.find do |lsi|
-          @query.contain?(lsi.range_key)
+        lsi = @source.local_secondary_indexes.values.find do |i|
+          @query.contain?(i.range_key)
         end
 
         if lsi.present?
@@ -90,9 +101,9 @@ module Dynamoid #:nodoc:
       # 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 |gsi|
-          @query.contain_with_eq_operator?(gsi.hash_key) && gsi.projected_attributes == :all &&
-            @query.contain?(gsi.range_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
 
         if gsi.present?
@@ -113,8 +124,8 @@ module Dynamoid #:nodoc:
       end
 
       def match_global_secondary_index
-        gsi = @source.global_secondary_indexes.values.find do |gsi|
-          @query.contain_with_eq_operator?(gsi.hash_key) && gsi.projected_attributes == :all
+        gsi = @source.global_secondary_indexes.values.find do |i|
+          @query.contain_with_eq_operator?(i.hash_key) && i.projected_attributes == :all
         end
 
         if gsi.present?
@@ -125,6 +136,16 @@ module Dynamoid #:nodoc:
           }
         end
       end
+
+      def match_forced_index
+        idx = @source.find_index_by_name(@forced_index_name)
+
+        {
+          hash_key: idx.hash_key,
+          range_key: idx.range_key,
+          index_name: idx.name,
+        }
+      end
     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

@@ -22,6 +22,7 @@ module Dynamoid
       attribute_method_affix prefix: 'restore_', suffix: '!'
     end
 
+    # @private
     module ClassMethods
       def update_fields(*)
         if model = super
@@ -44,6 +45,7 @@ module Dynamoid
       end
     end
 
+    # @private
     def save(*)
       if status = super
         changes_applied
@@ -51,24 +53,28 @@ module Dynamoid
       status
     end
 
+    # @private
     def save!(*)
       super.tap do
         changes_applied
       end
     end
 
+    # @private
     def update(*)
       super.tap do
         clear_changes_information
       end
     end
 
+    # @private
     def update!(*)
       super.tap do
         clear_changes_information
       end
     end
 
+    # @private
     def reload(*)
       super.tap do
         clear_changes_information
@@ -78,17 +84,22 @@ module Dynamoid
     # Returns +true+ if any attribute have unsaved changes, +false+ otherwise.
     #
     #   person.changed? # => false
-    #   person.name = 'bob'
+    #   person.name = 'Bob'
     #   person.changed? # => true
+    #
+    # @return [true|false]
     def changed?
       changed_attributes.present?
     end
 
-    # Returns an array with the name of the attributes with unsaved changes.
+    # Returns an array with names of the attributes with unsaved changes.
     #
+    #   person = Person.new
     #   person.changed # => []
-    #   person.name = 'bob'
+    #   person.name = 'Bob'
     #   person.changed # => ["name"]
+    #
+    # @return [Array[String]]
     def changed
       changed_attributes.keys
     end
@@ -97,18 +108,22 @@ module Dynamoid
     # and new values like <tt>attr => [original value, new value]</tt>.
     #
     #   person.changes # => {}
-    #   person.name = 'bob'
-    #   person.changes # => { "name" => ["bill", "bob"] }
+    #   person.name = 'Bob'
+    #   person.changes # => { "name" => ["Bill", "Bob"] }
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess]
     def changes
       ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
     #
-    #   person.name # => "bob"
-    #   person.name = 'robert'
+    #   person.name # => "Bob"
+    #   person.name = 'Robert'
     #   person.save
-    #   person.previous_changes # => {"name" => ["bob", "robert"]}
+    #   person.previous_changes # => {"name" => ["Bob", "Robert"]}
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess]
     def previous_changes
       @previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new
     end
@@ -116,15 +131,28 @@ module Dynamoid
     # 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"}
+    #   person.name # => "Bob"
+    #   person.name = 'Robert'
+    #   person.changed_attributes # => {"name" => "Bob"}
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess]
     def changed_attributes
       @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
     end
 
     # Handle <tt>*_changed?</tt> for +method_missing+.
-    def attribute_changed?(attr, options = {}) #:nodoc:
+    #
+    #  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)
@@ -132,88 +160,115 @@ module Dynamoid
     end
 
     # Handle <tt>*_was</tt> for +method_missing+.
-    def attribute_was(attr) # :nodoc:
+    #
+    #  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+.
-    def attribute_previously_changed?(attr) #:nodoc:
+    #
+    #  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
+    def changes_include?(attr_name)
+      attributes_changed_by_setter.include?(attr_name)
+    end
+    alias attribute_changed_by_setter? changes_include?
 
-      # 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
+    # Removes current changes and makes them accessible through +previous_changes+.
+    def changes_applied # :doc:
+      @previously_changed = changes
+      @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
+    # 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>*_will_change!</tt> for +method_missing+.
-      def attribute_will_change!(attr)
-        return if attribute_changed?(attr)
+    # Handle <tt>*_change</tt> for +method_missing+.
+    def attribute_change(attr)
+      [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+    end
 
-        begin
-          value = __send__(attr)
-          value = value.duplicable? ? value.clone : value
-        rescue TypeError, NoMethodError
-        end
+    # Handle <tt>*_will_change!</tt> for +method_missing+.
+    def attribute_will_change!(attr)
+      return if attribute_changed?(attr)
 
-        set_attribute_was(attr, value)
+      begin
+        value = __send__(attr)
+        value = value.duplicable? ? value.clone : value
+      rescue TypeError, NoMethodError
       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])
-        end
-      end
+      set_attribute_was(attr, value)
+    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)
+    # 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
 
-      # This is necessary because `changed_attributes` might be overridden in
-      # other implemntations (e.g. in `ActiveRecord`)
-      alias_method :attributes_changed_by_setter, :changed_attributes # :nodoc:
+    # 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
 
-      # Force an attribute to have a particular "before" value
-      def set_attribute_was(attr, old_value)
-        attributes_changed_by_setter[attr] = old_value
-      end
+    # This is necessary because `changed_attributes` might be overridden in
+    # other implemntations (e.g. in `ActiveRecord`)
+    alias attributes_changed_by_setter changed_attributes
 
-      # Remove changes information for the provided attributes.
-      def clear_attribute_changes(attributes) # :doc:
-        attributes_changed_by_setter.except!(*attributes)
-      end
+    # 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