mobility 0.6.0 → 0.7.0

data/lib/mobility/backend_resetter.rb

@@ -20,8 +20,9 @@ Resets backend cache when reset events occur.
     # @raise [ArgumentError] if no block is provided.
     def initialize(attribute_names, &block)
       raise ArgumentError, "block required" unless block_given?
+      names = attribute_names.map(&:to_sym)
       @model_reset_method = Proc.new do
-        attribute_names.each do |name|
+        names.each do |name|
           if @mobility_backends && @mobility_backends[name]
             @mobility_backends[name].instance_eval(&block)
           end

data/lib/mobility/backends/active_record.rb

@@ -1,19 +1,39 @@
 module Mobility
   module Backends
     module ActiveRecord
-      def setup_query_methods(query_methods)
-        setup do |attributes, options|
-          extend(Module.new do
-            define_method ::Mobility.query_method do
-              super().extending(query_methods.new(attributes, options))
-            end
-          end)
-        end
-      end
-
       def self.included(backend_class)
         backend_class.include(Backend)
-        backend_class.extend(self)
+        backend_class.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # @param [Symbol] name Attribute name
+        # @param [Symbol] locale Locale
+        def [](name, locale)
+          build_node(name.to_s, locale)
+        end
+
+        # @param [String] _attr Attribute name
+        # @param [Symbol] _locale Locale
+        # @return Arel node for this translated attribute
+        def build_node(_attr, _locale)
+          raise NotImplementedError
+        end
+
+        # @param [ActiveRecord::Relation] relation Relation to scope
+        # @param [Object] predicate Arel predicate
+        # @param [Symbol] locale Locale
+        # @option [Boolean] invert
+        # @return [ActiveRecord::Relation] Relation with scope added
+        def apply_scope(relation, _predicate, _locale, invert: false)
+          relation
+        end
+
+        private
+
+        def build_quoted(value)
+          ::Arel::Nodes.build_quoted(value)
+        end
       end
     end
   end

data/lib/mobility/backends/active_record/column.rb

@@ -34,8 +34,6 @@ or locales.)
       include ActiveRecord
       include Column
 
-      require 'mobility/backends/active_record/column/query_methods'
-
       # @!group Backend Accessors
       # @!macro backend_reader
       def read(locale, _ = {})
@@ -53,7 +51,13 @@ or locales.)
         available_locales.each { |l| yield(l) if present?(l) }
       end
 
-      setup_query_methods(QueryMethods)
+      # @param [String] attr Attribute name
+      # @param [Symbol] locale Locale
+      # @return [Arel::Attributes::Attribute] Arel node for translation column
+      #   on model table
+      def self.build_node(attr, locale)
+        model_class.arel_table[Column.column_name_for(attr, locale)]
+      end
 
       private
 

data/lib/mobility/backends/active_record/container.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "mobility/backends/active_record"
+require "mobility/arel/nodes/pg_ops"
 
 module Mobility
   module Backends
@@ -11,18 +12,14 @@ Implements the {Mobility::Backends::Container} backend for ActiveRecord models.
     class ActiveRecord::Container
       include ActiveRecord
 
-      require 'mobility/backends/active_record/container/json_query_methods'
-      require 'mobility/backends/active_record/container/jsonb_query_methods'
+      # @!method column_name
+      #   Returns name of json or jsonb column used to store translations
+      #   @return [Symbol] (:translations) Name of translations column
+      option_reader :column_name
 
-      # @return [Symbol] name of container column
-      attr_reader :column_name
-
-      # @!macro backend_constructor
-      # @option options [Symbol] column_name Name of container column
-      def initialize(model, attribute, options = {})
-        super
-        @column_name = options[:column_name]
-      end
+      # @!method column_type
+      #   @return [Symbol] Either :json or :jsonb
+      option_reader :column_type
 
       # @!group Backend Accessors
       #
@@ -60,6 +57,20 @@ Implements the {Mobility::Backends::Container} backend for ActiveRecord models.
       end
       # @!endgroup
 
+      # @param [String] attr Attribute name
+      # @param [Symbol] locale Locale
+      # @return [Mobility::Arel::Nodes::Json,Mobility::Arel::Nodes::Jsonb] Arel
+      #   node for attribute on json or jsonb column
+      def self.build_node(attr, locale)
+        column = model_class.arel_table[column_name]
+        case column_type
+        when :json
+          Arel::Nodes::JsonContainer.new(column, build_quoted(locale), build_quoted(attr))
+        when :jsonb
+          Arel::Nodes::JsonbContainer.new(column, build_quoted(locale), build_quoted(attr))
+        end
+      end
+
       # @!macro backend_iterator
       def each_locale
         model[column_name].each do |l, v|
@@ -67,9 +78,7 @@ Implements the {Mobility::Backends::Container} backend for ActiveRecord models.
         end
       end
 
-      backend_class = self
-
-      setup do |attributes, options|
+      setup do |_attributes, options|
         store options[:column_name], coder: Coder
 
         # Fix for duping depth-2 jsonb column in AR < 5.0
@@ -88,13 +97,6 @@ Implements the {Mobility::Backends::Container} backend for ActiveRecord models.
             include const_set(module_name, dupable)
           end
         end
-
-        query_methods = backend_class.const_get("#{options[:column_type].capitalize}QueryMethods")
-        extend(Module.new do
-          define_method ::Mobility.query_method do
-            super().extending(query_methods.new(attributes, options))
-          end
-        end)
       end
 
       private

data/lib/mobility/backends/active_record/hstore.rb

@@ -1,4 +1,5 @@
 require 'mobility/backends/active_record/pg_hash'
+require 'mobility/arel/nodes/pg_ops'
 
 module Mobility
   module Backends
@@ -6,25 +7,29 @@ module Mobility
 
 Implements the {Mobility::Backends::Hstore} backend for ActiveRecord models.
 
-@see Mobility::Backends::ActiveRecord::HashValued
+@see Mobility::Backends::HashValued
 
 =end
     module ActiveRecord
       class Hstore < PgHash
-        require 'mobility/backends/active_record/hstore/query_methods'
-
         # @!group Backend Accessors
         # @!macro backend_reader
-        # @!method read(locale, **options)
+        # @!method read(locale, options = {})
 
-        # @!group Backend Accessors
         # @!macro backend_writer
         def write(locale, value, options = {})
           super(locale, value && value.to_s, options)
         end
         # @!endgroup
 
-        setup_query_methods(QueryMethods)
+        # @param [String] attr Attribute name
+        # @param [Symbol] locale Locale
+        # @return [Mobility::Arel::Nodes::Hstore] Arel node for value of
+        #   attribute key on hstore column
+        def self.build_node(attr, locale)
+          column_name = column_affix % attr
+          Arel::Nodes::Hstore.new(model_class.arel_table[column_name], build_quoted(locale))
+        end
       end
     end
   end

data/lib/mobility/backends/active_record/json.rb

@@ -1,4 +1,5 @@
 require 'mobility/backends/active_record/pg_hash'
+require 'mobility/arel/nodes/pg_ops'
 
 module Mobility
   module Backends
@@ -6,32 +7,37 @@ module Mobility
 
 Implements the {Mobility::Backends::Json} backend for ActiveRecord models.
 
-@see Mobility::Backends::ActiveRecord::HashValued
+@see Mobility::Backends::HashValued
 
 =end
     module ActiveRecord
       class Json < PgHash
-        require 'mobility/backends/active_record/json/query_methods'
-
         # @!group Backend Accessors
         #
-        # @note Translation may be string, integer or boolean-valued since
-        #   value is stored on a JSON hash.
-        # @param [Symbol] locale Locale to read
-        # @param [Hash] options
-        # @return [String,Integer,Boolean] Value of translation
         # @!method read(locale, **options)
+        #   @note Translation may be string, integer or boolean-valued since
+        #     value is stored on a JSON hash.
+        #   @param [Symbol] locale Locale to read
+        #   @param [Hash] options
+        #   @return [String,Integer,Boolean] Value of translation
 
-        # @!group Backend Accessors
-        # @note Translation may be string, integer or boolean-valued since
-        #   value is stored on a JSON hash.
-        # @param [Symbol] locale Locale to write
-        # @param [String,Integer,Boolean] value Value to write
-        # @param [Hash] options
-        # @return [String,Integer,Boolean] Updated value
         # @!method write(locale, value, **options)
+        #   @note Translation may be string, integer or boolean-valued since
+        #     value is stored on a JSON hash.
+        #   @param [Symbol] locale Locale to write
+        #   @param [String,Integer,Boolean] value Value to write
+        #   @param [Hash] options
+        #   @return [String,Integer,Boolean] Updated value
+        # @!endgroup
 
-        setup_query_methods(QueryMethods)
+        # @param [String] attr Attribute name
+        # @param [Symbol] locale Locale
+        # @return [Mobility::Arel::Nodes::Json] Arel node for value of
+        #   attribute key on jsonb column
+        def self.build_node(attr, locale)
+          column_name = column_affix % attr
+          Arel::Nodes::Json.new(model_class.arel_table[column_name], build_quoted(locale))
+        end
       end
     end
   end

data/lib/mobility/backends/active_record/jsonb.rb

@@ -1,4 +1,5 @@
 require 'mobility/backends/active_record/pg_hash'
+require 'mobility/arel/nodes/pg_ops'
 
 module Mobility
   module Backends
@@ -6,32 +7,37 @@ module Mobility
 
 Implements the {Mobility::Backends::Jsonb} backend for ActiveRecord models.
 
-@see Mobility::Backends::ActiveRecord::HashValued
+@see Mobility::Backends::HashValued
 
 =end
     module ActiveRecord
       class Jsonb < PgHash
-        require 'mobility/backends/active_record/jsonb/query_methods'
-
         # @!group Backend Accessors
         #
-        # @note Translation may be any json type, but querying will only work on
-        #   string-typed values.
-        # @param [Symbol] locale Locale to read
-        # @param [Hash] options
-        # @return [String,Integer,Boolean] Value of translation
         # @!method read(locale, **options)
+        #   @note Translation may be any json type, but querying will only work on
+        #     string-typed values.
+        #   @param [Symbol] locale Locale to read
+        #   @param [Hash] options
+        #   @return [String,Integer,Boolean] Value of translation
 
-        # @!group Backend Accessors
-        # @note Translation may be any json type, but querying will only work on
-        #   string-typed values.
-        # @param [Symbol] locale Locale to write
-        # @param [String,Integer,Boolean] value Value to write
-        # @param [Hash] options
-        # @return [String,Integer,Boolean] Updated value
         # @!method write(locale, value, **options)
+        #   @note Translation may be any json type, but querying will only work on
+        #     string-typed values.
+        #   @param [Symbol] locale Locale to write
+        #   @param [String,Integer,Boolean] value Value to write
+        #   @param [Hash] options
+        #   @return [String,Integer,Boolean] Updated value
+        # @!endgroup
 
-        setup_query_methods(QueryMethods)
+        # @param [String] attr Attribute name
+        # @param [Symbol] locale Locale
+        # @return [Mobility::Arel::Nodes::Jsonb] Arel node for value of
+        #   attribute key on jsonb column
+        def self.build_node(attr, locale)
+          column_name = column_affix % attr
+          Arel::Nodes::Jsonb.new(model_class.arel_table[column_name], build_quoted(locale))
+        end
       end
     end
   end

data/lib/mobility/backends/active_record/key_value.rb

@@ -11,7 +11,7 @@ module Mobility
 Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
 
 @example
-  class Post < ActiveRecord::Base
+  class Post < ApplicationRecord
     extend Mobility
     translates :title, backend: :key_value, association_name: :translations, type: :string
   end
@@ -29,21 +29,131 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
       include ActiveRecord
       include KeyValue
 
-      require 'mobility/backends/active_record/key_value/query_methods'
+      option_reader :table_alias_affix
 
-      # @!group Backend Configuration
-      # @option (see Mobility::Backends::KeyValue::ClassMethods#configure)
-      # @raise (see Mobility::Backends::KeyValue::ClassMethods#configure)
-      def self.configure(options)
-        super
-        if type = options[:type]
-          options[:association_name] ||= :"#{options[:type]}_translations"
-          options[:class_name]       ||= Mobility::ActiveRecord.const_get("#{type.capitalize}Translation")
+      class << self
+        # @!group Backend Configuration
+        # @option (see Mobility::Backends::KeyValue::ClassMethods#configure)
+        # @raise (see Mobility::Backends::KeyValue::ClassMethods#configure)
+        def configure(options)
+          super
+          if type = options[:type]
+            options[:association_name] ||= :"#{options[:type]}_translations"
+            options[:class_name]       ||= Mobility::ActiveRecord.const_get("#{type.capitalize}Translation")
+          end
+          options[:table_alias_affix] = "#{options[:model_class]}_%s_#{options[:association_name]}"
+        rescue NameError
+          raise ArgumentError, "You must define a Mobility::ActiveRecord::#{type.capitalize}Translation class."
+        end
+        # @!endgroup
+
+        # @param [String] attr Attribute name
+        # @param [Symbol] _locale Locale
+        # @return [Mobility::Arel::Attribute] Arel attribute for aliased
+        #   translation table value column
+        def build_node(attr, locale)
+          aliased_table = class_name.arel_table.alias(table_alias(attr, locale))
+          Arel::Attribute.new(aliased_table, :value, locale, self, attribute_name: attr.to_sym)
+        end
+
+        # Joins translations using either INNER/OUTER join appropriate to the query.
+        # @param [ActiveRecord::Relation] relation Relation to scope
+        # @param [Object] predicate Arel predicate
+        # @param [Symbol] locale Locale
+        # @option [Boolean] invert
+        # @return [ActiveRecord::Relation] relation Relation with joins applied (if needed)
+        def apply_scope(relation, predicate, locale, invert: false)
+          visitor = Visitor.new(self, locale)
+          visitor.accept(predicate).inject(relation) do |rel, (attr, join_type)|
+            join_type &&= ::Arel::Nodes::InnerJoin if invert
+            join_translations(rel, attr, locale, join_type)
+          end
+        end
+
+        private
+
+        def table_alias(attr, locale)
+          table_alias_affix % "#{attr}_#{locale}"
+        end
+
+        def join_translations(relation, key, locale, join_type)
+          return relation if already_joined?(relation, key, locale, join_type)
+          m = model_class.arel_table
+          t = class_name.arel_table.alias(table_alias(key, locale))
+          relation.joins(m.join(t, join_type).
+                         on(t[:key].eq(key).
+                            and(t[:locale].eq(locale).
+                                and(t[:translatable_type].eq(model_class.base_class.name).
+                                    and(t[:translatable_id].eq(m[:id]))))).join_sources)
+        end
+
+        def already_joined?(relation, name, locale, join_type)
+          if join = get_join(relation, name, locale)
+            return true if (join_type == ::Arel::Nodes::OuterJoin) || (::Arel::Nodes::InnerJoin === join)
+            relation.joins_values = relation.joins_values - [join]
+          end
+          false
+        end
+
+        def get_join(relation, name, locale)
+          relation.joins_values.find do |v|
+            (::Arel::Nodes::Join === v) && (v.left.name == (table_alias(name, locale)))
+          end
+        end
+      end
+
+      # Internal class used to visit all nodes in a predicate clause and
+      # return a hash of key/value pairs corresponding to attributes (keys)
+      # and the respective join type (values) required for each attribute.
+      #
+      # Example:
+      #
+      #   class Post < ApplicationRecord
+      #     extend Mobility
+      #     translates :title, :content, backend: :key_value
+      #   end
+      #
+      #   backend_class = Post.mobility_backend_class(:title)
+      #   visitor = Mobility::Backends::ActiveRecord::KeyValue::Visitor.new(backend_class)
+      #
+      #   visitor.accept(title.eq("foo").and(content.eq(nil)))
+      #   #=> { title: Arel::Nodes::InnerJoin, content: Arel::Nodes::OuterJoin }
+      #
+      # The title predicate has a non-nil value, so we can use an INNER JOIN,
+      # whereas we are searching for nil content, which requires an OUTER JOIN.
+      #
+      class Visitor < Arel::Visitor
+        private
+
+        def visit_Arel_Nodes_Equality(object)
+          nils, nodes = [object.left, object.right].partition(&:nil?)
+          if hash = visit_collection(nodes)
+            hash.transform_values { nils.empty? ? INNER_JOIN : OUTER_JOIN }
+          end
+        end
+
+        def visit_collection(objects)
+          objects.map(&method(:visit)).compact.inject do |hash, visited|
+            visited.merge(hash) { |_, old, new| old == INNER_JOIN ? old : new }
+          end
+        end
+        alias :visit_Array :visit_collection
+
+        def visit_Arel_Nodes_Or(object)
+          [object.left, object.right].map(&method(:visit)).compact.inject(&:merge).
+            transform_values { OUTER_JOIN }
+        end
+
+        def visit_Mobility_Arel_Attribute(object)
+          if object.backend_class == backend_class && object.locale == locale
+            { object.attribute_name => INNER_JOIN }
+          end
+        end
+
+        def visit_default(_)
+          {}
         end
-      rescue NameError
-        raise ArgumentError, "You must define a Mobility::ActiveRecord::#{type.capitalize}Translation class."
       end
-      # @!endgroup
 
       setup do |attributes, options|
         association_name   = options[:association_name]
@@ -85,8 +195,6 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
         include DestroyKeyValueTranslations
       end
 
-      setup_query_methods(QueryMethods)
-
       # Returns translation for a given locale, or builds one if none is present.
       # @param [Symbol] locale
       # @return [Mobility::ActiveRecord::TextTranslation,Mobility::ActiveRecord::StringTranslation]