mobility 0.5.1 → 0.6.0

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

@@ -12,6 +12,7 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
 
 @example
   class Post < ActiveRecord::Base
+    extend Mobility
     translates :title, backend: :key_value, association_name: :translations, type: :string
   end
 
@@ -31,17 +32,16 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
       require 'mobility/backends/active_record/key_value/query_methods'
 
       # @!group Backend Configuration
-      # @option options [Symbol] type (:text) Column type to use
-      # @option options [Symbol] association_name (:text_translations) Name of association method
-      # @option options [String,Class] class_name ({Mobility::ActiveRecord::TextTranslation}) Translation class
-      # @raise [ArgumentError] if type is not either :text or :string
+      # @option (see Mobility::Backends::KeyValue::ClassMethods#configure)
+      # @raise (see Mobility::Backends::KeyValue::ClassMethods#configure)
       def self.configure(options)
         super
-        type = options[:type]
-        options[:class_name] ||= Mobility::ActiveRecord.const_get("#{type.capitalize}Translation")
-        options[:class_name] = options[:class_name].constantize if options[:class_name].is_a?(String)
-        options[:association_name] ||= :"#{options[:type]}_translations"
-        %i[type association_name].each { |key| options[key] = options[key].to_sym }
+        if type = options[:type]
+          options[:association_name] ||= :"#{options[:type]}_translations"
+          options[:class_name]       ||= Mobility::ActiveRecord.const_get("#{type.capitalize}Translation")
+        end
+      rescue NameError
+        raise ArgumentError, "You must define a Mobility::ActiveRecord::#{type.capitalize}Translation class."
       end
       # @!endgroup
 

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

@@ -3,67 +3,74 @@ require "mobility/backends/active_record/query_methods"
 
 module Mobility
   module Backends
-    class ActiveRecord::KeyValue::QueryMethods < ActiveRecord::QueryMethods
-      def initialize(attributes, association_name: nil, class_name: nil, **)
-        super
-        @association_name = association_name
+    module ActiveRecord
+      class KeyValue::QueryMethods < QueryMethods
+        def initialize(attributes, association_name: nil, class_name: nil, **)
+          super
+          @association_name = association_name
 
-        define_join_method(association_name, class_name)
-        define_query_methods(association_name)
-      end
+          define_join_method(association_name, class_name)
+          define_query_methods(association_name)
+        end
 
-      def extended(relation)
-        super
-        association_name = @association_name
-        q = self
+        def extended(relation)
+          super
+          association_name = @association_name
+          q = self
 
-        mod = Module.new do
-          define_method :not do |opts, *rest|
-            if i18n_keys = q.extract_attributes(opts)
-              opts = opts.with_indifferent_access
-              i18n_keys.each { |attr| opts["#{attr}_#{association_name}"] = { value: opts.delete(attr) }}
-              super(opts, *rest).send(:"join_#{association_name}", *i18n_keys)
-            else
-              super(opts, *rest)
+          mod = Module.new do
+            define_method :not do |opts, *rest|
+              if i18n_keys = q.extract_attributes(opts)
+                opts = opts.with_indifferent_access
+                i18n_keys.each do |attr|
+                  opts["#{attr}_#{association_name}"] = { value: q.collapse(opts.delete(attr)) }
+                end
+                super(opts, *rest).send(:"join_#{association_name}", *i18n_keys)
+              else
+                super(opts, *rest)
+              end
             end
           end
+          relation.mobility_where_chain.include(mod)
         end
-        relation.mobility_where_chain.include(mod)
-      end
 
-      private
+        private
 
-      def define_join_method(association_name, translation_class)
-        define_method :"join_#{association_name}" do |*attributes, **options|
-          attributes.inject(self) do |relation, attribute|
-            t = translation_class.arel_table.alias(:"#{attribute}_#{association_name}")
-            m = arel_table
-            join_type = options[:outer_join] ? Arel::Nodes::OuterJoin : Arel::Nodes::InnerJoin
-            relation.joins(m.join(t, join_type).
-                           on(t[:key].eq(attribute).
-                              and(t[:locale].eq(Mobility.locale).
-                                  and(t[:translatable_type].eq(base_class.name).
-                                      and(t[:translatable_id].eq(m[:id]))))).join_sources)
+        def define_join_method(association_name, translation_class)
+          define_method :"join_#{association_name}" do |*attributes, **options|
+            attributes.inject(self) do |relation, attribute|
+              t = translation_class.arel_table.alias("#{attribute}_#{association_name}")
+              m = arel_table
+              join_type = options[:outer_join] ? Arel::Nodes::OuterJoin : Arel::Nodes::InnerJoin
+              relation.joins(m.join(t, join_type).
+                             on(t[:key].eq(attribute).
+                                and(t[:locale].eq(Mobility.locale).
+                                    and(t[:translatable_type].eq(base_class.name).
+                                        and(t[:translatable_id].eq(m[:id]))))).join_sources)
+            end
           end
         end
-      end
 
-      def define_query_methods(association_name)
-        q = self
+        def define_query_methods(association_name)
+          q = self
 
-        define_method :where! do |opts, *rest|
-          if i18n_keys = q.extract_attributes(opts)
-            opts = opts.with_indifferent_access
-            i18n_nulls = i18n_keys.reject { |key| opts[key] && Array(opts[key]).all? }
-            i18n_keys.each { |attr| opts["#{attr}_#{association_name}"] = { value: opts.delete(attr) }}
-            super(opts, *rest).
-              send("join_#{association_name}", *(i18n_keys - i18n_nulls)).
-              send("join_#{association_name}", *i18n_nulls, outer_join: true)
-          else
-            super(opts, *rest)
+          define_method :where! do |opts, *rest|
+            if i18n_keys = q.extract_attributes(opts)
+              opts = opts.with_indifferent_access
+              i18n_nulls = i18n_keys.reject { |key| opts[key] && [*opts[key]].all? }
+              i18n_keys.each do |attr|
+                opts["#{attr}_#{association_name}"] = { value: q.collapse(opts.delete(attr)) }
+              end
+              super(opts, *rest).
+                send("join_#{association_name}", *(i18n_keys - i18n_nulls)).
+                send("join_#{association_name}", *i18n_nulls, outer_join: true)
+            else
+              super(opts, *rest)
+            end
           end
         end
       end
+      KeyValue.private_constant :QueryMethods
     end
   end
 end

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

@@ -10,39 +10,43 @@ Internal class used by ActiveRecord backends backed by a Postgres data type
 (hstore, jsonb).
 
 =end
-    class ActiveRecord::PgHash
-      include ActiveRecord
-      include HashValued
-
-      # @!macro backend_iterator
-      def each_locale
-        super { |l| yield l.to_sym }
-      end
+    module ActiveRecord
+      class PgHash
+        include ActiveRecord
+        include HashValued
+
+        # @!macro backend_iterator
+        def each_locale
+          super { |l| yield l.to_sym }
+        end
 
-      def translations
-        model.read_attribute(attribute)
-      end
+        def translations
+          model.read_attribute(column_name)
+        end
 
-      setup do |attributes|
-        attributes.each { |attribute| store attribute, coder: Coder }
-      end
+        setup do |attributes, options = {}|
+          affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
+          attributes.each { |attribute| store (affix % attribute), coder: Coder }
+        end
 
-      class Coder
-        def self.dump(obj)
-          if obj.is_a? Hash
-            obj.inject({}) do |translations, (locale, value)|
-              translations[locale] = value if value.present?
-              translations
+        class Coder
+          def self.dump(obj)
+            if obj.is_a? Hash
+              obj.inject({}) do |translations, (locale, value)|
+                translations[locale] = value if value.present?
+                translations
+              end
+            else
+              raise ArgumentError, "Attribute is supposed to be a Hash, but was a #{obj.class}. -- #{obj.inspect}"
             end
-          else
-            raise ArgumentError, "Attribute is supposed to be a Hash, but was a #{obj.class}. -- #{obj.inspect}"
           end
-        end
 
-        def self.load(obj)
-          obj
+          def self.load(obj)
+            obj
+          end
         end
       end
+      private_constant :PgHash
     end
   end
 end

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

@@ -1,11 +1,23 @@
+# frozen_string_literal: true
+
 module Mobility
   module Backends
     module ActiveRecord
 =begin
 
-Defines query methods for Postgres backends. Including class must define a
-single method, +matches+, which accepts a column, value and locale to
-match, and returns an Arel node.
+Internal module builder defining query methods for Postgres backends. Including
+class must define the following methods:
+
+- a method +matches+ which takes an attribute, and a locale to match, and
+  returns an Arel node which is used to check that the attribute has the
+  specified value in the specified locale
+- a method +exists+ which takes an attribute and a locale and
+  returns an Arel node checking that a value exists for the attribute in the
+  specified locale
+- a method +quote+ which quotes the value to be matched
+- an optional method +absent+ which takes an attribute and a locale and returns
+  an Arel node checking that the value for the attribute does not exist in the
+  specified locale. Defaults to +exists(key, locale).not+.
 
 This module avoids a lot of duplication between hstore/json/jsonb/container
 backend querying code.
@@ -18,18 +30,19 @@ backend querying code.
 
 =end
       module PgQueryMethods
-        attr_reader :arel_table
+        attr_reader :arel_table, :column_affix
 
         def initialize(attributes, options)
           super
-          @arel_table = options[:model_class].arel_table
+          @arel_table   = options[:model_class].arel_table
+          @column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
 
           q = self
 
           define_method :where! do |opts, *rest|
             if i18n_keys = q.extract_attributes(opts)
               opts = opts.with_indifferent_access
-              query = q.create_where_query!(opts, i18n_keys)
+              query = q.create_query!(opts, i18n_keys)
 
               opts.empty? ? super(query) : super(opts, *rest).where(query)
             else
@@ -46,7 +59,7 @@ backend querying code.
             define_method :not do |opts, *rest|
               if i18n_keys = q.extract_attributes(opts)
                 opts = opts.with_indifferent_access
-                query = q.create_not_query!(opts, i18n_keys)
+                query = q.create_query!(opts, i18n_keys, inverse: true)
 
                 super(opts, *rest).where(query)
               else
@@ -57,62 +70,85 @@ backend querying code.
           relation.mobility_where_chain.include(mod)
         end
 
-        # Create +where+ query for options hash, translated keys and arel_table
-        # @note This is a destructive operation, it will modify +opts+.
+        # Create +where+ query for specified key and value
         #
+        # @note This is a destructive operation, it will modify +opts+.
         # @param [Hash] opts Hash of attribute/value pairs
         # @param [Array] keys Translated attribute names
+        # @option [Boolean] inverse (false) If true, create a +not+ query
+        #   instead of a +where+ query
         # @return [Arel::Node] Arel node to pass to +where+
-        def create_where_query!(opts, keys)
-          locale = Mobility.locale
+        def create_query!(opts, keys, inverse: false)
           keys.map { |key|
-            values = opts.delete(key)
-
-            next has_locale(key, locale).not if values.nil?
-
-            Array.wrap(values).map { |value|
-              value.nil? ?
-                has_locale(key, locale).not :
-                matches(key, value, locale)
-            }.inject(&:or)
+            values = Array.wrap(opts.delete(key)).uniq
+            send(inverse ? :not_query : :where_query, key, values, Mobility.locale)
           }.inject(&:and)
         end
 
-        # Create +not+ query for options hash and translated keys
-        # @note This is a destructive operation, it will modify +opts+.
-        #
-        # @param [Hash] opts Hash of attribute/value pairs
-        # @param [Array] keys Translated attribute names
-        # @return [Arel::Node] Arel node to pass to +where+
-        def create_not_query!(opts, keys)
-          locale = Mobility.locale
-          keys.map { |key|
-            values = opts.delete(key)
-
-            Array.wrap(values).map { |value|
-              matches(key, value, locale).not
-            }.inject(has_locale(key, locale), &:and)
-          }.inject(&:and)
+        def matches(_key, _locale)
+          raise NotImplementedError
         end
 
-        private
+        def exists(_key, _locale)
+          raise NotImplementedError
+        end
 
-        def matches(_key, _value, _locale)
+        def quote(_value)
           raise NotImplementedError
         end
 
-        def has_locale(key, locale)
-          build_infix(:'?', arel_table[key], quote(locale))
+        def absent(key, locale)
+          exists(key, locale).not
         end
 
+        private
+
         def build_infix(*args)
           arel_table.grouping(Arel::Nodes::InfixOperation.new(*args))
         end
 
-        def quote(value)
+        def build_quoted(value)
           Arel::Nodes.build_quoted(value.to_s)
         end
+
+        def column_name(attribute)
+          column_affix % attribute
+        end
+
+        # Create +where+ query for specified key and values
+        #
+        # @param [String] key Translated attribute name
+        # @param [Array] values Values to match
+        # @param [Symbol] locale Locale to query for
+        # @return [Arel::Node] Arel node to pass to +where+
+        def where_query(key, values, locale)
+          nils, vals = values.partition(&:nil?)
+
+          return absent(key, locale) if vals.empty?
+
+          node = matches(key, locale)
+          vals = vals.map(&method(:quote))
+
+          query = vals.size == 1 ? node.eq(vals.first) : node.in(vals)
+          query = query.or(absent(key, locale)) unless nils.empty?
+          query
+        end
+
+        # Create +not+ query for specified key and values
+        #
+        # @param [String] key Translated attribute name
+        # @param [Array] values Values to match
+        # @param [Symbol] locale Locale to query for
+        # @return [Arel::Node] Arel node to pass to +where+
+        def not_query(key, values, locale)
+          vals = values.map(&method(:quote))
+          node = matches(key, locale)
+
+          query = vals.size == 1 ? node.eq(vals.first) : node.in(vals)
+          query.not.and(exists(key, locale))
+        end
       end
+      private_constant :PgQueryMethods
     end
   end
 end

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

@@ -21,23 +21,30 @@ models. For details see backend-specific subclasses.
 
         # @param [ActiveRecord::Relation] relation Relation being extended
         # @note Only want to define this once, even if multiple QueryMethods
-        #   modules are included, so define it here in extended method
+        #   modules are included, so include it here into the singleton class.
         def extended(relation)
-          unless relation.methods(false).include?(:mobility_where_chain)
-            relation.define_singleton_method(:mobility_where_chain) do
-              @mobility_where_chain ||= Class.new(::ActiveRecord::QueryMethods::WhereChain)
-            end
-
-            relation.define_singleton_method :where do |opts = :chain, *rest|
-              opts == :chain ? mobility_where_chain.new(spawn) : super(opts, *rest)
-            end
-          end
+          relation.singleton_class.include WhereChainable
         end
 
         def extract_attributes(opts)
           opts.is_a?(Hash) && (opts.keys.map(&:to_s) & @attributes).presence
         end
+
+        def collapse(value)
+          value.is_a?(Array) ? value.uniq : value
+        end
+      end
+
+      module WhereChainable
+        def where(opts = :chain, *rest)
+          opts == :chain ? mobility_where_chain.new(spawn) : super
+        end
+
+        def mobility_where_chain
+          @mobility_where_chain ||= Class.new(::ActiveRecord::QueryMethods::WhereChain)
+        end
       end
+      private_constant :QueryMethods, :WhereChainable
     end
   end
 end

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

@@ -11,6 +11,7 @@ Implements {Mobility::Backends::Serialized} backend for ActiveRecord models.
 
 @example Define attribute with serialized backend
   class Post < ActiveRecord::Base
+    extend Mobility
     translates :title, backend: :serialized, format: :yaml
   end
 
@@ -42,7 +43,8 @@ Implements {Mobility::Backends::Serialized} backend for ActiveRecord models.
 
       setup do |attributes, options|
         coder = { yaml: YAMLCoder, json: JSONCoder }[options[:format]]
-        attributes.each { |attribute| serialize attribute, coder }
+        column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
+        attributes.each { |attribute| serialize (column_affix % attribute), coder }
       end
 
       setup_query_methods(QueryMethods)
@@ -51,7 +53,7 @@ Implements {Mobility::Backends::Serialized} backend for ActiveRecord models.
       # Returns column value as a hash
       # @return [Hash]
       def translations
-        model.read_attribute(attribute)
+        model.read_attribute(column_name)
       end
 
       %w[yaml json].each do |format|