i18n-js 3.8.2 → 4.2.3

data/lib/i18n-js/cli/lint_scripts_command.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module I18nJS
+  class CLI
+    class LintScriptsCommand < Command
+      command_name "lint:scripts"
+      description "Lint files using TypeScript"
+
+      parse do |opts|
+        opts.banner = "Usage: i18n #{name} [options]"
+
+        opts.on(
+          "-cCONFIG_FILE",
+          "--config=CONFIG_FILE",
+          "The configuration file that will be used"
+        ) do |config_file|
+          options[:config_file] = config_file
+        end
+
+        opts.on(
+          "-rREQUIRE_FILE",
+          "--require=REQUIRE_FILE",
+          "A Ruby file that must be loaded"
+        ) do |require_file|
+          options[:require_file] = require_file
+        end
+
+        opts.on(
+          "-nNODE_PATH",
+          "--node-path=NODE_PATH",
+          "Set node.js path"
+        ) do |node_path|
+          options[:node_path] = node_path
+        end
+
+        opts.on("-h", "--help", "Prints this help") do
+          ui.exit_with opts.to_s
+        end
+      end
+
+      command do
+        set_defaults!
+        ui.colored = options[:colored]
+
+        unless options[:config_file]
+          ui.fail_with("=> ERROR: you need to specify the config file")
+        end
+
+        ui.stdout_print("=> Config file:", options[:config_file].inspect)
+        config_file = File.expand_path(options[:config_file])
+
+        if options[:require_file]
+          ui.stdout_print("=> Require file:", options[:require_file].inspect)
+          require_file = File.expand_path(options[:require_file])
+        end
+
+        node_path = options[:node_path] || find_node
+        ui.stdout_print("=> Node:", node_path.inspect)
+
+        unless File.file?(config_file)
+          ui.fail_with(
+            "=> ERROR: config file doesn't exist at",
+            config_file.inspect
+          )
+        end
+
+        if require_file && !File.file?(require_file)
+          ui.fail_with(
+            "=> ERROR: require file doesn't exist at",
+            require_file.inspect
+          )
+        end
+
+        found_node = node_path && File.executable?(File.expand_path(node_path))
+
+        unless found_node
+          ui.fail_with(
+            "=> ERROR: node.js couldn't be found (path: #{node_path})"
+          )
+        end
+
+        config = load_config_file(config_file)
+        I18nJS.load_plugins!
+        I18nJS.initialize_plugins!(config: config)
+        Schema.validate!(config)
+
+        load_require_file!(require_file) if require_file
+
+        available_locales = I18n.available_locales
+        ignored_keys = config.dig(:lint_scripts, :ignore) || []
+
+        ui.stdout_print "=> Available locales: #{available_locales.inspect}"
+
+        exported_files = I18nJS.call(config_file: config_file)
+        data = exported_files.each_with_object({}) do |file, buffer|
+          buffer.merge!(JSON.load_file(file, symbolize_names: true))
+        end
+
+        lint_file = File.expand_path(File.join(__dir__, "../lint.js"))
+        patterns = config.dig(:lint_scripts, :patterns) || %w[
+          !(node_modules)/**/*.js
+          !(node_modules)/**/*.ts
+          !(node_modules)/**/*.jsx
+          !(node_modules)/**/*.tsx
+        ]
+
+        ui.stdout_print "=> Patterns: #{patterns.inspect}"
+
+        out = IO.popen([node_path, lint_file, patterns.join(":")]).read
+        scopes = JSON.parse(out, symbolize_names: true)
+        map = Glob::Map.call(data)
+        missing_count = 0
+        ignored_count = 0
+
+        messages = []
+
+        available_locales.each do |locale|
+          scopes.each do |scope|
+            scope_with_locale = "#{locale}.#{scope[:full]}"
+
+            ignored = ignored_keys.include?(scope[:full]) ||
+                      ignored_keys.include?(scope_with_locale)
+
+            if ignored
+              ignored_count += 1
+              next
+            end
+
+            next if map.include?(scope_with_locale)
+
+            missing_count += 1
+            messages << "   - #{scope[:location]}: #{scope_with_locale}"
+          end
+        end
+
+        ui.stdout_print "=> #{map.size} translations, #{missing_count} " \
+                        "missing, #{ignored_count} ignored"
+        ui.stdout_print messages.sort.join("\n")
+
+        exit(missing_count.size)
+      end
+
+      private def set_defaults!
+        config_file = "./config/i18n.yml"
+        require_file = "./config/environment.rb"
+
+        options[:config_file] ||= config_file if File.file?(config_file)
+        options[:require_file] ||= require_file if File.file?(require_file)
+      end
+
+      private def find_node
+        ENV["PATH"]
+          .split(File::PATH_SEPARATOR)
+          .map {|dir| File.join(dir, "node") }
+          .find {|bin| File.executable?(bin) }
+      end
+    end
+  end
+end

data/lib/i18n-js/cli/lint_translations_command.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module I18nJS
+  class CLI
+    class LintTranslationsCommand < Command
+      command_name "lint:translations"
+      description "Check for missing translations based on the default locale"
+
+      parse do |opts|
+        opts.banner = "Usage: i18n #{name} [options]"
+
+        opts.on(
+          "-cCONFIG_FILE",
+          "--config=CONFIG_FILE",
+          "The configuration file that will be used"
+        ) do |config_file|
+          options[:config_file] = config_file
+        end
+
+        opts.on(
+          "-rREQUIRE_FILE",
+          "--require=REQUIRE_FILE",
+          "A Ruby file that must be loaded"
+        ) do |require_file|
+          options[:require_file] = require_file
+        end
+
+        opts.on(
+          "--[no-]color",
+          "Force colored output"
+        ) do |colored|
+          options[:colored] = colored
+        end
+
+        opts.on("-h", "--help", "Prints this help") do
+          ui.exit_with opts.to_s
+        end
+      end
+
+      command do
+        set_defaults!
+        ui.colored = options[:colored]
+
+        unless options[:config_file]
+          ui.fail_with("=> ERROR: you need to specify the config file")
+        end
+
+        ui.stdout_print("=> Config file:", options[:config_file].inspect)
+        config_file = File.expand_path(options[:config_file])
+
+        if options[:require_file]
+          ui.stdout_print("=> Require file:", options[:require_file].inspect)
+          require_file = File.expand_path(options[:require_file])
+        end
+
+        unless File.file?(config_file)
+          ui.fail_with(
+            "=> ERROR: config file doesn't exist at",
+            config_file.inspect
+          )
+        end
+
+        if require_file && !File.file?(require_file)
+          ui.fail_with(
+            "=> ERROR: require file doesn't exist at",
+            require_file.inspect
+          )
+        end
+
+        config = load_config_file(config_file)
+        I18nJS.load_plugins!
+        I18nJS.initialize_plugins!(config: config)
+        Schema.validate!(config)
+
+        load_require_file!(require_file) if require_file
+
+        default_locale = I18n.default_locale
+        available_locales = I18n.available_locales
+        ignored_keys = config.dig(:lint_translations, :ignore) || []
+
+        mapping = available_locales.each_with_object({}) do |locale, buffer|
+          buffer[locale] =
+            Glob::Map.call(Glob.filter(I18nJS.translations, ["#{locale}.*"]))
+                     .map {|key| key.gsub(/^.*?\./, "") }
+        end
+
+        default_locale_keys = mapping.delete(default_locale) || mapping
+
+        if ignored_keys.any?
+          ui.stdout_print "=> Check #{options[:config_file].inspect} for " \
+                          "ignored keys."
+        end
+
+        ui.stdout_print "=> #{default_locale}: #{default_locale_keys.size} " \
+                        "translations"
+
+        total_missing_count = 0
+
+        mapping.each do |locale, partial_keys|
+          ignored_count = 0
+
+          # Compute list of filtered keys (i.e. keys not ignored)
+          filtered_keys = partial_keys.reject do |key|
+            key = "#{locale}.#{key}"
+
+            ignored = ignored_keys.include?(key)
+            ignored_count += 1 if ignored
+            ignored
+          end
+
+          extraneous = (partial_keys - default_locale_keys).reject do |key|
+            key = "#{locale}.#{key}"
+            ignored = ignored_keys.include?(key)
+            ignored_count += 1 if ignored
+            ignored
+          end
+
+          missing = (default_locale_keys - (filtered_keys - extraneous))
+                    .reject {|key| ignored_keys.include?("#{locale}.#{key}") }
+
+          ignored_count += extraneous.size
+          total_missing_count += missing.size
+
+          ui.stdout_print "=> #{locale}: #{missing.size} missing, " \
+                          "#{extraneous.size} extraneous, " \
+                          "#{ignored_count} ignored"
+
+          all_keys = (default_locale_keys + extraneous + missing).uniq.sort
+
+          all_keys.each do |key|
+            next if ignored_keys.include?("#{locale}.#{key}")
+
+            label = if extraneous.include?(key)
+                      ui.yellow("extraneous")
+                    elsif missing.include?(key)
+                      ui.red("missing")
+                    else
+                      next
+                    end
+
+            ui.stdout_print("   - #{locale}.#{key} (#{label})")
+          end
+        end
+
+        exit(1) if total_missing_count.nonzero?
+      end
+
+      private def set_defaults!
+        config_file = "./config/i18n.yml"
+        require_file = "./config/environment.rb"
+
+        options[:config_file] ||= config_file if File.file?(config_file)
+        options[:require_file] ||= require_file if File.file?(require_file)
+      end
+    end
+  end
+end

data/lib/i18n-js/cli/plugins_command.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module I18nJS
+  class CLI
+    class PluginsCommand < Command
+      command_name "plugins"
+      description "List plugins that will be activated"
+
+      parse do |opts|
+        opts.banner = "Usage: i18n #{name} [options]"
+
+        opts.on(
+          "-rREQUIRE_FILE",
+          "--require=REQUIRE_FILE",
+          "A Ruby file that must be loaded"
+        ) do |require_file|
+          options[:require_file] = require_file
+        end
+
+        opts.on("-h", "--help", "Prints this help") do
+          ui.exit_with opts.to_s
+        end
+      end
+
+      command do
+        set_defaults!
+        ui.colored = options[:colored]
+
+        if options[:require_file]
+          ui.stdout_print("=> Require file:", options[:require_file].inspect)
+          require_file = File.expand_path(options[:require_file])
+        end
+
+        if require_file && !File.file?(require_file)
+          ui.fail_with(
+            "=> ERROR: require file doesn't exist at",
+            require_file.inspect
+          )
+        end
+
+        load_require_file!(require_file) if require_file
+
+        files = I18nJS.plugin_files
+
+        if files.empty?
+          ui.stdout_print("=> No plugins have been detected.")
+        else
+          ui.stdout_print("=> Plugins that will be activated:")
+
+          files.each do |file|
+            file = file.gsub("#{Dir.home}/", "~/")
+
+            ui.stdout_print("   * #{file}")
+          end
+        end
+      end
+
+      private def set_defaults!
+        config_file = "./config/i18n.yml"
+        require_file = "./config/environment.rb"
+
+        options[:config_file] ||= config_file if File.file?(config_file)
+        options[:require_file] ||= require_file if File.file?(require_file)
+      end
+    end
+  end
+end

data/lib/i18n-js/cli/ui.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module I18nJS
+  class CLI
+    class UI
+      attr_reader :stdout, :stderr
+      attr_accessor :colored
+
+      def initialize(stdout:, stderr:, colored: nil)
+        @stdout = stdout
+        @stderr = stderr
+        @colored = colored
+      end
+
+      def stdout_print(*message)
+        stdout << "#{message.join(' ')}\n"
+      end
+
+      def stderr_print(*message)
+        stderr << "#{message.join(' ')}\n"
+      end
+
+      def fail_with(*message)
+        stderr_print(message)
+        exit(1)
+      end
+
+      def exit_with(*message)
+        stdout_print(message)
+        exit(0)
+      end
+
+      def yellow(text)
+        ansi(text, 33)
+      end
+
+      def red(text)
+        ansi(text, 31)
+      end
+
+      def colored?
+        colored_output = if colored.nil?
+                           stdout.tty?
+                         else
+                           colored
+                         end
+
+        colored_output && !no_color?
+      end
+
+      def ansi(text, code)
+        if colored?
+          "\e[#{code}m#{text}\e[0m"
+        else
+          text
+        end
+      end
+
+      def no_color?
+        !ENV["NO_COLOR"].nil? && ENV["NO_COLOR"] == "1"
+      end
+    end
+  end
+end

data/lib/i18n-js/cli/version_command.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module I18nJS
+  class CLI
+    class VersionCommand < Command
+      command_name "version"
+      description "Show package version"
+
+      parse do |opts|
+        opts.banner = "Usage: i18n #{name}"
+
+        opts.on_tail do
+          ui.exit_with("v#{I18nJS::VERSION}")
+        end
+      end
+    end
+  end
+end

data/lib/i18n-js/cli.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../i18n-js"
+require_relative "cli/command"
+require_relative "cli/ui"
+require_relative "cli/init_command"
+require_relative "cli/version_command"
+require_relative "cli/export_command"
+require_relative "cli/plugins_command"
+require_relative "cli/lint_translations_command"
+require_relative "cli/lint_scripts_command"
+require_relative "cli/check_command"
+
+module I18nJS
+  class CLI
+    attr_reader :ui
+
+    def initialize(argv:, stdout:, stderr:, colored: stdout.tty?)
+      @argv = argv.dup
+      @ui = UI.new(stdout: stdout, stderr: stderr, colored: colored)
+    end
+
+    def call
+      command_name = @argv.shift
+      command = commands.find {|cmd| cmd.name == command_name }
+
+      ui.fail_with(root_help) unless command
+
+      command.call
+    end
+
+    private def command_classes
+      [
+        InitCommand,
+        ExportCommand,
+        VersionCommand,
+        PluginsCommand,
+        LintTranslationsCommand,
+        LintScriptsCommand,
+        CheckCommand
+      ]
+    end
+
+    private def commands
+      command_classes.map do |command_class|
+        command_class.new(argv: @argv, ui: ui)
+      end
+    end
+
+    private def root_help
+      commands_list = commands
+                      .map {|cmd| "- #{cmd.name}: #{cmd.description}" }
+                      .join("\n")
+
+      <<~TEXT
+        Usage: i18n COMMAND FLAGS
+
+        Commands:
+
+        #{commands_list}
+
+        Run `i18n COMMAND --help` for more information on specific commands.
+      TEXT
+    end
+  end
+end

data/lib/i18n-js/embed_fallback_translations_plugin.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module I18nJS
+  require "i18n-js/plugin"
+
+  class EmbedFallbackTranslationsPlugin < I18nJS::Plugin
+    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.deep_merge(target_hash, hash)
+        target_hash.merge(hash, &MERGER)
+      end
+    end
+
+    def setup
+      I18nJS::Schema.root_keys << config_key
+    end
+
+    def validate_schema
+      valid_keys = %i[enabled]
+
+      schema.expect_required_keys(keys: valid_keys, path: [config_key])
+      schema.reject_extraneous_keys(keys: valid_keys, path: [config_key])
+    end
+
+    def transform(translations:)
+      return translations unless enabled?
+
+      fallback_locale = I18n.default_locale.to_sym
+      locales_to_fallback = translations.keys - [fallback_locale]
+
+      translations_with_fallback = {}
+      translations_with_fallback[fallback_locale] =
+        translations[fallback_locale]
+
+      locales_to_fallback.each do |locale|
+        translations_with_fallback[locale] = Utils.deep_merge(
+          translations[fallback_locale], translations[locale]
+        )
+      end
+
+      translations_with_fallback
+    end
+  end
+
+  I18nJS.register_plugin(EmbedFallbackTranslationsPlugin)
+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