aws-record 2.10.1 → 2.12.0

data/lib/aws-record/record/item_operations.rb

@@ -3,7 +3,6 @@
 module Aws
   module Record
     module ItemOperations
-
       # @api private
       def self.included(sub_class)
         sub_class.extend(ItemOperationsClassMethods)
@@ -12,20 +11,27 @@ module Aws
       # Saves this instance of an item to Amazon DynamoDB. If this item is "new"
       # as defined by having new or altered key attributes, will attempt a
       # conditional
-      # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#put_item-instance_method Aws::DynamoDB::Client#put_item}
-      # call, which will not overwrite an existing item. If the item only has
-      # altered non-key attributes, will perform an
-      # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#update_item-instance_method Aws::DynamoDB::Client#update_item}
-      # call. Uses this item instance's attributes in order to build the
-      # request on your behalf.
+      # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#put_item-instance_method
+      # Aws::DynamoDB::Client#put_item} call, which will not overwrite an existing
+      # item. If the item only has altered non-key attributes, will perform an
+      # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#update_item-instance_method
+      # Aws::DynamoDB::Client#update_item} call. Uses this item instance's attributes
+      # in order to build the request on your behalf.
       #
       # You can use the +:force+ option to perform a simple put/overwrite
       # without conditional validation or update logic.
       #
-      # @param [Hash] opts
+      # @param [Hash] opts Options to pass through to the
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#put_item-instance_method
+      #  Aws::DynamoDB::Client#put_item} call or the
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#update_item-instance_method
+      #  Aws::DynamoDB::Client#update_item} call. +:put_item+ is used when
+      #  +:force+ is true or when the item is new. +:update_item+ is used when
+      #  the item is not new.
       # @option opts [Boolean] :force if true, will save as a put operation and
       #  overwrite any existing item on the remote end. Otherwise, and by
       #  default, will either perform a conditional put or an update call.
+      #
       # @raise [Aws::Record::Errors::KeyMissing] if a required key attribute
       #  does not have a value within this item instance.
       # @raise [Aws::Record::Errors::ConditionalWriteFailed] if a conditional
@@ -35,30 +41,35 @@ module Aws
       #  cause is dependent on the validation library you are using.
       def save!(opts = {})
         ret = save(opts)
-        if ret
-          ret
-        else
-          raise Errors::ValidationError.new("Validation hook returned false!")
-        end
+        raise Errors::ValidationError, 'Validation hook returned false!' unless ret
+
+        ret
       end
 
       # Saves this instance of an item to Amazon DynamoDB. If this item is "new"
       # as defined by having new or altered key attributes, will attempt a
       # conditional
-      # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#put_item-instance_method Aws::DynamoDB::Client#put_item}
-      # call, which will not overwrite an existing item. If the item only has
-      # altered non-key attributes, will perform an
-      # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#update_item-instance_method Aws::DynamoDB::Client#update_item}
-      # call. Uses this item instance's attributes in order to build the
-      # request on your behalf.
+      # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#put_item-instance_method
+      # Aws::DynamoDB::Client#put_item} call, which will not overwrite an
+      # existing item. If the item only has altered non-key attributes, will perform an
+      # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#update_item-instance_method
+      # Aws::DynamoDB::Client#update_item} call. Uses this item instance's attributes
+      # in order to build the request on your behalf.
       #
       # You can use the +:force+ option to perform a simple put/overwrite
       # without conditional validation or update logic.
       #
-      # @param [Hash] opts
+      # @param [Hash] opts Options to pass through to the
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#put_item-instance_method
+      #  Aws::DynamoDB::Client#put_item} call or the
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#update_item-instance_method
+      #  Aws::DynamoDB::Client#update_item} call. +:put_item+ is used when
+      #  +:force+ is true or when the item is new. +:update_item+ is used when
+      #  the item is not new.
       # @option opts [Boolean] :force if true, will save as a put operation and
       #  overwrite any existing item on the remote end. Otherwise, and by
       #  default, will either perform a conditional put or an update call.
+      #
       # @return false if the record is invalid as defined by an attempt to call
       #  +valid?+ on this item, if that method exists. Otherwise, returns client
       #  call return value.
@@ -70,7 +81,6 @@ module Aws
         end
       end
 
-
       # Assigns the attributes provided onto the model.
       #
       # @example Usage Example
@@ -99,7 +109,8 @@ module Aws
         opts.each do |field, new_value|
           field = field.to_sym
           setter = "#{field}="
-          raise ArgumentError.new "Invalid field: #{field} for model" unless respond_to?(setter)
+          raise ArgumentError, "Invalid field: #{field} for model" unless respond_to?(setter)
+
           public_send(setter, new_value)
         end
       end
@@ -134,12 +145,19 @@ module Aws
       #   model.dirty? # => false
       #
       #
-      # @param [Hash] new_param, contains the new parameters for the model
+      # @param [Hash] new_params Contains the new parameters for the model.
       #
-      # @param [Hash] opts
+      # @param [Hash] opts Options to pass through to the
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#put_item-instance_method
+      #  Aws::DynamoDB::Client#put_item} call or the
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#update_item-instance_method
+      #  Aws::DynamoDB::Client#update_item} call. +:put_item+ is used when
+      #  +:force+ is true or when the item is new. +:update_item+ is used when
+      #  the item is not new.
       # @option opts [Boolean] :force if true, will save as a put operation and
       #  overwrite any existing item on the remote end. Otherwise, and by
       #  default, will either perform a conditional put or an update call.
+      #
       # @return false if the record is invalid as defined by an attempt to call
       #  +valid?+ on this item, if that method exists. Otherwise, returns client
       #  call return value.
@@ -157,12 +175,18 @@ module Aws
       # but this will be interpreted as persisting a new item to your DynamoDB
       # table
       #
-      # @param [Hash] new_param, contains the new parameters for the model
-      #
-      # @param [Hash] opts
+      # @param [Hash] new_params Contains the new parameters for the model.
+      # @param [Hash] opts Options to pass through to the
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#put_item-instance_method
+      #  Aws::DynamoDB::Client#put_item} call or the
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#update_item-instance_method
+      #  Aws::DynamoDB::Client#update_item} call. +:put_item+ is used when
+      #  +:force+ is true or when the item is new. +:update_item+ is used when
+      #  the item is not new.
       # @option opts [Boolean] :force if true, will save as a put operation and
       #  overwrite any existing item on the remote end. Otherwise, and by
       #  default, will either perform a conditional put or an update call.
+      #
       # @return The update mode if the update is successful
       #
       # @raise [Aws::Record::Errors::ValidationError] if any new values
@@ -174,71 +198,74 @@ module Aws
 
       # Deletes the item instance that matches the key values of this item
       # instance in Amazon DynamoDB. Uses the
-      # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#delete_item-instance_method Aws::DynamoDB::Client#delete_item}
-      # API.
-      def delete!
-        dynamodb_client.delete_item(
+      # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#delete_item-instance_method
+      # Aws::DynamoDB::Client#delete_item} API.
+      #
+      # @param [Hash] opts Options to pass through to the
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#delete_item-instance_method
+      #  Aws::DynamoDB::Client#delete_item} call.
+      def delete!(opts = {})
+        delete_opts = {
           table_name: self.class.table_name,
           key: key_values
-        )
-        self.instance_variable_get("@data").destroyed = true
+        }
+        dynamodb_client.delete_item(opts.merge(delete_opts))
+        instance_variable_get('@data').destroyed = true
       end
 
       # Validates and generates the key values necessary for API operations such as the
-      # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#delete_item-instance_method Aws::DynamoDB::Client#delete_item}
-      # operation.
+      # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#delete_item-instance_method
+      # Aws::DynamoDB::Client#delete_item} operation.
       def key_values
         validate_key_values
         attributes = self.class.attributes
         self.class.keys.values.each_with_object({}) do |attr_name, hash|
           db_name = attributes.storage_name_for(attr_name)
-          hash[db_name] = attributes
-            .attribute_for(attr_name)
-            .serialize(@data.raw_value(attr_name))
+          hash[db_name] = attributes.attribute_for(attr_name)
+                                    .serialize(@data.raw_value(attr_name))
         end
       end
 
       # Validates key values and returns a hash consisting of the parameters
       # to save the record using the
-      # {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#batch_write_item-instance_method Aws::DynamoDB::Client#batch_write_item}
-      # operation.
+      # {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#batch_write_item-instance_method
+      # Aws::DynamoDB::Client#batch_write_item} operation.
       def save_values
         _build_item_for_save
       end
 
       private
-      def _invalid_record?(opts)
-        if self.respond_to?(:valid?)
-          if !self.valid?
-            true
-          else
-            false
-          end
+
+      def _invalid_record?(_opts)
+        if respond_to?(:valid?)
+          !valid?
         else
           false
         end
       end
 
       def _perform_save(opts)
-        force = opts[:force]
+        force = opts.delete(:force)
         expect_new = expect_new_item?
         if force
-          dynamodb_client.put_item(
+          put_opts = {
             table_name: self.class.table_name,
             item: _build_item_for_save
-          )
+          }
+          dynamodb_client.put_item(opts.merge(put_opts))
         elsif expect_new
           put_opts = {
             table_name: self.class.table_name,
             item: _build_item_for_save
           }.merge(prevent_overwrite_expression)
           begin
-            dynamodb_client.put_item(put_opts)
+            dynamodb_client.put_item(opts.merge(put_opts))
           rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
             raise Errors::ConditionalWriteFailed.new(
-              "Conditional #put_item call failed! Check that conditional write"\
-                " conditions are met, or include the :force option to clobber"\
-                " the remote item."
+              'Conditional #put_item call failed! Check that conditional write ' \
+              'conditions are met, or include the :force option to clobber ' \
+              'the remote item.',
+              e
             )
           end
         else
@@ -249,22 +276,22 @@ module Aws
           )
           if update_tuple
             uex, exp_attr_names, exp_attr_values = update_tuple
-            request_opts = {
+            update_opts = {
               table_name: self.class.table_name,
               key: key_values,
               update_expression: uex,
-              expression_attribute_names: exp_attr_names,
+              expression_attribute_names: exp_attr_names
             }
-            request_opts[:expression_attribute_values] = exp_attr_values unless exp_attr_values.empty?
-            dynamodb_client.update_item(request_opts)
+            update_opts[:expression_attribute_values] = exp_attr_values unless exp_attr_values.empty?
           else
-            dynamodb_client.update_item(
+            update_opts = {
               table_name: self.class.table_name,
               key: key_values
-            )
+            }
           end
+          dynamodb_client.update_item(opts.merge(update_opts))
         end
-        data = self.instance_variable_get("@data")
+        data = instance_variable_get('@data')
         data.destroyed = false
         data.new_record = false
         true
@@ -278,15 +305,11 @@ module Aws
 
       def validate_key_values
         missing = missing_key_values
-        unless missing.empty?
-          raise Errors::KeyMissing.new(
-            "Missing required keys: #{missing.join(', ')}"
-          )
-        end
+        raise Errors::KeyMissing, "Missing required keys: #{missing.join(', ')}" unless missing.empty?
       end
 
       def missing_key_values
-        self.class.keys.inject([]) do |acc, key|
+        self.class.keys.each_with_object([]) do |key, acc|
           acc << key.last if @data.raw_value(key.last).nil?
           acc
         end
@@ -302,32 +325,29 @@ module Aws
       def prevent_overwrite_expression
         conditions = []
         expression_attribute_names = {}
-        keys = self.class.instance_variable_get("@keys")
+        keys = self.class.instance_variable_get('@keys')
         # Hash Key
-        conditions << "attribute_not_exists(#H)"
-        expression_attribute_names["#H"] = keys.hash_key_attribute.database_name
+        conditions << 'attribute_not_exists(#H)'
+        expression_attribute_names['#H'] = keys.hash_key_attribute.database_name
         # Range Key
         if self.class.range_key
-          conditions << "attribute_not_exists(#R)"
-          expression_attribute_names["#R"] = keys.range_key_attribute.database_name
+          conditions << 'attribute_not_exists(#R)'
+          expression_attribute_names['#R'] = keys.range_key_attribute.database_name
         end
         {
-          condition_expression: conditions.join(" and "),
+          condition_expression: conditions.join(' and '),
           expression_attribute_names: expression_attribute_names
         }
       end
 
       def _dirty_changes_for_update
-        attributes = self.class.attributes
-        ret = dirty.inject({}) do |acc, attr_name|
+        dirty.each_with_object({}) do |attr_name, acc|
           acc[attr_name] = @data.raw_value(attr_name)
           acc
         end
-        ret
       end
 
       module ItemOperationsClassMethods
-
         # @example Usage Example
         #   check_exp = Model.transact_check_expression(
         #     key: { uuid: "foo" },
@@ -347,9 +367,10 @@ module Aws
         #
         # @param [Hash] opts Options matching the :condition_check contents in
         #   the
-        #   {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#transact_write_items-instance_method Aws::DynamoDB::Client#transact_write_items}
-        #   API, with the exception that keys will be marshalled for you, and
-        #   the table name will be provided for you by the operation.
+        #   {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#transact_write_items-instance_method
+        #   Aws::DynamoDB::Client#transact_write_items} API, with the exception that
+        #   keys will be marshalled for you, and the table name will be provided
+        #   for you by the operation.
         # @return [Hash] Options suitable to be used as a check expression when
         #   calling the +#transact_write+ operation.
         def transact_check_expression(opts)
@@ -358,14 +379,11 @@ module Aws
           key = opts.delete(:key)
           check_key = {}
           @keys.keys.each_value do |attr_sym|
-            unless key[attr_sym]
-              raise Errors::KeyMissing.new(
-                "Missing required key #{attr_sym} in #{key}"
-              )
-            end
+            raise Errors::KeyMissing, "Missing required key #{attr_sym} in #{key}" unless key[attr_sym]
+
             attr_name = attributes.storage_name_for(attr_sym)
-            check_key[attr_name] = attributes.attribute_for(attr_sym).
-              serialize(key[attr_sym])
+            check_key[attr_name] = attributes.attribute_for(attr_sym)
+                                             .serialize(key[attr_sym])
           end
           opts[:key] = check_key
           opts[:table_name] = table_name
@@ -384,14 +402,11 @@ module Aws
           key = opts.delete(:key)
           request_key = {}
           @keys.keys.each_value do |attr_sym|
-            unless key[attr_sym]
-              raise Errors::KeyMissing.new(
-                "Missing required key #{attr_sym} in #{key}"
-              )
-            end
+            raise Errors::KeyMissing, "Missing required key #{attr_sym} in #{key}" unless key[attr_sym]
+
             attr_name = attributes.storage_name_for(attr_sym)
-            request_key[attr_name] = attributes.attribute_for(attr_sym).
-              serialize(key[attr_sym])
+            request_key[attr_name] = attributes.attribute_for(attr_sym)
+                                               .serialize(key[attr_sym])
           end
           # this is a :get item used by #transact_get_items, with the exception
           # of :model_class which needs to be removed before passing along
@@ -422,10 +437,11 @@ module Aws
         # or virtual tables.
         #
         # @param [Hash] opts Options to pass through to
-        #   {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#transact_get_items-instance_method Aws::DynamoDB::Client#transact_get_items},
-        #   with the exception of the :transact_items array, which uses the
-        #   +#tfind_opts+ operation on your model class to provide extra
-        #   metadata used to marshal your items after retrieval.
+        #   {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#transact_get_items-instance_method
+        #   Aws::DynamoDB::Client#transact_get_items}, with the exception of the
+        #   :transact_items array, which uses the +#tfind_opts+ operation on
+        #   your model class to provide extra metadata used to marshal your
+        #   items after retrieval.
         # @option opts [Array] :transact_items A set of options describing
         #   instances of the model class to return.
         # @return [OpenStruct] Structured like the client API response from
@@ -479,32 +495,33 @@ module Aws
         # supports the options you are including, and avoid adding options not
         # recognized by the underlying client to avoid runtime exceptions.
         #
-        # @param [Hash] opts Options to pass through to the DynamoDB #get_item
-        #  request. The +:key+ option is a special case where attributes are
-        #  serialized and translated for you similar to the #find method.
+        # @param [Hash] opts Options to pass through to the
+        #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#get_item-instance_method
+        #  Aws::DynamoDB::Client#get_item} request. The +:key+ option is a
+        #  special case where attributes are serialized and translated for you
+        #  similar to the #find method.
         # @option opts [Hash] :key attribute-value pairs for the key you wish to
         #  search for.
+        #
         # @return [Aws::Record] builds and returns an instance of your model.
+        #
         # @raise [Aws::Record::Errors::KeyMissing] if your option parameters do
         #  not include all table keys.
         def find_with_opts(opts)
           key = opts.delete(:key)
           request_key = {}
           @keys.keys.each_value do |attr_sym|
-            unless key[attr_sym]
-              raise Errors::KeyMissing.new(
-                "Missing required key #{attr_sym} in #{key}"
-              )
-            end
+            raise Errors::KeyMissing, "Missing required key #{attr_sym} in #{key}" unless key[attr_sym]
+
             attr_name = attributes.storage_name_for(attr_sym)
-            request_key[attr_name] = attributes.attribute_for(attr_sym).
-              serialize(key[attr_sym])
+            request_key[attr_name] = attributes.attribute_for(attr_sym)
+                                               .serialize(key[attr_sym])
           end
-          request_opts = {
+          get_opts = {
             table_name: table_name,
             key: request_key
           }.merge(opts)
-          resp = dynamodb_client.get_item(request_opts)
+          resp = dynamodb_client.get_item(get_opts)
           if resp.item.nil?
             nil
           else
@@ -512,7 +529,6 @@ module Aws
           end
         end
 
-
         # @example Usage Example
         #   class MyModel
         #     include Aws::Record
@@ -561,53 +577,54 @@ module Aws
         #   MyModel.update(id: 1, name: "First", body: "Hello!")
         #
         # Performs an
-        # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#update_item-instance_method Aws::DynamoDB::Client#update_item}
-        # call immediately on the table, using the attribute key/value pairs
-        # provided.
+        # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#update_item-instance_method
+        # Aws::DynamoDB::Client#update_item} call immediately on the table,
+        # using the attribute key/value pairs provided.
         #
         # @param [Hash] opts attribute-value pairs for the update operation you
         #  wish to perform. You must include all key attributes for a valid
         #  call, then you may optionally include any other attributes that you
         #  wish to update.
+        #
         # @raise [Aws::Record::Errors::KeyMissing] if your option parameters do
         #  not include all table keys.
         def update(opts)
           key = {}
-          updates = {}
           @keys.keys.each_value do |attr_sym|
-            unless value = opts.delete(attr_sym)
-              raise Errors::KeyMissing.new(
-                "Missing required key #{attr_sym} in #{opts}"
-              )
+            unless (value = opts.delete(attr_sym))
+              raise Errors::KeyMissing, "Missing required key #{attr_sym} in #{opts}"
+
             end
+
             attr_name = attributes.storage_name_for(attr_sym)
             key[attr_name] = attributes.attribute_for(attr_sym).serialize(value)
           end
-          request_opts = {
+          update_opts = {
             table_name: table_name,
             key: key
           }
           update_tuple = _build_update_expression(opts)
           unless update_tuple.nil?
             uex, exp_attr_names, exp_attr_values = update_tuple
-            request_opts[:update_expression] = uex
-            request_opts[:expression_attribute_names] = exp_attr_names
-            request_opts[:expression_attribute_values] = exp_attr_values unless exp_attr_values.empty?
+            update_opts[:update_expression] = uex
+            update_opts[:expression_attribute_names] = exp_attr_names
+            update_opts[:expression_attribute_values] = exp_attr_values unless exp_attr_values.empty?
           end
-          dynamodb_client.update_item(request_opts)
+          dynamodb_client.update_item(update_opts)
         end
 
         private
+
         def _build_update_expression(attr_value_pairs)
           set_expressions = []
           remove_expressions = []
           exp_attr_names = {}
           exp_attr_values = {}
-          name_sub_token = "UE_A"
-          value_sub_token = "ue_a"
+          name_sub_token = 'UE_A'
+          value_sub_token = 'ue_a'
           attr_value_pairs.each do |attr_sym, value|
-            name_sub = "#" + name_sub_token
-            value_sub = ":" + value_sub_token
+            name_sub = "##{name_sub_token}"
+            value_sub = ":#{value_sub_token}"
             name_sub_token = name_sub_token.succ
             value_sub_token = value_sub_token.succ
 
@@ -615,29 +632,25 @@ module Aws
             attr_name = attributes.storage_name_for(attr_sym)
             exp_attr_names[name_sub] = attr_name
             if _update_type_remove?(attribute, value)
-              remove_expressions << "#{name_sub}"
+              remove_expressions << name_sub.to_s
             else
               set_expressions << "#{name_sub} = #{value_sub}"
               exp_attr_values[value_sub] = attribute.serialize(value)
             end
           end
           update_expressions = []
-          unless set_expressions.empty?
-            update_expressions << "SET " + set_expressions.join(", ")
-          end
-          unless remove_expressions.empty?
-            update_expressions << "REMOVE " + remove_expressions.join(", ")
-          end
+          update_expressions << ("SET #{set_expressions.join(', ')}") unless set_expressions.empty?
+          update_expressions << ("REMOVE #{remove_expressions.join(', ')}") unless remove_expressions.empty?
           if update_expressions.empty?
             nil
           else
-            [update_expressions.join(" "), exp_attr_names, exp_attr_values]
+            [update_expressions.join(' '), exp_attr_names, exp_attr_values]
           end
         end
 
         def build_item_from_resp(resp)
           record = new
-          data = record.instance_variable_get("@data")
+          data = record.instance_variable_get('@data')
           attributes.attributes.each do |name, attr|
             data.set_attribute(name, attr.extract(resp.item))
             data.new_record = false
@@ -649,7 +662,6 @@ module Aws
           value.nil? && !attribute.persist_nil?
         end
       end
-
     end
   end
 end

data/lib/aws-record/record/key_attributes.rb

@@ -2,7 +2,6 @@
 
 module Aws
   module Record
-
     # @api private
     class KeyAttributes
       attr_reader :keys
@@ -38,6 +37,5 @@ module Aws
         @range_key = value
       end
     end
-
   end
 end

data/lib/aws-record/record/marshalers/boolean_marshaler.rb

@@ -3,16 +3,14 @@
 module Aws
   module Record
     module Marshalers
-
       class BooleanMarshaler
         def initialize(opts = {})
+          # pass
         end
 
         def type_cast(raw_value)
           case raw_value
-          when nil
-            nil
-          when ''
+          when nil, ''
             nil
           when false, 'false', '0', 0
             false
@@ -36,7 +34,6 @@ module Aws
           end
         end
       end
-
     end
   end
 end

data/lib/aws-record/record/marshalers/date_marshaler.rb

@@ -5,7 +5,6 @@ require 'date'
 module Aws
   module Record
     module Marshalers
-
       class DateMarshaler
         def initialize(opts = {})
           @formatter = opts[:formatter] || Iso8601Formatter
@@ -13,9 +12,7 @@ module Aws
 
         def type_cast(raw_value)
           case raw_value
-          when nil
-            nil
-          when ''
+          when nil, ''
             nil
           when Date
             raw_value
@@ -36,7 +33,6 @@ module Aws
             raise ArgumentError, "expected a Date value or nil, got #{date.class}"
           end
         end
-
       end
 
       module Iso8601Formatter
@@ -44,7 +40,6 @@ module Aws
           date.iso8601
         end
       end
-
     end
   end
 end