i18n-active_record 0.4.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d742b8d5877fc39c8855a29b4cd864732b750f3167567ced3dcd3bf2e9ad3d25
-  data.tar.gz: e6f0df2b6ff56a75568c44e11c7e19e6a5e161352308247e12afeb8ffd294522
+  metadata.gz: 9a66ea934bb11309eb79e45fe45b206f596aecdef52de87d193b8d9ec9a8ac54
+  data.tar.gz: 92f91630acf638a76c02a527142c51565c8422bf1a9443254ba8eeca1a6ad0f8
 SHA512:
-  metadata.gz: 7fba006f4b5feb3d33cc9917a8c487d11b33e1bdfc64dff8e78e52f909393a0ee86b5a820b674f1b69ad28223459a336dba509fd1cf7f4a9eecbcf922ba4b86c
-  data.tar.gz: b8e8a9b39d0d531d0cea78034372f2ac46dedfe1a66269bd9aa72738dcc82544b307222aa603dd1037874a1609f9cb592f7349de4d879aca3c4a4f74f67736d4
+  metadata.gz: 6683c1ff6494df8ef79f0d96398842e0315a1a66d6850d0abc13157de0b45faa9728121c55459ccfa78ad70497faab5a084e2e64ad53d148647ad5fbe4fda433
+  data.tar.gz: 2699f7f14fd099990a227ee9cf5e8bd5a1d65957f2e752fcda2624220dfabc470c13b4c4f5f561578d2a79becf67dbc015517656a0f62d52d3e17f4c7f52d2bd

data/README.md

@@ -1,7 +1,7 @@
-# I18n::Backend::ActiveRecord
+# I18n::Backend::ActiveRecord [![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop) [![Tests Status](https://github.com/svenfuchs/i18n-active_record/actions/workflows/test.yml/badge.svg)](https://github.com/svenfuchs/i18n-active_record/actions) [![Linter Status](https://github.com/svenfuchs/i18n-active_record/actions/workflows/linter.yml/badge.svg)](https://github.com/svenfuchs/i18n-active_record/actions)
 
-This repository contains the I18n ActiveRecord backend and support code that has been extracted from the "I18n": http://github.com/svenfuchs/i18n.
-It is fully compatible with Rails 3, 4, 5 and 6.
+This repository contains the I18n ActiveRecord backend and support code that has been extracted from the `I18n` gem: http://github.com/svenfuchs/i18n.
+It is fully compatible with Rails 4, 5 and 6.
 
 ## Installation
 
@@ -45,7 +45,7 @@ By default the installer creates a new file in `config/initializers` named `i18n
 ```ruby
 require 'i18n/backend/active_record'
 
-Translation  = I18n::Backend::ActiveRecord::Translation
+Translation = I18n::Backend::ActiveRecord::Translation
 
 if Translation.table_exists?
   I18n.backend = I18n::Backend::ActiveRecord.new
@@ -77,11 +77,37 @@ I18n::Backend::ActiveRecord.configure do |config|
 end
 ```
 
+To configure the ActiveRecord backend to cache translations(might be useful in production) use:
+
+```ruby
+I18n::Backend::ActiveRecord.configure do |config|
+  config.cache_translations = true # defaults to false
+end
+```
+
 ## Usage
 
 You can now use `I18n.t('Your String')` to lookup translations in the database.
 
-## Missing Translations -> Interpolations
+## Missing Translations
+
+### Usage
+
+In order to make the `I18n::Backend::ActiveRecord::Missing` module working correctly pluralization rules should be configured properly.
+The `i18n.plural.keys` translation key should be present in any of the backends.
+See https://github.com/svenfuchs/i18n-active_record/blob/master/lib/i18n/backend/active_record/missing.rb for more information.
+
+```yaml
+en:
+  i18n:
+    plural:
+      keys:
+        - :zero
+        - :one
+        - :other
+```
+
+### Interpolations
 
 The `interpolations` field in the `translations` table is used by `I18n::Backend::ActiveRecord::Missing` to store the interpolations seen the first time this Translation was requested.  This will help translators understand what interpolations to expect, and thus to include when providing the translations.
 
@@ -91,6 +117,23 @@ The `interpolations` field is otherwise unused since the "value" in `Translation
 
 * http://collectiveidea.com/blog/archives/2016/05/31/beyond-yml-files-dynamic-translations/
 
+## Contributing
+
+### Test suite
+
+The test suite can be run with:
+
+    bundle exec rake
+
+By default it runs the tests for SQLite database, to specify a database the `DB` env variable can be used:
+
+    DB=postgres bundle exec rake
+    DB=mysql bundle exec rake
+
+To run tests for a specific rails version see [Appraisal](https://github.com/thoughtbot/appraisal):
+
+    bundle exec appraisal rails-4 rake test
+
 ## Maintainers
 
 * Sven Fuchs

data/Rakefile

@@ -1,66 +1,12 @@
-require 'rake'
+# frozen_string_literal: true
+
 require 'rake/testtask'
 require 'bundler/gem_tasks'
 
-def execute(command)
-  puts command
-  system command
-end
-
-def bundle_options
-  return '' unless ENV['BUNDLE_GEMFILE']
-
-  "--gemfile #{ENV['BUNDLE_GEMFILE']}"
-end
-
-def each_database(&block)
-  ['sqlite', 'postgres', 'mysql'].each &block
-end
-
-namespace :bundle do
-  task :env do
-    ar = ENV['AR'].to_s
-
-    next if ar.empty?
-
-    gemfile = "gemfiles/Gemfile.rails_#{ar}"
-    raise "Cannot find gemfile at #{gemfile}" unless File.exist?(gemfile)
-
-    ENV['BUNDLE_GEMFILE'] = gemfile
-    puts "Using gemfile: #{gemfile}"
-  end
-
-  task install: :env do
-    execute "bundle install #{bundle_options}"
-  end
-
-  task update: :env do
-    execute "bundle update #{bundle_options}"
-  end
-
-  task :install_all do
-    [nil, '3', '4', '5', '6', 'head'].each do |ar|
-      opt = ar && "AR=#{ar}"
-      execute "rake bundle:install #{opt}"
-    end
-  end
-end
-
-task :test do
-  each_database { |db| execute "rake #{db}:test" }
-end
-
-Rake::TestTask.new :_test do |t|
+Rake::TestTask.new :test do |t|
   t.libs << 'test'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = false
 end
 
-each_database do |db|
-  namespace db do
-    task(:env) { ENV['DB'] = db }
-    task test: ['env', 'bundle:env', '_test']
-  end
-end
-
 task default: :test

data/lib/generators/i18n/active_record/install_generator.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'rails/generators/active_record'
 
 module I18n
   module ActiveRecord
     module Generators
       class  InstallGenerator < ::ActiveRecord::Generators::Base
-        desc "Installs i18n-active_record and generates the necessary migrations"
+        desc 'Installs i18n-active_record and generates the necessary migrations'
 
         argument :name, type: :string, default: 'Translation'
 

data/lib/generators/i18n/active_record/templates/advanced_initializer.rb.erb

@@ -13,5 +13,6 @@ if Translation.table_exists?
 end
 
 I18n::Backend::ActiveRecord.configure do |config|
+  # config.cache_translations = true # defaults to false
   # config.cleanup_with_destroy = true # defaults to false
 end

data/lib/generators/i18n/active_record/templates/simple_initializer.rb.erb

@@ -2,5 +2,6 @@ require 'i18n/backend/active_record'
 I18n.backend = I18n::Backend::ActiveRecord.new
 
 I18n::Backend::ActiveRecord.configure do |config|
+  # config.cache_translations = true # defaults to false
   # config.cleanup_with_destroy = true # defaults to false
 end

data/lib/i18n/active_record/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module I18n
   module ActiveRecord
-    VERSION = '0.4.1'
+    VERSION = '1.0.0'
   end
 end

data/lib/i18n/active_record.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'i18n'

data/lib/i18n/backend/active_record/configuration.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 module I18n
   module Backend
     class ActiveRecord
       class Configuration
-        attr_accessor :cleanup_with_destroy
+        attr_accessor :cleanup_with_destroy, :cache_translations
 
         def initialize
           @cleanup_with_destroy = false
+          @cache_translations = false
         end
       end
     end

data/lib/i18n/backend/active_record/missing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #  This extension stores translation stub records for missing translations to
 #  the database.
 #
@@ -36,27 +38,28 @@ module I18n
         include Flatten
 
         def store_default_translations(locale, key, options = {})
-          count, scope, default, separator = options.values_at(:count, :scope, :default, :separator)
+          count, scope, _, separator = options.values_at(:count, :scope, :default, :separator)
           separator ||= I18n.default_separator
           key = normalize_flat_keys(locale, key, scope, separator)
 
-          unless ActiveRecord::Translation.locale(locale).lookup(key).exists?
-            interpolations = options.keys - I18n::RESERVED_KEYS
-            keys = count ? I18n.t('i18n.plural.keys', :locale => locale).map { |k| [key, k].join(FLATTEN_SEPARATOR) } : [key]
-            keys.each { |key| store_default_translation(locale, key, interpolations) }
-          end
+          return if ActiveRecord::Translation.locale(locale).lookup(key).exists?
+
+          interpolations = options.keys - I18n::RESERVED_KEYS
+          keys = count ? I18n.t('i18n.plural.keys', locale: locale).map { |k| [key, k].join(FLATTEN_SEPARATOR) } : [key]
+          keys.each { |k| store_default_translation(locale, k, interpolations) }
         end
 
         def store_default_translation(locale, key, interpolations)
-          translation = ActiveRecord::Translation.new :locale => locale.to_s, :key => key
+          translation = ActiveRecord::Translation.new locale: locale.to_s, key: key
           translation.interpolations = interpolations
           translation.save
         end
 
         def translate(locale, key, options = {})
           result = catch(:exception) { super }
+
           if result.is_a?(I18n::MissingTranslation)
-            self.store_default_translations(locale, key, options)
+            store_default_translations(locale, key, options)
             throw(:exception, result)
           else
             result

data/lib/i18n/backend/active_record/store_procs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This module is intended to be mixed into the ActiveRecord backend to allow
 # storing Ruby Procs as translation values in the database.
 #
@@ -21,13 +23,13 @@ module I18n
   module Backend
     class ActiveRecord
       module StoreProcs
-        def value=(v)
-          case v
+        def value=(val)
+          case val
           when Proc
-            write_attribute(:value, v.to_ruby)
+            write_attribute(:value, val.to_ruby)
             write_attribute(:is_proc, true)
           else
-            write_attribute(:value, v)
+            write_attribute(:value, val)
           end
         end
 
@@ -36,4 +38,3 @@ module I18n
     end
   end
 end
-

data/lib/i18n/backend/active_record/translation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record'
 
 module I18n
@@ -53,19 +55,20 @@ module I18n
 
         serialize :value
         serialize :interpolations, Array
+        after_commit :invalidate_translations_cache
 
         class << self
           def locale(locale)
-            where(:locale => locale.to_s)
+            where(locale: locale.to_s)
           end
 
           def lookup(keys, *separator)
             column_name = connection.quote_column_name('key')
-            keys = Array(keys).map! { |key| key.to_s }
+            keys = Array(keys).map!(&:to_s)
 
             unless separator.empty?
-              warn "[DEPRECATION] Giving a separator to Translation.lookup is deprecated. " <<
-                "You can change the internal separator by overwriting FLATTEN_SEPARATOR."
+              warn '[DEPRECATION] Giving a separator to Translation.lookup is deprecated. ' \
+                   'You can change the internal separator by overwriting FLATTEN_SEPARATOR.'
             end
 
             namespace = "#{keys.last}#{I18n::Backend::Flatten::FLATTEN_SEPARATOR}%"
@@ -83,14 +86,14 @@ module I18n
               keys.each.with_index.inject(locale_hash) do |iterator, (key_part, index)|
                 key = key_part.to_sym
                 iterator[key] = keys[index + 1] ? (iterator[key] || {}) : t.value
-                iterator[key]
+                iterator[key] # rubocop:disable Lint/UnmodifiedReduceAccumulator
               end
             end
           end
         end
 
         def interpolates?(key)
-          self.interpolations.include?(key) if self.interpolations
+          interpolations&.include?(key)
         end
 
         def value
@@ -107,14 +110,19 @@ module I18n
         end
 
         def value=(value)
-          if value === false
+          case value
+          when false
             value = FALSY_CHAR
-          elsif value === true
+          when true
             value = TRUTHY_CHAR
           end
 
           write_attribute(:value, value)
         end
+
+        def invalidate_translations_cache
+          I18n.backend.reload! if I18n::Backend::ActiveRecord.config.cache_translations
+        end
       end
     end
   end

data/lib/i18n/backend/active_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'i18n/backend/base'
 require 'i18n/backend/active_record/translation'
 
@@ -9,6 +11,9 @@ module I18n
       autoload :Translation,   'i18n/backend/active_record/translation'
       autoload :Configuration, 'i18n/backend/active_record/configuration'
 
+      include Base
+      include Flatten
+
       class << self
         def configure
           yield(config) if block_given?
@@ -19,103 +24,111 @@ module I18n
         end
       end
 
-      module Implementation
-        include Base, Flatten
+      def initialize(*args)
+        super
 
-        def available_locales
-          begin
-            Translation.available_locales
-          rescue ::ActiveRecord::StatementInvalid
-            []
-          end
-        end
+        reload!
+      end
 
-        def store_translations(locale, data, options = {})
-          escape = options.fetch(:escape, true)
-          flatten_translations(locale, data, escape, false).each do |key, value|
-            translation = Translation.locale(locale).lookup(expand_keys(key))
+      def available_locales
+        Translation.available_locales
+      rescue ::ActiveRecord::StatementInvalid
+        []
+      end
+
+      def store_translations(locale, data, options = {})
+        escape = options.fetch(:escape, true)
 
-            if ActiveRecord.config.cleanup_with_destroy
-              translation.destroy_all
-            else
-              translation.delete_all
-            end
+        flatten_translations(locale, data, escape, false).each do |key, value|
+          translation = Translation.locale(locale).lookup(expand_keys(key))
 
-            Translation.create(:locale => locale.to_s, :key => key.to_s, :value => value)
+          if ActiveRecord.config.cleanup_with_destroy
+            translation.destroy_all
+          else
+            translation.delete_all
           end
-        end
 
-        def reload!
-          @translations = nil
-          self
+          Translation.create(locale: locale.to_s, key: key.to_s, value: value)
         end
 
-        def initialized?
-          !@translations.nil?
-        end
+        reload! if ActiveRecord.config.cache_translations
+      end
 
-        def init_translations
-          @translations = Translation.to_hash
-        end
+      def reload!
+        @translations = nil
 
-        def translations(do_init: false)
-          init_translations if do_init || !initialized?
-          @translations ||= {}
-        end
+        self
+      end
+
+      def initialized?
+        !@translations.nil?
+      end
+
+      def init_translations
+        @translations = Translation.to_hash
+      end
+
+      def translations(do_init: false)
+        init_translations if do_init || !initialized?
+        @translations ||= {}
+      end
 
       protected
 
-        def lookup(locale, key, scope = [], options = {})
-          key = normalize_flat_keys(locale, key, scope, options[:separator])
-          if key.first == '.'
-            key = key[1..-1]
-          end
-          if key.last == '.'
-            key = key[0..-2]
-          end
+      def lookup(locale, key, scope = [], options = {})
+        key = normalize_flat_keys(locale, key, scope, options[:separator])
+        key = key[1..-1] if key.first == '.'
+        key = key[0..-2] if key.last == '.'
 
-          result = if key == ''
-            Translation.locale(locale).all
-          else
-            Translation.locale(locale).lookup(key)
-          end
+        if ActiveRecord.config.cache_translations
+          init_translations if @translations.nil? || @translations.empty?
 
-          if result.empty?
-            nil
-          elsif result.first.key == key
-            result.first.value
-          else
-            result = result.inject({}) do |hash, translation|
-              hash.deep_merge build_translation_hash_by_key(key, translation)
-            end
-            result.deep_symbolize_keys
-          end
+          keys = ([locale] + key.split(I18n::Backend::Flatten::FLATTEN_SEPARATOR)).map(&:to_sym)
+
+          return translations.dig(*keys)
         end
 
-        def build_translation_hash_by_key(lookup_key, translation)
-          hash = {}
-          if lookup_key == ''
-            chop_range = 0..-1
-          else
-            chop_range = (lookup_key.size + FLATTEN_SEPARATOR.size)..-1
-          end
-          translation_nested_keys = translation.key.slice(chop_range).split(FLATTEN_SEPARATOR)
-          translation_nested_keys.each.with_index.inject(hash) do |iterator, (key, index)|
-            iterator[key] = translation_nested_keys[index + 1] ?  {} : translation.value
-            iterator[key]
-          end
-          hash
+        result = if key == ''
+          Translation.locale(locale).all
+        else
+          Translation.locale(locale).lookup(key)
         end
 
-        # For a key :'foo.bar.baz' return ['foo', 'foo.bar', 'foo.bar.baz']
-        def expand_keys(key)
-          key.to_s.split(FLATTEN_SEPARATOR).inject([]) do |keys, key|
-            keys << [keys.last, key].compact.join(FLATTEN_SEPARATOR)
+        if result.empty?
+          nil
+        elsif result.first.key == key
+          result.first.value
+        else
+          result = result.inject({}) do |hash, translation|
+            hash.deep_merge build_translation_hash_by_key(key, translation)
           end
+          result.deep_symbolize_keys
         end
       end
 
-      include Implementation
+      def build_translation_hash_by_key(lookup_key, translation)
+        hash = {}
+
+        chop_range = if lookup_key == ''
+          0..-1
+        else
+          (lookup_key.size + FLATTEN_SEPARATOR.size)..-1
+        end
+        translation_nested_keys = translation.key.slice(chop_range).split(FLATTEN_SEPARATOR)
+        translation_nested_keys.each.with_index.inject(hash) do |iterator, (key, index)|
+          iterator[key] = translation_nested_keys[index + 1] ?  {} : translation.value
+          iterator[key]
+        end
+
+        hash
+      end
+
+      # For a key :'foo.bar.baz' return ['foo', 'foo.bar', 'foo.bar.baz']
+      def expand_keys(key)
+        key.to_s.split(FLATTEN_SEPARATOR).inject([]) do |keys, k|
+          keys << [keys.last, k].compact.join(FLATTEN_SEPARATOR)
+        end
+      end
     end
   end
 end

data/test/active_record_test.rb

@@ -1,136 +1,166 @@
-require_relative './test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class I18nBackendActiveRecordTest < I18n::TestCase
   def setup
+    super
+
+    I18n::Backend::ActiveRecord::Translation.destroy_all
     I18n.backend = I18n::Backend::ActiveRecord.new
-    store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
+
+    store_translations(:en, foo: { bar: 'bar', baz: 'baz' })
   end
 
   def teardown
-    I18n::Backend::ActiveRecord::Translation.destroy_all
     I18n::Backend::ActiveRecord.instance_variable_set :@config, I18n::Backend::ActiveRecord::Configuration.new
+
     super
   end
 
-  test "store_translations does not allow ambiguous keys (1)" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, :foo => 'foo')
-    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
-    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
+  class WithoutCacheTest < I18nBackendActiveRecordTest
+    def setup
+      super
 
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').all
-    assert_equal %w(bar baz), translations.map(&:value)
+      I18n::Backend::ActiveRecord.config.cache_translations = false
+    end
 
-    assert_equal({ :bar => 'bar', :baz => 'baz' }, I18n.t(:foo))
-  end
+    test 'store_translations does not allow ambiguous keys (1)' do
+      store_translations(:en, foo: 'foo')
+      store_translations(:en, foo: { bar: 'bar' })
+      store_translations(:en, foo: { baz: 'baz' })
 
-  test "store_translations does not allow ambiguous keys (2)" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
-    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
-    I18n.backend.store_translations(:en, :foo => 'foo')
+      translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').all
+      assert_equal %w[bar baz], translations.map(&:value)
 
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').all
-    assert_equal %w(foo), translations.map(&:value)
+      assert_equal({ bar: 'bar', baz: 'baz' }, I18n.t(:foo))
+    end
 
-    assert_equal 'foo', I18n.t(:foo)
-  end
+    test 'store_translations does not allow ambiguous keys (2)' do
+      store_translations(:en, foo: { bar: 'bar' })
+      store_translations(:en, foo: { baz: 'baz' })
+      store_translations(:en, foo: 'foo')
 
-  test "can store translations with keys that are translations containing special chars" do
-    I18n.backend.store_translations(:es, :"Pagina's" => "Pagina's" )
-    assert_equal "Pagina's", I18n.t(:"Pagina's", :locale => :es)
-  end
+      translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').all
+      assert_equal %w[foo], translations.map(&:value)
 
-  test "missing translations table does not cause an error in #available_locales" do
-    I18n::Backend::ActiveRecord::Translation.expects(:available_locales).raises(::ActiveRecord::StatementInvalid, 'msg')
-    assert_equal [], I18n.backend.available_locales
-  end
+      assert_equal 'foo', I18n.t(:foo)
+    end
 
-  test "expand_keys" do
-    assert_equal %w(foo foo.bar foo.bar.baz), I18n.backend.send(:expand_keys, :'foo.bar.baz')
-  end
+    test 'can store translations with keys that are translations containing special chars' do
+      store_translations(:es, "Pagina's": "Pagina's")
 
-  test "available_locales returns uniq locales" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
-    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
-    I18n.backend.store_translations(:de, :foo1 => 'foo')
-    I18n.backend.store_translations(:de, :foo2 => 'foo')
-    I18n.backend.store_translations(:uk, :foo3 => 'foo')
-
-    available_locales = I18n::Backend::ActiveRecord::Translation.available_locales
-    assert_equal 3, available_locales.size
-    assert_includes available_locales, :en
-    assert_includes available_locales, :de
-    assert_includes available_locales, :uk
-  end
+      assert_equal "Pagina's", I18n.t(:"Pagina's", locale: :es)
+    end
 
-  test "the default configuration has cleanup_with_destroy == false" do
-    refute I18n::Backend::ActiveRecord.config.cleanup_with_destroy
-  end
+    test 'missing translations table does not cause an error in #available_locales' do
+      I18n::Backend::ActiveRecord::Translation
+        .expects(:available_locales)
+        .raises(::ActiveRecord::StatementInvalid, 'msg')
+      assert_equal [], I18n.backend.available_locales
+    end
 
-  test "the configuration supports cleanup_with_destroy being set" do
-    I18n::Backend::ActiveRecord.configure do |config|
-      config.cleanup_with_destroy = true
+    test 'expand_keys' do
+      assert_equal %w[foo foo.bar foo.bar.baz], I18n.backend.send(:expand_keys, :'foo.bar.baz')
     end
 
-    assert I18n::Backend::ActiveRecord.config.cleanup_with_destroy
-  end
+    test 'available_locales returns uniq locales' do
+      store_translations(:en, foo: { bar: 'bar' })
+      store_translations(:en, foo: { baz: 'baz' })
+      store_translations(:de, foo1: 'foo')
+      store_translations(:de, foo2: 'foo')
+      store_translations(:uk, foo3: 'foo')
+
+      available_locales = I18n::Backend::ActiveRecord::Translation.available_locales
+      assert_equal 3, available_locales.size
+      assert_includes available_locales, :en
+      assert_includes available_locales, :de
+      assert_includes available_locales, :uk
+    end
 
-  test "fetching subtree of translations" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, foo: { bar: { fizz: 'buzz', spuz: 'zazz' }, baz: { fizz: 'buzz' } })
-    assert_equal I18n.t(:foo), { bar: { fizz: 'buzz', spuz: 'zazz' }, baz: { fizz: 'buzz' } }
-  end
+    test 'the default configuration has cleanup_with_destroy == false' do
+      refute I18n::Backend::ActiveRecord.config.cleanup_with_destroy
+    end
 
-  test "build_translation_hash_by_key" do
-    translation = I18n::Backend::ActiveRecord::Translation.new(value: 'translation', key: 'foo.bar.fizz.buzz')
-    expected_hash = { 'bar' => { 'fizz' => { 'buzz' => 'translation' } } }
-    assert_equal I18n.backend.send(:build_translation_hash_by_key, 'foo', translation), expected_hash
-  end
+    test 'the configuration supports cleanup_with_destroy being set' do
+      I18n::Backend::ActiveRecord.configure do |config|
+        config.cleanup_with_destroy = true
+      end
 
-  test "returning all keys via ." do
-    expected_hash = {:foo => { :bar => 'bar', :baz => 'baz' }}
-    assert_equal expected_hash, I18n.t('.')
-  end
+      assert I18n::Backend::ActiveRecord.config.cleanup_with_destroy
+    end
 
-  test "accessing keys with a trailing/leading period" do
-    expected_hash = { :bar => 'bar', :baz => 'baz' }
-    assert_equal expected_hash, I18n.t('foo')
-    assert_equal expected_hash, I18n.t('.foo')
-    assert_equal expected_hash, I18n.t('foo.')
-    assert_equal expected_hash, I18n.t('.foo.')
-    assert_equal expected_hash, I18n.t('.foo.')
-  end
+    test 'fetching subtree of translations' do
+      store_translations(:en, foo: { bar: { fizz: 'buzz', spuz: 'zazz' }, baz: { fizz: 'buzz' } })
 
-  test "returning all keys via . when there are no keys" do
-    I18n.t('.') # Fixes test flakiness by loading available locales
-    I18n::Backend::ActiveRecord::Translation.destroy_all
+      assert_equal I18n.t(:foo), { bar: { fizz: 'buzz', spuz: 'zazz' }, baz: { fizz: 'buzz' } }
+    end
 
-    assert_equal "translation missing: en.no key", I18n.t('.')
-  end
+    test 'build_translation_hash_by_key' do
+      translation = I18n::Backend::ActiveRecord::Translation.new(value: 'translation', key: 'foo.bar.fizz.buzz')
+      expected_hash = { 'bar' => { 'fizz' => { 'buzz' => 'translation' } } }
 
-  test "intially unitinitialized" do
-    refute I18n.backend.initialized?
-    I18n.backend.init_translations
-    assert I18n.backend.initialized?
-    I18n.backend.reload!
-    refute I18n.backend.initialized?
-    I18n.backend.init_translations
-    assert I18n.backend.initialized?
-  end
+      assert_equal I18n.backend.send(:build_translation_hash_by_key, 'foo', translation), expected_hash
+    end
+
+    test 'returning all keys via .' do
+      expected_hash = { foo: { bar: 'bar', baz: 'baz' } }
+
+      assert_equal expected_hash, I18n.t('.')
+    end
+
+    test 'accessing keys with a trailing/leading period' do
+      expected_hash = { bar: 'bar', baz: 'baz' }
+
+      assert_equal expected_hash, I18n.t('foo')
+      assert_equal expected_hash, I18n.t('.foo')
+      assert_equal expected_hash, I18n.t('foo.')
+      assert_equal expected_hash, I18n.t('.foo.')
+      assert_equal expected_hash, I18n.t('.foo.')
+    end
+
+    test 'returning all keys via . when there are no keys' do
+      I18n.t('.') # Fixes test flakiness by loading available locales
+      I18n::Backend::ActiveRecord::Translation.destroy_all
+
+      assert_equal 'translation missing: en.no key', I18n.t('.')
+    end
+
+    test 'intially unitinitialized' do
+      refute I18n.backend.initialized?
+
+      I18n.backend.init_translations
+      assert I18n.backend.initialized?
+
+      I18n.backend.reload!
+      refute I18n.backend.initialized?
+
+      I18n.backend.init_translations
+      assert I18n.backend.initialized?
+    end
+
+    test 'translations returns all translations' do
+      expected_hash = { en: { foo: { bar: 'bar', baz: 'baz' } } }
+      I18n.backend.init_translations
 
-  test "translations returns all translations" do
-    expected_hash = { :en => { :foo => { :bar => 'bar', :baz => 'baz' } } }
-    I18n.backend.init_translations
-    assert_equal expected_hash, I18n.backend.send(:translations)
-    assert I18n.backend.initialized?
+      assert_equal expected_hash, I18n.backend.send(:translations)
+      assert I18n.backend.initialized?
+    end
+
+    test 'translations initialized with do_init argument' do
+      expected_hash = { en: { foo: { bar: 'bar', baz: 'baz' } } }
+
+      refute I18n.backend.initialized?
+      assert_equal expected_hash, I18n.backend.send(:translations, do_init: true)
+      assert I18n.backend.initialized?
+    end
   end
 
-  test "translations initialized with do_init argument" do
-    expected_hash = { :en => { :foo => { :bar => 'bar', :baz => 'baz' } } }
-    refute I18n.backend.initialized?
-    assert_equal expected_hash, I18n.backend.send(:translations, { do_init: true })
-    assert I18n.backend.initialized?
+  class WithCacheTest < WithoutCacheTest
+    def setup
+      super
+
+      I18n::Backend::ActiveRecord.config.cache_translations = true
+    end
   end
 end

data/test/api_test.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class I18nActiveRecordApiTest < I18n::TestCase
   def setup
     I18n.backend = I18n::Backend::ActiveRecord.new
+
     super
   end
 
@@ -23,7 +26,7 @@ class I18nActiveRecordApiTest < I18n::TestCase
   include I18n::Tests::Localization::Time
   include I18n::Tests::Localization::Procs if can_store_procs?
 
-  test "make sure we use an ActiveRecord backend" do
+  test 'make sure we use an ActiveRecord backend' do
     assert_equal I18n::Backend::ActiveRecord, I18n.backend.class
   end
 end

data/test/missing_test.rb

@@ -1,70 +1,107 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class I18nActiveRecordMissingTest < I18n::TestCase
-  class Backend < I18n::Backend::ActiveRecord
+  class BackendWithMissing < I18n::Backend::ActiveRecord
     include I18n::Backend::ActiveRecord::Missing
   end
 
   def setup
-    I18n.backend.store_translations(:en, :bar => 'Bar', :i18n => { :plural => { :keys => [:zero, :one, :other] } })
-    I18n.backend = I18n::Backend::Chain.new(Backend.new, I18n.backend)
-    I18n::Backend::ActiveRecord::Translation.delete_all
-  end
+    super
+
+    I18n::Backend::ActiveRecord::Translation.destroy_all
+    I18n.backend = BackendWithMissing.new
 
-  test "can persist interpolations" do
-    translation = I18n::Backend::ActiveRecord::Translation.new(:key => 'foo', :value => 'bar', :locale => :en)
-    translation.interpolations = %w(count name)
-    translation.save
-    assert translation.valid?
+    store_translations(:en, bar: 'Bar', i18n: { plural: { keys: %i[zero one other] } })
   end
 
-  test "lookup persists the key" do
-    I18n.t('foo.bar.baz')
+  def teardown
+    I18n::Backend::ActiveRecord.instance_variable_set :@config, I18n::Backend::ActiveRecord::Configuration.new
 
-    assert_equal 1, I18n::Backend::ActiveRecord::Translation.count
-    assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
+    super
   end
 
-  test "lookup does not persist the key twice" do
-    2.times { I18n.t('foo.bar.baz') }
-    assert_equal 1, I18n::Backend::ActiveRecord::Translation.count
-    assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
-  end
+  class WithoutCacheTest < I18nActiveRecordMissingTest
+    def setup
+      super
 
-  test "lookup persists interpolation keys when looked up directly" do
-    I18n.t('foo.bar.baz', :cow => "lucy" )  # creates stub translation.
-    translation_stub = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo.bar.baz').first
-    assert translation_stub.interpolates?(:cow)
-  end
+      I18n::Backend::ActiveRecord.config.cache_translations = false
+    end
 
-  test "creates one stub per pluralization" do
-    I18n.t('foo', :count => 999)
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).where key: %w{ foo.zero foo.one foo.other }
-    assert_equal 3, translations.length
-  end
+    test 'can persist interpolations' do
+      translation = I18n::Backend::ActiveRecord::Translation.new(key: 'foo', value: 'bar', locale: :en)
+      translation.interpolations = %w[count name]
+      translation.save
 
-  test "creates no stub for base key in pluralization" do
-    I18n.t('foo', :count => 999)
-    assert_equal 3, I18n::Backend::ActiveRecord::Translation.locale(:en).lookup("foo").count
-    assert !I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key("foo")
-  end
+      assert translation.valid?
+    end
 
-  test "creates a stub when a custom separator is used" do
-    I18n.t('foo|baz', :separator => '|')
-    I18n::Backend::ActiveRecord::Translation.locale(:en).lookup("foo.baz").first.update(:value => 'baz!')
-    assert_equal 'baz!', I18n.t('foo|baz', :separator => '|')
-  end
+    test 'lookup persists the key' do
+      I18n.t('foo.bar.baz')
+
+      assert_equal 3, I18n::Backend::ActiveRecord::Translation.count
+      assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
+    end
+
+    test 'lookup does not persist the key twice' do
+      2.times { I18n.t('foo.bar.baz') }
+
+      assert_equal 3, I18n::Backend::ActiveRecord::Translation.count
+      assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
+    end
+
+    test 'lookup persists interpolation keys when looked up directly' do
+      I18n.t('foo.bar.baz', cow: 'lucy')  # creates stub translation.
+      translation_stub = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo.bar.baz').first
 
-  test "creates a stub per pluralization when a custom separator is used" do
-    I18n.t('foo|bar', :count => 999, :separator => '|')
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).where key: %w{ foo.bar.zero foo.bar.one foo.bar.other }
-    assert_equal 3, translations.length
+      assert translation_stub.interpolates?(:cow)
+    end
+
+    test 'creates one stub per pluralization' do
+      I18n.t('foo', count: 999)
+      translations = I18n::Backend::ActiveRecord::Translation.locale(:en).where(key: %w[foo.zero foo.one foo.other])
+
+      assert_equal 3, translations.length
+    end
+
+    test 'creates no stub for base key in pluralization' do
+      I18n.t('foo', count: 999)
+
+      assert_equal 3, I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').count
+      assert !I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo')
+    end
+
+    test 'creates a stub when a custom separator is used' do
+      I18n.t('foo|baz', separator: '|')
+      I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo.baz').first.update(value: 'baz!')
+
+      assert_equal 'baz!', I18n.t('foo|baz', separator: '|')
+    end
+
+    test 'creates a stub per pluralization when a custom separator is used' do
+      I18n.t('foo|bar', count: 999, separator: '|')
+      translations = I18n::Backend::ActiveRecord::Translation
+        .locale(:en)
+        .where(key: %w[foo.bar.zero foo.bar.one foo.bar.other])
+
+      assert_equal 3, translations.length
+    end
+
+    test 'creates a stub when a custom separator is used and the key contains the flatten separator(a dot character)' do
+      key = 'foo|baz.zab'
+      I18n.t(key, separator: '|')
+      I18n::Backend::ActiveRecord::Translation.locale(:en).lookup("foo.baz\001zab").first.update(value: 'baz!')
+
+      assert_equal 'baz!', I18n.t(key, separator: '|')
+    end
   end
 
-  test "creates a stub when a custom separator is used and the key contains the flatten separator (a dot character)" do
-    key = 'foo|baz.zab'
-    I18n.t(key, :separator => '|')
-    I18n::Backend::ActiveRecord::Translation.locale(:en).lookup("foo.baz\001zab").first.update(:value => 'baz!')
-    assert_equal 'baz!', I18n.t(key, :separator => '|')
+  class WithCacheTest < WithoutCacheTest
+    def setup
+      super
+
+      I18n::Backend::ActiveRecord.config.cache_translations = true
+    end
   end
 end

data/test/test_helper.rb

@@ -1,8 +1,8 @@
-$KCODE = 'u' if RUBY_VERSION <= '1.9'
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'minitest/autorun'
-require 'mocha/setup'
+require 'mocha/minitest'
 require 'test_declarative'
 
 require 'i18n/active_record'
@@ -15,67 +15,79 @@ rescue LoadError => e
   puts "can't use ActiveRecord backend because: #{e.message}"
 rescue ::ActiveRecord::ConnectionNotEstablished
   require 'i18n/backend/active_record'
+
   case ENV['DB']
   when 'postgres'
-    ::ActiveRecord::Base.establish_connection adapter: 'postgresql', database: 'i18n_unittest', username: ENV['PG_USER'] || 'i18n', password: '', host: 'localhost'
+    ::ActiveRecord::Base.establish_connection(
+      adapter: 'postgresql',
+      database: 'i18n_unittest',
+      username: ENV['PG_USER'] || 'postgres',
+      password: ENV['PG_PASSWORD'] || 'postgres',
+      host: 'localhost'
+    )
   when 'mysql'
-    ::ActiveRecord::Base.establish_connection adapter: 'mysql2', database: 'i18n_unittest', username: 'root', password: '', host: 'localhost'
+    ::ActiveRecord::Base.establish_connection(
+      adapter: 'mysql2',
+      database: 'i18n_unittest',
+      username: ENV['MYSQL_USER'] || 'root',
+      password: ENV['MYSQL_PASSWORD'] || '',
+      host: '127.0.0.1'
+    )
   else
     ::ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
   end
+
   ::ActiveRecord::Migration.verbose = false
-  ::ActiveRecord::Schema.define(:version => 1) do
-    create_table :translations, :force => true do |t|
+  ::ActiveRecord::Schema.define(version: 1) do
+    create_table :translations, force: true do |t|
       t.string :locale
       t.string :key
       t.text :value
       t.text :interpolations
-      t.boolean :is_proc, :default => false
+      t.boolean :is_proc, default: false
     end
-    add_index :translations, [:locale, :key], :unique => true
+    add_index :translations, %i[locale key], unique: true
   end
 end
 
 TEST_CASE = defined?(Minitest::Test) ? Minitest::Test : MiniTest::Unit::TestCase
 
-class TEST_CASE
-  alias :assert_raise :assert_raises
-  alias :assert_not_equal :refute_equal
+class TEST_CASE # rubocop:disable Naming/ClassAndModuleCamelCase
+  alias assert_raise assert_raises
+  alias assert_not_equal refute_equal
 
-  def assert_nothing_raised(*args)
+  def assert_nothing_raised(*_args)
     yield
   end
 end
 
-class I18n::TestCase < TEST_CASE
-  def setup
-    I18n.enforce_available_locales = false
-    I18n.available_locales = []
-    I18n.locale = :en
-    I18n.default_locale = :en
-    I18n.load_path = []
-    super
-  end
-
-  def teardown
-    I18n.enforce_available_locales = false
-    I18n.available_locales = []
-    I18n.locale = :en
-    I18n.default_locale = :en
-    I18n.load_path = []
-    I18n.backend = nil
-    super
-  end
+module I18n
+  class TestCase < TEST_CASE
+    def setup
+      I18n.enforce_available_locales = false
+      I18n.available_locales = []
+      I18n.locale = :en
+      I18n.default_locale = :en
+      I18n.load_path = []
+      super
+    end
 
-  def translations
-    I18n.backend.instance_variable_get(:@translations)
-  end
+    def teardown
+      I18n.enforce_available_locales = false
+      I18n.available_locales = []
+      I18n.locale = :en
+      I18n.default_locale = :en
+      I18n.load_path = []
+      I18n.backend = nil
+      super
+    end
 
-  def store_translations(locale, data)
-    I18n.backend.store_translations(locale, data)
-  end
+    def store_translations(locale, data)
+      I18n.backend.store_translations(locale, data)
+    end
 
-  def locales_dir
-    File.dirname(__FILE__) + '/test_data/locales'
+    def locales_dir
+      "#{File.dirname(__FILE__)}/test_data/locales"
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: i18n-active_record
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Sven Fuchs
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-24 00:00:00.000000000 Z
+date: 2021-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,76 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test_declarative
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: I18n ActiveRecord backend. Allows to store translations in a database
   using ActiveRecord, e.g. for providing a web-interface for managing translations.
 email: svenfuchs@artweb-design.de
@@ -82,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.29
 signing_key:
 specification_version: 4
 summary: I18n ActiveRecord backend