Reimplement Rails 4.2 compatible Dirty interface

Author: andrykonchin

lib/dynamoid/components.rb

@@ -17,22 +17,24 @@ module Components
       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

lib/dynamoid/dirty.rb

@@ -1,67 +1,202 @@
 # 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_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 reload(*)
+      super.tap do
+        clear_changes_information
       end
     end
 
-    def write_attribute(name, value)
-      attribute_will_change!(name) unless read_attribute(name) == value
-      super
+    # 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
 
-    protected
+    # 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
 
-    def attribute_method?(attr)
-      super || self.class.attributes.key?(attr.to_sym)
+    # 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
 
-    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 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 mutations_from_database
-        @mutations_from_database ||= ActiveModel::NullMutationTracker.instance
-      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
 
-      def forget_attribute_assignments; 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
 
-    if ActiveModel::VERSION::STRING < '4.2.0'
-      def clear_changes_information
-        changed_attributes.clear
-      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
+
+    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
+
+      # 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

lib/dynamoid/fields.rb

@@ -52,6 +52,8 @@ def field(name, type = :string, options = {})
         end
         self.attributes = attributes.merge(name => { type: type }.merge(options))
 
+        define_attribute_method(name) # Dirty API
+
         generated_methods.module_eval do
           define_method(named) { read_attribute(named) }
           define_method("#{named}?") do
@@ -85,6 +87,10 @@ def remove_field(field)
         field = field.to_sym
         attributes.delete(field) || raise('No such field')
 
+        # Dirty API
+        undefine_attribute_methods
+        define_attribute_methods attributes.keys
+
         generated_methods.module_eval do
           remove_method field
           remove_method :"#{field}="
@@ -121,6 +127,8 @@ def write_attribute(name, value)
         association.reset
       end
 
+      attribute_will_change!(name) # Dirty API
+
       @attributes_before_type_cast[name] = value
 
       value_casted = TypeCasting.cast_field(value, self.class.attributes[name])