dynamoid 3.8.0 → 3.12.1

data/lib/dynamoid/dirty.rb

@@ -26,19 +26,20 @@ module Dynamoid
     module ClassMethods
       def update_fields(*)
         super.tap do |model|
-          model.send(:clear_changes_information) if model
+          model.clear_changes_information if model
         end
       end
 
       def upsert(*)
         super.tap do |model|
-          model.send(:clear_changes_information) if model
+          model.clear_changes_information if model
         end
       end
 
-      def from_database(*)
-        super.tap do |m|
-          m.send(:clear_changes_information)
+      def from_database(attributes_from_database)
+        super.tap do |model|
+          model.clear_changes_information
+          model.assign_attributes_from_database(DeepDupper.dup_attributes(model.attributes, model.class))
         end
       end
     end
@@ -110,7 +111,7 @@ module Dynamoid
     #
     # @return [ActiveSupport::HashWithIndifferentAccess]
     def changes
-      ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
+      ActiveSupport::HashWithIndifferentAccess[changed_attributes.map { |name, old_value| [name, [old_value, read_attribute(name)]] }]
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
@@ -134,7 +135,31 @@ module Dynamoid
     #
     # @return [ActiveSupport::HashWithIndifferentAccess]
     def changed_attributes
-      @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      attributes_changed_by_setter.merge(attributes_changed_in_place)
+    end
+
+    # Clear all dirty data: current changes and previous changes.
+    def clear_changes_information
+      @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_from_database = HashWithIndifferentAccess.new(DeepDupper.dup_attributes(@attributes, self.class))
+    end
+
+    # Clears dirty data and moves +changes+ to +previous_changes+.
+    def changes_applied
+      @previously_changed = changes
+      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_from_database = HashWithIndifferentAccess.new(DeepDupper.dup_attributes(@attributes, self.class))
+    end
+
+    # Remove changes information for the provided attributes.
+    #
+    # @param attributes [Array[String]] - a list of attributes to clear changes for
+    def clear_attribute_changes(names)
+      attributes_changed_by_setter.except!(*names)
+
+      slice = HashWithIndifferentAccess.new(@attributes).slice(*names)
+      attributes_from_database.merge!(DeepDupper.dup_attributes(slice, self.class))
     end
 
     # Handle <tt>*_changed?</tt> for +method_missing+.
@@ -145,14 +170,14 @@ module Dynamoid
     #  person.attribute_changed?(:name, from: 'Alice', to: 'Bod')
     #
     # @private
-    # @param attr [Symbol] attribute name
+    # @param name [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)
+    def attribute_changed?(name, options = {})
+      result = changes_include?(name)
+      result &&= options[:to] == read_attribute(name) if options.key?(:to)
+      result &&= options[:from] == changed_attributes[name] if options.key?(:from)
       result
     end
 
@@ -163,16 +188,16 @@ module Dynamoid
     #  person.attribute_was(:name) # => "Alice"
     #
     # @private
-    # @param attr [Symbol] attribute name
-    def attribute_was(attr)
-      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+    # @param name [Symbol] attribute name
+    def attribute_was(name)
+      attribute_changed?(name) ? changed_attributes[name] : read_attribute(name)
     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 }
+    def restore_attributes(names = changed)
+      names.each { |name| restore_attribute! name }
     end
 
     # Handles <tt>*_previously_changed?</tt> for +method_missing+.
@@ -183,10 +208,10 @@ module Dynamoid
     #  person.attribute_changed?(:name) # => true
     #
     # @private
-    # @param attr [Symbol] attribute name
+    # @param name [Symbol] attribute name
     # @return [true|false]
-    def attribute_previously_changed?(attr)
-      previous_changes_include?(attr)
+    def attribute_previously_changed?(name)
+      previous_changes_include?(name)
     end
 
     # Handles <tt>*_previous_change</tt> for +method_missing+.
@@ -197,75 +222,136 @@ module Dynamoid
     #  person.attribute_previously_changed(:name) # => ["Alice", "Bob"]
     #
     # @private
-    # @param attr [Symbol]
+    # @param name [Symbol]
     # @return [Array]
-    def attribute_previous_change(attr)
-      previous_changes[attr] if attribute_previously_changed?(attr)
+    def attribute_previous_change(name)
+      previous_changes[name] if attribute_previously_changed?(name)
     end
 
-    private
-
-    def changes_include?(attr_name)
-      attributes_changed_by_setter.include?(attr_name)
+    # @private
+    def assign_attributes_from_database(attributes_from_database)
+      @attributes_from_database = HashWithIndifferentAccess.new(attributes_from_database)
     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
+    private
 
-    # Clear all dirty data: current changes and previous changes.
-    def clear_changes_information # :doc:
-      @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+    def changes_include?(name)
+      attribute_changed_by_setter?(name) || attribute_changed_in_place?(name)
     end
 
     # Handle <tt>*_change</tt> for +method_missing+.
-    def attribute_change(attr)
-      [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+    def attribute_change(name)
+      [changed_attributes[name], read_attribute(name)] if attribute_changed?(name)
     end
 
     # Handle <tt>*_will_change!</tt> for +method_missing+.
-    def attribute_will_change!(attr)
-      return if attribute_changed?(attr)
+    def attribute_will_change!(name)
+      return if attribute_changed?(name)
 
       begin
-        value = __send__(attr)
-        value = value.duplicable? ? value.clone : value
+        value = read_attribute(name)
+        value = value.clone if value.duplicable?
       rescue TypeError, NoMethodError
       end
 
-      set_attribute_was(attr, value)
+      set_attribute_was(name, 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])
+    def restore_attribute!(name)
+      if attribute_changed?(name)
+        write_attribute(name, changed_attributes[name])
+        clear_attribute_changes([name])
       end
     end
 
-    # Returns +true+ if attr_name were changed before the model was saved,
+    # Returns +true+ if name were changed before the model was saved,
     # +false+ otherwise.
-    def previous_changes_include?(attr_name)
-      previous_changes.include?(attr_name)
+    def previous_changes_include?(name)
+      previous_changes.include?(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
+    def attributes_changed_by_setter
+      @attributes_changed_by_setter ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def attribute_changed_by_setter?(name)
+      attributes_changed_by_setter.include?(name)
+    end
+
+    def attributes_from_database
+      @attributes_from_database ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
 
     # Force an attribute to have a particular "before" value
-    def set_attribute_was(attr, old_value)
-      attributes_changed_by_setter[attr] = old_value
+    def set_attribute_was(name, old_value)
+      attributes_changed_by_setter[name] = old_value
     end
 
-    # Remove changes information for the provided attributes.
-    def clear_attribute_changes(attributes)
-      attributes_changed_by_setter.except!(*attributes)
+    def attributes_changed_in_place
+      attributes_from_database.select do |name, _|
+        attribute_changed_in_place?(name)
+      end
+    end
+
+    def attribute_changed_in_place?(name)
+      return false if attribute_changed_by_setter?(name)
+
+      value_from_database = attributes_from_database[name]
+      return false if value_from_database.nil?
+
+      value = read_attribute(name)
+      type_options = self.class.attributes[name.to_sym]
+
+      unless type_options[:type].is_a?(Class) && !type_options[:comparable]
+        # common case
+        value != value_from_database
+      else
+        # objects of a custom type that does not implement its own `#==` method
+        # (that's declared by `comparable: false` or just not specifying the
+        # option `comparable`) are compared by comparing their dumps
+        dump = Dumping.dump_field(value, type_options)
+        dump_from_database = Dumping.dump_field(value_from_database, type_options)
+        dump != dump_from_database
+      end
+    end
+
+    module DeepDupper
+      def self.dup_attributes(attributes, klass)
+        attributes.map do |name, value|
+          type_options = klass.attributes[name.to_sym]
+          value_duplicate = dup_attribute(value, type_options)
+          [name, value_duplicate]
+        end.to_h
+      end
+
+      def self.dup_attribute(value, type_options)
+        type, of = type_options.values_at(:type, :of)
+
+        case value
+        when NilClass, TrueClass, FalseClass, Numeric, Symbol, IO
+          # Till Ruby 2.4 these immutable objects could not be duplicated.
+          # IO objects (used for the binary type) cannot be duplicated as well.
+          value
+        when Array
+          if of.is_a? Class
+            # custom type
+            value.map { |e| dup_attribute(e, type: of) }
+          else
+            value.deep_dup
+          end
+        when Set
+          Set.new(value.map { |e| dup_attribute(e, type: of) })
+        else
+          if type.is_a? Class
+            # custom type
+            dump = Dumping.dump_field(value, type_options)
+            Undumping.undump_field(dump.deep_dup, type_options)
+          else
+            value.deep_dup
+          end
+        end
+      end
     end
   end
 end

data/lib/dynamoid/document.rb

@@ -160,6 +160,22 @@ module Dynamoid
         end
       end
 
+      attr_accessor :abstract_class
+
+      def abstract_class?
+        defined?(@abstract_class) && @abstract_class == true
+      end
+
+      def sti_name
+        name
+      end
+
+      def sti_class_for(type_name)
+        type_name.constantize
+      rescue NameError
+        raise Errors::SubclassNotFound, "STI subclass does not found. Subclass: '#{type_name}'"
+      end
+
       # @private
       def deep_subclasses
         subclasses + subclasses.map(&:deep_subclasses).flatten
@@ -167,7 +183,7 @@ module Dynamoid
 
       # @private
       def choose_right_class(attrs)
-        attrs[inheritance_field] ? attrs[inheritance_field].constantize : self
+        attrs[inheritance_field] ? sti_class_for(attrs[inheritance_field]) : self
       end
     end
 
@@ -206,7 +222,7 @@ module Dynamoid
         load(attrs_with_defaults.merge(attrs_virtual))
 
         if block
-          block.call(self)
+          yield(self)
         end
       end
     end
@@ -244,7 +260,7 @@ module Dynamoid
     #
     # @return [Integer]
     def hash
-      hash_key.hash ^ range_value.hash
+      [hash_key, range_value].hash
     end
 
     # Return a model's hash key value.
@@ -278,6 +294,26 @@ module Dynamoid
       end
     end
 
+    def inspect
+      # attributes order is:
+      # - partition key
+      # - sort key
+      # - user defined attributes
+      # - timestamps - created_at/updated_at
+      names = [self.class.hash_key]
+      names << self.class.range_key if self.class.range_key
+      names += self.class.attributes.keys - names - %i[created_at updated_at]
+      names << :created_at if self.class.attributes.key?(:created_at)
+      names << :updated_at if self.class.attributes.key?(:updated_at)
+
+      inspection = names.map do |name|
+        value = read_attribute(name)
+        "#{name}: #{value.inspect}"
+      end.join(', ')
+
+      "#<#{self.class.name} #{inspection}>"
+    end
+
     private
 
     def dumped_range_value

data/lib/dynamoid/dumping.rb

@@ -70,7 +70,8 @@ module Dynamoid
       end
 
       def invalid_value?(value)
-        (value.is_a?(Set) || value.is_a?(String)) && value.empty?
+        (value.is_a?(Set) && value.empty?) ||
+          (value.is_a?(String) && value.empty? && Config.store_empty_string_as_nil)
       end
     end
 
@@ -86,6 +87,12 @@ module Dynamoid
 
     # string -> string
     class StringDumper < Base
+      def process(string)
+        return nil if string.nil?
+        return nil if string.empty? && Config.store_empty_string_as_nil
+
+        string
+      end
     end
 
     # integer -> number
@@ -101,6 +108,8 @@ module Dynamoid
       ALLOWED_TYPES = %i[string integer number date datetime serialized].freeze
 
       def process(set)
+        return nil if set.is_a?(Set) && set.empty?
+
         if @options.key?(:of)
           process_typed_collection(set)
         else
@@ -112,13 +121,13 @@ module Dynamoid
 
       def process_typed_collection(set)
         if allowed_type?
-          dumper = Dumping.find_dumper(element_options)
-          result = set.map { |el| dumper.process(el) }
-
-          if element_type == :string
-            result.reject!(&:empty?)
+          # StringDumper may replace "" with nil so we cannot distinguish it from an explicit nil
+          if element_type == :string && Config.store_empty_string_as_nil
+            set.reject! { |s| s && s.empty? }
           end
 
+          dumper = Dumping.find_dumper(element_options)
+          result = set.map { |el| dumper.process(el) }
           result.to_set
         else
           raise ArgumentError, "Set element type #{element_type} isn't supported"
@@ -164,14 +173,13 @@ module Dynamoid
 
       def process_typed_collection(array)
         if allowed_type?
-          dumper = Dumping.find_dumper(element_options)
-          result = array.map { |el| dumper.process(el) }
-
-          if element_type == :string
-            result.reject!(&:empty?)
+          # StringDumper may replace "" with nil so we cannot distinguish it from an explicit nil
+          if element_type == :string && Config.store_empty_string_as_nil
+            array.reject! { |s| s && s.empty? }
           end
 
-          result
+          dumper = Dumping.find_dumper(element_options)
+          array.map { |el| dumper.process(el) }
         else
           raise ArgumentError, "Array element type #{element_type} isn't supported"
         end
@@ -210,7 +218,7 @@ module Dynamoid
     # datetime -> integer/string
     class DateTimeDumper < Base
       def process(value)
-        !value.nil? ? format_datetime(value, @options) : nil
+        value.nil? ? nil : format_datetime(value, @options)
       end
 
       private
@@ -237,7 +245,7 @@ module Dynamoid
     # date -> integer/string
     class DateDumper < Base
       def process(value)
-        !value.nil? ? format_date(value, @options) : nil
+        value.nil? ? nil : format_date(value, @options)
       end
 
       private
@@ -289,10 +297,24 @@ module Dynamoid
       end
     end
 
-    # string -> string
+    # string -> StringIO
     class BinaryDumper < Base
       def process(value)
-        Base64.strict_encode64(value)
+        store_as_binary = if @options[:store_as_native_binary].nil?
+                            Dynamoid.config.store_binary_as_native
+                          else
+                            @options[:store_as_native_binary]
+                          end
+
+        if store_as_binary
+          if value.is_a?(StringIO) || value.is_a?(IO)
+            value
+          else
+            StringIO.new(value)
+          end
+        else
+          Base64.strict_encode64(value)
+        end
       end
     end
 
@@ -301,10 +323,10 @@ module Dynamoid
       def process(value)
         field_class = @options[:type]
 
-        if value.respond_to?(:dynamoid_dump)
-          value.dynamoid_dump
-        elsif field_class.respond_to?(:dynamoid_dump)
+        if field_class.respond_to?(:dynamoid_dump)
           field_class.dynamoid_dump(value)
+        elsif value.respond_to?(:dynamoid_dump)
+          value.dynamoid_dump
         else
           raise ArgumentError, "Neither #{field_class} nor #{value} supports serialization for Dynamoid."
         end

data/lib/dynamoid/errors.rb

@@ -6,6 +6,7 @@ module Dynamoid
     # Generic Dynamoid error
     class Error < StandardError; end
 
+    class MissingHashKey < Error; end
     class MissingRangeKey < Error; end
 
     class MissingIndex < Error; end
@@ -15,18 +16,27 @@ module Dynamoid
     class InvalidIndex < Error
       def initialize(item)
         if item.is_a? String
-          super(item)
+          super
         else
           super("Validation failed: #{item.errors.full_messages.join(', ')}")
         end
       end
     end
 
+    class RecordNotSaved < Error
+      attr_reader :record
+
+      def initialize(record)
+        super('Failed to save the item')
+        @record = record
+      end
+    end
+
     class RecordNotDestroyed < Error
       attr_reader :record
 
       def initialize(record)
-        super('Failed to destroy item')
+        super('Failed to destroy the item')
         @record = record
       end
     end
@@ -76,6 +86,25 @@ module Dynamoid
 
     class UnsupportedKeyType < Error; end
 
-    class UnknownAttribute < Error; end
+    class UnknownAttribute < Error
+      attr_reader :model_class, :attribute_name
+
+      def initialize(model_class, attribute_name)
+        super("Attribute #{attribute_name} does not exist in #{model_class}")
+
+        @model_class = model_class
+        @attribute_name = attribute_name
+      end
+    end
+
+    class SubclassNotFound < Error; end
+
+    class Rollback < Error; end
+
+    class ScanProhibited < Error
+      def initialize(_msg = nil)
+        super('Scan operations prohibited. Modify Dynamoid::Config.error_on_scan to change this behavior.')
+      end
+    end
   end
 end

data/lib/dynamoid/fields/declare.rb

@@ -48,7 +48,7 @@ module Dynamoid
 
         @source.generated_methods.module_eval do
           define_method(name) { read_attribute(name) }
-          define_method("#{name}?") do
+          define_method(:"#{name}?") do
             value = read_attribute(name)
             case value
             when true        then true
@@ -57,8 +57,8 @@ module Dynamoid
               !value.nil?
             end
           end
-          define_method("#{name}=") { |value| write_attribute(name, value) }
-          define_method("#{name}_before_type_cast") { read_attribute_before_type_cast(name) }
+          define_method(:"#{name}=") { |value| write_attribute(name, value) }
+          define_method(:"#{name}_before_type_cast") { read_attribute_before_type_cast(name) }
         end
       end
 
@@ -70,9 +70,9 @@ module Dynamoid
 
         @source.generated_methods.module_eval do
           alias_method alias_name, name
-          alias_method "#{alias_name}=", "#{name}="
-          alias_method "#{alias_name}?", "#{name}?"
-          alias_method "#{alias_name}_before_type_cast", "#{name}_before_type_cast"
+          alias_method :"#{alias_name}=", :"#{name}="
+          alias_method :"#{alias_name}?", :"#{name}?"
+          alias_method :"#{alias_name}_before_type_cast", :"#{name}_before_type_cast"
         end
       end