mobility 0.6.0 → 0.7.0

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

@@ -25,8 +25,7 @@ Internal class used by ActiveRecord backends backed by a Postgres data type
         end
 
         setup do |attributes, options = {}|
-          affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
-          attributes.each { |attribute| store (affix % attribute), coder: Coder }
+          attributes.each { |attribute| store (options[:column_affix] % attribute), coder: Coder }
         end
 
         class Coder

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

@@ -30,25 +30,26 @@ Implements {Mobility::Backends::Serialized} backend for ActiveRecord models.
       include ActiveRecord
       include HashValued
 
-      require 'mobility/backends/active_record/serialized/query_methods'
-
       # @!group Backend Configuration
       # @param (see Backends::Serialized.configure)
       # @option (see Backends::Serialized.configure)
       # @raise (see Backends::Serialized.configure)
       def self.configure(options)
+        super
         Serialized.configure(options)
       end
       # @!endgroup
 
+      def self.build_node(attr, _locale)
+        raise ArgumentError,
+          "You cannot query on mobility attributes translated with the Serialized backend (#{attr})."
+      end
+
       setup do |attributes, options|
         coder = { yaml: YAMLCoder, json: JSONCoder }[options[:format]]
-        column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
-        attributes.each { |attribute| serialize (column_affix % attribute), coder }
+        attributes.each { |attribute| serialize (options[:column_affix] % attribute), coder }
       end
 
-      setup_query_methods(QueryMethods)
-
       # @!group Cache Methods
       # Returns column value as a hash
       # @return [Hash]

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

@@ -19,7 +19,7 @@ If the translation table already exists, it will create a migration adding
 columns to that table.
 
 @example Model with table backend
-  class Post < ActiveRecord::Base
+  class Post < ApplicationRecord
     extend Mobility
     translates :title, backend: :table
   end
@@ -92,28 +92,151 @@ columns to that table.
       include ActiveRecord
       include Table
 
-      require 'mobility/backends/active_record/table/query_methods'
-
-      # @!group Backend Configuration
-      # @option options [Symbol] association_name (:translations)
-      #   Name of association method
-      # @option options [Symbol] table_name Name of translation table
-      # @option options [Symbol] foreign_key Name of foreign key
-      # @option options [Symbol] subclass_name (:Translation) Name of subclass
-      #   to append to model class to generate translation class
-      def self.configure(options)
-        table_name = options[:model_class].table_name
-        options[:table_name]  ||= "#{table_name.singularize}_translations"
-        options[:foreign_key] ||= table_name.downcase.singularize.camelize.foreign_key
-        if (association_name = options[:association_name]).present?
-          options[:subclass_name] ||= association_name.to_s.singularize.camelize.freeze
-        else
-          options[:association_name] = :translations
-          options[:subclass_name] ||= :Translation
+      class << self
+        # @!group Backend Configuration
+        # @option options [Symbol] association_name (:translations)
+        #   Name of association method
+        # @option options [Symbol] table_name Name of translation table
+        # @option options [Symbol] foreign_key Name of foreign key
+        # @option options [Symbol] subclass_name (:Translation) Name of subclass
+        #   to append to model class to generate translation class
+        def configure(options)
+          table_name = options[:model_class].table_name
+          options[:table_name]  ||= "#{table_name.singularize}_translations"
+          options[:foreign_key] ||= table_name.downcase.singularize.camelize.foreign_key
+          if (association_name = options[:association_name]).present?
+            options[:subclass_name] ||= association_name.to_s.singularize.camelize.freeze
+          else
+            options[:association_name] = :translations
+            options[:subclass_name] ||= :Translation
+          end
+          %i[foreign_key association_name subclass_name table_name].each { |key| options[key] = options[key].to_sym }
+        end
+        # @!endgroup
+
+        # @param [String] attr Attribute name
+        # @param [Symbol] _locale Locale
+        # @return [Mobility::Arel::Attribute] Arel node for column on translation table
+        def build_node(attr, locale)
+          aliased_table = model_class.const_get(subclass_name).arel_table.alias(table_alias(locale))
+          Arel::Attribute.new(aliased_table, attr, locale, self)
+        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)
+          if join_type = visitor.accept(predicate)
+            join_type &&= Visitor::INNER_JOIN if invert
+            join_translations(relation, locale, join_type)
+          else
+            relation
+          end
+        end
+
+        private
+
+        def table_alias(locale)
+          "#{locale}_#{table_name}"
+        end
+
+        def join_translations(relation, locale, join_type)
+          return relation if already_joined?(relation, locale, join_type)
+          m = model_class.arel_table
+          t = model_class.const_get(subclass_name).arel_table.alias(table_alias(locale))
+          relation.joins(m.join(t, join_type).
+                         on(t[foreign_key].eq(m[:id]).
+                            and(t[:locale].eq(locale))).join_sources)
+        end
+
+        def already_joined?(relation, locale, join_type)
+          if join = get_join(relation, locale)
+            return true if (join_type == Visitor::OUTER_JOIN) || (Visitor::INNER_JOIN === join)
+            relation.joins_values = relation.joins_values - [join]
+          end
+          false
+        end
+
+        def get_join(relation, locale)
+          relation.joins_values.find { |v| (::Arel::Nodes::Join === v) && (v.left.name == table_alias(locale).to_s) }
+        end
+      end
+
+      # Internal class used to visit all nodes in a predicate clause and
+      # return a single join type required for the predicate, or nil if no
+      # join is required. (Similar to the KeyValue Visitor class.)
+      #
+      # Example:
+      #
+      #   class Post < ApplicationRecord
+      #     extend Mobility
+      #     translates :title, :content, backend: :table
+      #   end
+      #
+      #   backend_class = Post.mobility_backend_class(:title)
+      #   visitor = Mobility::Backends::ActiveRecord::Table::Visitor.new(backend_class)
+      #
+      #   visitor.accept(title.eq(nil).and(content.eq(nil)))
+      #   #=> Arel::Nodes::OuterJoin
+      #
+      #   visitor.accept(title.eq("foo").and(content.eq(nil)))
+      #   #=> Arel::Nodes::InnerJoin
+      #
+      # In the first case, both attributes are matched against nil values, so
+      # we need an OUTER JOIN. In the second case, one attribute is matched
+      # against a non-nil value, so we can use an INNER JOIN.
+      #
+      class Visitor < Arel::Visitor
+        private
+
+        def visit_Arel_Nodes_Equality(object)
+          nils, nodes = [object.left, object.right].partition(&:nil?)
+          if nodes.any?(&method(:visit))
+            nils.empty? ? INNER_JOIN : OUTER_JOIN
+          end
+        end
+
+        def visit_collection(objects)
+          objects.map { |obj|
+            visit(obj).tap { |visited| return visited if visited == INNER_JOIN }
+          }.compact.first
+        end
+        alias :visit_Array :visit_collection
+
+        # If either left or right is an OUTER JOIN (predicate with a NULL
+        # argument) OR we are combining this with anything other than a
+        # column on the same translation table, we need to OUTER JOIN
+        # here. The *only* case where we can use an INNER JOIN is when we
+        # have predicates like this:
+        #
+        #   table.attribute1 = 'something' OR table.attribute2 = 'somethingelse'
+        #
+        # Here, both columns are on the same table, and both are non-nil, so
+        # we can safely INNER JOIN. This is pretty subtle, think about it.
+        #
+        def visit_Arel_Nodes_Or(object)
+          visited = [object.left, object.right].map(&method(:visit))
+          if visited.all? { |v| INNER_JOIN == v }
+            INNER_JOIN
+          elsif visited.any?
+            OUTER_JOIN
+          end
+        end
+
+        def visit_Mobility_Arel_Attribute(object)
+          # We compare table names here to ensure that attributes defined on
+          # different backends but the same table will correctly get an OUTER
+          # join when required. Use options[:table_name] here since we don't
+          # know if the other backend has a +table_name+ option accessor.
+          (backend_class.table_name == object.backend_class.options[:table_name]) &&
+            (locale == object.locale) && INNER_JOIN
         end
-        %i[foreign_key association_name subclass_name table_name].each { |key| options[key] = options[key].to_sym }
       end
-      # @!endgroup
 
       setup do |_attributes, options|
         association_name = options[:association_name]
@@ -143,7 +266,7 @@ columns to that table.
           touch: true
 
         before_save do
-          required_attributes = self.class.translated_attribute_names & translation_class.attribute_names
+          required_attributes = self.class.mobility_attributes & translation_class.attribute_names
           send(association_name).destroy_empty_translations(required_attributes)
         end
 
@@ -159,8 +282,6 @@ columns to that table.
         end
       end
 
-      setup_query_methods(QueryMethods)
-
       # Returns translation for a given locale, or builds one if none is present.
       # @param [Symbol] locale
       def translation_for(locale, _)

data/lib/mobility/backends/hash_valued.rb

@@ -8,15 +8,9 @@ Defines read and write methods that access the value at a key with value
 
 =end
     module HashValued
-      # @!macro backend_constructor
-      # @option options [Symbol] column_prefix Prefix added to generate column
-      #   name from attribute name
-      # @option options [Symbol] column_suffix Suffix added to generate column
-      #   name from attribute name
-      def initialize(_model, _attribute, options = {})
-        super
-        @column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
-      end
+      # @!method column_affix
+      #   Returns interpolation string used to generate column names.
+      #   @return [String] Affix to generate column names
 
       # @!group Backend Accessors
       #
@@ -36,10 +30,21 @@ Defines read and write methods that access the value at a key with value
         translations.each { |l, _| yield l }
       end
 
+      def self.included(backend_class)
+        backend_class.extend ClassMethods
+        backend_class.option_reader :column_affix
+      end
+
+      module ClassMethods
+        def configure(options)
+          options[:column_affix] = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
+        end
+      end
+
       private
 
       def column_name
-        @column_name ||= (@column_affix % attribute)
+        @column_name ||= (column_affix % attribute)
       end
     end
 

data/lib/mobility/backends/key_value.rb

@@ -46,15 +46,13 @@ other backends on model (otherwise one will overwrite the other).
     module KeyValue
       extend Backend::OrmDelegator
 
-      # @return [Symbol] name of the association
-      attr_reader :association_name
-
-      # @!macro backend_constructor
-      # @option options [Symbol] association_name Name of association
-      def initialize(model, attribute, options = {})
-        super
-        @association_name = options[:association_name]
-      end
+      # @!method association_name
+      #   Returns the name of the polymorphic association.
+      #   @return [Symbol] Name of the association
+
+      # @!method class_name
+      #   Returns translation class used in polymorphic association.
+      #   @return [Class] Translation class
 
       # @!group Backend Accessors
       # @!macro backend_reader
@@ -62,7 +60,7 @@ other backends on model (otherwise one will overwrite the other).
         translation_for(locale, options).value
       end
 
-      # @!macro backend_reader
+      # @!macro backend_writer
       def write(locale, value, options = {})
         translation_for(locale, options).value = value
       end
@@ -79,8 +77,10 @@ other backends on model (otherwise one will overwrite the other).
         model.send(association_name)
       end
 
-      def self.included(backend)
-        backend.extend ClassMethods
+      def self.included(backend_class)
+        backend_class.extend ClassMethods
+        backend_class.option_reader :association_name
+        backend_class.option_reader :class_name
       end
 
       module ClassMethods

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

@@ -11,15 +11,9 @@ Implements the {Mobility::Backends::Container} backend for Sequel models.
       require 'mobility/backends/sequel/container/json_query_methods'
       require 'mobility/backends/sequel/container/jsonb_query_methods'
 
-      # @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_name
+      #   @return [Symbol] (:translations) Name of translations column
+      option_reader :column_name
 
       # @!group Backend Accessors
       #

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

@@ -6,7 +6,7 @@ module Mobility
 
 Implements the {Mobility::Backends::Hstore} backend for Sequel models.
 
-@see Mobility::Backends::Sequel::HashValued
+@see Mobility::Backends::HashValued
 
 =end
     module Sequel
@@ -15,7 +15,7 @@ Implements the {Mobility::Backends::Hstore} backend for Sequel models.
 
         # @!group Backend Accessors
         # @!macro backend_reader
-        # @!method read(locale, **options)
+        # @!method read(locale, options = {})
 
         # @!group Backend Accessors
         # @!macro backend_writer

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

@@ -6,7 +6,7 @@ module Mobility
 
 Implements the {Mobility::Backends::Json} backend for Sequel models.
 
-@see Mobility::Backends::Sequel::HashValued
+@see Mobility::Backends::HashValued
 
 =end
     module Sequel
@@ -15,21 +15,21 @@ Implements the {Mobility::Backends::Json} backend for Sequel models.
 
         # @!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)
+        # @!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)
+        # @!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)
       end

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

@@ -6,7 +6,7 @@ module Mobility
 
 Implements the {Mobility::Backends::Jsonb} backend for Sequel models.
 
-@see Mobility::Backends::Sequel::HashValued
+@see Mobility::Backends::HashValued
 
 =end
     module Sequel
@@ -15,21 +15,21 @@ Implements the {Mobility::Backends::Jsonb} backend for Sequel models.
 
         # @!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)
-
-        # @!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
+        #   @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 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)
       end