mobility 0.8.8 → 1.0.0.alpha

data/lib/mobility/plugins/active_model.rb

@@ -1,6 +1,23 @@
+require_relative "./active_model/dirty"
+require_relative "./active_model/cache"
+
 module Mobility
   module Plugins
+=begin
+
+Plugin for ActiveModel models. In practice, this is simply a wrapper to include
+a few plugins which apply to models which include ActiveModel::Dirty but are
+not ActiveRecord models.
+
+=end
     module ActiveModel
+      extend Plugin
+
+      requires :active_model_dirty
+      requires :active_model_cache
+      requires :backend, include: :before
     end
+
+    register_plugin(:active_model, ActiveModel)
   end
 end

data/lib/mobility/plugins/active_model/cache.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+
+module Mobility
+  module Plugins
+    module ActiveModel
+=begin
+
+Adds hooks to clear Mobility cache when AM dirty reset methods are called.
+
+=end
+      module Cache
+        extend Plugin
+
+        requires :cache, include: false
+
+        included_hook do |klass, _|
+          if options[:cache]
+            define_cache_hooks(klass, :changes_applied, :clear_changes_information)
+          end
+        end
+      end
+    end
+
+    register_plugin(:active_model_cache, ActiveModel::Cache)
+  end
+end

data/lib/mobility/plugins/active_model/dirty.rb

@@ -17,83 +17,339 @@ following methods:
 - +title_previous_change+
 - +restore_title!+
 
-In addition, the private method +restore_attribute!+ will also restore the
-value of the translated attribute if passed to it.
+The following methods are also patched to work with translated attributes:
+- +changed_attributes+
+- +changes+
+- +changed+
+- +changed?+
+- +previous_changes+
+- +clear_attribute_changes+
+- +restore_attributes+
+
+In addition, the following ActiveModel attribute handler methods are also
+patched to work with translated attributes:
+- +attribute_changed?+
+- +attribute_previously_changed?+
+- +attribute_was+
+
+(When using these methods, you must pass the attribute name along with its
+locale suffix, so +title_en+, +title_pt_br+, etc.)
+
+Other methods are also included for ActiveRecord models, see documentation on
+the ActiveRecord dirty plugin for more information.
 
 @see http://api.rubyonrails.org/classes/ActiveModel/Dirty.html Rails documentation for Active Model Dirty module
 
 =end
       module Dirty
-        # @!group Backend Accessors
-        # @!macro backend_writer
-        # @param [Hash] options
-        def write(locale, value, options = {})
-          locale_accessor = Mobility.normalize_locale_accessor(attribute, locale)
-          if model.changed_attributes.has_key?(locale_accessor) && model.changed_attributes[locale_accessor] == value
-            model.send(:attributes_changed_by_setter).except!(locale_accessor)
-          elsif read(locale, options.merge(locale: true)) != value
-            model.send(:mobility_changed_attributes) << locale_accessor
-            model.send(:attribute_will_change!, locale_accessor)
-          end
-          super
+        extend Plugin
+
+        requires :dirty, include: false
+
+        initialize_hook do
+          if options[:dirty]
+            define_dirty_methods(names)
+            include dirty_handler_methods
+          end
         end
-        # @!endgroup
-
-        # Builds module which adds suffix/prefix methods for translated
-        # attributes so they act like normal dirty-tracked attributes.
-        class MethodsBuilder < Module
-          def initialize(*attribute_names)
-            attribute_names.each do |name|
-              method_suffixes.each do |suffix|
-                define_method "#{name}#{suffix}" do
-                  __send__("attribute#{suffix}", Mobility.normalize_locale_accessor(name))
-                end
+
+        included_hook do |klass, backend_class|
+          raise TypeError, "#{name} should include ActiveModel::Dirty to use the active_model plugin" unless active_model_dirty_class?(klass)
+
+          if options[:dirty]
+            private_methods = InstanceMethods.instance_methods & klass.private_instance_methods
+            klass.include InstanceMethods
+            klass.class_eval { private(*private_methods) }
+
+            backend_class.include BackendMethods
+          end
+        end
+
+        private
+
+        # Overridden in AR::Dirty plugin to define a different HandlerMethods module
+        def dirty_handler_methods
+          HandlerMethods
+        end
+
+        def active_model_dirty_class?(klass)
+          klass.ancestors.include?(::ActiveModel::Dirty)
+        end
+
+        def define_dirty_methods(attribute_names)
+          attribute_names.each do |name|
+            dirty_handler_methods.each_pattern(name) do |method_name, attribute_method|
+              define_method(method_name) do |*args|
+                mutations_from_mobility.send(attribute_method, Dirty.append_locale(name), *args)
               end
+            end
+
+            define_method "restore_#{name}!" do
+              locale_accessor = Dirty.append_locale(name)
+              if mutations_from_mobility.attribute_changed?(locale_accessor)
+                __send__("#{name}=", mutations_from_mobility.attribute_was(locale_accessor))
+                mutations_from_mobility.restore_attribute!(locale_accessor)
+              end
+            end
+          end
+
+          # This private method override is necessary to make
+          # +restore_attributes+ (which is public) work with translated
+          # attributes.
+          define_method :restore_attribute! do |attr|
+            attribute_names.include?(attr.to_s) ? send("restore_#{attr}!") : super(attr)
+          end
+          private :restore_attribute!
+        end
+
+        def self.append_locale(attr_name)
+          Mobility.normalize_locale_accessor(attr_name)
+        end
+
+        # Module builder which mimics dirty method handlers on a given dirty class.
+        # Used to mimic ActiveModel::Dirty and ActiveRecord::Dirty, which have
+        # similar but slightly different sets of handler methods. Doing it this
+        # way with introspection allows us to support basically all AR/AM
+        # versions without changes here.
+        class HandlerMethodsBuilder < Module
+          attr_reader :klass
 
-              define_method "restore_#{name}!" do
-                locale_accessor = Mobility.normalize_locale_accessor(name)
-                if attribute_changed?(locale_accessor)
-                  __send__("#{name}=", changed_attributes[locale_accessor])
+          # @param [Class] klass Dirty class to mimic
+          def initialize(klass)
+            @klass = klass
+            define_handler_methods
+          end
+
+          def each_pattern(attr_name)
+            patterns.each do |pattern|
+              yield pattern % attr_name, pattern % 'attribute'
+            end
+          end
+
+          def define_handler_methods
+            public_patterns.each do |pattern|
+              method_name = pattern % 'attribute'
+
+              module_eval <<-EOM, __FILE__, __LINE__ + 1
+              def #{method_name}(attr_name, *rest)
+                if (mutations_from_mobility.attribute_changed?(attr_name) ||
+                    mutations_from_mobility.attribute_previously_changed?(attr_name))
+                  mutations_from_mobility.send(#{method_name.inspect}, attr_name, *rest)
+                else
+                  super
                 end
               end
+              EOM
             end
+          end
 
-            define_method :restore_attribute! do |attr|
-              attribute_names.include?(attr.to_s) ? send("restore_#{attr}!") : super(attr)
+          # Get method suffixes. Creating an object just to get the list of
+          # suffixes is simplest given they change from Rails version to version.
+          def patterns
+            @patterns ||=
+              (klass.attribute_method_matchers.map { |p| "#{p.prefix}%s#{p.suffix}" } - excluded_patterns)
+          end
+
+          private
+
+          def public_patterns
+            @public_patterns ||= patterns.select do |p|
+              klass.public_method_defined?(p % 'attribute')
             end
-            private :restore_attribute!
           end
 
-          def included(model_class)
-            model_class.include ChangedAttributes
+          def excluded_patterns
+            ['%s', 'restore_%s!']
+          end
+        end
+
+        # Module which defines generic handler methods like
+        # +attribute_changed?+ that are patched to work with translated
+        # attributes.
+        HandlerMethods = HandlerMethodsBuilder.new(Class.new { include ::ActiveModel::Dirty })
+
+        module InstanceMethods
+          def changed_attributes
+            super.merge(mutations_from_mobility.changed_attributes)
+          end
+
+          def changes_applied
+            super
+            mutations_from_mobility.finalize_changes
+          end
+
+          def changes
+            super.merge(mutations_from_mobility.changes)
+          end
+
+          def changed
+            # uniq is required for Rails < 6.0
+            (super + mutations_from_mobility.changed).uniq
+          end
+
+          def changed?
+            super || mutations_from_mobility.changed?
+          end
+
+          def previous_changes
+            super.merge(mutations_from_mobility.previous_changes)
+          end
+
+          def clear_changes_information
+            @mutations_from_mobility = nil
+            super
+          end
+
+          def clear_attribute_changes(attr_names)
+            attr_names.each { |attr_name| mutations_from_mobility.restore_attribute!(attr_name) }
+            super
           end
 
           private
 
-          # Get method suffixes. Creating an object just to get the list of
-          # suffixes is not very efficient, but the most reliable way given that
-          # they change from Rails version to version.
-          def method_suffixes
-            @method_suffixes ||=
-              Class.new do
-                include ::ActiveModel::Dirty
-              end.attribute_method_matchers.map(&:suffix).select { |m| m =~ /\A_/ }
-          end
-
-          # Tracks which translated attributes have been changed, separate from
-          # the default tracking of changes in ActiveModel/ActiveRecord Dirty.
-          # This is required in order for the Mobility ActiveRecord Dirty
-          # plugin to correctly read the value of locale accessors like
-          # +title_en+ in dirty tracking.
-          module ChangedAttributes
-            private
-
-            def mobility_changed_attributes
-              @mobility_changed_attributes ||= Set.new
+          def mutations_from_mobility
+            @mutations_from_mobility ||= MobilityMutationTracker.new(self)
+          end
+        end
+
+        # @note Seriously, I really don't want to reproduce all of
+        #   ActiveModel::Dirty here, but having fought with upstream changes
+        #   many many times I finally decided it's more future-proof to just
+        #   re-implement the stuff we need here, to avoid weird breakage.
+        #
+        #   Although this is somewhat ugly, at least it's explicit and since
+        #   it's self-defined (rather than hooking into fickle private methods
+        #   in Rails), it won't break all of a sudden. We just need to ensure
+        #   that specs are up-to-date with the latest weird dirty method
+        #   pattern Rails has decided to support.
+        class MobilityMutationTracker
+          OPTION_NOT_GIVEN = Object.new
+
+          attr_reader :previous_changes
+
+          def initialize(model)
+            @model = model
+            @current_changes = {}.with_indifferent_access
+            @previous_changes = {}.with_indifferent_access
+          end
+
+          def finalize_changes
+            @previous_changes = changes
+            @current_changes = {}.with_indifferent_access
+          end
+
+          def changed
+            attr_names.select { |attr_name| attribute_changed?(attr_name) }
+          end
+
+          def changed_attributes
+            attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+              if attribute_changed?(attr_name)
+                result[attr_name] = attribute_was(attr_name)
+              end
+            end
+          end
+
+          def changes
+            attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+              if change = attribute_change(attr_name)
+                result.merge!(attr_name => change)
+              end
+            end
+          end
+
+          def changed?
+            attr_names.any? { |attr| attribute_changed?(attr) }
+          end
+
+          def attribute_change(attr_name)
+            if attribute_changed?(attr_name)
+              [attribute_was(attr_name), fetch_value(attr_name)]
+            end
+          end
+
+          def attribute_previous_change(attr_name)
+            previous_changes[attr_name]
+          end
+
+          def attribute_previously_was(attr_name)
+            if attribute_previously_changed?(attr_name)
+              # Calling +first+ here fetches the value before change from the
+              # hash.
+              previous_changes[attr_name].first
+            end
+          end
+
+          def attribute_changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
+            current_changes.include?(attr_name) &&
+              (OPTION_NOT_GIVEN == from || attribute_was(attr_name) == from) &&
+              (OPTION_NOT_GIVEN == to || fetch_value(attr_name) == to)
+          end
+
+          def attribute_previously_changed?(attr_name)
+            previous_changes.include?(attr_name)
+          end
+
+          def attribute_was(attr_name)
+            if attribute_changed?(attr_name)
+              current_changes[attr_name]
+            else
+              fetch_value(attr_name)
+            end
+          end
+
+          def attribute_will_change!(attr_name)
+            current_changes[attr_name] = fetch_value(attr_name) unless current_changes.include?(attr_name)
+          end
+
+          def restore_attribute!(attr_name)
+            current_changes.delete(attr_name)
+          end
+
+          # These are for ActiveRecord, but we'll define them here.
+          alias_method :saved_change_to_attribute?,     :attribute_previously_changed?
+          alias_method :saved_change_to_attribute,      :attribute_previous_change
+          alias_method :attribute_before_last_save,     :attribute_previously_was
+          alias_method :will_save_change_to_attribute?, :attribute_changed?
+          alias_method :attribute_change_to_be_saved,   :attribute_change
+          alias_method :attribute_in_database,          :attribute_was
+
+          private
+          attr_reader :model, :current_changes
+
+          def attr_names
+            current_changes.keys
+          end
+
+          def fetch_value(attr_name)
+            model.__send__(attr_name)
+          end
+        end
+
+        module BackendMethods
+          # @!group Backend Accessors
+          # @!macro backend_writer
+          # @param [Hash] options
+          def write(locale, value, options = {})
+            locale_accessor = Mobility.normalize_locale_accessor(attribute, locale)
+            if model.changed_attributes.has_key?(locale_accessor) && model.changed_attributes[locale_accessor] == value
+              mutations_from_mobility.restore_attribute!(locale_accessor)
+            elsif read(locale, options.merge(locale: true)) != value
+              mutations_from_mobility.attribute_will_change!(locale_accessor)
             end
+            super
+          end
+          # @!endgroup
+
+          private
+
+          def mutations_from_mobility
+            model.send(:mutations_from_mobility)
           end
         end
       end
     end
+
+    register_plugin(:active_model_dirty, ActiveModel::Dirty)
   end
 end

data/lib/mobility/plugins/active_record.rb

@@ -1,6 +1,40 @@
+# frozen_string_literal: true
+require_relative "./active_record/backend"
+require_relative "./active_record/dirty"
+require_relative "./active_record/cache"
+require_relative "./active_record/query"
+require_relative "./active_record/uniqueness_validation"
+
 module Mobility
+=begin
+
+Plugin for ActiveRecord models.
+
+=end
   module Plugins
     module ActiveRecord
+      extend Plugin
+
+      requires :active_record_backend, include: :after
+      requires :active_record_dirty
+      requires :active_record_cache
+      requires :active_record_query
+      requires :active_record_uniqueness_validation
+
+      included_hook do |klass|
+        unless active_record_class?(klass)
+          name = klass.name || klass.to_s
+          raise TypeError, "#{name} should be a subclass of ActiveRecord::Base to use the active_record plugin"
+        end
+      end
+
+      private
+
+      def active_record_class?(klass)
+        klass < ::ActiveRecord::Base
+      end
     end
+
+    register_plugin(:active_record, ActiveRecord)
   end
 end