mobility 0.8.8 → 1.0.0.alpha

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

@@ -12,7 +12,6 @@ details on usage.
 In addition to methods added by {Mobility::Plugins::ActiveModel::Dirty}, the
 AR::Dirty plugin adds support for the following persistence-specific methods
 (for a model with a translated attribute +title+):
-- +saved_changes+
 - +saved_change_to_title?+
 - +saved_change_to_title+
 - +title_before_last_save+
@@ -20,129 +19,101 @@ AR::Dirty plugin adds support for the following persistence-specific methods
 - +title_change_to_be_saved+
 - +title_in_database+
 
+The following methods are also patched to include translated attribute changes:
+- +saved_changes+
+- +has_changes_to_save?+
+- +changes_to_save+
+- +changed_attribute_names_to_save+
+- +attributes_in_database+
+
+In addition, the following ActiveModel attribute handler methods are also
+patched to work with translated attributes:
+- +saved_change_to_attribute?+
+- +saved_change_to_attribute+
+- +attribute_before_last_save+
+- +will_save_change_to_attribute?+
+- +attribute_change_to_be_saved+
+- +attribute_in_database+
+
+(When using these methods, you must pass the attribute name along with its
+locale suffix, so +title_en+, +title_pt_br+, etc.)
+
 =end
       module Dirty
-        include ActiveModel::Dirty
-
-        # Builds module which patches a few AR methods to handle changes to
-        # translated attributes just like normal attributes.
-        class MethodsBuilder < ActiveModel::Dirty::MethodsBuilder
-          def initialize(*attribute_names)
-            super
-            @attribute_names = attribute_names
-            define_method_overrides if ::ActiveRecord::VERSION::STRING < '5.2'
-            define_attribute_methods if ::ActiveRecord::VERSION::STRING >= '5.1'
-          end
+        extend Plugin
 
-          # Overrides +ActiveRecord::AttributeMethods::ClassMethods#has_attribute+ (in AR 5.1) and
-          # +ActiveModel::AttributeMethods#_read_attribute+ (in AR >= 5.2) to
-          # ensure that fallthrough attribute methods are treated like "real"
-          # attribute methods.
-          #
-          # @note Patching +has_attribute?+ is necessary in AR 5.1 due to this commit[https://github.com/rails/rails/commit/4fed08fa787a316fa51f14baca9eae11913f5050].
-          # @param [Attributes] attributes
-          def included(model_class)
-            super
-
-            if ::ActiveRecord::VERSION::MAJOR == 5 && ::ActiveRecord::VERSION::MINOR == 1
-              names = @attribute_names
-              method_name_regex = /\A(#{names.join('|')})_([a-z]{2}(_[a-z]{2})?)(=?|\??)\z/.freeze
-              has_attribute = Module.new do
-                define_method :has_attribute? do |attr_name|
-                  super(attr_name) || (String === attr_name && !!method_name_regex.match(attr_name))
-                end
-              end
-              model_class.extend has_attribute
-            elsif ::ActiveRecord::VERSION::STRING >= '5.2'
-              model_class.include ReadAttribute
-            end
+        requires :dirty, include: false
+        requires :active_model_dirty, include: :before
+
+        initialize_hook do
+          if options[:dirty]
+            include InstanceMethods
           end
+        end
 
-          private
+        included_hook do |_, backend_class|
+          if options[:dirty]
+            backend_class.include BackendMethods
+          end
+        end
 
-          # @note These method overrides are needed for AR versions < 5.2,
-          #   since AR::Dirty overrides AM::Dirty, disabling previous_changes
-          #   from being set. Here we "undo" that.
-          def define_method_overrides
-            changes_applied_method = ::ActiveRecord::VERSION::STRING < '5.1' ? :changes_applied : :changes_internally_applied
-            define_method changes_applied_method do
-              @previously_changed = changes
-              super()
-            end
+        private
 
-            define_method :clear_changes_information do
-              @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-              super()
-            end
+        def dirty_handler_methods
+          HandlerMethods
+        end
 
-            define_method :previous_changes do
-              (@previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new).merge(super())
-            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
+        )
 
-          # For AR >= 5.1 only
-          def define_attribute_methods
-            define_method :saved_changes do
-              (@previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new).merge(super())
+        module InstanceMethods
+          if ::ActiveRecord::VERSION::STRING >= '5.1' # define patterns added in 5.1
+            def saved_changes
+              super.merge(mutations_from_mobility.previous_changes)
             end
 
-            @attribute_names.each do |name|
-              define_method :"saved_change_to_#{name}?" do
-                previous_changes.include?(Mobility.normalize_locale_accessor(name))
-              end
-
-              define_method :"saved_change_to_#{name}" do
-                previous_changes[Mobility.normalize_locale_accessor(name)]
-              end
+            def changes_to_save
+              super.merge(mutations_from_mobility.changes)
+            end
 
-              define_method :"#{name}_before_last_save" do
-                previous_changes[Mobility.normalize_locale_accessor(name)].first
-              end
+            def changed_attribute_names_to_save
+              super + mutations_from_mobility.changed
+            end
 
-              alias_method :"will_save_change_to_#{name}?", :"#{name}_changed?"
-              alias_method :"#{name}_change_to_be_saved", :"#{name}_change"
-              alias_method :"#{name}_in_database", :"#{name}_was"
+            def attributes_in_database
+              super.merge(mutations_from_mobility.changed_attributes)
             end
-          end
 
-          # Overrides _read_attribute to correctly dispatch reads on translated
-          # attributes to their respective setters, rather than to
-          # +@attributes+, which would otherwise return +nil+.
-          #
-          # For background on why this is necessary, see:
-          # https://github.com/shioyama/mobility/issues/115
-          module ReadAttribute
-            # @note We first check if attributes has the key +attr+ to avoid
-            #   doing any extra work in case this is a "normal"
-            #   (non-translated) attribute.
-            def _read_attribute(attr, *args)
-              if @attributes.key?(attr)
-                super
-              else
-                mobility_changed_attributes.include?(attr) ? __send__(attr) : super
+            if ::ActiveRecord::VERSION::STRING >= '6.0'
+              def has_changes_to_save?
+                super || mutations_from_mobility.changed?
               end
             end
+          end
 
-            # @note This is necessary due to a performance fix in e12607
-            #   which skips setting @previously_changed if @attributes is
-            #   defined. For Mobility models using the Dirty plugin, there will
-            #   be cases where @attributes has been set, but there are *other*
-            #   changes on virtual translated attributes which need to also be
-            #   assigned. In this case, we use the presence of such changed
-            #   virtual attributes as an alternative trigger to set this variable.
-            #
-            #   See:
-            #   - https://github.com/rails/rails/commit/e126078a0e013acfe0a397a8dad33b2c9de78732
-            #   - https://github.com/shioyama/mobility/pull/166
-            def changes_applied
-              if defined?(@attributes) && mobility_changed_attributes.any?
-                @previously_changed = changes
-              end
-              super
+          def reload(*)
+            super.tap do
+              @mutations_from_mobility = nil
             end
           end
         end
+
+        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?
 
@@ -139,8 +143,10 @@ enabled for any one attribute on the model.
 
           if ::ActiveRecord::VERSION::STRING >= '5.0'
             %w[pluck group select].each do |method_name|
-              define_method method_name do |*attrs|
-                return super(*attrs) unless attrs.any?(&@klass.method(:mobility_attribute?))
+              define_method method_name do |*attrs, &block|
+                return super(*attrs, &block) if (method_name == 'select' && block.present?)
+
+                return super(*attrs, &block) unless attrs.any?(&@klass.method(:mobility_attribute?))
 
                 keys = attrs.dup
 
@@ -154,7 +160,7 @@ enabled for any one attribute on the model.
                   @klass.mobility_backend_class(key).apply_scope(query, backend_node(key))
                 end
 
-                base.public_send(method_name, *keys)
+                base.public_send(method_name, *keys, &block)
               end
             end
           end
@@ -180,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
@@ -193,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?
 
@@ -213,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)
@@ -265,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

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

@@ -0,0 +1,60 @@
+module Mobility
+  module Plugins
+    module ActiveRecord
+      module UniquenessValidation
+        extend Plugin
+
+        requires :query, include: false
+
+        included_hook do |klass|
+          klass.class_eval do
+            unless const_defined?(:UniquenessValidator, false)
+              self.const_set(:UniquenessValidator, Class.new(UniquenessValidator))
+            end
+          end
+        end
+
+        class UniquenessValidator < ::ActiveRecord::Validations::UniquenessValidator
+          # @param [ActiveRecord::Base] record Translated model
+          # @param [String] attribute Name of attribute
+          # @param [Object] value Attribute value
+          def validate_each(record, attribute, value)
+            klass = record.class
+
+            if ([*options[:scope]] + [attribute]).any? { |name| klass.mobility_attribute?(name) }
+              return unless value.present?
+              relation = klass.unscoped.__mobility_query_scope__ do |m|
+                node = m.__send__(attribute)
+                options[:case_sensitive] == false ? node.lower.eq(value.downcase) : node.eq(value)
+              end
+              relation = relation.where.not(klass.primary_key => record.id) if record.persisted?
+              relation = mobility_scope_relation(record, relation)
+              relation = relation.merge(options[:conditions]) if options[:conditions]
+
+              if relation.exists?
+                error_options = options.except(:case_sensitive, :scope, :conditions)
+                error_options[:value] = value
+
+                record.errors.add(attribute, :taken, error_options)
+              end
+            else
+              super
+            end
+          end
+
+          private
+
+          def mobility_scope_relation(record, relation)
+            [*options[:scope]].inject(relation) do |scoped_relation, scope_item|
+              scoped_relation.__mobility_query_scope__ do |m|
+                m.__send__(scope_item).eq(record.send(scope_item))
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:active_record_uniqueness_validation, ActiveRecord::UniquenessValidation)
+  end
+end