mobility 0.8.9 → 1.0.0.beta1

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?
 
@@ -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

data/lib/mobility/plugins/attribute_methods.rb

@@ -12,30 +12,38 @@ attributes only.
 
 =end
     module AttributeMethods
-      class << self
-        # Applies attribute_methods plugin for a given option value.
-        # @param [Attributes] attributes
-        # @param [Boolean] option Value of option
-        # @raise [ArgumentError] if model class does not support dirty tracking
-        def apply(attributes, option)
-          if option
-            include_attribute_methods_module(attributes.model_class, *attributes.names)
-          end
+      extend Plugin
+
+      default true
+
+      initialize_hook do |*names|
+        include InstanceMethods
+
+        define_method :translated_attributes do
+          super().merge(names.inject({}) do |attributes, name|
+            attributes.merge(name.to_s => send(name))
+          end)
+        end
+      end
+
+      # Applies attribute_methods plugin for a given option value.
+      included_hook do
+        if options[:attribute_methods]
+          define_method :untranslated_attributes, ::ActiveRecord::Base.instance_method(:attributes)
         end
+      end
 
-        private
-
-        def include_attribute_methods_module(model_class, *attribute_names)
-          module_builder =
-            if Loaded::ActiveRecord && model_class.ancestors.include?(::ActiveRecord::AttributeMethods)
-              require "mobility/plugins/active_record/attribute_methods"
-              Plugins::ActiveRecord::AttributeMethods
-            else
-              raise ArgumentError, "#{model_class} does not support AttributeMethods plugin."
-            end
-          model_class.include module_builder.new(*attribute_names)
+      module InstanceMethods
+        def translated_attributes
+          {}
+        end
+
+        def attributes
+          super.merge(translated_attributes)
         end
       end
     end
+
+    register_plugin(:attribute_methods, AttributeMethods)
   end
 end

data/lib/mobility/plugins/attributes.rb

@@ -0,0 +1,70 @@
+# frozen-string-literal: true
+module Mobility
+  module Plugins
+=begin
+
+Takes arguments, converts them to strings, and stores in an array +@names+,
+made available with an +attr_reader+. Also provides some convenience methods
+for aggregating attributes.
+
+=end
+    module Attributes
+      extend Plugin
+
+      # Attribute names for which accessors will be defined
+      # @return [Array<String>] Array of names
+      attr_reader :names
+
+      initialize_hook do |*names|
+        @names = names.map(&:to_s).freeze
+      end
+
+      # Yield each attribute name to block
+      # @yieldparam [String] Attribute
+      def each &block
+        names.each(&block)
+      end
+
+      # Show useful information about this module.
+      # @return [String]
+      def inspect
+        "#<Translations @names=#{names.join(", ")}>"
+      end
+
+      included_hook do |klass|
+        klass.extend ClassMethods
+        @names.each { |name| klass.register_mobility_attribute(name) }
+      end
+
+      module ClassMethods
+        # Return true if attribute name is translated on this model.
+        # @param [String, Symbol] Attribute name
+        # @return [Boolean]
+        def mobility_attribute?(name)
+          mobility_attributes.include?(name.to_s)
+        end
+
+        # Register a new attribute name. Public, but treat as internal.
+        # @param [String, Symbol] Attribute name
+        def register_mobility_attribute(name)
+          (self.mobility_attributes << name.to_s).uniq!
+        end
+
+        def inherited(klass)
+          super
+          mobility_attributes.each { |name| klass.register_mobility_attribute(name) }
+        end
+
+        protected
+
+        # Return translated attribute names on this model.
+        # @return [Array<String>] Attribute names
+        def mobility_attributes
+          @mobility_attributes ||= []
+        end
+      end
+    end
+
+    register_plugin(:attributes, Attributes)
+  end
+end

data/lib/mobility/plugins/backend.rb

@@ -0,0 +1,161 @@
+# frozen-string-literal: true
+module Mobility
+  module Plugins
+=begin
+
+Plugin for setting up a backend for a set of model attributes. All backend
+plugins must depend on this.
+
+Defines:
+- instance method +mobility_backends+ which returns a hash whose keys are
+  attribute names and values a backend for each attribute.
+- class method +mobility_backend_class+ which takes an attribute name and
+  returns the backend class for that name.
+
+=end
+    module Backend
+      extend Plugin
+
+      requires :attributes, include: :before
+
+      # Backend class
+      # @return [Class] Backend class
+      attr_reader :backend_class
+
+      # Backend
+      # @return [Symbol,Class,Class] Name of backend, or backend class
+      attr_reader :backend
+
+      # Backend options
+      # @return [Hash] Options for backend
+      attr_reader :backend_options
+
+      def initialize(*args, **original_options)
+        super
+
+        # Validate that the default backend from config has valid keys
+        if (default = self.class.defaults[:backend])
+          name, backend_options = default
+          extra_keys = backend_options.keys - backend.valid_keys
+          raise InvalidOptionKey, "These are not valid #{name} backend keys: #{extra_keys.join(', ')}." unless extra_keys.empty?
+        end
+
+        include InstanceMethods
+      end
+
+      # Setup backend class, include modules into model class, include/extend
+      # shared modules and setup model with backend setup block (see
+      # {Mobility::Backend::Setup#setup_model}).
+      def included(klass)
+        super
+
+        klass.extend ClassMethods
+
+        if backend
+          @backend_class = backend.build_subclass(klass, backend_options)
+
+          backend_class.setup_model(klass, names)
+
+          @names.each do |name|
+            klass.register_mobility_backend_class(name, @backend_class)
+          end
+
+          backend_class
+        end
+      end
+
+      # Include backend name in inspect string.
+      # @return [String]
+      def inspect
+        "#<Translations (#{backend}) @names=#{names.join(", ")}>"
+      end
+
+      def load_backend(backend)
+        Backends.load_backend(backend)
+      rescue Backends::LoadError => e
+        raise e, "could not find a #{backend} backend. Did you forget to include an ORM plugin like active_record or sequel?"
+      end
+
+      private
+
+      # Override to extract backend options from options hash.
+      def initialize_options(original_options)
+        super
+
+        case options[:backend]
+        when String, Symbol, Class
+          @backend, @backend_options = options[:backend], options
+        when Array
+          @backend, @backend_options = options[:backend]
+          @backend_options = @backend_options.merge(original_options)
+        when NilClass
+          @backend = @backend_options = nil
+        else
+          raise ArgumentError, "backend must be either a backend name, a backend class, or a two-element array"
+        end
+
+        @backend = load_backend(backend)
+      end
+
+      # Override default validation to exclude backend options, which may be
+      # mixed in with plugin options.
+      def validate_options(options)
+        return super unless backend
+        super(options.slice(*(options.keys - backend.valid_keys)))
+      end
+
+      # Override default argument-handling in DSL to store kwargs passed along
+      # with plugin name.
+      def self.configure_default(defaults, key, backend = nil, backend_options = {})
+        defaults[key] = [backend, backend_options] if backend
+      end
+
+      module InstanceMethods
+        # Return a new backend for an attribute name.
+        # @return [Hash] Hash of attribute names and backend instances
+        # @api private
+        def mobility_backends
+          @mobility_backends ||= ::Hash.new do |hash, name|
+            next hash[name.to_sym] if String === name
+            hash[name] = self.class.mobility_backend_class(name).new(self, name.to_s)
+          end
+        end
+
+        def initialize_dup(other)
+          @mobility_backends = nil
+          super
+        end
+      end
+
+      module ClassMethods
+        # Return backend class for a given attribute name.
+        # @param [Symbol,String] Name of attribute
+        # @return [Class] Backend class
+        def mobility_backend_class(name)
+          mobility_backend_classes.fetch(name.to_sym)
+        rescue KeyError
+          raise KeyError, "No backend for: #{name}"
+        end
+
+        def register_mobility_backend_class(name, backend_class)
+          mobility_backend_classes[name.to_sym] = backend_class
+        end
+
+        def inherited(klass)
+          klass.mobility_backend_classes.merge!(@mobility_backend_classes)
+          super
+        end
+
+        protected
+
+        def mobility_backend_classes
+          @mobility_backend_classes ||= {}
+        end
+      end
+
+      class InvalidOptionKey < Error; end
+    end
+
+    register_plugin(:backend, Backend)
+  end
+end