i18n-js 4.0.0 → 4.2.3

data/lib/i18n-js/lint.ts

@@ -0,0 +1,196 @@
+import { readFileSync, statSync } from "fs";
+import * as ts from "typescript";
+import { glob } from "glob";
+
+type ScopeInfo = {
+  type: "default" | "scope" | "base";
+  location: string;
+  base: string | null;
+  full: string;
+  scope: string;
+};
+
+function location(node: ts.Node, append: string = ":") {
+  const sourceFile = node.getSourceFile();
+  let { line, character } = sourceFile.getLineAndCharacterOfPosition(
+    node.getStart(sourceFile)
+  );
+
+  line += 1;
+  character += 1;
+  const file = sourceFile.fileName;
+  const location = `${file}:${line}:${character}`;
+
+  return `${location}${append}`;
+}
+
+const callExpressions = ["t", "i18n.t", "i18n.translate"];
+
+function tsKind(node: ts.Node) {
+  const keys = Object.keys(ts.SyntaxKind);
+  const values = Object.values(ts.SyntaxKind);
+
+  return keys[values.indexOf(node.kind)];
+}
+
+function getTranslationScopesFromFile(filePath: string) {
+  const scopes: ScopeInfo[] = [];
+
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    readFileSync(filePath).toString(),
+    ts.ScriptTarget.ES2015,
+    true
+  );
+
+  inspect(sourceFile);
+
+  return scopes;
+
+  function inspect(node: ts.Node) {
+    const next = () => {
+      ts.forEachChild(node, inspect);
+    };
+
+    if (node.kind !== ts.SyntaxKind.CallExpression) {
+      return next();
+    }
+
+    const expr = node.getChildAt(0).getText();
+    const text = JSON.stringify(node.getText(sourceFile));
+
+    if (!callExpressions.includes(expr)) {
+      return next();
+    }
+
+    const syntaxList = node.getChildAt(2);
+
+    if (!syntaxList.getText().trim()) {
+      return next();
+    }
+
+    const scopeNode = syntaxList.getChildAt(0) as ts.StringLiteral;
+    const optionsNode = syntaxList.getChildAt(2) as ts.ObjectLiteralExpression;
+
+    if (scopeNode.kind !== ts.SyntaxKind.StringLiteral) {
+      return next();
+    }
+
+    if (
+      optionsNode &&
+      optionsNode.kind !== ts.SyntaxKind.ObjectLiteralExpression
+    ) {
+      return next();
+    }
+
+    if (!optionsNode) {
+      scopes.push({
+        type: "scope",
+        scope: scopeNode.text,
+        base: null,
+        full: scopeNode.text,
+        location: location(node, ""),
+      });
+      return next();
+    }
+
+    scopes.push(...getScopes(scopeNode, optionsNode));
+  }
+
+  function mapProperties(node: ts.ObjectLiteralExpression): {
+    name: string;
+    value: ts.Node;
+  }[] {
+    return node.properties.map((p) => ({
+      name: (p.name as ts.Identifier).escapedText.toString(),
+      value: p.getChildAt(2),
+    }));
+  }
+
+  function getScopes(
+    scopeNode: ts.StringLiteral,
+    node: ts.ObjectLiteralExpression
+  ): ScopeInfo[] {
+    const suffix = scopeNode.text;
+
+    const result: ScopeInfo[] = [];
+    const properties = mapProperties(node);
+
+    if (
+      properties.length === 0 ||
+      !properties.some((p) => p.name === "scope")
+    ) {
+      result.push({
+        type: "scope",
+        scope: suffix,
+        base: null,
+        full: suffix,
+        location: location(scopeNode, ""),
+      });
+    }
+
+    properties.forEach((property) => {
+      if (
+        property.name === "scope" &&
+        property.value.kind === ts.SyntaxKind.StringLiteral
+      ) {
+        const base = (property.value as ts.StringLiteral).text;
+
+        result.push({
+          type: "base",
+          scope: suffix,
+          base,
+          full: `${base}.${suffix}`,
+          location: location(scopeNode, ""),
+        });
+      }
+
+      if (
+        property.name === "defaults" &&
+        property.value.kind === ts.SyntaxKind.ArrayLiteralExpression
+      ) {
+        const op = property.value as ts.ArrayLiteralExpression;
+        const values = op.getChildAt(1);
+        const objects = (
+          values
+            .getChildren()
+            .filter(
+              (n) => n.kind === ts.SyntaxKind.ObjectLiteralExpression
+            ) as ts.ObjectLiteralExpression[]
+        ).map(mapProperties);
+
+        objects.forEach((object) => {
+          object.forEach((prop) => {
+            if (
+              prop.name === "scope" &&
+              prop.value.kind === ts.SyntaxKind.StringLiteral
+            ) {
+              const text = (prop.value as ts.StringLiteral).text;
+
+              result.push({
+                type: "default",
+                scope: text,
+                base: null,
+                full: text,
+                location: location(prop.value, ""),
+              });
+            }
+          });
+        });
+      }
+    });
+
+    return result;
+  }
+}
+
+const patterns = (
+  process.argv[2] ??
+  "!(node_modules)/**/*.js:!(node_modules)/**/*.ts:!(node_modules)/**/*.jsx:!(node_modules)/**/*.tsx"
+).split(":");
+const files = patterns.flatMap((pattern) => glob.sync(pattern));
+const scopes = files
+  .filter((filePath) => statSync(filePath).isFile())
+  .flatMap((path) => getTranslationScopesFromFile(path));
+
+console.log(JSON.stringify(scopes, null, 2));

data/lib/i18n-js/listen.rb

@@ -7,7 +7,9 @@ module I18nJS
 
   def self.listen(
     config_file: Rails.root.join("config/i18n.yml"),
-    locales_dir: Rails.root.join("config/locales")
+    locales_dir: Rails.root.join("config/locales"),
+    run_on_start: true,
+    options: {}
   )
     return unless Rails.env.development?
     return if started
@@ -18,13 +20,15 @@ module I18nJS
 
     self.started = true
 
+    locales_dirs = Array(locales_dir).map {|path| File.expand_path(path) }
+
     relative_paths =
-      [config_file, locales_dir].map {|path| relative_path(path) }
+      [config_file, *locales_dirs].map {|path| relative_path(path) }
 
     debug("Watching #{relative_paths.inspect}")
 
-    listener(config_file, locales_dir.to_s).start
-    I18nJS.call(config_file: config_file)
+    listener(config_file, locales_dirs.map(&:to_s), options).start
+    I18nJS.call(config_file: config_file) if run_on_start
   end
 
   def self.relative_path(path)
@@ -43,12 +47,12 @@ module I18nJS
     @logger ||= ActiveSupport::TaggedLogging.new(Rails.logger)
   end
 
-  def self.listener(config_file, locales_dir)
-    paths = [File.dirname(config_file), locales_dir]
+  def self.listener(config_file, locales_dirs, options)
+    paths = [File.dirname(config_file), *locales_dirs]
 
-    Listen.to(*paths) do |changed, added, removed|
+    Listen.to(*paths, options) do |changed, added, removed|
       changes = compute_changes(
-        [config_file, locales_dir],
+        [config_file, *locales_dirs],
         changed,
         added,
         removed
@@ -58,11 +62,22 @@ module I18nJS
 
       debug(changes.map {|key, value| "#{key}=#{value.inspect}" }.join(", "))
 
-      ::I18n.backend.reload!
-      I18nJS.call(config_file: config_file)
+      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) }
 

data/lib/i18n-js/plugin.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "schema"
+
+module I18nJS
+  def self.available_plugins
+    @available_plugins ||= Set.new
+  end
+
+  def self.plugins
+    @plugins ||= []
+  end
+
+  def self.register_plugin(plugin)
+    available_plugins << plugin
+  end
+
+  def self.plugin_files
+    Gem.find_files("i18n-js/*_plugin.rb")
+  end
+
+  def self.load_plugins!
+    plugin_files.each do |path|
+      require path
+    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`.
+    def transform(translations:)
+      translations
+    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 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
+
+    # 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

@@ -4,14 +4,28 @@ 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_LINT_TRANSLATIONS_KEYS = %i[ignore].freeze
+    REQUIRED_LINT_SCRIPTS_KEYS = %i[ignore patterns].freeze
     REQUIRED_TRANSLATION_KEYS = %i[file patterns].freeze
     TRANSLATION_KEYS = %i[file patterns].freeze
 
+    def self.root_keys
+      @root_keys ||= Set.new(%i[
+        translations
+        lint_translations
+        lint_scripts
+        check
+      ])
+    end
+
+    def self.required_root_keys
+      @required_root_keys ||= Set.new(%i[translations])
+    end
+
     def self.validate!(target)
-      new(target).validate!
+      schema = new(target)
+      schema.validate!
+      schema
     end
 
     attr_reader :target
@@ -21,41 +35,96 @@ 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(REQUIRED_ROOT_KEYS, target)
-      reject_extraneous_keys(ROOT_KEYS, target)
       validate_translations
-      validate_check
+      validate_lint_translations
+      validate_lint_scripts
+      validate_plugins
     end
 
-    def validate_check
-      return unless target.key?(:check)
+    def validate_plugins
+      I18nJS.plugins.each do |plugin|
+        next unless target.key?(plugin.config_key)
 
-      check = target[:check]
+        expect_type(
+          path: [plugin.config_key, :enabled],
+          types: [TrueClass, FalseClass]
+        )
 
-      expect_type(:check, check, Hash, target)
-      expect_required_keys(REQUIRED_CHECK_KEYS, check)
-      expect_type(:ignore, check[:ignore], Array, check)
+        plugin.validate_schema
+      end
     end
 
-    def validate_translations
-      translations = target[:translations]
+    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
+      key = :lint_translations
+
+      return unless target.key?(key)
+
+      expect_type(path: [key], types: Hash)
+
+      expect_required_keys(
+        keys: REQUIRED_LINT_TRANSLATIONS_KEYS,
+        path: [key]
+      )
+
+      expect_type(path: [key, :ignore], types: Array)
+    end
+
+    def validate_lint_scripts
+      key = :lint_scripts
 
-      expect_type(:translations, translations, Array, target)
-      expect_array_with_items(:translations, translations)
+      return unless target.key?(key)
 
-      translations.each do |translation|
-        validate_translation(translation)
+      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
+      expect_array_with_items(path: [:translations])
+
+      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)
@@ -63,42 +132,85 @@ module I18nJS
       raise InvalidError, "#{error_message}#{node_json}"
     end
 
-    def expect_type(attribute, value, expected_type, payload)
-      return if value.is_a?(expected_type)
+    def expect_type(path:, types:)
+      path = prepare_path(path: path)
+      value = value_for(path: path)
+      types = Array(types)
+
+      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)
+
+      keys.each do |key|
+        next if actual_keys.include?(key)
 
-      required_keys.each do |key|
-        next if keys.include?(key)
+        path_desc = if path.empty?
+                      key.to_s.inspect
+                    else
+                      (path + [key]).join(".").inspect
+                    end
 
-        reject "Expected #{key.inspect} to be defined", value
+        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 - allowed_keys
+    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/sort_hash.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module I18nJS
+  def self.sort_hash(hash)
+    return hash unless hash.is_a?(Hash)
+
+    hash.keys.sort_by(&:to_s).each_with_object({}) do |key, seed|
+      value = hash[key]
+      seed[key] = value.is_a?(Hash) ? sort_hash(value) : value
+    end
+  end
+end

data/lib/i18n-js/version.rb

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