i18n-js 3.9.2 → 4.0.1

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,55 @@
+# 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/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, 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/listen.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module I18nJS
+  class << self
+    attr_accessor :started
+  end
+
+  def self.listen(
+    config_file: Rails.root.join("config/i18n.yml"),
+    locales_dir: Rails.root.join("config/locales"),
+    options: {}
+  )
+    return unless Rails.env.development?
+    return if started
+
+    gem "listen"
+    require "listen"
+    require "i18n-js"
+
+    self.started = true
+
+    locales_dirs = Array(locales_dir)
+
+    relative_paths =
+      [config_file, *locales_dirs].map {|path| relative_path(path) }
+
+    debug("Watching #{relative_paths.inspect}")
+
+    listener(config_file, locales_dirs.map(&:to_s), options).start
+    I18nJS.call(config_file: config_file)
+  end
+
+  def self.relative_path(path)
+    Pathname.new(path).relative_path_from(Rails.root).to_s
+  end
+
+  def self.relative_path_list(paths)
+    paths.map {|path| relative_path(path) }
+  end
+
+  def self.debug(message)
+    logger.tagged("i18n-js") { logger.debug(message) }
+  end
+
+  def self.logger
+    @logger ||= ActiveSupport::TaggedLogging.new(Rails.logger)
+  end
+
+  def self.listener(config_file, locales_dirs, options)
+    paths = [File.dirname(config_file), *locales_dirs]
+
+    Listen.to(*paths, options) do |changed, added, removed|
+      changes = compute_changes(
+        [config_file, *locales_dirs],
+        changed,
+        added,
+        removed
+      )
+
+      next unless changes.any?
+
+      debug(changes.map {|key, value| "#{key}=#{value.inspect}" }.join(", "))
+
+      capture do
+        system "i18n", "export", "--config", config_file.to_s
+      end
+    end
+  end
+
+  def self.capture
+    original = $stdout
+    $stdout = StringIO.new
+    yield
+  rescue StandardError
+    # noop
+  ensure
+    $stdout = original
+  end
+
+  def self.compute_changes(paths, changed, added, removed)
+    paths = paths.map {|path| relative_path(path) }
+
+    {
+      changed: included_on_watched_paths(paths, changed),
+      added: included_on_watched_paths(paths, added),
+      removed: included_on_watched_paths(paths, removed)
+    }.select {|_k, v| v.any? }
+  end
+
+  def self.included_on_watched_paths(paths, changes)
+    changes.map {|change| relative_path(change) }.select do |change|
+      paths.any? {|path| change.start_with?(path) }
+    end
+  end
+end

data/lib/i18n-js/schema.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module I18nJS
+  class Schema
+    InvalidError = Class.new(StandardError)
+
+    ROOT_KEYS = %i[translations check].freeze
+    REQUIRED_ROOT_KEYS = %i[translations].freeze
+    REQUIRED_CHECK_KEYS = %i[ignore].freeze
+    REQUIRED_TRANSLATION_KEYS = %i[file patterns].freeze
+    TRANSLATION_KEYS = %i[file patterns].freeze
+
+    def self.validate!(target)
+      new(target).validate!
+    end
+
+    attr_reader :target
+
+    def initialize(target)
+      @target = target
+    end
+
+    def validate!
+      expect_type(:root, target, Hash, target)
+
+      expect_required_keys(REQUIRED_ROOT_KEYS, target)
+      reject_extraneous_keys(ROOT_KEYS, target)
+      validate_translations
+      validate_check
+    end
+
+    def validate_check
+      return unless target.key?(:check)
+
+      check = target[:check]
+
+      expect_type(:check, check, Hash, target)
+      expect_required_keys(REQUIRED_CHECK_KEYS, check)
+      expect_type(:ignore, check[:ignore], Array, check)
+    end
+
+    def validate_translations
+      translations = target[:translations]
+
+      expect_type(:translations, translations, Array, target)
+      expect_array_with_items(:translations, translations)
+
+      translations.each do |translation|
+        validate_translation(translation)
+      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)
+    end
+
+    def reject(error_message, node = nil)
+      node_json = "\n#{JSON.pretty_generate(node)}" if node
+      raise InvalidError, "#{error_message}#{node_json}"
+    end
+
+    def expect_type(attribute, value, expected_type, payload)
+      return if value.is_a?(expected_type)
+
+      actual_type = value.class
+
+      message = [
+        "Expected #{attribute.inspect} to be #{expected_type};",
+        "got #{actual_type} instead"
+      ].join(" ")
+
+      reject message, payload
+    end
+
+    def expect_array_with_items(attribute, value, payload = value)
+      return unless value.empty?
+
+      reject "Expected #{attribute.inspect} to have at least one item", payload
+    end
+
+    def expect_required_keys(required_keys, value)
+      keys = value.keys.map(&:to_sym)
+
+      required_keys.each do |key|
+        next if keys.include?(key)
+
+        reject "Expected #{key.inspect} to be defined", value
+      end
+    end
+
+    def reject_extraneous_keys(allowed_keys, value)
+      keys = value.keys.map(&:to_sym)
+      extraneous = keys - allowed_keys
+
+      return if extraneous.empty?
+
+      reject "Unexpected keys: #{extraneous.join(', ')}", value
+    end
+  end
+end

data/lib/i18n-js/version.rb

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

data/lib/i18n-js.rb

@@ -1 +1,73 @@
-require "i18n/js"
+# frozen_string_literal: true
+
+require "i18n"
+require "json"
+require "yaml"
+require "glob"
+require "fileutils"
+require "optparse"
+
+require_relative "i18n-js/schema"
+require_relative "i18n-js/version"
+
+module I18nJS
+  MissingConfigError = Class.new(StandardError)
+
+  def self.call(config_file: nil, config: nil)
+    if !config_file && !config
+      raise MissingConfigError,
+            "you must set either `config_file` or `config`"
+    end
+
+    config = Glob::SymbolizeKeys.call(config || YAML.load_file(config_file))
+    Schema.validate!(config)
+    exported_files = []
+
+    config[:translations].each do |group|
+      exported_files += export_group(group)
+    end
+
+    exported_files
+  end
+
+  def self.export_group(group)
+    filtered_translations = Glob.filter(translations, group[:patterns])
+    output_file_path = File.expand_path(group[:file])
+    exported_files = []
+
+    if output_file_path.include?(":locale")
+      filtered_translations.each_key do |locale|
+        locale_file_path = output_file_path.gsub(/:locale/, locale.to_s)
+        exported_files << write_file(locale_file_path,
+                                     locale => filtered_translations[locale])
+      end
+    else
+      exported_files << write_file(output_file_path, filtered_translations)
+    end
+
+    exported_files
+  end
+
+  def self.write_file(file_path, translations)
+    FileUtils.mkdir_p(File.dirname(file_path))
+
+    contents = ::JSON.pretty_generate(translations)
+    digest = Digest::MD5.hexdigest(contents)
+    file_path = file_path.gsub(/:digest/, digest)
+
+    File.open(file_path, "w") do |file|
+      file << contents
+    end
+
+    file_path
+  end
+
+  def self.translations
+    ::I18n.backend.instance_eval do
+      has_been_initialized_before =
+        respond_to?(:initialized?, true) && initialized?
+      init_translations unless has_been_initialized_before
+      translations
+    end
+  end
+end