dynamoid 3.2.0 → 3.3.0

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/until_past_table_status.rb

@@ -4,9 +4,10 @@ module Dynamoid
   module AdapterPlugin
     class AwsSdkV3
       class UntilPastTableStatus
-        attr_reader :table_name, :status
+        attr_reader :client, :table_name, :status
 
-        def initialize(table_name, status = :creating)
+        def initialize(client, table_name, status = :creating)
+          @client = client
           @table_name = table_name
           @status = status
         end

data/lib/dynamoid/components.rb

@@ -17,21 +17,24 @@ module Dynamoid
       after_initialize :set_inheritance_field
     end
 
-    include ActiveModel::AttributeMethods
+    include ActiveModel::AttributeMethods # Actually it will be inclided in Dirty module again
     include ActiveModel::Conversion
     include ActiveModel::MassAssignmentSecurity if defined?(ActiveModel::MassAssignmentSecurity)
     include ActiveModel::Naming
     include ActiveModel::Observing if defined?(ActiveModel::Observing)
     include ActiveModel::Serializers::JSON
     include ActiveModel::Serializers::Xml if defined?(ActiveModel::Serializers::Xml)
+    include Dynamoid::Persistence
+    include Dynamoid::Loadable
+    # Dirty module should be included after Persistence and Loadable
+    # because it overrides some methods declared in these modules
+    include Dynamoid::Dirty
     include Dynamoid::Fields
     include Dynamoid::Indexes
-    include Dynamoid::Persistence
     include Dynamoid::Finders
     include Dynamoid::Associations
     include Dynamoid::Criteria
     include Dynamoid::Validations
     include Dynamoid::IdentityMap
-    include Dynamoid::Dirty
   end
 end

data/lib/dynamoid/config.rb

@@ -31,6 +31,7 @@ module Dynamoid
     option :sync_retry_max_times, default: 60 # a bit over 2 minutes
     option :sync_retry_wait_seconds, default: 2
     option :convert_big_decimal, default: false
+    option :store_attribute_with_nil_value, default: false # keep or ignore attribute with nil value at saving
     option :models_dir, default: './app/models' # perhaps you keep your dynamoid models in a different directory?
     option :application_timezone, default: :utc # available values - :utc, :local, time zone name like "Hawaii"
     option :dynamodb_timezone, default: :utc # available values - :utc, :local, time zone name like "Hawaii"

data/lib/dynamoid/criteria.rb

@@ -8,7 +8,7 @@ module Dynamoid
     extend ActiveSupport::Concern
 
     module ClassMethods
-      %i[where all first last each record_limit scan_limit batch start scan_index_forward find_by_pages].each do |meth|
+      %i[where all first last each record_limit scan_limit batch start scan_index_forward find_by_pages project].each do |meth|
         # Return a criteria chain in response to a method that will begin or end a chain. For more information,
         # see Dynamoid::Criteria::Chain.
         #

data/lib/dynamoid/criteria/chain.rb

@@ -159,6 +159,11 @@ module Dynamoid
         pages.each(&block)
       end
 
+      def project(*fields)
+        @project = fields.map(&:to_sym)
+        self
+      end
+
       private
 
       # The actual records referenced by the association.
@@ -190,9 +195,12 @@ module Dynamoid
       #
       # @since 3.1.0
       def pages_via_query
-        Enumerator.new do |yielder|
+        Enumerator.new do |y|
           Dynamoid.adapter.query(source.table_name, range_query).each do |items, metadata|
-            yielder.yield items.map { |hash| source.from_database(hash) }, metadata.slice(:last_evaluated_key)
+            page = items.map { |h| source.from_database(h) }
+            options = metadata.slice(:last_evaluated_key)
+
+            y.yield page, options
           end
         end
       end
@@ -203,9 +211,12 @@ module Dynamoid
       #
       # @since 3.1.0
       def pages_via_scan
-        Enumerator.new do |yielder|
+        Enumerator.new do |y|
           Dynamoid.adapter.scan(source.table_name, scan_query, scan_opts).each do |items, metadata|
-            yielder.yield(items.map { |hash| source.from_database(hash) }, metadata.slice(:last_evaluated_key))
+            page = items.map { |h| source.from_database(h) }
+            options = metadata.slice(:last_evaluated_key)
+
+            y.yield page, options
           end
         end
       end
@@ -271,6 +282,13 @@ module Dynamoid
                  { contains: val }
                when 'not_contains'
                  { not_contains: val }
+               # NULL/NOT_NULL operators don't have parameters
+               # So { null: true } means NULL check and { null: false } means NOT_NULL one
+               # The same logic is used for { not_null: BOOL }
+               when 'null'
+                 val ? { null: nil } : { not_null: nil }
+               when 'not_null'
+                 val ? { not_null: nil } : { null: nil }
                end
 
         { name.to_sym => hash }
@@ -314,10 +332,15 @@ module Dynamoid
         opts.merge(query_opts).merge(consistent_opts)
       end
 
+      # TODO casting should be operator aware
+      # e.g. for NULL operator value should be boolean
+      # and isn't related to an attribute own type
       def type_cast_condition_parameter(key, value)
         return value if %i[array set].include?(source.attributes[key.to_sym][:type])
 
-        if !value.respond_to?(:to_ary)
+        if [true, false].include?(value) # Support argument for null/not_null operators
+          value
+        elsif !value.respond_to?(:to_ary)
           options = source.attributes[key.to_sym]
           value_casted = TypeCasting.cast_field(value, options)
           Dumping.dump_field(value_casted, options)
@@ -356,13 +379,16 @@ module Dynamoid
 
       def query_opts
         opts = {}
+        # Don't specify select = ALL_ATTRIBUTES option explicitly because it's
+        # already a default value of Select statement. Explicite Select value
+        # conflicts with AttributesToGet statement (project option).
         opts[:index_name] = @key_fields_detector.index_name if @key_fields_detector.index_name
-        opts[:select] = 'ALL_ATTRIBUTES'
         opts[:record_limit] = @record_limit if @record_limit
         opts[:scan_limit] = @scan_limit if @scan_limit
         opts[:batch_size] = @batch_size if @batch_size
         opts[:exclusive_start_key] = start_key if @start
         opts[:scan_index_forward] = @scan_index_forward
+        opts[:project] = @project
         opts
       end
 
@@ -386,6 +412,7 @@ module Dynamoid
         opts[:batch_size] = @batch_size if @batch_size
         opts[:exclusive_start_key] = start_key if @start
         opts[:consistent_read] = true if @consistent_read
+        opts[:project] = @project
         opts
       end
     end

data/lib/dynamoid/criteria/key_fields_detector.rb

@@ -3,57 +3,126 @@
 module Dynamoid #:nodoc:
   module Criteria
     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?(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
-
-        detect_keys
+        @query = Query.new(query)
+        @result = find_keys_in_query
       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 |lsi|
+          @query.contain?(lsi.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 |gsi|
+          @query.contain_with_eq_operator?(gsi.hash_key) && gsi.projected_attributes == :all &&
+            @query.contain?(gsi.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 |gsi|
+          @query.contain_with_eq_operator?(gsi.hash_key) && gsi.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/dirty.rb

@@ -1,67 +1,219 @@
 # 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
 
     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
 
     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
+    def save!(*)
+      super.tap do
+        changes_applied
+      end
     end
 
-    def reload
-      super.tap { clear_changes }
+    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
+    def update!(*)
+      super.tap do
+        clear_changes_information
       end
     end
 
-    def write_attribute(name, value)
-      attribute_will_change!(name) unless read_attribute(name) == value
-      super
+    def reload(*)
+      super.tap do
+        clear_changes_information
+      end
     end
 
-    protected
+    # Returns +true+ if any attribute have unsaved changes, +false+ otherwise.
+    #
+    #   person.changed? # => false
+    #   person.name = 'bob'
+    #   person.changed? # => true
+    def changed?
+      changed_attributes.present?
+    end
 
-    def attribute_method?(attr)
-      super || self.class.attributes.key?(attr.to_sym)
+    # Returns an array with the name of the attributes with unsaved changes.
+    #
+    #   person.changed # => []
+    #   person.name = 'bob'
+    #   person.changed # => ["name"]
+    def changed
+      changed_attributes.keys
     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
+    # 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"] }
+    def changes
+      ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
+    end
 
-      def mutations_from_database
-        @mutations_from_database ||= ActiveModel::NullMutationTracker.instance
-      end
+    # 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"]}
+    def previous_changes
+      @previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
 
-      def forget_attribute_assignments; end
+    # 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"}
+    def changed_attributes
+      @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
     end
 
-    if ActiveModel::VERSION::STRING < '4.2.0'
-      def clear_changes_information
-        changed_attributes.clear
-      end
+    # Handle <tt>*_changed?</tt> for +method_missing+.
+    def attribute_changed?(attr, options = {}) #:nodoc:
+      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
+
+    # Handle <tt>*_was</tt> for +method_missing+.
+    def attribute_was(attr) # :nodoc:
+      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+    end
+
+    # Restore all previous data of the provided attributes.
+    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:
+      previous_changes_include?(attr)
     end
+
+    # Handles <tt>*_previous_change</tt> for +method_missing+.
+    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
+
+        set_attribute_was(attr, 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])
+        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_method :attributes_changed_by_setter, :changed_attributes # :nodoc:
+
+      # 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) # :doc:
+        attributes_changed_by_setter.except!(*attributes)
+      end
   end
 end