mobility 0.7.6 → 0.8.0

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

@@ -36,8 +36,6 @@ Sequel serialization plugin.
       include Sequel
       include HashValued
 
-      require 'mobility/backends/sequel/serialized/query_methods'
-
       # @!group Backend Configuration
       # @param (see Backends::Serialized.configure)
       # @option (see Backends::Serialized.configure)
@@ -48,6 +46,11 @@ Sequel serialization plugin.
       end
       # @!endgroup
 
+      def self.build_op(attr, _locale)
+        raise ArgumentError,
+          "You cannot query on mobility attributes translated with the Serialized backend (#{attr})."
+      end
+
       setup do |attributes, options|
         format = options[:format]
         columns = attributes.map { |attribute| (options[:column_affix] % attribute).to_sym }
@@ -71,8 +74,6 @@ Sequel serialization plugin.
         include SerializationModificationDetectionFix
       end
 
-      setup_query_methods(QueryMethods)
-
       # Returns deserialized column value
       # @return [Hash]
       def translations

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

@@ -3,6 +3,7 @@ require "mobility/util"
 require "mobility/backends/sequel"
 require "mobility/backends/key_value"
 require "mobility/sequel/model_translation"
+require "mobility/sequel/sql"
 
 module Mobility
   module Backends
@@ -15,37 +16,107 @@ Implements the {Mobility::Backends::Table} backend for Sequel models.
       include Sequel
       include Table
 
-      require 'mobility/backends/sequel/table/query_methods'
-
       def translation_class
         self.class.translation_class
       end
 
-      # @return [Symbol] class for translations
-      def self.translation_class
-        @translation_class ||= model_class.const_get(subclass_name)
-      end
+      class << self
+        # @return [Symbol] class for translations
+        def translation_class
+          @translation_class ||= model_class.const_get(subclass_name)
+        end
+
+        # @!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 Name of subclass to append to model class to generate translation class
+        # @raise [CacheRequired] if cache option is false
+        def configure(options)
+          raise CacheRequired, "Cache required for Sequel::Table backend" if options[:cache] == false
+          table_name = Util.singularize(options[:model_class].table_name)
+          options[:table_name]  ||= :"#{table_name}_translations"
+          options[:foreign_key] ||= Util.foreign_key(Util.camelize(table_name.downcase))
+          if association_name = options[:association_name]
+            options[:subclass_name] ||= Util.camelize(Util.singularize(association_name))
+          else
+            options[:association_name] = :translations
+            options[:subclass_name] ||= :Translation
+          end
+          %i[table_name foreign_key association_name subclass_name].each { |key| options[key] = options[key].to_sym }
+        end
+        # @!endgroup
+
+        # @param [Symbol] name Attribute name
+        # @param [Symbol] locale Locale
+        # @return [Sequel::SQL::QualifiedIdentifier]
+        def build_op(attr, locale)
+          ::Mobility::Sequel::SQL::QualifiedIdentifier.new(table_alias(locale), attr, locale, self, attribute_name: attr)
+        end
+
+        # @param [Sequel::Dataset] dataset Dataset to prepare
+        # @param [Object] predicate Predicate
+        # @param [Symbol] locale Locale
+        # @return [Sequel::Dataset] Prepared dataset
+        def prepare_dataset(dataset, predicate, locale)
+          join_translations(dataset, locale, visit(predicate, locale))
+        end
+
+        private
+
+        def join_translations(dataset, locale, join_type)
+          if joins = dataset.opts[:join]
+            return dataset if joins.any? { |clause| clause.table_expr.alias == table_alias(locale) }
+          end
+          dataset.join_table(join_type,
+                             translation_class.table_name,
+                             {
+                               locale: locale.to_s,
+                               foreign_key => ::Sequel[model_class.table_name][:id]
+                             },
+                             table_alias: table_alias(locale))
+        end
+
+        # @return [Symbol] Join type
+        def visit(predicate, locale)
+          case predicate
+          when Array
+            visit_collection(predicate, locale)
+          when ::Mobility::Sequel::SQL::QualifiedIdentifier
+            visit_sql_identifier(predicate, locale)
+          when ::Sequel::SQL::BooleanExpression
+            visit_boolean(predicate, locale)
+          when ::Sequel::SQL::Expression
+            visit(predicate.args, locale)
+          else
+            nil
+          end
+        end
+
+        def visit_collection(collection, locale)
+          collection.map { |obj|
+            visit(obj, locale).tap do |visited|
+              return visited if visited == :inner
+            end
+          }.compact.first
+        end
 
-      # @!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 Name of subclass to append to model class to generate translation class
-      # @raise [CacheRequired] if cache option is false
-      def self.configure(options)
-        raise CacheRequired, "Cache required for Sequel::Table backend" if options[:cache] == false
-        table_name = Util.singularize(options[:model_class].table_name)
-        options[:table_name]  ||= :"#{table_name}_translations"
-        options[:foreign_key] ||= Util.foreign_key(Util.camelize(table_name.downcase))
-        if association_name = options[:association_name]
-          options[:subclass_name] ||= Util.camelize(Util.singularize(association_name))
-        else
-          options[:association_name] = :translations
-          options[:subclass_name] ||= :Translation
+        def visit_sql_identifier(identifier, locale)
+          (table_alias(locale) == identifier.table) && :inner
+        end
+
+        def visit_boolean(boolean, locale)
+          if boolean.op == :'='
+            boolean.args.any? { |op| visit(op, locale) } && :inner
+          elsif boolean.op == :IS
+            boolean.args.any?(&:nil?) && :left_outer
+          elsif boolean.op == :OR
+            boolean.args.any? { |op| visit(op, locale) } && :left_outer
+          else
+            visit(boolean.args, locale)
+          end
         end
-        %i[table_name foreign_key association_name subclass_name].each { |key| options[key] = options[key].to_sym }
       end
-      # @!endgroup
 
       setup do |attributes, options|
         association_name = options[:association_name]
@@ -86,8 +157,6 @@ Implements the {Mobility::Backends::Table} backend for Sequel models.
         include Mobility::Sequel::ColumnChanges.new(attributes)
       end
 
-      setup_query_methods(QueryMethods)
-
       def translation_for(locale, _)
         translation = model.send(association_name).find { |t| t.locale == locale.to_s }
         translation ||= translation_class.new(locale: locale)

data/lib/mobility/backends/table.rb

@@ -125,6 +125,10 @@ set.
             super
           end
         end
+
+        def table_alias(locale)
+          "#{table_name}_#{Mobility.normalize_locale(locale)}"
+        end
       end
 
       # Simple hash cache to memoize translations as a hash so they can be

data/lib/mobility/configuration.rb

@@ -104,7 +104,7 @@ default_fallbacks= will be removed in the next major version of Mobility.
       @accessor_method = :translates
       @query_method = :i18n
       @fallbacks_generator = lambda { |fallbacks| Mobility::Fallbacks.build(fallbacks) }
-      @default_accessor_locales = lambda { I18n.available_locales }
+      @default_accessor_locales = lambda { Mobility.available_locales }
       @default_options = Options[{
         cache:    true,
         presence: true,

data/lib/mobility/plugins/active_record/query.rb

@@ -17,9 +17,7 @@ enabled for any one attribute on the model.
       module Query
         class << self
           def apply(attributes)
-            model_class = attributes.model_class
-
-            model_class.class_eval do
+            attributes.model_class.class_eval do
               extend QueryMethod
               extend FindByMethods.new(*attributes.names)
               singleton_class.send :alias_method, Mobility.query_method, :__mobility_query_scope__
@@ -48,7 +46,7 @@ enabled for any one attribute on the model.
           end
 
           def method_missing(m, *)
-            if @model_class.mobility_attributes.include?(m.to_s)
+            if @model_class.mobility_attribute?(m)
               @__backends |= [@model_class.mobility_backend_class(m)]
               @model_class.mobility_backend_class(m).build_node(m, @locale)
             elsif @model_class.column_names.include?(m.to_s)
@@ -91,6 +89,26 @@ enabled for any one attribute on the model.
             opts == :chain ? WhereChain.new(spawn) : super
           end
 
+          def order(opts, *rest)
+            case opts
+            when Symbol, String
+              @klass.mobility_attribute?(opts) ? order({ opts => :asc }, *rest) : super
+            when Hash
+              i18n_keys, keys = opts.keys.partition(&@klass.method(:mobility_attribute?))
+              return super if i18n_keys.empty?
+
+              base = keys.empty? ? self : super(opts.slice(keys))
+
+              i18n_keys.inject(base) do |query, key|
+                backend_class = @klass.mobility_backend_class(key)
+                dir, node = opts[key], backend_node(key)
+                backend_class.apply_scope(query, node).order(node.send(dir.downcase))
+              end
+            else
+              super
+            end
+          end
+
           # Return backend node for attribute name.
           # @param [Symbol,String] name Name of attribute
           # @param [Symbol] locale Locale
@@ -108,38 +126,42 @@ enabled for any one attribute on the model.
           end
 
           module QueryBuilder
+            IDENTITY = ->(x) { x }.freeze
+
             class << self
-              def build(scope, where_opts, invert: false)
+              def build(scope, where_opts, invert: false, &block)
                 return yield unless Hash === where_opts
 
                 opts = where_opts.with_indifferent_access
                 locale = opts.delete(:locale) || Mobility.locale
 
-                maps = build_maps!(scope, opts, locale, invert: invert)
-                return yield if maps.empty?
-
-                base = opts.empty? ? scope : yield(opts)
-                maps.inject(base) { |rel, map| map[rel] }
+                _build(scope, opts, locale, invert, &block)
               end
 
               private
 
-              def build_maps!(scope, opts, locale, invert:)
-                keys = opts.keys.map(&:to_s)
+              # Builds a translated relation for a given opts hash and optional
+              # invert boolean.
+              def _build(scope, opts, locale, invert)
+                keys, predicates = opts.keys.map(&:to_s), []
 
-                scope.mobility_modules.map { |mod|
-                  next if (i18n_keys = mod.names & keys).empty?
+                query_map = scope.mobility_modules.inject(IDENTITY) do |qm, mod|
+                  i18n_keys = mod.names & keys
+                  next qm if i18n_keys.empty?
 
-                  predicates = i18n_keys.map do |key|
+                  mod_predicates = i18n_keys.map do |key|
                     build_predicate(scope.backend_node(key.to_sym, locale), opts.delete(key))
                   end
+                  invert_predicates!(mod_predicates) if invert
+                  predicates += mod_predicates
 
-                  ->(relation) do
-                    relation = mod.backend_class.apply_scope(relation, predicates, locale, invert: invert)
-                    predicates = predicates.map(&method(:invert_predicate)) if invert
-                    relation.where(predicates.inject(&:and))
-                  end
-                }.compact
+                  ->(r) { mod.backend_class.apply_scope(qm[r], mod_predicates, locale, invert: invert) }
+                end
+
+                return yield if query_map == IDENTITY
+
+                relation = opts.empty? ? scope : yield(opts)
+                query_map[relation.where(predicates.inject(&:and))]
               end
 
               def build_predicate(node, values)
@@ -156,15 +178,19 @@ enabled for any one attribute on the model.
                 Array.wrap(values).uniq.partition(&:nil?)
               end
 
+              def invert_predicates!(predicates)
+                predicates.map!(&method(:invert_predicate))
+              end
+
               # Adapted from AR::Relation::WhereClause#invert_predicate
-              def invert_predicate(node)
-                case node
+              def invert_predicate(predicate)
+                case predicate
                 when ::Arel::Nodes::In
-                  ::Arel::Nodes::NotIn.new(node.left, node.right)
+                  ::Arel::Nodes::NotIn.new(predicate.left, predicate.right)
                 when ::Arel::Nodes::Equality
-                  ::Arel::Nodes::NotEqual.new(node.left, node.right)
+                  ::Arel::Nodes::NotEqual.new(predicate.left, predicate.right)
                 else
-                  ::Arel::Nodes::Not.new(node)
+                  ::Arel::Nodes::Not.new(predicate)
                 end
               end
             end

data/lib/mobility/plugins/locale_accessors.rb

@@ -10,7 +10,8 @@ locales directly with a method call, using a suffix including the locale:
   article.title_pt_br
 
 If no locales are passed as an option to the initializer,
-+I18n.available_locales+ will be used by default.
++Mobility.available_locales+ (i.e. +I18n.available_locales+, or Rails-set
+available locales for a Rails application) will be used by default.
 
 @example
   class Post
@@ -41,7 +42,7 @@ If no locales are passed as an option to the initializer,
 
       # @param [String] One or more attribute names
       # @param [Array<Symbol>] Locales
-      def initialize(*attribute_names, locales: I18n.available_locales)
+      def initialize(*attribute_names, locales:)
         attribute_names.each do |name|
           locales.each do |locale|
             define_reader(name, locale)

data/lib/mobility/plugins/query.rb

@@ -20,6 +20,9 @@ module Mobility
           if Loaded::ActiveRecord && attributes.model_class < ::ActiveRecord::Base
             require "mobility/plugins/active_record/query"
             ActiveRecord::Query.apply(attributes)
+          elsif Loaded::Sequel && attributes.model_class < ::Sequel::Model
+            require "mobility/plugins/sequel/query"
+            Sequel::Query.apply(attributes)
           end
         end
       end

data/lib/mobility/plugins/sequel/query.rb

@@ -0,0 +1,140 @@
+# frozen-string-literal: true
+module Mobility
+  module Plugins
+=begin
+
+See ActiveRecord::Query plugin.
+
+=end
+    module Sequel
+      module Query
+        class << self
+          def apply(attributes)
+            attributes.model_class.class_eval do
+              extend QueryMethod
+              singleton_class.send :alias_method, Mobility.query_method, :__mobility_query_dataset__
+            end
+          end
+        end
+
+        module QueryMethod
+          def __mobility_query_dataset__(locale: Mobility.locale, &block)
+            if block_given?
+              VirtualRow.build_query(self, locale, &block)
+            else
+              dataset.with_extend(QueryExtension)
+            end
+          end
+        end
+
+        # Internal class to create a "clean room" for manipulating translated
+        # attribute nodes in an instance-eval'ed block. Inspired by Sequel's
+        # (much more sophisticated) virtual rows.
+        class VirtualRow < BasicObject
+          attr_reader :__backends
+
+          def initialize(model_class, locale)
+            @model_class, @locale, @__backends = model_class, locale, []
+          end
+
+          def method_missing(m, *)
+            if @model_class.mobility_attribute?(m)
+              @__backends |= [@model_class.mobility_backend_class(m)]
+              @model_class.mobility_backend_class(m).build_op(m.to_s, @locale)
+            elsif @model_class.columns.include?(m.to_s)
+              ::Sequel::SQL::QualifiedIdentifier.new(@model_class.table_name, m)
+            else
+              super
+            end
+          end
+
+          class << self
+            def build_query(klass, locale, &block)
+              row = new(klass, locale)
+              query = block.arity.zero? ? row.instance_eval(&block) : block.call(row)
+
+              if ::Sequel::Dataset === query
+                predicates = query.opts[:where]
+                prepare_datasets(query, row.__backends, locale, predicates)
+              else
+                prepare_datasets(klass.dataset, row.__backends, locale, query).where(query)
+              end
+            end
+
+            private
+
+            def prepare_datasets(dataset, backends, locale, predicates)
+              backends.inject(dataset) { |ds, b| b.prepare_dataset(ds, predicates, locale) }
+            end
+          end
+        end
+        private_constant :QueryMethod, :VirtualRow
+
+        module QueryExtension
+          %w[exclude or where].each do |method_name|
+            module_eval <<-EOM, __FILE__, __LINE__ + 1
+            def #{method_name}(*conds, &block)
+              QueryBuilder.build(self, #{method_name.inspect}, conds) do |untranslated_conds|
+                untranslated_conds ? super(untranslated_conds, &block) : super
+              end
+            end
+            EOM
+          end
+
+          # Return backend node for attribute name.
+          # @param [Symbol,String] name Name of attribute
+          # @param [Symbol] locale Locale
+          # @return [Arel::Node] Arel node for this attribute in given locale
+          def backend_op(name, locale = Mobility.locale)
+            model.mobility_backend_class(name)[name, locale]
+          end
+        end
+
+        module QueryBuilder
+          IDENTITY = ->(x) { x }.freeze
+
+          class << self
+            def build(dataset, query_method, query_conds, &block)
+              return yield unless Hash === query_conds.first
+
+              cond = query_conds.first.dup
+              locale = cond.delete(:locale) || Mobility.locale
+
+              _build(dataset, cond, locale, query_method, &block)
+            end
+
+            private
+
+            def _build(dataset, cond, locale, query_method)
+              keys, predicates = cond.keys, []
+              model = dataset.model
+
+              query_map = model.mobility_modules.inject(IDENTITY) do |qm, mod|
+                i18n_keys = mod.names.map(&:to_sym) & keys
+                next qm if i18n_keys.empty?
+
+                mod_predicates = i18n_keys.map do |key|
+                  build_predicate(dataset.backend_op(key, locale), cond.delete(key))
+                end
+                predicates += mod_predicates
+
+                ->(ds) { mod.backend_class.prepare_dataset(qm[ds], mod_predicates, locale) }
+              end
+
+              return yield if query_map == IDENTITY
+
+              predicates = ::Sequel.&(*predicates, cond) unless cond.empty?
+              query_map[dataset.public_send(query_method, ::Sequel.&(*predicates))]
+            end
+
+            def build_predicate(op, values)
+              vals = values.is_a?(Array) ? values.uniq: [values]
+              vals = vals.first if vals.size == 1
+              op =~ vals
+            end
+          end
+        end
+      end
+    end
+  end
+end