mobility 1.0.7 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddbf8662456ee4b547ed3ead85fd44a3af486cbe94d85ad77679f811a7a5b98d
-  data.tar.gz: 62fed63232e0bf182db5fdf9994ca3d2f50b61872b9e3c0bf4d1b4c7cf739698
+  metadata.gz: 225a8aa8a3eb8691e9a89d60fdd56509b47f7f36d22d1bb8d0c6f485f0e7cc2d
+  data.tar.gz: be10ccdea2727e568da790950b4df0633a543094543f7fd5f9c89154d5ea803e
 SHA512:
-  metadata.gz: 449d4f885917546ffe9dab2678e39d597ecc340028e0e09293073487b8f8269ee097cea0b1ee28232cf04c05a1598d1e65be4d0be72b63b27f7e5cc543ab49bb
-  data.tar.gz: 19f561713598217a2f8cf18aee0d906076086adf254995d7ddaccbd3e4d5b3db27f3d402f189d935538b1ef84d8e1fe33471af746a7c8d502095baa8f9cadd12
+  metadata.gz: 6f350d0a8e5fcf4f1804716f2cdfc0d500abd033ca0243e0c6be663adedf3ee192d785546a1be1274acbd5738533c7b5e3b9f8c48446e22bde39c26de8217819
+  data.tar.gz: 78fb7729118181d00e21f78c1144166916270e555bb4191c05a10cc660fb57d36b8af034cc7d42bfbd3d66d9509d1686f80554f85538b9a6d0fd488becd12966

data/CHANGELOG.md

@@ -1,6 +1,24 @@
 # Mobility Changelog
 
-### Unreleased
+## Unreleased
+- Assign blank values in pg hash backends
+  ([#516](https://github.com/shioyama/mobility/pull/516))
+
+## 1.1
+
+### 1.1.3
+- Do not swallow keyword args on ruby 3 in fallthrough accessors
+  ([#520](https://github.com/shioyama/mobility/pull/520)) thanks
+  [doits](https://github.com/doits)!
+
+### 1.1.2
+- Check whether class responds to mobility_attribute?
+  ([#515](https://github.com/shioyama/mobility/pull/515))
+
+### 1.1.1
+- Updated signing key
+
+### 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

@@ -12,8 +12,8 @@ group :development, :test do
     case orm_version
     when '4.2', '5.0', '5.1', '5.2', '6.0', '6.1'
       gem 'activerecord', "~> #{orm_version}.0"
-    when '6.2'
-      git 'https://github.com/rails/rails.git' do
+    when '7.0'
+      git 'https://github.com/rails/rails.git', branch: 'main' do
         gem 'activerecord'
         gem 'activesupport'
       end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mobility (1.0.6)
+    mobility (1.1.2)
       i18n (>= 0.6.10, < 2)
       request_store (~> 1.0)
 
@@ -14,7 +14,7 @@ GEM
     concurrent-ruby (1.1.8)
     database_cleaner (1.99.0)
     diff-lcs (1.4.4)
-    ffi (1.14.2)
+    ffi (1.15.0)
     formatador (0.2.5)
     guard (2.16.2)
       formatador (>= 0.2.4)
@@ -30,9 +30,9 @@ GEM
       guard (~> 2.1)
       guard-compat (~> 1.1)
       rspec (>= 2.99.0, < 4.0)
-    i18n (1.8.8)
+    i18n (1.8.10)
       concurrent-ruby (~> 1.0)
-    listen (3.4.1)
+    listen (3.5.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     lumberjack (1.2.8)
@@ -68,7 +68,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.2)
-    sequel (5.41.0)
+    sequel (5.44.0)
     shellany (0.0.1)
     thor (1.1.0)
     yard (0.9.26)

data/README.md

@@ -12,7 +12,7 @@ Mobility
 [docs]: http://www.rubydoc.info/gems/mobility
 [wiki]: https://github.com/shioyama/mobility/wiki
 
-**This is the readme for version 1.0 of Mobility. If you are using an earlier
+**This is the readme for version 1.x of Mobility. If you are using an earlier
 version (0.8.x or earlier), you probably want the readme on the [0-8
 branch](https://github.com/shioyama/mobility/tree/0-8).**
 
@@ -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.3'
 ```
 
 ### 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
@@ -131,9 +130,7 @@ default `type` option for the KeyValue backend to `:string`.
  end
 ```
 
-We will assume the configuration above in the examples that follow. Other
-configuration options are described in the [API
-docs](http://www.rubydoc.info/gems/mobility/Mobility/Configuration).
+We will assume the configuration above in the examples that follow.
 
 See [Getting Started](#quickstart) to get started translating your models.
 
@@ -487,9 +484,7 @@ end
 ```
 
 Internally, Mobility assigns the fallbacks hash to an instance of
-`I18n::Locale::Fallbacks.new` (this can be customized by setting the
-`fallbacks_generator` configuration option, see the [API documentation on
-configuration](http://www.rubydoc.info/gems/mobility/Mobility/Configuration)).
+`I18n::Locale::Fallbacks.new`.
 
 By setting fallbacks for German and French to Japanese, values will fall
 through to the Japanese value if none is present for either of these locales,
@@ -1029,6 +1024,9 @@ Integrations
 * [mobility-ransack](https://github.com/shioyama/mobility-ransack): Search
   attributes translated by Mobility with
   [Ransack](https://github.com/activerecord-hackery/ransack).
+* [mobility-actiontext](https://github.com/sedubois/mobility-actiontext): Translate
+  Rails [Action Text](https://guides.rubyonrails.org/action_text_overview.html) rich text
+  with Mobility.
 
 Tutorials
 ---------

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
@@ -72,6 +73,9 @@ fallbacks plugin, whereas +Post+ uses +Translations+ which does not have that
 plugin enabled.
 
 =end
+
+def ruby2_keywords(*); end unless respond_to?(:ruby2_keywords, true)
+
 module Mobility
   # A generic exception used by Mobility.
   class Error < StandardError
@@ -83,8 +87,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 +203,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 +227,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 +241,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/active_record/pg_hash.rb

@@ -32,7 +32,7 @@ Internal class used by ActiveRecord backends backed by a Postgres data type
           def self.dump(obj)
             if obj.is_a? ::Hash
               obj.inject({}) do |translations, (locale, value)|
-                translations[locale] = value if value.present?
+                translations[locale] = value unless value.nil?
                 translations
               end
             else

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/backends/sequel/pg_hash.rb

@@ -41,7 +41,7 @@ jsonb).
           mod = Module.new do
             define_method :before_validation do
               columns.each do |column|
-                self[column].delete_if { |_, v| Util.blank?(v) }
+                self[column].delete_if { |_, v| v.nil? }
               end
               super()
             end

data/lib/mobility/backends/serialized.rb

@@ -40,7 +40,7 @@ Format for serialization. Either +:yaml+ (default) or +:json+.
             return if obj.nil?
             if obj.is_a? ::Hash
               obj = obj.inject({}) do |translations, (locale, value)|
-                translations[locale] = value.to_s if Util.present?(value)
+                translations[locale] = value.to_s unless value.nil?
                 translations
               end
             else

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
@@ -122,6 +137,8 @@ enabled for any one attribute on the model.
           end
 
           def order(opts, *rest)
+            return super unless @klass.respond_to?(:mobility_attribute?)
+
             case opts
             when Symbol, String
               @klass.mobility_attribute?(opts) ? order({ opts => :asc }, *rest) : super
@@ -146,6 +163,9 @@ enabled for any one attribute on the model.
               define_method method_name do |*attrs, &block|
                 return super(*attrs, &block) if (method_name == 'select' && block.present?)
 
+                if ::ActiveRecord::VERSION::STRING < '7.0'
+                  return super(*attrs, &block) unless @klass.respond_to?(:mobility_attribute?)
+                end
                 return super(*attrs, &block) unless attrs.any?(&@klass.method(:mobility_attribute?))
 
                 keys = attrs.dup

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/fallthrough_accessors.rb

@@ -55,6 +55,13 @@ model class is generated.
           end
         end
 
+        # Following is needed in order to not swallow `kwargs` on ruby >= 3.0.
+        # Otherwise `kwargs` are not passed by `super` to a possible other
+        # `method_missing` defined like this:
+        #
+        # def method_missing(name, *args, **kwargs, &block); end
+        ruby2_keywords :method_missing
+
         define_method :respond_to_missing? do |method_name, include_private = false|
           (method_name =~ method_name_regex) || super(method_name, include_private)
         end

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 = 3
     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.3
 platform: ruby
 authors:
 - Chris Salzberg
@@ -11,30 +11,30 @@ cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
   MIIEODCCAqCgAwIBAgIBATANBgkqhkiG9w0BAQsFADAjMSEwHwYDVQQDDBhjaHJp
-  cy9EQz1kZWppbXN0YS9EQz1jb20wHhcNMjAwMjExMDEwMjM1WhcNMjEwMjEwMDEw
-  MjM1WjAjMSEwHwYDVQQDDBhjaHJpcy9EQz1kZWppbXN0YS9EQz1jb20wggGiMA0G
-  CSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQC99crJF+gE4WQnN7S4xdacGpZWg7hZ
-  UlXPXM1vX4HVaw8essO6eNGafYqKRQKf3WDW4uM6kqPd4OZTfahGhocVtVScJYGi
-  5SRuw9rrJeFlojUkCSqy47on7t858OebbD28eo71sZLTclGmza6UpjiLZqy0AL4P
-  9dkK2j9pQJ3jYTNYteq7P6A109ExSGWbaRvkAKU+vTMJsK5MW2bWullsOGHrZiPW
-  7PXAaU33X29ddLu/zj/4qe83GVvnrprjw5RRgoQgP0Umw8zKG50XB7nS3TAUiaRz
-  oD+eKgOIeZpPRwemINf0VsP1L+/FnUS6BkzVCOV9MWhUbrkdxCHLrSB8JL4ooXXR
-  N/J4KlR5xpv6b+z+i2lScfkrH7r9RF4ZtpiDQzyCxvuIZOQTzUneUSzMIk9BaEN2
-  5S19cDUjW5fi75npJ+YnrUN83Ta3sa/Pp4dnUqiBK7WHBDnHMN6j7iASoAjKVTgM
-  8F/xjk4qgxA7vjv2obj2zv65CknnQprLCpMCAwEAAaN3MHUwCQYDVR0TBAIwADAL
-  BgNVHQ8EBAMCBLAwHQYDVR0OBBYEFOO4919GTuKTQA2Klo2QO3jGlbJTMB0GA1Ud
-  EQQWMBSBEmNocmlzQGRlamltc3RhLmNvbTAdBgNVHRIEFjAUgRJjaHJpc0BkZWpp
-  bXN0YS5jb20wDQYJKoZIhvcNAQELBQADggGBADfIFBldH77wyUv2RZ1kwvuvRvpL
-  RNFdQlCbuVSn3abRAmc9rIsh80syhjWjYnml3guf+g2tYB1rU3NeTFRVupdvcUWJ
-  T6mITUeDHpNoxF6KAp3zSsdoBoEHdOBNH7Jpxp+L3a2LZ0k6fW12xEafmymOD3fp
-  BmIrE2Vr9aUec2Sk4fbKEYqsxhmXx+o8kKU7tnxVYMv4cX5X3yo45FA7Rh2JQuub
-  MBT+NALoYFaSTHWIr/4tAolWVt8NNGUKEokaFjjf5gAGM6piq6ohTHl5dCtcEPX1
-  klHOa2pIFwuUAWoVCpZa9XzRV5qz+mUrU70DF9dX6Cotv/sKOIxiGvQLnwzlSQWH
-  iXMqkM6Y5FSwViOQy4U2egDDSTB5a16iAnN7/qzqex6SYTsQdSmyc0mWCb9rkIoF
-  gSQml7TqcC6dZRsZRwYqzD9kUwdAJoCqno2CBUKs2l0yQAjFT36lRrVJznb7uWwa
-  xpPFnsrtyaZW6Dty8TSG3qzmeGpmpIotA8x1VA==
+  cy9EQz1kZWppbWF0YS9EQz1jb20wHhcNMjEwMjE4MTMxMzA5WhcNMjIwMjE4MTMx
+  MzA5WjAjMSEwHwYDVQQDDBhjaHJpcy9EQz1kZWppbWF0YS9EQz1jb20wggGiMA0G
+  CSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDURCKbt5oY0sCp4kYK1u5SLzVHg6Q1
+  2LejeQvUGpR3gulWqrq/507XRxE/9FSpLfgo3cGGYio1/gg2Yp7pBI4ZNEz8d2Vg
+  6caWLHYtHYF0/jlo177UspEF1bt3lCCmaA/ZyQpvoLi76Jf6VCBjepMqhLjeBSsA
+  xUqSdgNT8lzduOzdYk/GWf2Trvyz72IN6rY7hSwJ/U4R2DusRNTbKC55iyu0MyqI
+  Nks33les0xQERucqes1YzSEnpott/GUQ/fFWV1Qx7M1hMnqbQIm493BueR6X95a2
+  B7/aqY7LUVVmn9p65NMBJhbbP/pbAcLYV0C+y1Jy9NaVQTpWmJXVKBpYwlAzOJOQ
+  +b/7MBzT5Zzudkq9OlA5rZJB0hFo/Bm38MOCTSTk1/RT+zmoOyb4bx/h400L4ZUt
+  bRGON33BZ99gPiYdGfd3Pc/7FooteJASjKIO4Hman2ELRIdu6Bq+fIkTdJBcruS/
+  XL6xoRitCG7CX0IqmMKuLiKA/J0amAikHGsCAwEAAaN3MHUwCQYDVR0TBAIwADAL
+  BgNVHQ8EBAMCBLAwHQYDVR0OBBYEFMNUGAhS68egZT6DOfJwrfIdCtT/MB0GA1Ud
+  EQQWMBSBEmNocmlzQGRlamltYXRhLmNvbTAdBgNVHRIEFjAUgRJjaHJpc0BkZWpp
+  bWF0YS5jb20wDQYJKoZIhvcNAQELBQADggGBAH1RnWhD9bum/ijqzAAlkGWYzGza
+  h/3seA2bg1r5bbttFjD48f7RepfoAMxAqfiUWcukoukJeu7UY8jWmUIn9ut1oXct
+  Fh0YnueLFzzmppCCU+/SX5mc1y7mHYZHiU5n8qy1wJ6ljLWXVeprgJ96NdnmxuVU
+  dzPPSDTex/x7xBvHiaPc/uZSLc173N3qdY/Cd0B3/OflYeU2h5UpIHnmXrsONdMC
+  Xohy+Rrr2yT09MPYG+llpLHDnXmTnPsOZUSL5Q4c/iolodv4xJZKwLMZwrm2hQl9
+  9Or9Os+qxY0zWxmWuAtTFrskLAMhckCPDEcqSZmW4CT1a/quC2Oh0y1GsXPcqtqt
+  hLRuwfTXGor6bg4CrU7GRbSqjvnBepct5lwZiZrOCnMEUpY+9Q8fwmG3o3B+wBsw
+  eBMcZq0d1tbtv1M1UXND9mOfhLZ31YvoSTPkrJiRpljUNgD0+ugelnr1/5X/9k8y
+  J9QOd3C5jpSShf/HMvpJnFuSYFm19cH9GrHjvw==
   -----END CERTIFICATE-----
-date: 2021-02-04 00:00:00.000000000 Z
+date: 2021-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: request_store