i18n-js 4.1.0 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60f1ad0e9477d8e6570573f64ac2a55136653da8e4791c6fc32e69c9547e197b
-  data.tar.gz: d46a3d8b8a25020635d9c108b2cb2caf3a256e419112a21a0d986f94e1e19c37
+  metadata.gz: 0545bfe4fee26d8a5aed4aec6262e8a3db733ac951dbb0111f05e8fb2488e516
+  data.tar.gz: 50dd6e5e4e019f01e7b72fcfacb71faf2faa73ed7157082c647432b4ef96f263
 SHA512:
-  metadata.gz: a1d63d094866a836a69a9b3fc8f2989608a1b794daf5d5c82062e17b3bcb07ab7fb0ec8f2c05aa27a2585236cff33d974c313ca81be96de129340ecce8f78490
-  data.tar.gz: 7ec126b41663f765a421950c1ddcb215d460681355088fc77731673c44f3baf590cc58c6e5841bc9dda6f58732249488cdad3b020287b57d7d1de70cf8e95716
+  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,22 @@ 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
+  called whenever whenever I18nJS finishes exporting files. You can use it to
+  further process files, or generate new files based on the exported files.
+- [Added] Bult-in plugin `I18nJS::ExportFilesPlugin`, which allows exporting
+  files out of the translations file by using a custom template.
+
 ## v4.1.0 - Dec 09, 2022
 
 - [Added] Parse configuration files as erb.
@@ -18,6 +34,8 @@ Prefix your message with one of the following:
   exported during `I18n.listen`'s boot. The default value is `true`.
 - [Added] Now it's possible to transform translations before exporting them
   using a stable plugin api.
+- [Added] Built-in plugin `I18nJS::EmbedFallbackTranslationsPlugin`, which
+  allows embedding missing translations on exported files.
 - [Deprecated] The `i18n check` has been deprecated. Use
   `i18n lint:translations` instead.
 - [Added] Use `i18n lint:scripts` to lint JavaScript/TypeScript.

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

@@ -140,30 +140,91 @@ embed_fallback_translations:
   enabled: true
 ```
 
+##### `export_files`:
+
+By default, i18n-js will export only JSON files out of your translations. This
+plugin allows exporting other file formats. To use it, add the following to your
+configuration file:
+
+```yaml
+export_files:
+  enabled: true
+  files:
+    - template: path/to/template.erb
+      output: "%{dir}/%{base_name}.ts"
+```
+
+You can export multiple files by define more entries.
+
+The output name can use the following placeholders:
+
+- `%{dir}`: the directory where the translation file is.
+- `%{name}`: file name with extension.
+- `%{base_name}`: file name without extension.
+- `%{digest}`: MD5 hexdigest from the generated file.
+
+The template file must be a valid eRB template. You can execute arbitrary Ruby
+code, so be careful. An example of how you can generate a file can be seen
+below:
+
+```erb
+/* eslint-disable */
+<%= banner %>
+
+import { i18n } from "config/i18n";
+
+i18n.store(<%= JSON.pretty_generate(translations) %>);
+```
+
+This template is loading the instance from `config/i18n` and storing the
+translations that have been loaded. The
+`banner(comment: "// ", include_time: true)` method is built-in. The generated
+file will look something like this:
+
+```typescript
+/* eslint-disable */
+// File generated by i18n-js on 2022-12-10 15:37:00 +0000
+
+import { i18n } from "config/i18n";
+
+i18n.store({
+  en: {
+    "bunny rabbit adventure": "bunny rabbit adventure",
+    "hello sunshine!": "hello sunshine!",
+    "time for bed!": "time for bed!",
+  },
+  es: {
+    "bunny rabbit adventure": "conejito conejo aventura",
+    bye: "adios",
+    "time for bed!": "hora de acostarse!",
+  },
+  pt: {
+    "bunny rabbit adventure": "a aventura da coelhinha",
+    bye: "tchau",
+    "time for bed!": "hora de dormir!",
+  },
+});
+```
+
 #### Plugin API
 
 You can transform the exported translations by adding plugins. A plugin must
-inherit from `I18nJS::Plugin` and can have 3 class methods. The following
-example shows how the built-in `embed_fallback_translations` plugin is
-implemented.
+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
-  require "i18n-js/plugin"
-
-  class EmbedFallbackTranslationsPlugin < I18nJS::Plugin
-    CONFIG_KEY = :embed_fallback_translations
+  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`.
+    def transform(translations:)
+      # transform `translations` here…
 
-    # This method must set up the basic plugin configuration, like adding the
-    # config's root key in case your plugin accepts configuration (defined via
-    # the config file).
-    #
-    # If you don't add this key, the linter will prevent non-default keys from
-    # being added to the configuration file.
-    def self.setup
-      I18nJS::Schema.root_keys << CONFIG_KEY
+      translations
     end
 
     # In case your plugin accepts configuration, this is where you must validate
@@ -171,63 +232,44 @@ 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:)
-      return unless config.key?(CONFIG_KEY)
-
-      plugin_config = config[CONFIG_KEY]
-      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])
+    #
+    # 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 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`.
+    # This method must set up the basic plugin configuration, like adding the
+    # config's root key in case your plugin accepts configuration (defined via
+    # the config file).
     #
-    # 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:)
-      return translations unless config.dig(CONFIG_KEY, :enabled)
-
-      translations_glob = Glob.new(translations)
-      translations_glob << "*"
-
-      mapping = translations.keys.each_with_object({}) do |locale, buffer|
-        buffer[locale] = Glob.new(translations[locale]).tap do |glob|
-          glob << "*"
-        end
-      end
-
-      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
-      end
+    # If you don't add this key, the linter will prevent non-default keys from
+    # being added to the configuration file.
+    def setup
+      # If you plugin has configuration, uncomment the line below
+      # I18nJS::Schema.root_keys << config_key
+    end
 
-      translations_glob.to_h
+    # This method is called whenever `I18nJS.call(**kwargs)` finishes exporting
+    # JSON files based on your configuration.
+    #
+    # You can use it to further process exported files, or generate new files
+    # based on the translations that have been exported.
+    def after_export(files:)
+      # process exported files here…
     end
   end
-
-  I18nJS.register_plugin(EmbedFallbackTranslationsPlugin)
 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
@@ -242,7 +284,20 @@ To list missing and extraneous translations, you can use
 how `i18n export` does, but will output the list of keys that don't have a
 matching translation against the default locale. Here's an example:
 
-![`i18n lint:translations` command in action](https://github.com/fnando/i18n-js/raw/main/images/i18njs-check.gif)
+```console
+$ i18n lint:translations
+=> Config file: "./config/i18n.yml"
+=> Require file: "./config/environment.rb"
+=> Check "./config/i18n.yml" for ignored keys.
+=> en: 232 translations
+=> pt-BR: 5 missing, 1 extraneous, 1 ignored
+   - pt-BR.actors.github.metrics (missing)
+   - pt-BR.actors.github.metrics_hint (missing)
+   - pt-BR.actors.github.repo_metrics (missing)
+   - pt-BR.actors.github.repository (missing)
+   - pt-BR.actors.github.user_metrics (missing)
+   - pt-BR.github.repository (extraneous)
+```
 
 This command will exist with status 1 whenever there are missing translations.
 This way you can use it as a CI linting.
@@ -300,9 +355,9 @@ you're using dynamic scoping through variables (e.g.
 `const scope = "message"; i18n.t(scope)`), they will be skipped.
 
 ```console
-$ i18n lint:scripts --config test/config/lint.yml --require test/config/require.rb
-=> Config file: "test/config/lint.yml"
-=> Require file: "test/config/require.rb"
+$ i18n lint:scripts
+=> Config file: "./config/i18n.yml"
+=> Require file: "./config/environment.rb"
 => Node: "/Users/fnando/.asdf/shims/node"
 => Available locales: [:en, :es, :pt]
 => Patterns: ["!(node_modules)/**/*.js", "!(node_modules)/**/*.ts", "!(node_modules)/**/*.jsx", "!(node_modules)/**/*.tsx"]
@@ -464,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/bin/{pack → release}

@@ -19,7 +19,7 @@ major, minor, patch = *segments.take(3).map(&:to_i)
 pre = segments[4].to_s
 pre_version = pre.gsub(/[^\d]/m, "").to_i
 date = Time.now.strftime("%b %d, %Y")
-release = false
+dry_run = false
 alpha = false
 
 OptionParser.new do |opts|
@@ -39,8 +39,8 @@ OptionParser.new do |opts|
     alpha = true
   end
 
-  opts.on("--release") do
-    release = true
+  opts.on("--dry-run") do
+    dry_run = true
   end
 end.parse!
 
@@ -69,11 +69,13 @@ write_file version_path,
 
 puts "=> Updated #{version_path}"
 
-if release
+unless dry_run
   system "git", "add", changelog_path, version_path
   system "git", "commit", "-m", "Bump up version (v#{version})"
-  system "git", "tag", "v#{version}"
+  system "rake", "release"
 end
 
-system "rake", "build"
-system "git", "checkout", changelog_path, version_path unless release
+if dry_run
+  system "rake", "build"
+  system "git", "checkout", changelog_path, version_path
+end

data/lib/i18n-js/embed_fallback_translations_plugin.rb

@@ -4,73 +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
 
-    # This method must set up the basic plugin configuration, like adding the
-    # config's root key in case your plugin accepts configuration (defined via
-    # the config file).
-    #
-    # If you don't add this key, the linter will prevent non-default keys from
-    # being added to the configuration file.
-    def self.setup
-      I18nJS::Schema.root_keys << CONFIG_KEY
+      def self.deep_merge(target_hash, hash)
+        target_hash.merge(hash, &MERGER)
+      end
     end
 
-    # In case your plugin accepts configuration, this is where you must validate
-    # the configuration, making sure only valid keys and type is provided.
-    # 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:)
-      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
 
-    # 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:)
-      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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module I18nJS
+  require "i18n-js/plugin"
+
+  class ExportFilesPlugin < I18nJS::Plugin
+    def setup
+      I18nJS::Schema.root_keys << config_key
+    end
+
+    def validate_schema
+      valid_keys = %i[enabled files]
+
+      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]
+
+        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"
+
+      files.each do |file|
+        dir = File.dirname(file)
+        name = File.basename(file)
+        extension = File.extname(name)
+        base_name = File.basename(file, extension)
+
+        config[:files].each do |export|
+          translations = JSON.load_file(file)
+          template = Template.new(
+            file: file,
+            translations: translations,
+            template: export[:template]
+          )
+
+          contents = template.render
+
+          output = format(
+            export[:output],
+            dir: dir,
+            name: name,
+            extension: extension,
+            digest: Digest::MD5.hexdigest(contents),
+            base_name: base_name
+          )
+
+          File.open(output, "w") do |io|
+            io << contents
+          end
+        end
+      end
+    end
+
+    class Template
+      attr_accessor :file, :translations, :template
+
+      def initialize(**kwargs)
+        kwargs.each do |key, value|
+          public_send("#{key}=", value)
+        end
+      end
+
+      def banner(comment: "// ", include_time: true)
+        [
+          "#{comment}File generated by i18n-js",
+          include_time ? " on #{Time.now}" : nil
+        ].compact.join
+      end
+
+      def render
+        ERB.new(File.read(template)).result(binding)
+      end
+    end
+  end
+
+  I18nJS.register_plugin(ExportFilesPlugin)
+end

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,17 +25,79 @@ 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
-    def self.transform(translations:, config:) # rubocop:disable Lint/UnusedMethodArgument
+    # 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`.
+    def transform(translations:)
       translations
     end
 
-    # Must raise I18nJS::SchemaInvalidError with the error message if schema
-    # validation has failed.
-    def self.validate_schema(config:)
+    # In case your plugin accepts configuration, this is where you must validate
+    # the configuration, making sure only valid keys and type is provided.
+    # If the configuration contains invalid data, then you must raise an
+    # exception using something like
+    # `raise I18nJS::Schema::InvalidError, error_message`.
+    def validate_schema
+    end
+
+    # This method must set up the basic plugin configuration, like adding the
+    # config's root key in case your plugin accepts configuration (defined via
+    # the config file).
+    #
+    # If you don't add this key, the linter will prevent non-default keys from
+    # being added to the configuration file.
+    def setup
     end
 
-    def self.setup
+    # This method is called whenever `I18nJS.call(**kwargs)` finishes exporting
+    # JSON files based on your configuration.
+    #
+    # You can use it to further process exported files, or generate new files
+    # based on the translations that have been exported.
+    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.1.0"
+  VERSION = "4.2.1"
 end

data/lib/i18n-js.rb

@@ -23,25 +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)
+    config[:translations].each {|group| exported_files += export_group(group) }
+
+    plugins.each do |plugin|
+      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.1.0
+  version: 4.2.1
 platform: ruby
 authors:
 - Nando Vieira
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-09 00:00:00.000000000 Z
+date: 2022-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: glob
@@ -190,7 +190,7 @@ files:
 - MIGRATING_FROM_V3_TO_V4.md
 - README.md
 - Rakefile
-- bin/pack
+- bin/release
 - exe/i18n
 - i18n-js.gemspec
 - lib/guard/i18n-js.rb
@@ -208,6 +208,7 @@ files:
 - lib/i18n-js/cli/ui.rb
 - lib/i18n-js/cli/version_command.rb
 - lib/i18n-js/embed_fallback_translations_plugin.rb
+- lib/i18n-js/export_files_plugin.rb
 - lib/i18n-js/lint.js
 - lib/i18n-js/lint.ts
 - lib/i18n-js/listen.rb
@@ -222,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.1.0
-  changelog_uri: https://github.com/fnando/i18n-js/tree/v4.1.0/CHANGELOG.md
-  documentation_uri: https://github.com/fnando/i18n-js/tree/v4.1.0/README.md
-  license_uri: https://github.com/fnando/i18n-js/tree/v4.1.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:
@@ -241,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.