i18n-js 2.1.2 → 3.9.2

data/lib/i18n/js/segment.rb

@@ -0,0 +1,81 @@
+require "i18n/js/private/hash_with_symbol_keys"
+require "i18n/js/formatters/js"
+require "i18n/js/formatters/json"
+
+module I18n
+  module JS
+
+    # Class which enscapulates a translations hash and outputs a single JSON translation file
+    class Segment
+      OPTIONS = [:namespace, :pretty_print, :js_extend, :prefix, :suffix, :sort_translation_keys, :json_only].freeze
+      LOCALE_INTERPOLATOR = /%\{locale\}/
+
+      attr_reader *([:file, :translations] | OPTIONS)
+
+      def initialize(file, translations, options = {})
+        @file         = file
+        # `#slice` will be used
+        # But when activesupport is absent,
+        # the core extension from `i18n` gem will be used instead
+        # And it's causing errors (at least in test)
+        #
+        # So the input is wrapped by our class for better `#slice`
+        @translations = Private::HashWithSymbolKeys.new(translations)
+        @namespace    = options[:namespace] || 'I18n'
+        @pretty_print = !!options[:pretty_print]
+        @js_extend    = options.key?(:js_extend) ? !!options[:js_extend] : true
+        @prefix       = options.key?(:prefix) ? options[:prefix] : nil
+        @suffix       = options.key?(:suffix) ? options[:suffix] : nil
+        @sort_translation_keys = options.key?(:sort_translation_keys) ? !!options[:sort_translation_keys] : true
+        @json_only = options.key?(:json_only) ? !!options[:json_only] : false
+      end
+
+      # Saves JSON file containing translations
+      def save!
+        if @file =~ LOCALE_INTERPOLATOR
+          I18n::JS.js_available_locales.each do |locale|
+            write_file(file_for_locale(locale), @translations.slice(locale))
+          end
+        else
+          write_file
+        end
+      end
+
+      protected
+
+      def file_for_locale(locale)
+        @file.gsub(LOCALE_INTERPOLATOR, locale.to_s)
+      end
+
+      def write_file(_file = @file, _translations = @translations)
+        FileUtils.mkdir_p File.dirname(_file)
+        _translations = Utils.deep_key_sort(_translations) if @sort_translation_keys
+        _translations = Utils.deep_remove_procs(_translations)
+        contents = formatter.format(_translations)
+
+        return if File.exist?(_file) && File.read(_file) == contents
+
+        File.open(_file, "w+") do |f|
+          f << contents
+        end
+      end
+
+      def formatter
+        if @json_only
+          Formatters::JSON.new(**formatter_options)
+        else
+          Formatters::JS.new(**formatter_options)
+        end
+      end
+
+      def formatter_options
+        { js_extend: @js_extend,
+          namespace: @namespace,
+          pretty_print: @pretty_print,
+          prefix: @prefix,
+          suffix: @suffix
+        }
+      end
+    end
+  end
+end

data/lib/i18n/js/utils.rb

@@ -0,0 +1,91 @@
+module I18n
+  module JS
+    module Utils
+      PLURAL_KEYS = %i[zero one two few many other].freeze
+
+      # 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_MERGER = proc do |_key, v1, v2|
+        v1 || v2
+      end
+      MERGER = proc do |_key, v1, v2|
+        if Hash === v1 && Hash === v2
+          if (v2.keys - PLURAL_KEYS).empty?
+            slice(v2.merge(v1, &PLURAL_MERGER), v2.keys)
+          else
+            v1.merge(v2, &MERGER)
+          end
+        else
+          v2 || v1
+        end
+      end
+
+      HASH_NIL_VALUE_CLEANER_PROC = proc do |k, v|
+        v.kind_of?(Hash) ? (v.delete_if(&HASH_NIL_VALUE_CLEANER_PROC); false) : v.nil?
+      end
+
+      def self.slice(hash, keys)
+        if hash.respond_to?(:slice) # ruby 2.5 onwards
+          hash.slice(*keys)
+        else
+          hash.select {|key, _| keys.include?(key)}
+        end
+      end
+
+      def self.strip_keys_with_nil_values(hash)
+        hash.dup.delete_if(&HASH_NIL_VALUE_CLEANER_PROC)
+      end
+
+      def self.deep_merge(target_hash, hash) # :nodoc:
+        target_hash.merge(hash, &MERGER)
+      end
+
+      def self.deep_merge!(target_hash, hash) # :nodoc:
+        target_hash.merge!(hash, &MERGER)
+      end
+
+      def self.deep_reject(hash, scopes = [], &block)
+        hash.each_with_object({}) do |(k, v), memo|
+          unless block.call(k, v, scopes + [k.to_s])
+            memo[k] = v.kind_of?(Hash) ? deep_reject(v, scopes + [k.to_s], &block) : v
+          end
+        end
+      end
+
+      def self.scopes_match?(scopes1, scopes2)
+        if scopes1.length == scopes2.length
+          [scopes1, scopes2].transpose.all? do |scope1, scope2|
+            scope1.to_s == '*' || scope2.to_s == '*' || scope1.to_s == scope2.to_s
+          end
+        end
+      end
+
+      def self.deep_key_sort(hash)
+        # Avoid things like `true` or `1` from YAML which causes error
+        hash.keys.sort {|a, b| a.to_s <=> b.to_s}.
+          each_with_object({}) do |key, seed|
+          value = hash[key]
+          seed[key] = value.is_a?(Hash) ? deep_key_sort(value) : value
+        end
+      end
+
+      def self.deep_remove_procs(hash)
+        # procs exist in `i18n.plural.rule` as pluralizer
+        # But having it in translation causes the exported JS/JSON changes every time
+        # https://github.com/ruby-i18n/i18n/blob/v1.8.7/lib/i18n/backend/pluralization.rb#L51
+        hash.keys.
+          each_with_object({}) do |key, seed|
+          value = hash[key]
+          next if value.is_a?(Proc)
+
+          seed[key] = value.is_a?(Hash) ? deep_remove_procs(value) : value
+        end
+      end
+    end
+  end
+end

data/lib/i18n/js/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module I18n
+  module JS
+    VERSION = "3.9.2"
+  end
+end

data/lib/i18n/js.rb

@@ -0,0 +1,274 @@
+require "yaml"
+require "fileutils"
+require "i18n"
+
+require "i18n/js/utils"
+require "i18n/js/private/hash_with_symbol_keys"
+require "i18n/js/private/config_store"
+
+module I18n
+  module JS
+    require "i18n/js/dependencies"
+    require "i18n/js/fallback_locales"
+    require "i18n/js/segment"
+    if JS::Dependencies.rails?
+      require "i18n/js/middleware"
+      require "i18n/js/engine"
+    end
+
+    DEFAULT_CONFIG_PATH = "config/i18n-js.yml"
+    DEFAULT_EXPORT_DIR_PATH = "public/javascripts"
+
+    # The configuration file. This defaults to the `config/i18n-js.yml` file.
+    #
+    def self.config_file_path
+      @config_file_path ||= DEFAULT_CONFIG_PATH
+    end
+
+    def self.config_file_path=(new_path)
+      @config_file_path = new_path
+      # new config file path = need to re-read config from new file
+      Private::ConfigStore.instance.flush_cache
+    end
+
+    # Allow using a different backend than the one globally configured
+    def self.backend
+      @backend ||= I18n.backend
+    end
+
+    def self.backend=(alternative_backend)
+      @backend = alternative_backend
+    end
+
+    # Export translations to JavaScript, considering settings
+    # from configuration file
+    def self.export
+      export_i18n_js
+
+      translation_segments.each(&:save!)
+    end
+
+    def self.segment_for_scope(scope, exceptions)
+      if scope == "*"
+        exclude(translations, exceptions)
+      else
+        scoped_translations(scope, exceptions)
+      end
+    end
+
+    def self.configured_segments
+      config[:translations].inject([]) do |segments, options_hash|
+        options_hash_with_symbol_keys = Private::HashWithSymbolKeys.new(options_hash)
+        file = options_hash_with_symbol_keys[:file]
+        only = options_hash_with_symbol_keys[:only] || '*'
+        exceptions = [options_hash_with_symbol_keys[:except] || []].flatten
+
+        result = segment_for_scope(only, exceptions)
+
+        merge_with_fallbacks!(result) if fallbacks
+
+        unless result.empty?
+          segments << Segment.new(
+            file,
+            result,
+            extract_segment_options(options_hash_with_symbol_keys),
+          )
+        end
+
+        segments
+      end
+    end
+
+    # deep_merge! given result with result for fallback locale
+    def self.merge_with_fallbacks!(result)
+      js_available_locales.each do |locale|
+        fallback_locales = FallbackLocales.new(fallbacks, locale)
+        fallback_locales.each do |fallback_locale|
+          # `result[fallback_locale]` could be missing
+          result[locale] = Utils.deep_merge(result[fallback_locale] || {}, result[locale] || {})
+        end
+      end
+    end
+
+    def self.filtered_translations
+      translations = {}.tap do |result|
+        translation_segments.each do |segment|
+          Utils.deep_merge!(result, segment.translations)
+        end
+      end
+      return Utils.deep_key_sort(translations) if I18n::JS.sort_translation_keys?
+      translations
+    end
+
+    def self.translation_segments
+      if config_file_exists? && config[:translations]
+        configured_segments
+      else
+        [Segment.new("#{DEFAULT_EXPORT_DIR_PATH}/translations.js", translations)]
+      end
+    end
+
+    # Load configuration file for partial exporting and
+    # custom output directory
+    def self.config
+      Private::ConfigStore.instance.fetch do
+        if config_file_exists?
+          erb_result_from_yaml_file = ERB.new(File.read(config_file_path)).result
+          Private::HashWithSymbolKeys.new(
+            (::YAML.load(erb_result_from_yaml_file) || {})
+          )
+        else
+          Private::HashWithSymbolKeys.new({})
+        end.freeze
+      end
+    end
+
+    # @api private
+    # Check if configuration file exist
+    def self.config_file_exists?
+      File.file? config_file_path
+    end
+
+    def self.scoped_translations(scopes, exceptions = []) # :nodoc:
+      result = {}
+
+      [scopes].flatten.each do |scope|
+        translations_without_exceptions = exclude(translations, exceptions)
+        filtered_translations = filter(translations_without_exceptions, scope) || {}
+
+        Utils.deep_merge!(result, filtered_translations)
+      end
+
+      result
+    end
+
+    # Exclude keys from translations listed in the `except:` section in the config file
+    def self.exclude(translations, exceptions)
+      return translations if exceptions.empty?
+
+      exceptions.inject(translations) do |memo, exception|
+        exception_scopes = exception.to_s.split(".")
+        Utils.deep_reject(memo) do |key, value, scopes|
+          Utils.scopes_match?(scopes, exception_scopes)
+        end
+      end
+    end
+
+    # Filter translations according to the specified scope.
+    def self.filter(translations, scopes)
+      scopes = scopes.split(".") if scopes.is_a?(String)
+      scopes = scopes.clone
+      scope = scopes.shift
+
+      if scope == "*"
+        results = {}
+        translations.each do |scope, translations|
+          tmp = scopes.empty? ? translations : filter(translations, scopes)
+          results[scope.to_sym] = tmp unless tmp.nil?
+        end
+        return results
+      elsif translations.respond_to?(:key?) && translations.key?(scope.to_sym)
+        return {scope.to_sym => scopes.empty? ? translations[scope.to_sym] : filter(translations[scope.to_sym], scopes)}
+      end
+      nil
+    end
+
+    # Initialize and return translations
+    def self.translations
+      self.backend.instance_eval do
+        init_translations unless initialized?
+        # When activesupport is absent,
+        # the core extension (`#slice`) from `i18n` gem will be used instead
+        # And it's causing errors (at least in test)
+        #
+        # So the input is wrapped by our class for better `#slice`
+        Private::HashWithSymbolKeys.new(translations).
+          slice(*::I18n::JS.js_available_locales).
+          to_h
+      end
+    end
+
+    def self.use_fallbacks?
+      fallbacks != false
+    end
+
+    def self.json_only
+      config.fetch(:json_only) do
+        # default value
+        false
+      end
+    end
+
+    def self.fallbacks
+      config.fetch(:fallbacks) do
+        # default value
+        true
+      end
+    end
+
+    def self.js_extend
+      config.fetch(:js_extend) do
+        # default value
+        true
+      end
+    end
+
+    # Get all available locales.
+    #
+    # @return [Array<Symbol>] the locales.
+    def self.js_available_locales
+      config.fetch(:js_available_locales) do
+        # default value
+        I18n.available_locales
+      end.map(&:to_sym)
+    end
+
+    def self.sort_translation_keys?
+      @sort_translation_keys ||= (config[:sort_translation_keys]) if config.key?(:sort_translation_keys)
+      @sort_translation_keys = true if @sort_translation_keys.nil?
+      @sort_translation_keys
+    end
+
+    def self.sort_translation_keys=(value)
+      @sort_translation_keys = !!value
+    end
+
+    def self.extract_segment_options(options)
+      segment_options = Private::HashWithSymbolKeys.new({
+        js_extend: js_extend,
+        sort_translation_keys: sort_translation_keys?,
+        json_only: json_only
+      }).freeze
+      segment_options.merge(options.slice(*Segment::OPTIONS))
+    end
+
+    ### Export i18n.js
+    begin
+
+      # Copy i18n.js
+      def self.export_i18n_js
+        return unless export_i18n_js_dir_path.is_a? String
+
+        FileUtils.mkdir_p(export_i18n_js_dir_path)
+
+        i18n_js_path = File.expand_path('../../../app/assets/javascripts/i18n.js', __FILE__)
+        destination_path = File.expand_path("i18n.js", export_i18n_js_dir_path)
+        return if File.exist?(destination_path) && FileUtils.identical?(i18n_js_path, destination_path)
+
+        FileUtils.cp(i18n_js_path, export_i18n_js_dir_path)
+      end
+
+      def self.export_i18n_js_dir_path
+        @export_i18n_js_dir_path ||= (config[:export_i18n_js] || :none) if config.key?(:export_i18n_js)
+        @export_i18n_js_dir_path ||= DEFAULT_EXPORT_DIR_PATH
+        @export_i18n_js_dir_path
+      end
+
+      # Setting this to nil would disable i18n.js exporting
+      def self.export_i18n_js_dir_path=(new_path)
+        new_path = :none unless new_path.is_a? String
+        @export_i18n_js_dir_path = new_path
+      end
+    end
+  end
+end

data/lib/i18n-js.rb

@@ -1,177 +1 @@
-require "FileUtils" unless defined?(FileUtils)
-
-module SimplesIdeias
-  module I18n
-    extend self
-
-    require "i18n-js/railtie" if Rails.version >= "3.0"
-    require "i18n-js/engine" if Rails.version >= "3.1"
-    require "i18n-js/middleware"
-
-    # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
-    MERGER = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &MERGER) : v2 }
-
-    # Under rails 3.1.1 and higher, perform a check to ensure that the
-    # full environment will be available during asset compilation.
-    # This is required to ensure I18n is loaded.
-    def assert_usable_configuration!
-      @usable_configuration ||= Rails.version >= "3.1.1" &&
-        Rails.configuration.assets.initialize_on_precompile ||
-        raise("Cannot precompile i18n-js translations unless environment is initialized. Please set config.assets.initialize_on_precompile to true.")
-    end
-
-    def has_asset_pipeline?
-      Rails.configuration.respond_to?(:assets) && Rails.configuration.assets.enabled
-    end
-
-    def config_file
-      Rails.root.join("config/i18n-js.yml")
-    end
-
-    def export_dir
-      if has_asset_pipeline?
-        "app/assets/javascripts/i18n"
-      else
-        "public/javascripts"
-      end
-    end
-
-    def javascript_file
-      Rails.root.join(export_dir, "i18n.js")
-    end
-
-    # Export translations to JavaScript, considering settings
-    # from configuration file
-    def export!
-      translation_segments.each do |filename, translations|
-        save(translations, filename)
-      end
-    end
-
-    def segments_per_locale(pattern,scope)
-      ::I18n.available_locales.each_with_object({}) do |locale,segments|
-        result = scoped_translations("#{locale}.#{scope}")
-        unless result.empty?
-          segment_name = ::I18n.interpolate(pattern,{:locale => locale})
-          segments[segment_name] = result
-        end
-      end
-    end
-
-    def segment_for_scope(scope)
-      if scope == "*"
-        translations
-      else
-        scoped_translations(scope)
-      end
-    end
-
-    def configured_segments
-      config[:translations].each_with_object({}) do |options,segments|
-        options.reverse_merge!(:only => "*")
-        if options[:file] =~ ::I18n::INTERPOLATION_PATTERN
-          segments.merge!(segments_per_locale(options[:file],options[:only]))
-        else
-          result = segment_for_scope(options[:only])
-          segments[options[:file]] = result unless result.empty?
-        end
-      end
-    end
-
-    def translation_segments
-      if config? && config[:translations]
-        configured_segments
-      else
-        {"#{export_dir}/translations.js" => translations}
-      end
-    end
-
-    # Load configuration file for partial exporting and
-    # custom output directory
-    def config
-      if config?
-        (YAML.load_file(config_file) || {}).with_indifferent_access
-      else
-        {}
-      end
-    end
-
-    # Check if configuration file exist
-    def config?
-      File.file? config_file
-    end
-
-    # Copy configuration and JavaScript library files to
-    # <tt>config/i18n-js.yml</tt> and <tt>public/javascripts/i18n.js</tt>.
-    def setup!
-      FileUtils.cp(File.dirname(__FILE__) + "/../vendor/assets/javascripts/i18n.js", javascript_file) unless Rails.version >= "3.1"
-      FileUtils.cp(File.dirname(__FILE__) + "/../config/i18n-js.yml", config_file) unless config?
-    end
-
-    # Retrieve an updated JavaScript library from Github.
-    def update!
-      require "open-uri"
-      contents = open("https://raw.github.com/fnando/i18n-js/master/vendor/assets/javascripts/i18n.js").read
-      File.open(javascript_file, "w+") {|f| f << contents}
-    end
-
-    # Convert translations to JSON string and save file.
-    def save(translations, file)
-      file = Rails.root.join(file)
-      FileUtils.mkdir_p File.dirname(file)
-
-      File.open(file, "w+") do |f|
-        f << %(var I18n = I18n || {};\n)
-        f << %(I18n.translations = );
-        f << translations.to_json
-        f << %(;)
-      end
-    end
-
-    def scoped_translations(scopes) # :nodoc:
-      result = {}
-
-      [scopes].flatten.each do |scope|
-        deep_merge! result, filter(translations, scope)
-      end
-
-      result
-    end
-
-    # Filter translations according to the specified scope.
-    def filter(translations, scopes)
-      scopes = scopes.split(".") if scopes.is_a?(String)
-      scopes = scopes.clone
-      scope = scopes.shift
-
-      if scope == "*"
-        results = {}
-        translations.each do |scope, translations|
-          tmp = scopes.empty? ? translations : filter(translations, scopes)
-          results[scope.to_sym] = tmp unless tmp.nil?
-        end
-        return results
-      elsif translations.has_key?(scope.to_sym)
-        return {scope.to_sym => scopes.empty? ? translations[scope.to_sym] : filter(translations[scope.to_sym], scopes)}
-      end
-      nil
-    end
-
-    # Initialize and return translations
-    def translations
-      ::I18n.backend.instance_eval do
-        init_translations unless initialized?
-        translations
-      end
-    end
-
-    def deep_merge(target, hash) # :nodoc:
-      target.merge(hash, &MERGER)
-    end
-
-    def deep_merge!(target, hash) # :nodoc:
-      target.merge!(hash, &MERGER)
-    end
-  end
-end
-
+require "i18n/js"

data/lib/rails/generators/i18n/js/config/config_generator.rb

@@ -0,0 +1,19 @@
+module I18n
+  module Js
+    class ConfigGenerator < Rails::Generators::Base
+      # Copied files come from templates folder
+      source_root File.expand_path('../templates', __FILE__)
+
+      # Generator desc
+      desc <<-DESC
+        Creates a default i18n-js.yml configuration file in your app's config
+        folder. This file allows you to customize i18n:js:export rake task
+        outputted files.
+      DESC
+
+      def copy_initializer_file
+        copy_file "i18n-js.yml", "config/i18n-js.yml"
+      end
+    end
+  end
+end

data/{config → lib/rails/generators/i18n/js/config/templates}/i18n-js.yml

@@ -1,4 +1,5 @@
 # Split context in several files.
+#
 # By default only one file with all translations is exported and
 # no configuration is required. Your settings for asset pipeline
 # are automatically recognized.
@@ -7,16 +8,20 @@
 # locale contexts that will be exported, just use this file to do
 # so.
 #
+# For more informations about the export options with this file, please
+# refer to the README
+#
+#
 # If you're going to use the Rails 3.1 asset pipeline, change
 # the following configuration to something like this:
 #
-#   translations:
-#     - file: "app/assets/javascripts/i18n/translations.js"
+# translations:
+#   - file: "app/assets/javascripts/i18n/translations.js"
 #
 # If you're running an old version, you can use something
 # like this:
 #
-#   translations:
-#     - file: "public/javascripts/translations.js"
-#       only: "*"
-#
+# translations:
+#   - file: "app/assets/javascripts/i18n/translations.js"
+#     only: "*"
+#

data/lib/tasks/export.rake

@@ -0,0 +1,8 @@
+namespace :i18n do
+  namespace :js do
+    desc "Export translations to JS file(s)"
+    task :export => :environment do
+      I18n::JS.export
+    end
+  end
+end