mobility 0.6.0 → 0.7.0

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

@@ -25,17 +25,6 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
 
       require 'mobility/backends/sequel/key_value/query_methods'
 
-      # @return [Class] translation model class
-      attr_reader :class_name
-
-      # @!macro backend_constructor
-      # @option options [Symbol] association_name Name of association
-      # @option options [Class] class_name Translation model class
-      def initialize(model, attribute, options = {})
-        super
-        @class_name = options[:class_name]
-      end
-
       # @!group Backend Configuration
       # @option (see Mobility::Backends::KeyValue::ClassMethods#configure)
       # @raise (see Mobility::Backends::KeyValue::ClassMethods#configure)

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

@@ -35,8 +35,7 @@ jsonb).
         end
 
         setup do |attributes, options|
-          column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
-          columns = attributes.map { |attribute| (column_affix % attribute).to_sym }
+          columns = attributes.map { |attribute| (options[:column_affix] % attribute).to_sym }
 
           before_validation = Module.new do
             define_method :before_validation do
@@ -48,7 +47,7 @@ jsonb).
           end
           include before_validation
           include Mobility::Sequel::HashInitializer.new(*columns)
-          include Mobility::Sequel::ColumnChanges.new(attributes, column_affix: column_affix)
+          include Mobility::Sequel::ColumnChanges.new(attributes, column_affix: options[:column_affix])
 
           plugin :defaults_setter
           columns.each { |column| default_values[column] = {} }

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

@@ -30,7 +30,7 @@ for hstore/json/jsonb/container backends.)
 
         def initialize(attributes, options)
           super
-          @column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
+          @column_affix = options[:column_affix]
           define_query_methods
         end
 

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

@@ -13,11 +13,11 @@ models. For details see backend-specific subclasses.
       class QueryMethods < Module
         # @param [Array<String>] attributes Translated attributes
         def initialize(attributes, _)
-          @attributes = attributes.map!(&:to_sym)
+          @attributes = attributes.map(&:to_sym)
 
-          attributes.each do |attribute|
+          @attributes.each do |attribute|
             define_method :"first_by_#{attribute}" do |value|
-              where(attribute.to_sym => value).select_all(model.table_name).first
+              where(attribute => value).select_all(model.table_name).first
             end
           end
         end

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

@@ -43,14 +43,14 @@ Sequel serialization plugin.
       # @option (see Backends::Serialized.configure)
       # @raise (see Backends::Serialized.configure)
       def self.configure(options)
+        super
         Serialized.configure(options)
       end
       # @!endgroup
 
       setup do |attributes, options|
         format = options[:format]
-        column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
-        columns = attributes.map { |attribute| (column_affix % attribute).to_sym }
+        columns = attributes.map { |attribute| (options[:column_affix] % attribute).to_sym }
 
         plugin :serialization
         plugin :serialization_modification_detection

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

@@ -14,17 +14,16 @@ Implements the {Mobility::Backends::Table} backend for Sequel models.
     class Sequel::Table
       include Sequel
       include Table
-      include Util
 
       require 'mobility/backends/sequel/table/query_methods'
 
-      # @return [Symbol] class for translations
-      attr_reader :translation_class
+      def translation_class
+        self.class.translation_class
+      end
 
-      # @!macro backend_constructor
-      def initialize(model, attribute, options = {})
-        super
-        @translation_class = options[:model_class].const_get(options[:subclass_name])
+      # @return [Symbol] class for translations
+      def self.translation_class
+        @translation_class ||= model_class.const_get(subclass_name)
       end
 
       # @!group Backend Configuration
@@ -35,11 +34,11 @@ Implements the {Mobility::Backends::Table} backend for Sequel models.
       # @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 = options[:model_class].table_name
-        options[:table_name]  ||= :"#{singularize(table_name)}_translations"
-        options[:foreign_key] ||= foreign_key(camelize(singularize(table_name.to_s.downcase)))
+        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] ||= camelize(singularize(association_name))
+          options[:subclass_name] ||= Util.camelize(Util.singularize(association_name))
         else
           options[:association_name] = :translations
           options[:subclass_name] ||= :Translation

data/lib/mobility/backends/table.rb

@@ -66,16 +66,21 @@ set.
 =end
     module Table
       extend Backend::OrmDelegator
+      # @!method association_name
+      #   Returns the name of the translations association.
+      #   @return [Symbol] Name of the association
 
-      # @return [Symbol] name of the association method
-      attr_reader :association_name
+      # @!method subclass_name
+      #   Returns translation subclass under model class namespace.
+      #   @return [Symbol] Name of translation subclass
 
-      # @!macro backend_constructor
-      # @option options [Symbol] association_name Name of association
-      def initialize(model, attribute, options = {})
-        super
-        @association_name = options[:association_name]
-      end
+      # @!method foreign_key
+      #   Returns foreign_key for translations association.
+      #   @return [Symbol] Name of foreign key
+
+      # @!method table_name
+      #   Returns name of table where translations are stored.
+      #   @return [Symbol] Name of translations table
 
       # @!group Backend Accessors
       # @!macro backend_reader
@@ -102,6 +107,10 @@ set.
 
       def self.included(backend)
         backend.extend ClassMethods
+        backend.option_reader :association_name
+        backend.option_reader :subclass_name
+        backend.option_reader :foreign_key
+        backend.option_reader :table_name
       end
 
       module ClassMethods

data/lib/mobility/configuration.rb

@@ -106,10 +106,13 @@ default_fallbacks= will be removed in the next major version of Mobility.
       @fallbacks_generator = lambda { |fallbacks| Mobility::Fallbacks.build(fallbacks) }
       @default_accessor_locales = lambda { I18n.available_locales }
       @default_options = Options[{
-        cache: true,
+        cache:    true,
         presence: true,
+        query:    true,
+        default:  Plugins::OPTION_UNSET
       }]
       @plugins = %i[
+        query
         cache
         dirty
         fallbacks

data/lib/mobility/plugins.rb

@@ -31,5 +31,6 @@ option value. For examples, see classes under the {Mobility::Plugins} namespace.
 
 =end
   module Plugins
+    OPTION_UNSET = Object.new
   end
 end

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

@@ -0,0 +1,192 @@
+# frozen-string-literal: true
+module Mobility
+  module Plugins
+=begin
+
+Adds a scope which enables querying on translated attributes using +where+ and
++not+ as if they were normal attributes. Under the hood, this plugin uses the
+generic +build_node+ and +apply_scope+ methods implemented in each backend
+class to build ActiveRecord queries from Arel nodes. The plugin also adds
++find_by_<attribute>+ shortcuts for translated attributes.
+
+The query scope applies to all translated attributes once the plugin has been
+enabled for any one attribute on the model.
+
+=end
+    module ActiveRecord
+      module Query
+        class << self
+          def apply(attributes)
+            model_class = attributes.model_class
+
+            model_class.class_eval do
+              extend QueryMethod
+              extend FindByMethods.new(*attributes.names)
+              singleton_class.send :alias_method, Mobility.query_method, :__mobility_query_scope__
+            end
+          end
+        end
+
+        module QueryMethod
+          def __mobility_query_scope__(locale: Mobility.locale, &block)
+            if block_given?
+              VirtualRow.build_query(self, locale, &block)
+            else
+              all.extending(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_attributes.include?(m.to_s)
+              @__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)
+              @model_class.arel_table[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 ::ActiveRecord::Relation === query
+                predicates = query.arel.constraints
+                apply_scopes(klass.all, row.__backends, locale, predicates).merge(query)
+              else
+                apply_scopes(klass.all, row.__backends, locale, query).where(query)
+              end
+            end
+
+            private
+
+            def apply_scopes(scope, backends, locale, predicates)
+              backends.inject(scope) { |r, b| b.apply_scope(r, predicates, locale) }
+            end
+          end
+        end
+        private_constant :QueryMethod, :VirtualRow
+
+        module QueryExtension
+          def where!(opts, *rest)
+            QueryBuilder.build(self, opts) do |untranslated_opts|
+              untranslated_opts ? super(untranslated_opts, *rest) : super
+            end
+          end
+
+          def where(opts = :chain, *rest)
+            opts == :chain ? WhereChain.new(spawn) : super
+          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_node(name, locale = Mobility.locale)
+            @klass.mobility_backend_class(name)[name, locale]
+          end
+
+          class WhereChain < ::ActiveRecord::QueryMethods::WhereChain
+            def not(opts, *rest)
+              QueryBuilder.build(@scope, opts, invert: true) do |untranslated_opts|
+                untranslated_opts ? super(untranslated_opts, *rest) : super
+              end
+            end
+          end
+
+          module QueryBuilder
+            class << self
+              def build(scope, where_opts, invert: false)
+                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] }
+              end
+
+              private
+
+              def build_maps!(scope, opts, locale, invert:)
+                keys = opts.keys.map(&:to_s)
+
+                scope.mobility_modules.map { |mod|
+                  next if (i18n_keys = mod.names & keys).empty?
+
+                  predicates = i18n_keys.map do |key|
+                    build_predicate(scope.backend_node(key.to_sym, locale), opts.delete(key))
+                  end
+
+                  ->(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
+              end
+
+              def build_predicate(node, values)
+                nils, vals = partition_values(values)
+
+                return node.eq(nil) if vals.empty?
+
+                predicate = vals.length == 1 ? node.eq(vals.first) : node.in(vals)
+                predicate = predicate.or(node.eq(nil)) unless nils.empty?
+                predicate
+              end
+
+              def partition_values(values)
+                Array.wrap(values).uniq.partition(&:nil?)
+              end
+
+              # Adapted from AR::Relation::WhereClause#invert_predicate
+              def invert_predicate(node)
+                case node
+                when ::Arel::Nodes::In
+                  ::Arel::Nodes::NotIn.new(node.left, node.right)
+                when ::Arel::Nodes::Equality
+                  ::Arel::Nodes::NotEqual.new(node.left, node.right)
+                else
+                  ::Arel::Nodes::Not.new(node)
+                end
+              end
+            end
+          end
+
+          private_constant :WhereChain, :QueryBuilder
+        end
+
+        class FindByMethods < Module
+          def initialize(*attributes)
+            attributes.each do |attribute|
+              module_eval <<-EOM, __FILE__, __LINE__ + 1
+              def find_by_#{attribute}(value)
+                find_by(#{attribute}: value)
+              end
+              EOM
+            end
+          end
+        end
+
+        private_constant :QueryExtension, :FindByMethods
+      end
+    end
+  end
+end

data/lib/mobility/plugins/cache.rb

@@ -37,9 +37,8 @@ Values are added to the cache in two ways:
       # @group Backend Accessors
       #
       # @!macro backend_reader
-      # @option options [Boolean] cache
-      #   *false* to disable cache.
       # @!method read(locale, value, options = {})
+      #   @option options [Boolean] cache *false* to disable cache.
       include TranslationCacher.new(:read)
 
       # @!macro backend_writer

data/lib/mobility/plugins/default.rb

@@ -5,7 +5,9 @@ module Mobility
 =begin
 
 Defines value or proc to fall through to if return value from getter would
-otherwise be nil.
+otherwise be nil. This plugin is disabled by default but will be enabled if any
+value (other than +Mobility::Plugins::OPTION_UNSET+) is passed as the +default+
+option key.
 
 If default is a +Proc+, it will be called with the context of the model, and
 passed arguments:
@@ -60,27 +62,39 @@ The proc can accept zero to three arguments (see examples below)
   post.title(default: lambda { self.class.name.to_s })
   #=> "Post"
 =end
-    class Default < Module
+    module Default
       # Applies default plugin to attributes.
       # @param [Attributes] attributes
       # @param [Object] option
       def self.apply(attributes, option)
-        attributes.backend_class.include(new(option))
+        attributes.backend_class.include(self) unless option == Plugins::OPTION_UNSET
       end
 
-      def initialize(default_option)
-        define_method :read do |locale, options = {}|
-          default = options.has_key?(:default) ? options.delete(:default) : default_option
-          if (value = super(locale, options)).nil?
-            return default unless default.is_a?(Proc)
-            args = [attribute, locale, options]
-            args = args.first(default.arity) unless default.arity < 0
-            model.instance_exec(*args, &default)
-          else
-            value
-          end
+      # Generate a default value for given parameters.
+      # @param [Object, Proc] default_value A default value or Proc
+      # @param [Symbol] locale
+      # @param [Hash] accessor_options
+      # @param [String] attribute
+      def self.[](default_value, locale:, accessor_options:, model:, attribute:)
+        return default_value unless default_value.is_a?(Proc)
+        args = [attribute, locale, accessor_options]
+        args = args.first(default_value.arity) unless default_value.arity < 0
+        model.instance_exec(*args, &default_value)
+      end
+
+      # @!group Backend Accessors
+      # @!macro backend_reader
+      # @option accessor_options [Boolean] default
+      #   *false* to disable presence filter.
+      def read(locale, accessor_options = {})
+        default = accessor_options.has_key?(:default) ? accessor_options.delete(:default) : options[:default]
+        if (value = super(locale, accessor_options)).nil?
+          Default[default, locale: locale, accessor_options: accessor_options, model: model, attribute: attribute]
+        else
+          value
         end
       end
+      # @!endgroup
     end
   end
 end