mobility 0.6.0 → 0.7.0

data/lib/mobility/active_record/uniqueness_validator.rb

@@ -25,13 +25,12 @@ To use the validator, you must +extend Mobility+ before calling +validates+
       def validate_each(record, attribute, value)
         klass = record.class
 
-        if (([*options[:scope]] + [attribute]).map(&:to_s) & klass.translated_attribute_names).present?
-          warn %{
-WARNING: The Mobility uniqueness validator for translated attributes does not
-support case-insensitive validation. This option will be ignored for: #{attribute}
-} if options[:case_sensitive] == false
+        if (([*options[:scope]] + [attribute]).map(&:to_s) & klass.mobility_attributes).present?
           return unless value.present?
-          relation = klass.send(Mobility.query_method).where(attribute => value)
+          relation = klass.__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]
@@ -50,8 +49,10 @@ support case-insensitive validation. This option will be ignored for: #{attribut
       private
 
       def mobility_scope_relation(record, relation)
-        [*options[:scope]].inject(relation) do |scoped_relation, scope_item|
-          scoped_relation.where(scope_item => record.send(scope_item))
+        [*options[:scope]].inject(relation.unscoped) 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

data/lib/mobility/arel.rb

@@ -0,0 +1,20 @@
+# frozen-string-literal: true
+require "mobility/arel/nodes"
+require "mobility/arel/visitor"
+
+module Mobility
+  module Arel
+    class Attribute < ::Arel::Attributes::Attribute
+      attr_reader :backend_class
+      attr_reader :locale
+      attr_reader :attribute_name
+
+      def initialize(relation, column_name, locale, backend_class, attribute_name: nil)
+        @backend_class = backend_class
+        @locale = locale
+        @attribute_name = attribute_name || column_name
+        super(relation, column_name)
+      end
+    end
+  end
+end

data/lib/mobility/arel/nodes.rb

@@ -0,0 +1,16 @@
+# frozen-string-literal: true
+module Mobility
+  module Arel
+    module Nodes
+      class Unary  < ::Arel::Nodes::Unary;  end
+      class Binary < ::Arel::Nodes::Binary; end
+      class Grouping < ::Arel::Nodes::Grouping; end
+      class Equality < ::Arel::Nodes::Equality; end
+
+      ::Arel::Visitors::ToSql.class_eval do
+        alias :visit_Mobility_Arel_Nodes_Equality :visit_Arel_Nodes_Equality
+        alias :visit_Mobility_Arel_Nodes_Grouping :visit_Arel_Nodes_Grouping
+      end
+    end
+  end
+end

data/lib/mobility/arel/nodes/pg_ops.rb

@@ -0,0 +1,136 @@
+# frozen-string-literal: true
+require "mobility/arel"
+
+module Mobility
+  module Arel
+    module Nodes
+      %w[
+        JsonDashArrow
+        JsonDashDoubleArrow
+        JsonbDashArrow
+        JsonbDashDoubleArrow
+        JsonbQuestion
+        HstoreDashArrow
+        HstoreQuestion
+      ].each do |name|
+        const_set name, (Class.new(Binary) do
+          include ::Arel::Expressions
+          include ::Arel::Predications
+          include ::Arel::OrderPredications
+          include ::Arel::AliasPredication
+
+          def eq other
+            Equality.new self, quoted_node(other)
+          end
+
+          def lower
+            super self
+          end
+        end)
+      end
+
+      # Needed for AR 4.2, can be removed when support is deprecated
+      if ::ActiveRecord::VERSION::STRING < '5.0'
+        [JsonbDashDoubleArrow, HstoreDashArrow].each do |klass|
+          klass.class_eval do
+            def quoted_node other
+              other && super
+            end
+          end
+        end
+      end
+
+      class Jsonb  < JsonbDashDoubleArrow
+        def to_dash_arrow
+          JsonbDashArrow.new left, right
+        end
+
+        def to_question
+          JsonbQuestion.new left, right
+        end
+
+        def eq other
+          case other
+          when NilClass
+            to_question.not
+          when Integer, Array, Hash
+            to_dash_arrow.eq other.to_json
+          when Jsonb
+            to_dash_arrow.eq other.to_dash_arrow
+          when JsonbDashArrow
+            to_dash_arrow.eq other
+          else
+            super
+          end
+        end
+      end
+
+      class Hstore < HstoreDashArrow
+        def to_question
+          HstoreQuestion.new left, right
+        end
+
+        def eq other
+          other.nil? ? to_question.not : super
+        end
+      end
+
+      class Json < JsonDashDoubleArrow; end
+
+      class JsonContainer < Json
+        def initialize column, locale, attr
+          super(Arel::Nodes::JsonDashArrow.new(column, locale), attr)
+        end
+      end
+
+      class JsonbContainer < Jsonb
+        def initialize column, locale, attr
+          @column, @locale = column, locale
+          super(JsonbDashArrow.new(column, locale), attr)
+        end
+
+        def eq other
+          other.nil? ? super.or(JsonbQuestion.new(@column, @locale).not) : super
+        end
+      end
+    end
+
+    module Visitors
+      def visit_Mobility_Arel_Nodes_JsonDashArrow o, a
+        json_infix o, a, '->'
+      end
+
+      def visit_Mobility_Arel_Nodes_JsonDashDoubleArrow o, a
+        json_infix o, a, '->>'
+      end
+
+      def visit_Mobility_Arel_Nodes_JsonbDashArrow o, a
+        json_infix o, a, '->'
+      end
+
+      def visit_Mobility_Arel_Nodes_JsonbDashDoubleArrow o, a
+        json_infix o, a, '->>'
+      end
+
+      def visit_Mobility_Arel_Nodes_JsonbQuestion o, a
+        json_infix o, a, '?'
+      end
+
+      def visit_Mobility_Arel_Nodes_HstoreDashArrow o, a
+        json_infix o, a, '->'
+      end
+
+      def visit_Mobility_Arel_Nodes_HstoreQuestion o, a
+        json_infix o, a, '?'
+      end
+
+      private
+
+      def json_infix o, a, opr
+        visit(Nodes::Grouping.new(::Arel::Nodes::InfixOperation.new(opr, o.left, o.right)), a)
+      end
+    end
+
+    ::Arel::Visitors::PostgreSQL.include Visitors
+  end
+end

data/lib/mobility/arel/visitor.rb

@@ -0,0 +1,61 @@
+# frozen-string-literal: true
+module Mobility
+  module Arel
+    class Visitor < ::Arel::Visitors::Visitor
+      INNER_JOIN = ::Arel::Nodes::InnerJoin
+      OUTER_JOIN = ::Arel::Nodes::OuterJoin
+
+      attr_reader :backend_class, :locale
+
+      def initialize(backend_class, locale)
+        super()
+        @backend_class, @locale = backend_class, locale
+      end
+
+      private
+
+      def visit(object)
+        super
+      rescue TypeError
+        visit_default(object)
+      end
+
+      def visit_collection(_objects)
+        raise NotImplementedError
+      end
+      alias :visit_Array :visit_collection
+
+      def visit_Arel_Nodes_Unary(object)
+        visit(object.expr)
+      end
+
+      def visit_Arel_Nodes_Binary(object)
+        visit_collection([object.left, object.right])
+      end
+
+      def visit_Arel_Nodes_Function(object)
+        visit_collection(object.expressions)
+      end
+
+      def visit_Arel_Nodes_Case(object)
+        visit_collection([object.case, object.conditions, object.default])
+      end
+
+      def visit_Arel_Nodes_And(object)
+        visit_Array(object.children)
+      end
+
+      def visit_Arel_Nodes_Node(object)
+        visit_default(object)
+      end
+
+      def visit_Arel_Attributes_Attribute(object)
+        visit_default(object)
+      end
+
+      def visit_default(_object)
+        nil
+      end
+    end
+  end
+end

data/lib/mobility/attributes.rb

@@ -133,20 +133,18 @@ with other backends.
       raise ArgumentError, "method must be one of: reader, writer, accessor" unless %i[reader writer accessor].include?(method)
       @method = method
       @options = Mobility.default_options.to_h.merge(backend_options)
-      @names = attribute_names.map(&:to_s)
-      raise Mobility::BackendRequired, "Backend option required if Mobility.config.default_backend is not set." if backend.nil?
+      @names = attribute_names.map(&:to_s).freeze
+      raise BackendRequired, "Backend option required if Mobility.config.default_backend is not set." if backend.nil?
       @backend_name = backend
     end
 
-    # Setup backend class, include modules into model class, add this
-    # attributes module to shared {Mobility::Accumulator} and setup model with
-    # backend setup block (see {Mobility::Backend::Setup#setup_model}).
+    # 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}).
     # @param klass [Class] Class of model
     def included(klass)
       @model_class = @options[:model_class] = klass
-      @backend_class = Class.new(get_backend_class(backend_name).for(model_class))
-
-      @backend_class.configure(options) if @backend_class.respond_to?(:configure)
+      @backend_class = get_backend_class(backend_name).for(model_class).with_options(options)
 
       Mobility.plugins.each do |name|
         plugin = get_plugin_class(name)
@@ -159,8 +157,10 @@ with other backends.
         define_writer(name) if %i[accessor writer].include?(method)
       end
 
-      model_class.mobility << self
-      backend_class.setup_model(model_class, names, options)
+      klass.include InstanceMethods
+      klass.extend ClassMethods
+
+      backend_class.setup_model(model_class, names)
     end
 
     # Yield each attribute name to block
@@ -169,6 +169,8 @@ with other backends.
       names.each(&block)
     end
 
+    # Show useful information about this module.
+    # @return [String]
     def inspect
       "#<Attributes (#{backend_name}) @names=#{names.join(", ")}>"
     end
@@ -176,37 +178,35 @@ with other backends.
     private
 
     def define_backend(attribute)
-      backend_class_, options_ = backend_class, options
-      define_method Backend.method_name(attribute) do
-        @mobility_backends ||= {}
-        @mobility_backends[attribute] ||= backend_class_.new(self, attribute, options_)
+      module_eval <<-EOM, __FILE__, __LINE__ + 1
+      def #{Backend.method_name(attribute)}
+        mobility_backends[:#{attribute}]
       end
+      EOM
     end
 
     def define_reader(attribute)
-      backend = Backend.method_name(attribute)
       class_eval <<-EOM, __FILE__, __LINE__ + 1
         def #{attribute}(**options)
           return super() if options.delete(:super)
           #{set_locale_from_options_inline}
-          #{backend}.read(locale, options)
+          mobility_backends[:#{attribute}].read(locale, options)
         end
 
         def #{attribute}?(**options)
           return super() if options.delete(:super)
           #{set_locale_from_options_inline}
-          #{backend}.present?(locale, options)
+          mobility_backends[:#{attribute}].present?(locale, options)
         end
       EOM
     end
 
     def define_writer(attribute)
-      backend = Backend.method_name(attribute)
       class_eval <<-EOM, __FILE__, __LINE__ + 1
         def #{attribute}=(value, **options)
           return super(value) if options.delete(:super)
           #{set_locale_from_options_inline}
-          #{backend}.write(locale, value, options)
+          mobility_backends[:#{attribute}].write(locale, value, options)
         end
       EOM
     end
@@ -240,5 +240,68 @@ EOL
       klass_name = key.to_s.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
       parent_class.const_get(klass_name)
     end
+
+    module InstanceMethods
+      # Return a new backend for an attribute name.
+      # @return [Hash] Hash of attribute names and backend instances
+      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 all {Mobility::Attribute} module instances from among ancestors
+      # of this model.
+      # @return [Array<Mobility::Attributes>] Attribute modules
+      def mobility_modules
+        ancestors.select { |mod| Attributes === mod }
+      end
+
+      # Return translated attribute names on this model.
+      # @return [Array<String>] Attribute names
+      def mobility_attributes
+        mobility_modules.map(&:names).flatten
+      end
+
+      # @!method translated_attribute_names
+      # @return (see #mobility_attributes)
+      alias translated_attribute_names mobility_attributes
+
+      # Return backend class for a given attribute name.
+      # @param [Symbol,String] Name of attribute
+      # @return [Class] Backend class
+      def mobility_backend_class(name)
+        @backends ||= BackendsCache.new(self)
+        @backends[name.to_sym]
+      end
+
+      class BackendsCache < Hash
+        def initialize(klass)
+          # Preload backend mapping
+          klass.mobility_modules.each do |mod|
+            mod.names.each { |name| self[name.to_sym] = mod.backend_class }
+          end
+
+          super() do |hash, name|
+            if mod = klass.mobility_modules.find { |m| m.names.include? name.to_s }
+              hash[name] = mod.backend_class
+            else
+              raise KeyError, "No backend for: #{name}."
+            end
+          end
+        end
+      end
+      private_constant :BackendsCache
+    end
   end
+
+  class BackendRequired < ArgumentError; end
 end

data/lib/mobility/backend.rb

@@ -66,7 +66,7 @@ On top of this, a backend will normally:
     # @!macro [new] backend_constructor
     #   @param model Model on which backend is defined
     #   @param [String] attribute Backend attribute
-    def initialize(model, attribute, **_)
+    def initialize(model, attribute)
       @model = model
       @attribute = attribute
     end
@@ -106,10 +106,22 @@ On top of this, a backend will normally:
       Util.present?(read(locale, options))
     end
 
-    # Extend included class with +setup+ method
+    # @!method model_class
+    #   Returns name of model in which backend is used.
+    #   @return [Class] Model class
+
+    # @return [Hash] options
+    def options
+      self.class.options
+    end
+
+    # Extend included class with +setup+ method and other class methods
     def self.included(base)
-      base.extend(Setup)
-      base.extend(ClassMethods)
+      base.extend ClassMethods
+      def base.options
+        @options
+      end
+      base.option_reader :model_class
     end
 
     # @param [String] attribute
@@ -120,7 +132,7 @@ On top of this, a backend will normally:
     end
 
     # Defines setup hooks for backend to customize model class.
-    module Setup
+    module ClassMethods
       # Assign block to be called on model class.
       # @yield [attribute_names, options]
       # @note When called multiple times, setup blocks will be appended
@@ -139,19 +151,46 @@ On top of this, a backend will normally:
 
       def inherited(subclass)
         subclass.instance_variable_set(:@setup_block, @setup_block)
+        subclass.instance_variable_set(:@options, @options)
       end
 
       # Call setup block on a class with attributes and options.
       # @param model_class Class to be setup-ed
       # @param [Array<String>] attribute_names
       # @param [Hash] options
-      def setup_model(model_class, attribute_names, **options)
+      def setup_model(model_class, attribute_names)
         return unless setup_block = @setup_block
         model_class.class_exec(attribute_names, options, &setup_block)
       end
-    end
 
-    module ClassMethods
+      # Build a subclass of this backend class for a given set of options
+      # @note This method also freezes the options hash to prevent it from
+      #   being changed.
+      # @param [Hash] options
+      # @return [Class] backend subclass
+      def with_options(options = {}, &block)
+        configure(options) if respond_to?(:configure)
+        options.freeze
+        Class.new(self) do
+          @options = options
+          class_eval(&block) if block_given?
+        end
+      end
+
+      # Create instance and class methods to access value on options hash
+      # @param [Symbol] name Name of option reader
+      def option_reader(name)
+        module_eval <<-EOM, __FILE__, __LINE__ + 1
+        def self.#{name}
+          options[:#{name}]
+        end
+
+        def #{name}
+          self.class.options[:#{name}]
+        end
+        EOM
+      end
+
       # {Attributes} uses this method to get a backend class specific to the
       # model using the backend. Backend classes can override this method to
       # return a class specific to the model class using the backend (e.g.
@@ -172,6 +211,12 @@ On top of this, a backend will normally:
       def apply_plugin(_)
         false
       end
+
+      # Show useful information about this backend class, if it has no name.
+      # @return [String]
+      def inspect
+        name ? super : "#<#{superclass.name}>"
+      end
     end
 
     Translation = Struct.new(:backend, :locale) do