i18n-js 4.2.0 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dac70b6202710a44a8303deff7206848d702b4cdb3cc926552aec41114ff745
-  data.tar.gz: 2631494d675d0d8459ab5450bb634fee6c305dd6c01d32bb03d647ac2a657d9e
+  metadata.gz: 0545bfe4fee26d8a5aed4aec6262e8a3db733ac951dbb0111f05e8fb2488e516
+  data.tar.gz: 50dd6e5e4e019f01e7b72fcfacb71faf2faa73ed7157082c647432b4ef96f263
 SHA512:
-  metadata.gz: 67c7b4a499d4848967461c1d3a798de2d814af972049f6977d7cf4dc5c6781bfc6ecdc1129068f963ba8dc115ebe5c219f078ef00b92204f86c54a114d55aba3
-  data.tar.gz: 329799184d84e27455783a6a4522b9a0cce446ba33ab3d5cfe74e22d08f685736abb4329e2506e1c2d83504d963c777317f8998a838fb3fae8c358f65569c5b5
+  metadata.gz: b5366522c08e868ce0b555a4d0c0d10029bbee9270cb9602600f1ca4f2e89473f02baa577644dd5ae9a38046c3c03abf6c66029d79bac7d4ca41f50ed6ea4b86
+  data.tar.gz: c3a0670b398c51c9bd1e01b163c46b2e69fe8f4ee06a099d8d46dc78ee57da1e78bff51e35db98ddb15b91fe2f422c8a8584fadb0b4066dc191a01eab65adac4

data/.github/workflows/ruby-tests.yml

@@ -44,7 +44,7 @@ jobs:
             hashFiles('package.json') }}
 
       - name: Set up Node
-        uses: actions/setup-node@v2-beta
+        uses: actions/setup-node@v3.5.1
         with:
           node-version: ${{ matrix.node }}
 

data/CHANGELOG.md

@@ -11,6 +11,14 @@ Prefix your message with one of the following:
 - [Security] in case of vulnerabilities.
 -->
 
+## v4.2.1 - Dec 25, 2022
+
+- [Changed] Change plugin api to be based on instance methods. This avoids
+  having to pass in the config for each and every method. It also allows us
+  adding helper methods to the base class.
+- [Fixed] Fix performance issues with embed fallback translations' initial
+  implementation.
+
 ## v4.2.0 - Dec 10, 2022
 
 - [Added] Add `I18nJS::Plugin.after_export(files:, config:)` method, that's

data/MIGRATING_FROM_V3_TO_V4.md

@@ -47,8 +47,8 @@ JSON
 ```
 
 You can also use guard. Make sure you have both
-[guard](https://rubygems.org/packages/guard) and
-[guard-compat](https://rubygems.org/packages/guard-compat) installed and use
+[guard](https://rubygems.org/gems/guard) and
+[guard-compat](https://rubygems.org/gems/guard-compat) installed and use
 Guardfile file with the following contents:
 
 ```ruby
@@ -174,8 +174,8 @@ translations:
 
 Other configuration options:
 
-- `export_i18n_js`: removed without an equivalent
-- `fallbacks`: removed without an equivalent
+- `export_i18n_js`: replaced by [export_files plugin](https://github.com/fnando/i18n-js#export_files)
+- `fallbacks`: replaced by [embed_fallback_translations plugin](https://github.com/fnando/i18n-js#embed_fallback_translations)
 - `js_available_locales`: removed (on v4 you can use groups, like in
   `{pt-BR,en}.*`)
 - `namespace`: removed without an equivalent

data/README.md

@@ -209,26 +209,21 @@ i18n.store({
 #### Plugin API
 
 You can transform the exported translations by adding plugins. A plugin must
-inherit from `I18nJS::Plugin` and can have 4 class methods. To see a real
-example, see
-[lib/i18n-js/embed_fallback_translations_plugin.rb](https://github.com/fnando/i18n-js/blob/main/lib/i18n-js/embed_fallback_translations_plugin.rb)
-
-Here's the base `I18nJS::Plugin` class with the documented api:
+inherit from `I18nJS::Plugin` and can have 4 class methods (they're all optional
+and will default to a noop implementation). For real examples, see [lib/i18n-js/embed_fallback_translations_plugin.rb](https://github.com/fnando/i18n-js/blob/main/lib/i18n-js/embed_fallback_translations_plugin.rb) and [lib/i18n-js/export_files_plugin.rb](https://github.com/fnando/i18n-js/blob/main/lib/i18n-js/export_files_plugin.rb)
 
 ```ruby
 # frozen_string_literal: true
 
 module I18nJS
-  class Plugin
+  class SamplePlugin < I18nJS::Plugin
     # This method is responsible for transforming the translations. The
     # translations you'll receive may be already be filtered by other plugins
     # and by the default filtering itself. If you need to access the original
     # translations, use `I18nJS.translations`.
-    #
-    # Make sure you always check whether your plugin is active before
-    # transforming translations; otherwise, opting out transformation won't be
-    # possible.
-    def self.transform(translations:, config:)
+    def transform(translations:)
+      # transform `translations` here…
+
       translations
     end
 
@@ -237,7 +232,11 @@ module I18nJS
     # If the configuration contains invalid data, then you must raise an
     # exception using something like
     # `raise I18nJS::Schema::InvalidError, error_message`.
-    def self.validate_schema(config:)
+    #
+    # Notice the validation will only happen when the plugin configuration is
+    # set (i.e. the configuration contains your config key).
+    def validate_schema
+      # validate plugin schema here…
     end
 
     # This method must set up the basic plugin configuration, like adding the
@@ -246,7 +245,9 @@ module I18nJS
     #
     # If you don't add this key, the linter will prevent non-default keys from
     # being added to the configuration file.
-    def self.setup
+    def setup
+      # If you plugin has configuration, uncomment the line below
+      # I18nJS::Schema.root_keys << config_key
     end
 
     # This method is called whenever `I18nJS.call(**kwargs)` finishes exporting
@@ -254,15 +255,21 @@ module I18nJS
     #
     # You can use it to further process exported files, or generate new files
     # based on the translations that have been exported.
-    #
-    # Make sure you always check whether your plugin is active before
-    # processing files; otherwise, opting out won't be possible.
-    def self.after_export(files:, config:)
+    def after_export(files:)
+      # process exported files here…
     end
   end
 end
 ```
 
+The class `I18nJS::Plugin` implements some helper methods that you can use:
+
+- `I18nJS::Plugin#config_key`: the configuration key that was inferred out of
+  your plugin's class name.
+- `I18nJS::Plugin#config`: the plugin configuration.
+- `I18nJS::Plugin#enabled?`: whether the plugin is enabled or not based on the
+  plugin's configuration.
+
 To distribute this plugin, you need to create a gem package that matches the
 pattern `i18n-js/*_plugin.rb`. You can test whether your plugin will be found by
 installing your gem, opening a iRB session and running
@@ -512,7 +519,7 @@ that loads all the exported translation.
 
 [There's a document](https://github.com/fnando/i18n-js/tree/main/MIGRATING_FROM_V3_TO_V4.md)
 outlining some of the things you need to do to migrate from v3 to v4. It may not
-be as complete as we'd like it to be, so let's know if you face any issues
+be as complete as we'd like it to be, so let us know if you face any issues
 during the migration is not outline is that document.
 
 #### How can I export translations without having a database around?

data/lib/i18n-js/embed_fallback_translations_plugin.rb

@@ -4,54 +4,65 @@ module I18nJS
   require "i18n-js/plugin"
 
   class EmbedFallbackTranslationsPlugin < I18nJS::Plugin
-    CONFIG_KEY = :embed_fallback_translations
+    module Utils
+      # Based on deep_merge by Stefan Rusterholz, see
+      # <https://www.ruby-forum.com/topic/142809>.
+      # This method is used to handle I18n fallbacks. Given two equivalent path
+      # nodes in two locale trees:
+      # 1. If the node in the current locale appears to be an I18n pluralization
+      #    (:one, :other, etc.), use the node, but merge in any missing/non-nil
+      #    keys from the fallback (default) locale.
+      # 2. Else if both nodes are Hashes, combine (merge) the key-value pairs of
+      #    the two nodes into one, prioritizing the current locale.
+      # 3. Else if either node is nil, use the other node.
+
+      PLURAL_KEYS = %i[zero one two few many other].freeze
+      PLURAL_MERGER = proc {|_key, v1, v2| v1 || v2 }
+      MERGER = proc do |_key, v1, v2|
+        if v1.is_a?(Hash) && v2.is_a?(Hash)
+          if (v2.keys - PLURAL_KEYS).empty?
+            v2.merge(v1, &PLURAL_MERGER).slice(*v2.keys)
+          else
+            v1.merge(v2, &MERGER)
+          end
+        else
+          v2 || v1
+        end
+      end
 
-    def self.setup
-      I18nJS::Schema.root_keys << CONFIG_KEY
+      def self.deep_merge(target_hash, hash)
+        target_hash.merge(hash, &MERGER)
+      end
     end
 
-    def self.validate_schema(config:)
-      return unless config.key?(CONFIG_KEY)
+    def setup
+      I18nJS::Schema.root_keys << config_key
+    end
 
-      plugin_config = config[CONFIG_KEY]
+    def validate_schema
       valid_keys = %i[enabled]
-      schema = I18nJS::Schema.new(config)
 
-      schema.expect_required_keys(valid_keys, plugin_config)
-      schema.reject_extraneous_keys(valid_keys, plugin_config)
-      schema.expect_enabled_config(CONFIG_KEY, plugin_config[:enabled])
+      schema.expect_required_keys(keys: valid_keys, path: [config_key])
+      schema.reject_extraneous_keys(keys: valid_keys, path: [config_key])
     end
 
-    def self.transform(translations:, config:)
-      return translations unless config.dig(CONFIG_KEY, :enabled)
+    def transform(translations:)
+      return translations unless enabled?
 
-      translations_glob = Glob.new(translations)
-      translations_glob << "*"
+      fallback_locale = I18n.default_locale.to_sym
+      locales_to_fallback = translations.keys - [fallback_locale]
 
-      mapping = translations.keys.each_with_object({}) do |locale, buffer|
-        buffer[locale] = Glob.new(translations[locale]).tap do |glob|
-          glob << "*"
-        end
-      end
+      translations_with_fallback = {}
+      translations_with_fallback[fallback_locale] =
+        translations[fallback_locale]
 
-      default_locale = I18n.default_locale
-      default_locale_glob = mapping.delete(default_locale)
-      default_locale_paths = default_locale_glob.paths
-
-      mapping.each do |locale, glob|
-        missing_keys = default_locale_paths - glob.paths
-
-        missing_keys.each do |key|
-          components = key.split(".").map(&:to_sym)
-          fallback_translation = translations.dig(default_locale, *components)
-
-          next unless fallback_translation
-
-          translations_glob.set([locale, key].join("."), fallback_translation)
-        end
+      locales_to_fallback.each do |locale|
+        translations_with_fallback[locale] = Utils.deep_merge(
+          translations[fallback_locale], translations[locale]
+        )
       end
 
-      translations_glob.to_h
+      translations_with_fallback
     end
   end
 

data/lib/i18n-js/export_files_plugin.rb

@@ -4,37 +4,43 @@ module I18nJS
   require "i18n-js/plugin"
 
   class ExportFilesPlugin < I18nJS::Plugin
-    CONFIG_KEY = :export_files
-
-    def self.setup
-      I18nJS::Schema.root_keys << CONFIG_KEY
+    def setup
+      I18nJS::Schema.root_keys << config_key
     end
 
-    def self.validate_schema(config:)
-      return unless config.key?(CONFIG_KEY)
-
-      plugin_config = config[CONFIG_KEY]
+    def validate_schema
       valid_keys = %i[enabled files]
-      schema = I18nJS::Schema.new(config)
-
-      schema.expect_required_keys(valid_keys, plugin_config)
-      schema.reject_extraneous_keys(valid_keys, plugin_config)
-      schema.expect_enabled_config(CONFIG_KEY, plugin_config[:enabled])
-      schema.expect_array_with_items(:files, plugin_config[:files])
-
-      plugin_config[:files].each do |exports|
-        schema.expect_required_keys(%i[template output], exports)
-        schema.reject_extraneous_keys(%i[template output], exports)
-        schema.expect_type(:template, exports[:template], String, exports)
-        schema.expect_type(:output, exports[:output], String, exports)
-      end
-    end
 
-    def self.after_export(files:, config:)
-      return unless config.dig(CONFIG_KEY, :enabled)
+      schema.expect_required_keys(keys: valid_keys, path: [config_key])
+      schema.reject_extraneous_keys(keys: valid_keys, path: [config_key])
+      schema.expect_array_with_items(path: [config_key, :files])
+
+      config[:files].each_with_index do |_exports, index|
+        export_keys = %i[template output]
 
-      exports = config.dig(CONFIG_KEY, :files)
+        schema.expect_required_keys(
+          keys: export_keys,
+          path: [config_key, :files, index]
+        )
+
+        schema.reject_extraneous_keys(
+          keys: export_keys,
+          path: [config_key, :files, index]
+        )
+
+        schema.expect_type(
+          path: [config_key, :files, index, :template],
+          types: String
+        )
+
+        schema.expect_type(
+          path: [config_key, :files, index, :output],
+          types: String
+        )
+      end
+    end
 
+    def after_export(files:)
       require "erb"
       require "digest/md5"
       require "json"
@@ -45,7 +51,7 @@ module I18nJS
         extension = File.extname(name)
         base_name = File.basename(file, extension)
 
-        exports.each do |export|
+        config[:files].each do |export|
           translations = JSON.load_file(file)
           template = Template.new(
             file: file,

data/lib/i18n-js/plugin.rb

@@ -3,13 +3,16 @@
 require_relative "schema"
 
 module I18nJS
+  def self.available_plugins
+    @available_plugins ||= Set.new
+  end
+
   def self.plugins
     @plugins ||= []
   end
 
   def self.register_plugin(plugin)
-    plugins << plugin
-    plugin.setup
+    available_plugins << plugin
   end
 
   def self.plugin_files
@@ -22,16 +25,53 @@ module I18nJS
     end
   end
 
+  def self.initialize_plugins!(config:)
+    @plugins = available_plugins.map do |plugin|
+      plugin.new(config: config).tap(&:setup)
+    end
+  end
+
   class Plugin
+    # The configuration that's being used to export translations.
+    attr_reader :main_config
+
+    # The `I18nJS::Schema` instance that can be used to validate your plugin's
+    # configuration.
+    attr_reader :schema
+
+    def initialize(config:)
+      @main_config = config
+      @schema = I18nJS::Schema.new(@main_config)
+    end
+
+    # Infer the config key name out of the class.
+    # If you plugin is called `MySamplePlugin`, the key will be `my_sample`.
+    def config_key
+      self.class.name.split("::").last
+          .gsub(/Plugin$/, "")
+          .gsub(/^([A-Z]+)([A-Z])/) { "#{$1.downcase}#{$2}" }
+          .gsub(/^([A-Z]+)/) { $1.downcase }
+          .gsub(/([A-Z]+)/m) { "_#{$1.downcase}" }
+          .downcase
+          .to_sym
+    end
+
+    # Return the plugin configuration
+    def config
+      main_config[config_key] || {}
+    end
+
+    # Check whether plugin is enabled or not.
+    # A plugin is enabled when the plugin configuration has `enabled: true`.
+    def enabled?
+      config[:enabled]
+    end
+
     # This method is responsible for transforming the translations. The
     # translations you'll receive may be already be filtered by other plugins
     # and by the default filtering itself. If you need to access the original
     # translations, use `I18nJS.translations`.
-    #
-    # Make sure you always check whether your plugin is active before
-    # transforming translations; otherwise, opting out transformation won't be
-    # possible.
-    def self.transform(translations:, config:) # rubocop:disable Lint/UnusedMethodArgument
+    def transform(translations:)
       translations
     end
 
@@ -40,7 +80,7 @@ module I18nJS
     # If the configuration contains invalid data, then you must raise an
     # exception using something like
     # `raise I18nJS::Schema::InvalidError, error_message`.
-    def self.validate_schema(config:)
+    def validate_schema
     end
 
     # This method must set up the basic plugin configuration, like adding the
@@ -49,7 +89,7 @@ module I18nJS
     #
     # If you don't add this key, the linter will prevent non-default keys from
     # being added to the configuration file.
-    def self.setup
+    def setup
     end
 
     # This method is called whenever `I18nJS.call(**kwargs)` finishes exporting
@@ -57,10 +97,7 @@ module I18nJS
     #
     # You can use it to further process exported files, or generate new files
     # based on the translations that have been exported.
-    #
-    # Make sure you always check whether your plugin is active before
-    # processing files; otherwise, opting out won't be possible.
-    def self.after_export(files:, config:)
+    def after_export(files:)
     end
   end
 end

data/lib/i18n-js/schema.rb

@@ -25,7 +25,7 @@ module I18nJS
     def self.validate!(target)
       schema = new(target)
       schema.validate!
-      I18nJS.plugins.each {|plugin| plugin.validate_schema(config: target) }
+      schema
     end
 
     attr_reader :target
@@ -35,13 +35,44 @@ module I18nJS
     end
 
     def validate!
-      expect_type(:root, target, Hash, target)
+      validate_root
+
+      expect_required_keys(
+        keys: self.class.required_root_keys,
+        path: nil
+      )
+
+      reject_extraneous_keys(
+        keys: self.class.root_keys,
+        path: nil
+      )
 
-      expect_required_keys(self.class.required_root_keys, target)
-      reject_extraneous_keys(self.class.root_keys, target)
       validate_translations
       validate_lint_translations
       validate_lint_scripts
+      validate_plugins
+    end
+
+    def validate_plugins
+      I18nJS.plugins.each do |plugin|
+        next unless target.key?(plugin.config_key)
+
+        expect_type(
+          path: [plugin.config_key, :enabled],
+          types: [TrueClass, FalseClass]
+        )
+
+        plugin.validate_schema
+      end
+    end
+
+    def validate_root
+      return if target.is_a?(Hash)
+
+      message =  "Expected config to be \"Hash\"; " \
+                 "got #{target.class} instead"
+
+      reject message, target
     end
 
     def validate_lint_translations
@@ -49,11 +80,14 @@ module I18nJS
 
       return unless target.key?(key)
 
-      config = target[key]
+      expect_type(path: [key], types: Hash)
+
+      expect_required_keys(
+        keys: REQUIRED_LINT_TRANSLATIONS_KEYS,
+        path: [key]
+      )
 
-      expect_type(key, config, Hash, target)
-      expect_required_keys(REQUIRED_LINT_TRANSLATIONS_KEYS, config)
-      expect_type(:ignore, config[:ignore], Array, config)
+      expect_type(path: [key, :ignore], types: Array)
     end
 
     def validate_lint_scripts
@@ -61,31 +95,36 @@ module I18nJS
 
       return unless target.key?(key)
 
-      config = target[key]
-
-      expect_type(key, config, Hash, target)
-      expect_required_keys(REQUIRED_LINT_SCRIPTS_KEYS, config)
-      expect_type(:ignore, config[:ignore], Array, config)
-      expect_type(:patterns, config[:patterns], Array, config)
+      expect_type(path: [key], types: Hash)
+      expect_required_keys(
+        keys: REQUIRED_LINT_SCRIPTS_KEYS,
+        path: [key]
+      )
+      expect_type(path: [key, :ignore], types: Array)
+      expect_type(path: [key, :patterns], types: Array)
     end
 
     def validate_translations
-      translations = target[:translations]
-
-      expect_type(:translations, translations, Array, target)
-      expect_array_with_items(:translations, translations)
+      expect_array_with_items(path: [:translations])
 
-      translations.each do |translation|
-        validate_translation(translation)
+      target[:translations].each_with_index do |translation, index|
+        validate_translation(translation, index)
       end
     end
 
-    def validate_translation(translation)
-      expect_required_keys(REQUIRED_TRANSLATION_KEYS, translation)
-      reject_extraneous_keys(TRANSLATION_KEYS, translation)
-      expect_type(:file, translation[:file], String, translation)
-      expect_type(:patterns, translation[:patterns], Array, translation)
-      expect_array_with_items(:patterns, translation[:patterns], translation)
+    def validate_translation(_translation, index)
+      expect_required_keys(
+        path: [:translations, index],
+        keys: REQUIRED_TRANSLATION_KEYS
+      )
+
+      reject_extraneous_keys(
+        keys: TRANSLATION_KEYS,
+        path: [:translations, index]
+      )
+
+      expect_type(path: [:translations, index, :file], types: String)
+      expect_array_with_items(path: [:translations, index, :patterns])
     end
 
     def reject(error_message, node = nil)
@@ -93,51 +132,85 @@ module I18nJS
       raise InvalidError, "#{error_message}#{node_json}"
     end
 
-    def expect_enabled_config(config_key, value)
-      return if [TrueClass, FalseClass].include?(value.class)
-
-      actual_type = value.class
-
-      reject "Expected #{config_key}.enabled to be a boolean; " \
-             "got #{actual_type} instead"
-    end
+    def expect_type(path:, types:)
+      path = prepare_path(path: path)
+      value = value_for(path: path)
+      types = Array(types)
 
-    def expect_type(attribute, value, expected_type, payload)
-      return if value.is_a?(expected_type)
+      return if types.any? {|type| value.is_a?(type) }
 
       actual_type = value.class
 
+      type_desc = if types.size == 1
+                    types[0].to_s.inspect
+                  else
+                    "one of #{types.inspect}"
+                  end
+
       message = [
-        "Expected #{attribute.inspect} to be #{expected_type};",
+        "Expected #{path.join('.').inspect} to be #{type_desc};",
         "got #{actual_type} instead"
       ].join(" ")
 
-      reject message, payload
+      reject message, target
     end
 
-    def expect_array_with_items(attribute, value, payload = value)
+    def expect_array_with_items(path:)
+      expect_type(path: path, types: Array)
+
+      path = prepare_path(path: path)
+      value = value_for(path: path)
+
       return unless value.empty?
 
-      reject "Expected #{attribute.inspect} to have at least one item", payload
+      reject "Expected #{path.join('.').inspect} to have at least one item",
+             target
     end
 
-    def expect_required_keys(required_keys, value)
-      keys = value.keys.map(&:to_sym)
+    def expect_required_keys(keys:, path:)
+      path = prepare_path(path: path)
+      value = value_for(path: path)
+      actual_keys = value.keys.map(&:to_sym)
 
-      required_keys.each do |key|
-        next if keys.include?(key)
+      keys.each do |key|
+        next if actual_keys.include?(key)
 
-        reject "Expected #{key.inspect} to be defined", value
+        path_desc = if path.empty?
+                      key.to_s.inspect
+                    else
+                      (path + [key]).join(".").inspect
+                    end
+
+        reject "Expected #{path_desc} to be defined", target
       end
     end
 
-    def reject_extraneous_keys(allowed_keys, value)
-      keys = value.keys.map(&:to_sym)
-      extraneous = keys.to_a - allowed_keys.to_a
+    def reject_extraneous_keys(keys:, path:)
+      path = prepare_path(path: path)
+      value = value_for(path: path)
+
+      actual_keys = value.keys.map(&:to_sym)
+      extraneous = actual_keys.to_a - keys.to_a
 
       return if extraneous.empty?
 
-      reject "Unexpected keys: #{extraneous.join(', ')}", value
+      path_desc = if path.empty?
+                    "config"
+                  else
+                    path.join(".").inspect
+                  end
+
+      reject "#{path_desc} has unexpected keys: #{extraneous.inspect}",
+             target
+    end
+
+    def prepare_path(path:)
+      path = path.to_s.split(".").map(&:to_sym) unless path.is_a?(Array)
+      path
+    end
+
+    def value_for(path:)
+      path.empty? ? target : target.dig(*path)
     end
   end
 end

data/lib/i18n-js/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module I18nJS
-  VERSION = "4.2.0"
+  VERSION = "4.2.1"
 end

data/lib/i18n-js.rb

@@ -23,29 +23,32 @@ module I18nJS
             "you must set either `config_file` or `config`"
     end
 
-    load_plugins!
-
     config = Glob::SymbolizeKeys.call(config || load_config_file(config_file))
 
+    load_plugins!
+    initialize_plugins!(config: config)
     Schema.validate!(config)
+
     exported_files = []
 
-    config[:translations].each do |group|
-      exported_files += export_group(group, config)
-    end
+    config[:translations].each {|group| exported_files += export_group(group) }
 
     plugins.each do |plugin|
-      plugin.after_export(files: exported_files.dup, config: config)
+      plugin.after_export(files: exported_files.dup) if plugin.enabled?
     end
 
     exported_files
   end
 
-  def self.export_group(group, config)
+  def self.export_group(group)
     filtered_translations = Glob.filter(translations, group[:patterns])
     filtered_translations =
       plugins.reduce(filtered_translations) do |buffer, plugin|
-        plugin.transform(translations: buffer, config: config)
+        if plugin.enabled?
+          plugin.transform(translations: buffer)
+        else
+          buffer
+        end
       end
 
     output_file_path = File.expand_path(group[:file])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: i18n-js
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.2.1
 platform: ruby
 authors:
 - Nando Vieira
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-11 00:00:00.000000000 Z
+date: 2022-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: glob
@@ -223,10 +223,10 @@ metadata:
   rubygems_mfa_required: 'true'
   homepage_uri: https://github.com/fnando/i18n-js
   bug_tracker_uri: https://github.com/fnando/i18n-js/issues
-  source_code_uri: https://github.com/fnando/i18n-js/tree/v4.2.0
-  changelog_uri: https://github.com/fnando/i18n-js/tree/v4.2.0/CHANGELOG.md
-  documentation_uri: https://github.com/fnando/i18n-js/tree/v4.2.0/README.md
-  license_uri: https://github.com/fnando/i18n-js/tree/v4.2.0/LICENSE.md
+  source_code_uri: https://github.com/fnando/i18n-js/tree/v4.2.1
+  changelog_uri: https://github.com/fnando/i18n-js/tree/v4.2.1/CHANGELOG.md
+  documentation_uri: https://github.com/fnando/i18n-js/tree/v4.2.1/README.md
+  license_uri: https://github.com/fnando/i18n-js/tree/v4.2.1/LICENSE.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -242,7 +242,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Export i18n translations and use them on JavaScript.