dynamoid 3.8.0 → 3.10.0

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
@@ -48,17 +68,40 @@ module Dynamoid
         end
 
         # 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
+        # Uses the original lock_version value from Dirty API
+        # in case user changed 'lock_version' manually
+        if @model.class.attributes[:lock_version] && (@model.changes[:lock_version][0])
+          conditions[:if] ||= {}
+          conditions[:if][:lock_version] = @model.changes[:lock_version][0]
         end
 
         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] ||= {}
+        conditions[:if][@model.class.hash_key] = @model.hash_key
+
+        # Add an optimistic locking check if the lock_version column exists
+        # Uses the original lock_version value from Dirty API
+        # in case user changed 'lock_version' manually
+        if @model.class.attributes[:lock_version] && (@model.changes[:lock_version][0])
+          conditions[:if] ||= {}
+          conditions[:if][:lock_version] = @model.changes[:lock_version][0]
+        end
+
+        options[:conditions] = conditions
+
+        options
+      end
     end
   end
 end

data/lib/dynamoid/persistence/update_fields.rb

@@ -54,8 +54,8 @@ module Dynamoid
         end
 
         conditions = @conditions.deep_dup
-        conditions[:if_exists] ||= {}
-        conditions[:if_exists][@model_class.hash_key] = @partition_key
+        conditions[:if] ||= {}
+        conditions[:if][@model_class.hash_key] = @partition_key
         options[:conditions] = conditions
 
         options

data/lib/dynamoid/persistence/update_validations.rb

@@ -7,9 +7,9 @@ module Dynamoid
       def self.validate_attributes_exist(model_class, attributes)
         model_attributes = model_class.attributes.keys
 
-        attributes.each do |attr_name, _|
+        attributes.each_key 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

data/lib/dynamoid/persistence.rb

@@ -8,6 +8,7 @@ require 'dynamoid/persistence/import'
 require 'dynamoid/persistence/update_fields'
 require 'dynamoid/persistence/upsert'
 require 'dynamoid/persistence/save'
+require 'dynamoid/persistence/inc'
 require 'dynamoid/persistence/update_validations'
 
 # encoding: utf-8
@@ -270,7 +271,7 @@ module Dynamoid
       # meets the specified conditions. Conditions can be specified as a +Hash+
       # with +:if+ key:
       #
-      #   User.update_fields('1', { age: 26 }, if: { version: 1 })
+      #   User.update_fields('1', { age: 26 }, { if: { version: 1 } })
       #
       # Here +User+ model has an integer +version+ field and the document will
       # be updated only if the +version+ attribute currently has value 1.
@@ -278,6 +279,13 @@ module Dynamoid
       # If a document with specified hash and range keys doesn't exist or
       # conditions were specified and failed the method call returns +nil+.
       #
+      # To check if some attribute (or attributes) isn't stored in a DynamoDB
+      # item (e.g. it wasn't set explicitly) there is another condition -
+      # +unless_exists+:
+      #
+      #   user = User.create(name: 'Tylor')
+      #   User.update_fields(user.id, { age: 18 }, { unless_exists: [:age] })
+      #
       # +update_fields+ uses the +UpdateItem+ operation so it saves changes and
       # loads an updated document back with one HTTP request.
       #
@@ -322,11 +330,18 @@ module Dynamoid
       # meets the specified conditions. Conditions can be specified as a +Hash+
       # with +:if+ key:
       #
-      #   User.upsert('1', { age: 26 }, if: { version: 1 })
+      #   User.upsert('1', { age: 26 }, { if: { version: 1 } })
       #
       # Here +User+ model has an integer +version+ field and the document will
       # be updated only if the +version+ attribute currently has value 1.
       #
+      # To check if some attribute (or attributes) isn't stored in a DynamoDB
+      # item (e.g. it wasn't set explicitly) there is another condition -
+      # +unless_exists+:
+      #
+      #   user = User.create(name: 'Tylor')
+      #   User.upsert(user.id, { age: 18 }, { unless_exists: [:age] })
+      #
       # If conditions were specified and failed the method call returns +nil+.
       #
       # +upsert+ uses the +UpdateItem+ operation so it saves changes and loads
@@ -378,28 +393,21 @@ module Dynamoid
       # Doesn't run validations and callbacks. Doesn't update +created_at+ and
       # +updated_at+ as well.
       #
+      # When `:touch` option is passed the timestamp columns are updating. If
+      # attribute names are passed, they are updated along with updated_at
+      # attribute:
+      #
+      #   User.inc('1', age: 2, touch: true)
+      #   User.inc('1', age: 2, touch: :viewed_at)
+      #   User.inc('1', age: 2, touch: [:viewed_at, :accessed_at])
+      #
       # @param hash_key_value [Scalar value] hash key
       # @param range_key_value [Scalar value] range key (optional)
       # @param counters [Hash] value to increase by
+      # @option counters [true | Symbol | Array[Symbol]] :touch to update update_at attribute and optionally the specified ones
       # @return [Model class] self
       def inc(hash_key_value, range_key_value = nil, counters)
-        options = if range_key
-                    value_casted = TypeCasting.cast_field(range_key_value, attributes[range_key])
-                    value_dumped = Dumping.dump_field(value_casted, attributes[range_key])
-                    { range_key: value_dumped }
-                  else
-                    {}
-                  end
-
-        Dynamoid.adapter.update_item(table_name, hash_key_value, options) do |t|
-          counters.each do |k, v|
-            value_casted = TypeCasting.cast_field(v, attributes[k])
-            value_dumped = Dumping.dump_field(value_casted, attributes[k])
-
-            t.add(k => value_dumped)
-          end
-        end
-
+        Inc.call(self, hash_key_value, range_key_value, counters)
         self
       end
     end
@@ -410,17 +418,43 @@ module Dynamoid
     #
     #   post.touch
     #
-    # Can update another field in addition with the same timestamp if it's name passed as argument.
+    # Can update other fields in addition with the same timestamp if their
+    # names passed as arguments.
+    #
+    #   user.touch(:last_login_at, :viewed_at)
+    #
+    # Some specific value can be used to save:
+    #
+    #   user.touch(time: 1.hour.ago)
     #
-    #   user.touch(:last_login_at)
+    # No validation is performed and only +after_touch+ callback is called.
     #
-    # @param name [Symbol] attribute name to update (optional)
+    # The method must be used on a persisted object, otherwise
+    # +Dynamoid::Errors::Error+ will be thrown.
+    #
+    # @param names [*Symbol] a list of attribute names to update (optional)
+    # @param time [Time] datetime value that can be used instead of the current time (optional)
     # @return [Dynamoid::Document] self
-    def touch(name = nil)
-      now = DateTime.now
-      self.updated_at = now
-      attributes[name] = now if name
-      save
+    def touch(*names, time: nil)
+      if new_record?
+        raise Dynamoid::Errors::Error, 'cannot touch on a new or destroyed record object'
+      end
+
+      time_to_assign = time || DateTime.now
+
+      self.updated_at = time_to_assign
+      names.each do |name|
+        attributes[name] = time_to_assign
+      end
+
+      attribute_names = names.map(&:to_sym) + [:updated_at]
+      attributes_with_values = attributes.slice(*attribute_names)
+
+      run_callbacks :touch do
+        self.class.update_fields(hash_key, range_value, attributes_with_values)
+        clear_attribute_changes(attribute_names.map(&:to_s))
+      end
+
       self
     end
 
@@ -487,15 +521,15 @@ module Dynamoid
     # @return [true|false] Whether saving successful or not
     # @since 0.2.0
     def save(options = {})
-      self.class.create_table(sync: true)
-
-      @_touch_record = options[:touch]
+      if Dynamoid.config.create_table_on_save
+        self.class.create_table(sync: true)
+      end
 
       create_or_update = new_record? ? :create : :update
 
-      run_callbacks(create_or_update) do
-        run_callbacks(:save) do
-          Save.call(self)
+      run_callbacks(:save) do
+        run_callbacks(create_or_update) do
+          Save.call(self, touch: options[:touch])
         end
       end
     end
@@ -540,6 +574,8 @@ module Dynamoid
     #
     #   user.update_attribute(:last_name, 'Tylor')
     #
+    # Validation is skipped.
+    #
     # Raises a +Dynamoid::Errors::UnknownAttribute+ exception if any of the
     # attributes is not on the model
     #
@@ -557,7 +593,7 @@ module Dynamoid
 
     # Update a model.
     #
-    # Runs validation and callbacks. Reloads all attribute values.
+    # Doesn't run validation. Runs only +update+ callbacks. Reloads all attribute values.
     #
     # Accepts mandatory block in order to specify operations which will modify
     # attributes. Supports following operations: +add+, +delete+ and +set+.
@@ -599,6 +635,15 @@ module Dynamoid
     #     t.add(age: 1)
     #   end
     #
+    # To check if some attribute (or attributes) isn't stored in a DynamoDB
+    # item (e.g. it wasn't set explicitly) there is another condition -
+    # +unless_exists+:
+    #
+    #   user = User.create(name: 'Tylor')
+    #   user.update!(unless_exists: [:age]) do |t|
+    #     t.set(age: 18)
+    #   end
+    #
     # If a document doesn't meet conditions it raises
     # +Dynamoid::Errors::StaleObjectError+ exception.
     #
@@ -644,7 +689,7 @@ module Dynamoid
 
     # Update a model.
     #
-    # Runs validation and callbacks. Reloads all attribute values.
+    # Doesn't run validation. Runs only +update+ callbacks. Reloads all attribute values.
     #
     # Accepts mandatory block in order to specify operations which will modify
     # attributes. Supports following operations: +add+, +delete+ and +set+.
@@ -695,6 +740,15 @@ module Dynamoid
     #     t.add(age: 1)
     #   end
     #
+    # To check if some attribute (or attributes) isn't stored in a DynamoDB
+    # item (e.g. it wasn't set explicitly) there is another condition -
+    # +unless_exists+:
+    #
+    #   user = User.create(name: 'Tylor')
+    #   user.update(unless_exists: [:age]) do |t|
+    #     t.set(age: 18)
+    #   end
+    #
     # If a document doesn't meet conditions it just returns +false+. Otherwise it returns +true+.
     #
     # It will increment the +lock_version+ attribute if a table has the column,
@@ -736,14 +790,32 @@ module Dynamoid
     #   user.increment!(:followers_count)
     #   user.increment!(:followers_count, 2)
     #
-    # Returns +true+ if a model was saved and +false+ otherwise.
+    # Only `attribute` is saved. The model itself is not saved. So any other
+    # modified attributes will still be dirty. Validations and callbacks are
+    # skipped.
+    #
+    # When `:touch` option is passed the timestamp columns are updating. If
+    # attribute names are passed, they are updated along with updated_at
+    # attribute:
+    #
+    #   user.increment!(:followers_count, touch: true)
+    #   user.increment!(:followers_count, touch: :viewed_at)
+    #   user.increment!(:followers_count, touch: [:viewed_at, :accessed_at])
     #
     # @param attribute [Symbol] attribute name
     # @param by [Numeric] value to add (optional)
-    # @return [true|false] whether saved model successfully
-    def increment!(attribute, by = 1)
+    # @param touch [true | Symbol | Array[Symbol]] to update update_at attribute and optionally the specified ones
+    # @return [Dynamoid::Document] self
+    def increment!(attribute, by = 1, touch: nil)
       increment(attribute, by)
-      save
+      change = read_attribute(attribute) - (attribute_was(attribute) || 0)
+
+      run_callbacks :touch do
+        self.class.inc(hash_key, range_value, attribute => change, touch: touch)
+        clear_attribute_changes(attribute)
+      end
+
+      self
     end
 
     # Change numeric attribute value.
@@ -758,9 +830,7 @@ module Dynamoid
     # @param by [Numeric] value to subtract (optional)
     # @return [Dynamoid::Document] self
     def decrement(attribute, by = 1)
-      self[attribute] ||= 0
-      self[attribute] -= by
-      self
+      increment(attribute, -by)
     end
 
     # Change numeric attribute value and save a model.
@@ -771,14 +841,24 @@ module Dynamoid
     #   user.decrement!(:followers_count)
     #   user.decrement!(:followers_count, 2)
     #
-    # Returns +true+ if a model was saved and +false+ otherwise.
+    # Only `attribute` is saved. The model itself is not saved. So any other
+    # modified attributes will still be dirty. Validations and callbacks are
+    # skipped.
+    #
+    # When `:touch` option is passed the timestamp columns are updating. If
+    # attribute names are passed, they are updated along with updated_at
+    # attribute:
+    #
+    #   user.decrement!(:followers_count, touch: true)
+    #   user.decrement!(:followers_count, touch: :viewed_at)
+    #   user.decrement!(:followers_count, touch: [:viewed_at, :accessed_at])
     #
     # @param attribute [Symbol] attribute name
     # @param by [Numeric] value to subtract (optional)
-    # @return [true|false] whether saved model successfully
-    def decrement!(attribute, by = 1)
-      decrement(attribute, by)
-      save
+    # @param touch [true | Symbol | Array[Symbol]] to update update_at attribute and optionally the specified ones
+    # @return [Dynamoid::Document] self
+    def decrement!(attribute, by = 1, touch: nil)
+      increment!(attribute, -by, touch: touch)
     end
 
     # Delete a model.
@@ -844,7 +924,7 @@ module Dynamoid
 
       Dynamoid.adapter.delete(self.class.table_name, hash_key, options)
 
-      self.class.associations.each do |name, options|
+      self.class.associations.each_key do |name|
         send(name).disassociate_source
       end
 

data/lib/dynamoid/type_casting.rb

@@ -57,11 +57,12 @@ module Dynamoid
 
     class StringTypeCaster < Base
       def process(value)
-        if value == true
+        case value
+        when true
           't'
-        elsif value == false
+        when false
           'f'
-        elsif value.is_a? String
+        when String
           value.dup
         else
           value.to_s
@@ -71,6 +72,7 @@ module Dynamoid
 
     class IntegerTypeCaster < Base
       def process(value)
+        # rubocop:disable Lint/DuplicateBranch
         if value == true
           1
         elsif value == false
@@ -84,11 +86,13 @@ module Dynamoid
         else
           value.to_i
         end
+        # rubocop:enable Lint/DuplicateBranch
       end
     end
 
     class NumberTypeCaster < Base
       def process(value)
+        # rubocop:disable Lint/DuplicateBranch
         if value == true
           1
         elsif value == false
@@ -104,6 +108,7 @@ module Dynamoid
         else
           value.to_d
         end
+        # rubocop:enable Lint/DuplicateBranch
       end
     end
 
@@ -135,7 +140,7 @@ module Dynamoid
           raise ArgumentError, "Set element type #{element_type} isn't supported"
         end
 
-        set.map { |el| type_caster.process(el) }.to_set
+        set.to_set { |el| type_caster.process(el) }
       end
 
       def element_type
@@ -227,10 +232,10 @@ module Dynamoid
           nil
         elsif value.is_a?(String)
           dt = begin
-                 DateTime.parse(value)
-               rescue StandardError
-                 nil
-               end
+            DateTime.parse(value)
+          rescue StandardError
+            nil
+          end
           if dt
             seconds = string_utc_offset(value) || ApplicationTimeZone.utc_offset
             offset = seconds_to_offset(seconds)
@@ -255,9 +260,7 @@ module Dynamoid
 
     class DateTypeCaster < Base
       def process(value)
-        if !value.respond_to?(:to_date)
-          nil
-        else
+        if value.respond_to?(:to_date)
           begin
             value.to_date
           rescue StandardError
@@ -277,10 +280,8 @@ module Dynamoid
       def process(value)
         if value == ''
           nil
-        elsif [false, 'false', 'FALSE', 0, '0', 'f', 'F', 'off', 'OFF'].include? value
-          false
         else
-          true
+          ![false, 'false', 'FALSE', 0, '0', 'f', 'F', 'off', 'OFF'].include? value
         end
       end
     end

data/lib/dynamoid/undumping.rb

@@ -115,7 +115,7 @@ module Dynamoid
       def process_typed_collection(set)
         if allowed_type?
           undumper = Undumping.find_undumper(element_options)
-          set.map { |el| undumper.process(el) }.to_set
+          set.to_set { |el| undumper.process(el) }
         else
           raise ArgumentError, "Set element type #{element_type} isn't supported"
         end

data/lib/dynamoid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dynamoid
-  VERSION = '3.8.0'
+  VERSION = '3.10.0'
 end