mobility 0.8.13 → 1.0.0.alpha

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

@@ -42,106 +42,132 @@ the ActiveRecord dirty plugin for more information.
 
 =end
       module Dirty
-        # Builds module which adds suffix/prefix methods for translated
-        # attributes so they act like normal dirty-tracked attributes.
-        class MethodsBuilder < Module
-          delegate :dirty_class, :handler_methods_module, :method_patterns, to: :class
+        extend Plugin
 
-          def initialize(*attribute_names)
-            define_dirty_methods(attribute_names)
+        requires :dirty, include: false
+
+        initialize_hook do
+          if options[:dirty]
+            define_dirty_methods(names)
+            include dirty_handler_methods
           end
+        end
 
-          def included(model_class)
-            model_class.include InstanceMethods
-            model_class.include handler_methods_module
+        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)
 
-            # In earlier versions of Rails, these methods are private
-            %i[clear_attribute_changes clear_changes_information changes_applied].each do |method_name|
-              if dirty_class.private_instance_methods.include?(method_name)
-                model_class.class_eval { private method_name }
-              end
-            end
-          end
+          if options[:dirty]
+            private_methods = InstanceMethods.instance_methods & klass.private_instance_methods
+            klass.include InstanceMethods
+            klass.class_eval { private(*private_methods) }
 
-          def append_locale(attr_name)
-            Mobility.normalize_locale_accessor(attr_name)
+            backend_class.include BackendMethods
           end
+        end
 
-          private
+        private
 
-          def define_dirty_methods(attribute_names)
-            m = self
+        # Overridden in AR::Dirty plugin to define a different HandlerMethods module
+        def dirty_handler_methods
+          HandlerMethods
+        end
 
-            attribute_names.each do |name|
-              method_patterns.each do |pattern|
-                define_method(pattern % name) do |*args|
-                  mutations_from_mobility.send(pattern % 'attribute', m.append_locale(name), *args)
-                end
-              end
+        def active_model_dirty_class?(klass)
+          klass.ancestors.include?(::ActiveModel::Dirty)
+        end
 
-              define_method "restore_#{name}!" do
-                locale_accessor = m.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
+        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
 
-            # 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
-
-          class << self
-            def handler_methods_module
-              @handler_methods_module ||= (AttributeHandlerMethods.new.tap do |mod|
-                public_method_patterns.each do |pattern|
-                  method_name = pattern % 'attribute'
-
-                  mod.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_#{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
 
-            # Get method suffixes. Creating an object just to get the list of
-            # suffixes is simplest given they change from Rails version to version.
-            def method_patterns
-              @method_patterns ||=
-                (dirty_class.attribute_method_matchers.map { |p| "#{p.prefix}%s#{p.suffix}" } - excluded_method_patterns)
+        # 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
+
+          # @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 public_method_patterns
-              @public_method_patterns ||= method_patterns.select do |p|
-                !dirty_class.private_instance_methods.include?(:"#{p % 'attribute'}")
+          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
 
-            def dirty_class
-              @dirty_class ||= Class.new { include ::ActiveModel::Dirty }
-            end
+          # 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
+          private
 
-            def excluded_method_patterns
-              ['%s', 'restore_%s!']
+          def public_patterns
+            @public_patterns ||= patterns.select do |p|
+              klass.public_method_defined?(p % 'attribute')
             end
           end
+
+          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)
@@ -186,9 +212,16 @@ the ActiveRecord dirty plugin for more information.
           end
         end
 
-        # Give the module builder a name so it's easier to see in the model's ancestors
-        class AttributeHandlerMethods < Module; 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
 
@@ -316,5 +349,7 @@ the ActiveRecord dirty plugin for more information.
         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

data/lib/mobility/plugins/active_record/backend.rb

@@ -0,0 +1,25 @@
+module Mobility
+  module Plugins
+    module ActiveRecord
+      module Backend
+        extend Plugin
+
+        requires :backend, include: :before
+
+        def load_backend(backend)
+          if Symbol === backend
+            require "mobility/backends/active_record/#{backend}"
+            Backends.load_backend("active_record_#{backend}".to_sym)
+          else
+            super
+          end
+        rescue LoadError => e
+          raise unless e.message =~ /active_record\/#{backend}/
+          super
+        end
+      end
+    end
+
+    register_plugin(:active_record_backend, ActiveRecord::Backend)
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+require "mobility/plugins/active_model/cache"
+
+module Mobility
+  module Plugins
+    module ActiveRecord
+=begin
+
+Resets cache on calls to +reload+, in addition to other AM dirty reset
+methods.
+
+=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, :reload)
+          end
+        end
+      end
+    end
+
+    register_plugin(:active_record_cache, ActiveRecord::Cache)
+  end
+end

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

@@ -40,29 +40,44 @@ locale suffix, so +title_en+, +title_pt_br+, etc.)
 
 =end
       module Dirty
-        class MethodsBuilder < ActiveModel::Dirty::MethodsBuilder
-          # @param [Attributes] attributes
-          def included(model_class)
-            super
+        extend Plugin
 
-            model_class.include InstanceMethods
+        requires :dirty, include: false
+        requires :active_model_dirty, include: :before
+
+        initialize_hook do
+          if options[:dirty]
+            include InstanceMethods
           end
+        end
 
-          class << self
-            def dirty_class
-              @dirty_class ||= (Class.new do
-                # In earlier versions of Rails, these are needed to avoid an
-                # exception when including the AR Dirty module outside of an
-                # AR::Base class. Eventually we should be able to drop them.
-                def self.after_create; end
-                def self.after_update; end
-
-                include ::ActiveRecord::AttributeMethods::Dirty
-              end)
-            end
+        included_hook do |_, backend_class|
+          if options[:dirty]
+            backend_class.include BackendMethods
           end
         end
 
+        private
+
+        def dirty_handler_methods
+          HandlerMethods
+        end
+
+        # Module which defines generic ActiveRecord::Dirty handler methods like
+        # +attribute_before_last_save+ that are patched to work with translated
+        # attributes.
+        HandlerMethods = ActiveModel::Dirty::HandlerMethodsBuilder.new(
+          Class.new do
+            # In earlier versions of Rails, these are needed to avoid an
+            # exception when including the AR Dirty module outside of an
+            # AR::Base class. Eventually we should be able to drop them.
+            def self.after_create; end
+            def self.after_update; end
+
+            include ::ActiveRecord::AttributeMethods::Dirty
+          end
+        )
+
         module InstanceMethods
           if ::ActiveRecord::VERSION::STRING >= '5.1' # define patterns added in 5.1
             def saved_changes
@@ -98,5 +113,7 @@ locale suffix, so +title_en+, +title_pt_br+, etc.)
         BackendMethods = ActiveModel::Dirty::BackendMethods
       end
     end
+
+    register_plugin(:active_record_dirty, ActiveRecord::Dirty)
   end
 end

data/lib/mobility/plugins/active_record/query.rb

@@ -1,4 +1,6 @@
 # frozen-string-literal: true
+require "active_record/relation"
+
 module Mobility
   module Plugins
 =begin
@@ -15,45 +17,47 @@ enabled for any one attribute on the model.
 =end
     module ActiveRecord
       module Query
-        class << self
-          def apply(attributes)
-            attributes.model_class.class_eval do
+        extend Plugin
+
+        requires :query, include: false
+
+        included_hook do |klass, backend_class|
+          plugin = self
+          if options[:query]
+            raise MissingBackend, "backend required for Query plugin" unless backend_class
+
+            klass.class_eval do
               extend QueryMethod
-              extend FindByMethods.new(*attributes.names)
-              singleton_class.send :alias_method, Mobility.query_method, :__mobility_query_scope__
+              extend FindByMethods.new(*plugin.names)
+              singleton_class.send :alias_method, plugin.query_method, :__mobility_query_scope__
             end
-            attributes.backend_class.include self
+            backend_class.include BackendMethods
           end
+        end
 
+        class << self
           def attribute_alias(attribute, locale = Mobility.locale)
             "__mobility_%s_%s__"  % [attribute, ::Mobility.normalize_locale(locale)]
           end
         end
 
-        # @note We use +instance_variable_get+ here to get the +AttributeSet+
-        #   rather than the hash of attributes. Getting the full hash of
-        #   attributes is a performance hit and better to avoid if unnecessary.
-        # TODO: Improve this.
-        def read(locale, **)
-          if (model_attributes_defined? &&
-              model_attributes.key?(alias_ = Query.attribute_alias(attribute, locale)))
-            model_attributes[alias_].value
-          else
-            super
+        module BackendMethods
+          # @note We use +instance_variable_get+ here to get the +AttributeSet+
+          #   rather than the hash of attributes. Getting the full hash of
+          #   attributes is a performance hit and better to avoid if unnecessary.
+          # TODO: Improve this.
+          def read(locale, **)
+            if model.instance_variable_defined?(:@attributes) &&
+                (model_attributes = model.instance_variable_get(:@attributes)).key?(alias_ = Query.attribute_alias(attribute, locale))
+              model_attributes[alias_].value
+            else
+              super
+            end
           end
         end
 
-        private
-
-        def model_attributes_defined?
-          model.instance_variable_defined?(:@attributes)
-        end
-
-        def model_attributes
-          model.instance_variable_get(:@attributes)
-        end
-
         module QueryMethod
+          # This is required for UniquenessValidator.
           def __mobility_query_scope__(locale: Mobility.locale, &block)
             if block_given?
               VirtualRow.build_query(self, locale, &block)
@@ -121,7 +125,7 @@ enabled for any one attribute on the model.
             case opts
             when Symbol, String
               @klass.mobility_attribute?(opts) ? order({ opts => :asc }, *rest) : super
-            when Hash
+            when ::Hash
               i18n_keys, keys = opts.keys.partition(&@klass.method(:mobility_attribute?))
               return super if i18n_keys.empty?
 
@@ -182,7 +186,7 @@ enabled for any one attribute on the model.
 
             class << self
               def build(scope, where_opts, invert: false, &block)
-                return yield unless Hash === where_opts
+                return yield unless ::Hash === where_opts
 
                 opts = where_opts.with_indifferent_access
                 locale = opts.delete(:locale) || Mobility.locale
@@ -195,11 +199,11 @@ enabled for any one attribute on the model.
               # Builds a translated relation for a given opts hash and optional
               # invert boolean.
               def _build(scope, opts, locale, invert)
-                return yield unless scope.respond_to?(:mobility_modules)
+                return yield if (mods = attribute_modules(scope)).empty?
 
                 keys, predicates = opts.keys.map(&:to_s), []
 
-                query_map = scope.mobility_modules.inject(IDENTITY) do |qm, mod|
+                query_map = mods.inject(IDENTITY) do |qm, mod|
                   i18n_keys = mod.names & keys
                   next qm if i18n_keys.empty?
 
@@ -215,7 +219,11 @@ enabled for any one attribute on the model.
                 return yield if query_map == IDENTITY
 
                 relation = opts.empty? ? scope : yield(opts)
-                query_map[relation.where(predicates.inject(&:and))]
+                query_map[relation.where(predicates.inject(:and))]
+              end
+
+              def attribute_modules(scope)
+                scope.model.ancestors.grep(::Mobility::Translations)
               end
 
               def build_predicate(node, values)
@@ -267,6 +275,10 @@ enabled for any one attribute on the model.
 
         private_constant :QueryExtension, :FindByMethods
       end
+
+      class MissingBackend < Mobility::Error; end
     end
+
+    register_plugin(:active_record_query, ActiveRecord::Query)
   end
 end