mobility 1.0.7 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddbf8662456ee4b547ed3ead85fd44a3af486cbe94d85ad77679f811a7a5b98d
-  data.tar.gz: 62fed63232e0bf182db5fdf9994ca3d2f50b61872b9e3c0bf4d1b4c7cf739698
+  metadata.gz: b22675841d6b6330a4db417e3576767b42a81614b80cf376a208088ad9432de4
+  data.tar.gz: 1b2c44b38c87fc0b1e8ca5e463e9c265c09f0d307d0d663ba3aa39b6b5ca771b
 SHA512:
-  metadata.gz: 449d4f885917546ffe9dab2678e39d597ecc340028e0e09293073487b8f8269ee097cea0b1ee28232cf04c05a1598d1e65be4d0be72b63b27f7e5cc543ab49bb
-  data.tar.gz: 19f561713598217a2f8cf18aee0d906076086adf254995d7ddaccbd3e4d5b3db27f3d402f189d935538b1ef84d8e1fe33471af746a7c8d502095baa8f9cadd12
+  metadata.gz: 708d6ba16ec279e6a114abc811d107aa759590c711ca389d7f4b86407e100fbaed30a38b7b787ef98008291c480715949b0d4562efc2d5120eba73587fc375db
+  data.tar.gz: bd8f79dd23f7c482292c011bb800d7db20dc3b1fb06797b53fdf91ecdb9c9895c1634e3b1da06e90cff4e7b32e4aa5ebdf8f5d8b5c76f1fafbc08ca891ac99dc

data/CHANGELOG.md

@@ -1,6 +1,8 @@
 # Mobility Changelog
 
-### Unreleased
+## 1.1
+
+### 1.1.0
 - Remove `Mobility::Plugins::Attributes#each`
   ([#475](https://github.com/shioyama/mobility/pull/475))
 - Add public method `Mobility::Plugins::ActiveRecord::Query.build_query`

data/Gemfile.lock

@@ -1,13 +1,24 @@
 PATH
   remote: .
   specs:
-    mobility (1.0.6)
+    mobility (1.0.7)
       i18n (>= 0.6.10, < 2)
       request_store (~> 1.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activemodel (6.0.3.4)
+      activesupport (= 6.0.3.4)
+    activerecord (6.0.3.4)
+      activemodel (= 6.0.3.4)
+      activesupport (= 6.0.3.4)
+    activesupport (6.0.3.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2, >= 2.2.2)
     benchmark-ips (2.8.4)
     byebug (11.1.3)
     coderay (1.1.3)
@@ -37,6 +48,7 @@ GEM
       rb-inotify (~> 0.9, >= 0.9.10)
     lumberjack (1.2.8)
     method_source (1.0.0)
+    minitest (5.14.3)
     nenv (0.3.0)
     notiffany (0.1.3)
       nenv (~> 0.1)
@@ -68,15 +80,19 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.2)
-    sequel (5.41.0)
     shellany (0.0.1)
     thor (1.1.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.9)
+      thread_safe (~> 0.1)
     yard (0.9.26)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activerecord (~> 6.0.0)
   benchmark-ips
   database_cleaner (~> 1.5, >= 1.5.3)
   guard-rspec
@@ -85,7 +101,6 @@ DEPENDENCIES
   pry-byebug
   rake (~> 12, >= 12.2.1)
   rspec (~> 3.0)
-  sequel (~> 5.0)
   yard (~> 0.9.0)
 
 BUNDLED WITH

data/README.md

@@ -52,17 +52,16 @@ section of the wiki.
 Installation
 ------------
 
-To use the latest pre-version of Mobility 1.0, add this line to your
-application's Gemfile:
+Add this line to your application's Gemfile:
 
 ```ruby
-gem 'mobility', '~> 1.0.7'
+gem 'mobility', '~> 1.1.0'
 ```
 
 ### ActiveRecord (Rails)
 
 Requirements:
-- ActiveRecord >= 5.0 (including 6.0)
+- ActiveRecord >= 5.0 (including 6.x)
 
 (Support for most backends and features is also supported with
 ActiveRecord/Rails 4.2, but there are some tests still failing. To see exactly

data/lib/mobility.rb

@@ -31,8 +31,9 @@ So the above example is equivalent to:
 `Mobility.translations_class` is a subclass of `Mobility::Translations` created
 when `Mobility.configure` is called to configure Mobility. In fact, when you
 call `Mobility.configure`, it is the subclass of `Mobility::Translations` which
-is passed to the block as `config`. Plugins and plugin configuration is all
-applied to the same `Mobility.translations_class`.
+is passed to the block as `config` (or as `self` if no argument is passed to
+the block). Plugins and plugin configuration is all applied to the same
+`Mobility.translations_class`.
 
 There is another way to use Mobility, which is to create your own subclass or
 subclasses of +Mobility::Translations+ and include them explicitly, without
@@ -83,8 +84,6 @@ module Mobility
   require "mobility/plugins"
   require "mobility/translations"
 
-  # General error for version compatibility conflicts
-  class VersionNotSupportedError < ArgumentError; end
   CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
   private_constant :CALL_COMPILABLE_REGEXP
 
@@ -201,6 +200,14 @@ module Mobility
       end
     end
 
+    # Check that a non-nil locale is valid. (Does not actually parse locale to
+    # check its format.)
+    # @raise [InvalidLocale] if locale is not a Symbol or not available
+    def validate_locale!(locale)
+      raise Mobility::InvalidLocale.new(locale) unless Symbol === locale
+      enforce_available_locales!(locale) if I18n.enforce_available_locales
+    end
+
     # Raises InvalidLocale exception if the locale passed in is present but not available.
     # @param [String,Symbol] locale
     # @raise [InvalidLocale] if locale is present but not available
@@ -217,7 +224,7 @@ module Mobility
     #   simply default to +I18n.available_locales+, we may define many more
     #   methods (in LocaleAccessors) than is really necessary.
     def available_locales
-      if defined?(Rails) && Rails.application
+      if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
         Rails.application.config.i18n.available_locales&.map(&:to_sym) || I18n.available_locales
       else
         I18n.available_locales
@@ -231,8 +238,8 @@ module Mobility
     end
 
     def set_locale(locale)
-      locale = locale.to_sym if locale
-      enforce_available_locales!(locale) if I18n.enforce_available_locales
+      locale = locale.to_sym if String === locale
+      validate_locale!(locale) if locale
       storage[:mobility_locale] = locale
     end
   end

data/lib/mobility/backend.rb

@@ -17,8 +17,10 @@ On top of this, a backend will normally:
 - implement a +write+ instance method to write to the backend
 - implement an +each_locale+ instance method to iterate through available locales
   (used to define other +Enumerable+ traversal and search methods)
+- implement a +valid_keys+ class method returning an array of symbols
+  corresponding to valid keys for configuring this backend.
 - implement a +configure+ class method to apply any normalization to the
-  options hash
+  keys on the options hash included in +valid_keys+
 - call the +setup+ method yielding attributes and options to configure the
   model class
 

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

@@ -37,7 +37,6 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
             options[:association_name] ||= :"#{options[:type]}_translations"
             options[:class_name]       ||= const_get("#{type.capitalize}Translation")
           end
-          options[:table_alias_affix] = "#{model_class}_%s_#{options[:association_name]}"
         rescue NameError
           raise ArgumentError, "You must define a Mobility::Backends::ActiveRecord::KeyValue::#{type.capitalize}Translation class."
         end
@@ -49,7 +48,7 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
         #   translation table value column
         def build_node(attr, locale)
           aliased_table = class_name.arel_table.alias(table_alias(attr, locale))
-          Plugins::Arel::Attribute.new(aliased_table, :value, locale, self, attr.to_sym)
+          Plugins::Arel::Attribute.new(aliased_table, value_column, locale, self, attr.to_sym)
         end
 
         # Joins translations using either INNER/OUTER join appropriate to the query.
@@ -73,10 +72,10 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
           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).
+                         on(t[key_column].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)
+                                and(t[:"#{belongs_to}_type"].eq(model_class.base_class.name).
+                                    and(t[:"#{belongs_to}_id"].eq(m[:id]))))).join_sources)
         end
 
         def already_joined?(relation, name, locale, join_type)
@@ -151,8 +150,11 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
       end
 
       setup do |attributes, options|
-        association_name   = options[:association_name]
-        translations_class = options[:class_name]
+        association_name  = options[:association_name]
+        translation_class = options[:class_name]
+        key_column         = options[:key_column]
+        value_column       = options[:value_column]
+        belongs_to         = options[:belongs_to]
 
         # Track all attributes for this association, so that we can limit the scope
         # of keys for the association to only these attributes. We need to track the
@@ -163,13 +165,13 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
         association_attributes = (instance_variable_get(:"@#{attrs_method_name}") || []) + attributes
         instance_variable_set(:"@#{attrs_method_name}", association_attributes)
 
-        has_many association_name, ->{ where key: association_attributes },
-          as: :translatable,
-          class_name: translations_class.name,
-          inverse_of: :translatable,
+        has_many association_name, ->{ where key_column => association_attributes },
+          as: belongs_to,
+          class_name: translation_class.name,
+          inverse_of: belongs_to,
           autosave:   true
         before_save do
-          send(association_name).select { |t| t.value.blank? }.each do |translation|
+          send(association_name).select { |t| t.send(value_column).blank? }.each do |translation|
             send(association_name).destroy(translation)
           end
         end
@@ -181,33 +183,32 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
               super(source)
               self.send("#{association_name}=", source.send(association_name).map(&:dup))
               # Set inverse on associations
-              send(association_name).each { |translation| translation.translatable = self }
+              send(association_name).each do |translation|
+                translation.send(:"#{belongs_to}=", self)
+              end
             end
           end
           include const_set(module_name, callback_methods)
         end
 
-        include DestroyKeyValueTranslations
+        # Ensure we only call after destroy hook once per translations class
+        translation_classes = [translation_class, *Mobility::Backends::ActiveRecord::KeyValue::Translation.descendants].uniq
+        after_destroy do
+          @mobility_after_destroy_translation_classes = [] unless defined?(@mobility_after_destroy_translation_classes)
+          (translation_classes - @mobility_after_destroy_translation_classes).each { |klass| klass.where(belongs_to => self).destroy_all }
+          @mobility_after_destroy_translation_classes += translation_classes
+        end
       end
 
       # Returns translation for a given locale, or builds one if none is present.
       # @param [Symbol] locale
       # @return [Mobility::Backends::ActiveRecord::KeyValue::TextTranslation,Mobility::Backends::ActiveRecord::KeyValue::StringTranslation]
       def translation_for(locale, **)
-        translation = translations.find { |t| t.key == attribute && t.locale == locale.to_s }
-        translation ||= translations.build(locale: locale, key: attribute)
-        translation
-      end
-
-      module DestroyKeyValueTranslations
-        def self.included(model_class)
-          model_class.after_destroy do
-            [:string, :text].each do |type|
-              Mobility::Backends::ActiveRecord::KeyValue.const_get("#{type.capitalize}Translation").
-                where(translatable: self).destroy_all
-            end
-          end
+        translation = translations.find do |t|
+          t.send(key_column) == attribute && t.locale == locale.to_s
         end
+        translation ||= translations.build(locale: locale, key_column => attribute)
+        translation
       end
 
       class Translation < ::ActiveRecord::Base

data/lib/mobility/backends/key_value.rb

@@ -55,18 +55,18 @@ other backends on model (otherwise one will overwrite the other).
       # @!group Backend Accessors
       # @!macro backend_reader
       def read(locale, **options)
-        translation_for(locale, **options).value
+        translation_for(locale, **options).send(value_column)
       end
 
       # @!macro backend_writer
       def write(locale, value, **options)
-        translation_for(locale, **options).value = value
+        translation_for(locale, **options).send(:"#{value_column}=", value)
       end
       # @!endgroup
 
       # @!macro backend_iterator
       def each_locale
-        translations.each { |t| yield(t.locale.to_sym) if t.key == attribute }
+        translations.each { |t| yield(t.locale.to_sym) if t.send(key_column) == attribute }
       end
 
       private
@@ -79,12 +79,14 @@ other backends on model (otherwise one will overwrite the other).
         backend_class.extend ClassMethods
         backend_class.option_reader :association_name
         backend_class.option_reader :class_name
-        backend_class.option_reader :table_alias_affix
+        backend_class.option_reader :key_column
+        backend_class.option_reader :value_column
+        backend_class.option_reader :belongs_to
       end
 
       module ClassMethods
         def valid_keys
-          [:type, :association_name, :class_name]
+          [:type, :association_name, :class_name, :key_column, :value_column, :belongs_to]
         end
 
         # @!group Backend Configuration
@@ -99,6 +101,9 @@ other backends on model (otherwise one will overwrite the other).
           options[:type]             &&= options[:type].to_sym
           options[:association_name] &&= options[:association_name].to_sym
           options[:class_name]       &&= Util.constantize(options[:class_name])
+          options[:key_column]       ||= :key
+          options[:value_column]     ||= :value
+          options[:belongs_to]       ||= :translatable
           if !(options[:type] || (options[:class_name] && options[:association_name]))
             raise ArgumentError, "KeyValue backend requires an explicit type option, either text or string."
           end
@@ -110,7 +115,7 @@ other backends on model (otherwise one will overwrite the other).
         end
 
         def table_alias(attr, locale)
-          table_alias_affix % "#{attr}_#{Mobility.normalize_locale(locale)}"
+          "#{model_class}_#{attr}_#{Mobility.normalize_locale(locale)}_#{options[:association_name]}"
         end
       end
 

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

@@ -32,14 +32,13 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
             options[:association_name] ||= :"#{options[:type]}_translations"
             options[:class_name]       ||= const_get("#{type.capitalize}Translation")
           end
-          options[:table_alias_affix] = "#{model_class}_%s_#{options[:association_name]}"
         rescue NameError
           raise ArgumentError, "You must define a Mobility::Sequel::#{type.capitalize}Translation class."
         end
         # @!endgroup
 
         def build_op(attr, locale)
-          QualifiedIdentifier.new(table_alias(attr, locale), :value, locale, self, attr)
+          QualifiedIdentifier.new(table_alias(attr, locale), value_column, locale, self, attr)
         end
 
         # @param [Sequel::Dataset] dataset Dataset to prepare
@@ -58,10 +57,10 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
           dataset.join_table(join_type,
                              class_name.table_name,
                              {
-                               key: attr.to_s,
-                               locale: locale.to_s,
-                               translatable_type: model_class.name,
-                               translatable_id: ::Sequel[:"#{model_class.table_name}"][:id]
+                               key_column => attr.to_s,
+                               :locale => locale.to_s,
+                               :"#{belongs_to}_type" => model_class.name,
+                               :"#{belongs_to}_id" => ::Sequel[:"#{model_class.table_name}"][:id]
                              },
                              table_alias: table_alias(attr, locale))
         end
@@ -127,27 +126,37 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
       backend = self
 
       setup do |attributes, options|
-        association_name   = options[:association_name]
-        translations_class = options[:class_name]
-
+        association_name  = options[:association_name]
+        translation_class = options[:class_name]
+        key_column        = options[:key_column]
+        value_column      = options[:value_column]
+        belongs_to        = options[:belongs_to]
+        belongs_to_id     = :"#{belongs_to}_id"
+        belongs_to_type   = :"#{belongs_to}_type"
+
+        # Track all attributes for this association, so that we can limit the scope
+        # of keys for the association to only these attributes. We need to track the
+        # attributes assigned to the association in case this setup code is called
+        # multiple times, so we don't "forget" earlier attributes.
+        #
         attrs_method_name = :"#{association_name}_attributes"
         association_attributes = (instance_variable_get(:"@#{attrs_method_name}") || []) + attributes
         instance_variable_set(:"@#{attrs_method_name}", association_attributes)
 
         one_to_many association_name,
-          reciprocal:      :translatable,
-          key:             :translatable_id,
+          reciprocal:      belongs_to,
+          key:             belongs_to_id,
           reciprocal_type: :one_to_many,
-          conditions:      { translatable_type: self.to_s, key: association_attributes },
-          adder:           proc { |translation| translation.update(translatable_id: pk, translatable_type: self.class.to_s) },
-          remover:         proc { |translation| translation.update(translatable_id: nil, translatable_type: nil) },
-          clearer:         proc { send(:"#{association_name}_dataset").update(translatable_id: nil, translatable_type: nil) },
-          class:           translations_class
+          conditions:      { belongs_to_type => self.to_s, key_column => association_attributes },
+          adder:           proc { |translation| translation.update(belongs_to_id => pk, belongs_to_type => self.class.to_s) },
+          remover:         proc { |translation| translation.update(belongs_to_id => nil, belongs_to_type => nil) },
+          clearer:         proc { send_(:"#{association_name}_dataset").update(belongs_to_id => nil, belongs_to_type => nil) },
+          class:           translation_class
 
         callback_methods = Module.new do
           define_method :before_save do
             super()
-            send(association_name).select { |t| attributes.include?(t.key) && Util.blank?(t.value) }.each(&:destroy)
+            send(association_name).select { |t| attributes.include?(t.__send__(key_column)) && Util.blank?(t.__send__(value_column)) }.each(&:destroy)
           end
           define_method :after_save do
             super()
@@ -156,7 +165,17 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
         end
         include callback_methods
 
-        include DestroyKeyValueTranslations
+        # Clean up *all* leftover translations of this model, only once.
+        translation_classes = [translation_class, *Mobility::Backends::Sequel::KeyValue::Translation.descendants].uniq
+        define_method :after_destroy do
+          super()
+
+          @mobility_after_destroy_translation_classes = [] unless defined?(@mobility_after_destroy_translation_classes)
+          (translation_classes - @mobility_after_destroy_translation_classes).each do |klass|
+            klass.where(belongs_to_id => id, belongs_to_type => self.class.name).destroy
+          end
+          @mobility_after_destroy_translation_classes += translation_classes
+        end
         include(mod = Module.new)
         backend.define_column_changes(mod, attributes)
       end
@@ -165,30 +184,19 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
       # @param [Symbol] locale
       # @return [Mobility::Backends::Sequel::KeyValue::TextTranslation,Mobility::Backends::Sequel::KeyValue::StringTranslation]
       def translation_for(locale, **)
-        translation = model.send(association_name).find { |t| t.key == attribute && t.locale == locale.to_s }
-        translation ||= class_name.new(locale: locale, key: attribute)
+        translation = model.send(association_name).find { |t| t.__send__(key_column) == attribute && t.locale == locale.to_s }
+        translation ||= class_name.new(locale: locale, key_column => attribute)
         translation
       end
 
       # Saves translation which have been built and which have non-blank values.
       def save_translations
         cache.each_value do |translation|
-          next unless present?(translation.value)
+          next unless present?(translation.__send__ value_column)
           translation.id ? translation.save : model.send("add_#{singularize(association_name)}", translation)
         end
       end
 
-      # Clean up *all* leftover translations of this model, only once.
-      module DestroyKeyValueTranslations
-        def after_destroy
-          super
-          [:string, :text].freeze.each do |type|
-            Mobility::Backends::Sequel::KeyValue.const_get("#{type.capitalize}Translation").
-              where(translatable_id: id, translatable_type: self.class.name).destroy
-          end
-        end
-      end
-
       class CacheRequired < ::StandardError; end
 
       module Cache
@@ -212,8 +220,32 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
         end
       end
 
-      module Translation
-        def self.included(base)
+      class Translatable < Module
+        attr_reader :key_column, :value_column, :belongs_to, :id_column, :type_column
+
+        def initialize(key_column, value_column, belongs_to)
+          @key_column = key_column
+          @value_column = value_column
+          @belongs_to = belongs_to
+          @id_column = :"#{belongs_to}_id"
+          @type_column = :"#{belongs_to}_type"
+        end
+
+        # Strictly these are not "descendants", but to keep terminology
+        # consistent with ActiveRecord KeyValue backend.
+        def descendants
+          @descendants ||= Set.new
+        end
+
+        def included(base)
+          @descendants ||= Set.new
+          @descendants << base
+
+          mod = self
+          key_column = mod.key_column
+          id_column = mod.id_column
+          type_column = mod.type_column
+
           base.class_eval do
             plugin :validation_helpers
 
@@ -221,16 +253,16 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
             #
             model = underscore(self.to_s)
             plural_model = pluralize(model)
-            many_to_one :translatable,
+            many_to_one mod.belongs_to,
               reciprocal: plural_model.to_sym,
               reciprocal_type: :many_to_one,
               setter: (proc do |able_instance|
-                self[:translatable_id]   = (able_instance.pk if able_instance)
-                self[:translatable_type] = (able_instance.class.name if able_instance)
+                self[id_column]   = (able_instance.pk if able_instance)
+                self[type_column] = (able_instance.class.name if able_instance)
               end),
               dataset: (proc do
-                translatable_type = send :translatable_type
-                translatable_id   = send :translatable_id
+                translatable_type = send type_column
+                translatable_id   = send id_column
                 return if translatable_type.nil? || translatable_id.nil?
                 klass = self.class.send(:constantize, translatable_type)
                 klass.where(klass.primary_key => translatable_id)
@@ -238,29 +270,30 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
               eager_loader: (proc do |eo|
                 id_map = {}
                 eo[:rows].each do |model|
-                  model_able_type = model.send :translatable_type
-                  model_able_id = model.send :translatable_id
-                  model.associations[:translatable] = nil
+                  model_able_type = model.send type_column
+                  model_able_id = model.send id_column
+                  model.associations[belongs_to] = nil
                   ((id_map[model_able_type] ||= {})[model_able_id] ||= []) << model if !model_able_type.nil? && !model_able_id.nil?
                 end
                 id_map.each do |klass_name, id_map|
                   klass = constantize(camelize(klass_name))
                   klass.where(klass.primary_key=>id_map.keys).all do |related_obj|
                     id_map[related_obj.pk].each do |model|
-                      model.associations[:translatable] = related_obj
+                      model.associations[belongs_to] = related_obj
                     end
                   end
                 end
               end)
 
-            def validate
-              super
-              validates_presence [:locale, :key, :translatable_id, :translatable_type]
-              validates_unique   [:locale, :key, :translatable_id, :translatable_type]
+            define_method :validate do
+              super()
+              validates_presence [:locale, key_column, id_column, type_column]
+              validates_unique   [:locale, key_column, id_column, type_column]
             end
           end
         end
       end
+      Translation = Translatable.new(:key, :value, :translatable)
 
       class TextTranslation < ::Sequel::Model(:mobility_text_translations)
         include Translation

data/lib/mobility/plugins/active_record.rb

@@ -8,7 +8,9 @@ require_relative "./active_record/uniqueness_validation"
 module Mobility
 =begin
 
-Plugin for ActiveRecord models.
+Plugin for ActiveRecord models. This plugin automatically requires activerecord
+related plugins, which are not actually "active" unless their base plugin (e.g.
+dirty for active_record_dirty) is also enabled.
 
 =end
   module Plugins

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

@@ -3,6 +3,11 @@
 module Mobility
   module Plugins
     module ActiveRecord
+=begin
+
+Maps backend names to ActiveRecord namespaced backends.
+
+=end
       module Backend
         extend Plugin
 

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

@@ -29,7 +29,9 @@ enabled for any one attribute on the model.
             klass.class_eval do
               extend QueryMethod
               extend FindByMethods.new(*plugin.names)
-              singleton_class.send :alias_method, plugin.query_method, :__mobility_query_scope__
+              singleton_class.define_method(plugin.query_method) do |locale: Mobility.locale, &block|
+                Query.build_query(self, locale, &block)
+              end
             end
             backend_class.include BackendMethods
           end
@@ -39,6 +41,14 @@ enabled for any one attribute on the model.
           def attribute_alias(attribute, locale = Mobility.locale)
             "__mobility_%s_%s__"  % [attribute, ::Mobility.normalize_locale(locale)]
           end
+
+          def build_query(klass, locale = Mobility.locale, &block)
+            if block_given?
+              VirtualRow.build_query(klass, locale, &block)
+            else
+              klass.all.extending(QueryExtension)
+            end
+          end
         end
 
         module BackendMethods
@@ -57,13 +67,9 @@ enabled for any one attribute on the model.
         end
 
         module QueryMethod
-          # This is required for UniquenessValidator.
           def __mobility_query_scope__(locale: Mobility.locale, &block)
-            if block_given?
-              VirtualRow.build_query(self, locale, &block)
-            else
-              all.extending(QueryExtension)
-            end
+            warn '__mobility_query_scope__ is an internal method and will be deprecated in the next release.'
+            Query.build_query(self, locale, &block)
           end
         end
 
@@ -71,18 +77,21 @@ enabled for any one attribute on the model.
         # an instance-eval'ed block. Inspired by Sequel's (much more
         # sophisticated) virtual rows.
         class VirtualRow < BasicObject
-          attr_reader :__backends
+          attr_reader :backends, :locales
 
-          def initialize(model_class, locale)
-            @model_class, @locale, @__backends = model_class, locale, []
+          def initialize(klass, global_locale)
+            @klass, @global_locale, @locales, @backends = klass, global_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_node(m, @locale)
-            elsif @model_class.column_names.include?(m.to_s)
-              @model_class.arel_table[m]
+          def method_missing(m, *args)
+            if @klass.mobility_attribute?(m)
+              @backends |= [@klass.mobility_backend_class(m)]
+              ::Mobility.validate_locale!(args[0]) if args[0]
+              locale = args[0] || @global_locale
+              @locales |= [locale]
+              @klass.mobility_backend_class(m).build_node(m, locale)
+            elsif @klass.column_names.include?(m.to_s)
+              @klass.arel_table[m]
             else
               super
             end
@@ -90,21 +99,27 @@ enabled for any one attribute on the model.
 
           class << self
             def build_query(klass, locale, &block)
+              ::Mobility.validate_locale!(locale)
+
               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)
+                apply_scopes(klass.all, row.backends, row.locales, predicates).merge(query)
               else
-                apply_scopes(klass.all, row.__backends, locale, query).where(query)
+                apply_scopes(klass.all, row.backends, row.locales, query).where(query)
               end
             end
 
             private
 
-            def apply_scopes(scope, backends, locale, predicates)
-              backends.inject(scope) { |r, b| b.apply_scope(r, predicates, locale) }
+            def apply_scopes(scope, backends, locales, predicates)
+              backends.inject(scope) do |scope_, b|
+                locales.inject(scope_) do |r, locale|
+                  b.apply_scope(r, predicates, locale)
+                end
+              end
             end
           end
         end

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

@@ -27,7 +27,7 @@ module Mobility
 
             if ([*options[:scope]] + [attribute]).any? { |name| klass.mobility_attribute?(name) }
               return unless value.present?
-              relation = klass.unscoped.__mobility_query_scope__ do |m|
+              relation = Plugins::ActiveRecord::Query.build_query(klass.unscoped, Mobility.locale) do |m|
                 node = m.__send__(attribute)
                 options[:case_sensitive] == false ? node.lower.eq(value.downcase) : node.eq(value)
               end
@@ -50,7 +50,7 @@ module Mobility
 
           def mobility_scope_relation(record, relation)
             [*options[:scope]].inject(relation) do |scoped_relation, scope_item|
-              scoped_relation.__mobility_query_scope__ do |m|
+              Plugins::ActiveRecord::Query.build_query(scoped_relation, Mobility.locale) do |m|
                 m.__send__(scope_item).eq(record.send(scope_item))
               end
             end

data/lib/mobility/plugins/attributes.rb

@@ -19,12 +19,6 @@ for aggregating attributes.
         @names = names.map(&:to_s).freeze
       end
 
-      # Yield each attribute name to block
-      # @yieldparam [String] Attribute
-      def each &block
-        names.each(&block)
-      end
-
       # Show useful information about this module.
       # @return [String]
       def inspect

data/lib/mobility/plugins/sequel.rb

@@ -1,5 +1,4 @@
 require "sequel"
-raise VersionNotSupportedError, "Mobility is only compatible with Sequel 4.0 and greater" if ::Sequel::MAJOR < 4
 require "sequel/plugins/mobility"
 unless defined?(ActiveSupport::Inflector)
   # TODO: avoid automatically including the inflector extension
@@ -13,6 +12,13 @@ require_relative "./sequel/query"
 
 module Mobility
   module Plugins
+=begin
+
+Plugin for Sequel models. This plugin automatically requires sequel related
+plugins, which are not actually "active" unless their base plugin (e.g. dirty
+for sequel_dirty) is also enabled.
+
+=end
     module Sequel
       extend Plugin
 

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

@@ -1,6 +1,11 @@
 module Mobility
   module Plugins
     module Sequel
+=begin
+
+Maps backend names to Sequel namespaced backends.
+
+=end
       module Backend
         extend Plugin
 

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

@@ -3,7 +3,8 @@ module Mobility
   module Plugins
 =begin
 
-See ActiveRecord::Query plugin.
+Supports querying on Sequel model translated attributes. Similar API to the
+ActiveRecord query plugin.
 
 =end
     module Sequel
@@ -19,35 +20,47 @@ See ActiveRecord::Query plugin.
 
             klass.class_eval do
               extend QueryMethod
-              singleton_class.send :alias_method, plugin.query_method, :__mobility_query_dataset__
+              singleton_class.define_method(plugin.query_method) do |locale: Mobility.locale, &block|
+                Query.build_query(self, locale, &block)
+              end
             end
           end
         end
 
-        module QueryMethod
-          def __mobility_query_dataset__(locale: Mobility.locale, &block)
+        class << self
+          def build_query(klass, locale = Mobility.locale, &block)
             if block_given?
-              VirtualRow.build_query(self, locale, &block)
+              VirtualRow.build_query(klass, locale, &block)
             else
-              dataset.with_extend(QueryExtension)
+              klass.dataset.with_extend(QueryExtension)
             end
           end
         end
 
+        module QueryMethod
+          def __mobility_query_dataset__(locale: Mobility.locale, &block)
+            warn '__mobility_query_dataset__ is an internal method and will be deprecated in the next release.'
+            Query.build_query(self, locale, &block)
+          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
+          attr_reader :backends, :locales
 
-          def initialize(model_class, locale)
-            @model_class, @locale, @__backends = model_class, locale, []
+          def initialize(model_class, global_locale)
+            @model_class, @global_locale, @backends, @locales = model_class, global_locale, [], []
           end
 
-          def method_missing(m, *)
+          def method_missing(m, *args)
             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)
+              @backends |= [@model_class.mobility_backend_class(m)]
+              ::Mobility.validate_locale!(args[0]) if args[0]
+              locale = args[0] || @global_locale
+              @locales |= [locale]
+              @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
@@ -57,21 +70,27 @@ See ActiveRecord::Query plugin.
 
           class << self
             def build_query(klass, locale, &block)
+              ::Mobility.validate_locale!(locale)
+
               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)
+                prepare_datasets(query, row.backends, row.locales, predicates)
               else
-                prepare_datasets(klass.dataset, row.__backends, locale, query).where(query)
+                prepare_datasets(klass.dataset, row.backends, row.locales, query).where(query)
               end
             end
 
             private
 
-            def prepare_datasets(dataset, backends, locale, predicates)
-              backends.inject(dataset) { |ds, b| b.prepare_dataset(ds, predicates, locale) }
+            def prepare_datasets(dataset, backends, locales, predicates)
+              backends.inject(dataset) do |dataset_, b|
+                locales.inject(dataset_) do |ds, locale|
+                  b.prepare_dataset(ds, predicates, locale)
+                end
+              end
             end
           end
         end

data/lib/mobility/version.rb

@@ -7,8 +7,8 @@ module Mobility
 
   module VERSION
     MAJOR = 1
-    MINOR = 0
-    TINY = 7
+    MINOR = 1
+    TINY = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mobility
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.1.0
 platform: ruby
 authors:
 - Chris Salzberg
@@ -34,7 +34,7 @@ cert_chain:
   gSQml7TqcC6dZRsZRwYqzD9kUwdAJoCqno2CBUKs2l0yQAjFT36lRrVJznb7uWwa
   xpPFnsrtyaZW6Dty8TSG3qzmeGpmpIotA8x1VA==
   -----END CERTIFICATE-----
-date: 2021-02-04 00:00:00.000000000 Z
+date: 2021-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: request_store