i18n-js 2.1.2 → 3.8.3

data/lib/i18n/js.rb

@@ -0,0 +1,264 @@
+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)
+      I18n.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.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
+
+    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/dependencies.rb

@@ -0,0 +1,63 @@
+module I18n
+  module JS
+    # When using `safe_gem_check` to check for a pre-release version of gem,
+    # we need to specify pre-release version suffix in version constraint
+    module Dependencies
+      class << self
+        def rails?
+          defined?(Rails) && Rails.respond_to?(:version)
+        end
+
+        def sprockets_rails_v2_plus?
+          safe_gem_check("sprockets-rails", ">= 2")
+        end
+
+        # This cannot be called at class definition time
+        # Since not all libraries are loaded
+        #
+        # Call this in an initializer
+        def using_asset_pipeline?
+          assets_pipeline_available =
+            (rails3? || rails4? || rails5? || rails6?) &&
+            Rails.respond_to?(:application) &&
+            Rails.application.config.respond_to?(:assets)
+          rails3_assets_enabled =
+            rails3? &&
+            assets_pipeline_available &&
+            Rails.application.config.assets.enabled != false
+
+          assets_pipeline_available && (rails4? || rails5? || rails6? || rails3_assets_enabled)
+        end
+
+        private
+
+        def rails3?
+          rails? && Rails.version.to_i == 3
+        end
+
+        def rails4?
+          rails? && Rails.version.to_i == 4
+        end
+
+        def rails5?
+          rails? && Rails.version.to_i == 5
+        end
+
+        def rails6?
+          rails? && Rails.version.to_i == 6
+        end
+
+        def safe_gem_check(*args)
+          if Gem::Specification.respond_to?(:find_by_name)
+            Gem::Specification.find_by_name(*args)
+          elsif Gem.respond_to?(:available?)
+            Gem.available?(*args)
+          end
+        rescue Gem::LoadError
+          false
+        end
+
+      end
+    end
+  end
+end

data/lib/i18n/js/engine.rb

@@ -0,0 +1,87 @@
+require "i18n/js"
+
+module I18n
+  module JS
+    # @api private
+    # The class cannot be private
+    class SprocketsExtension
+      # Actual definition is placed below
+    end
+
+    class Engine < ::Rails::Engine
+      # See https://github.com/rails/sprockets/blob/master/guides/extending_sprockets.md#supporting-all-versions-of-sprockets-in-processors
+      # for reference of supporting multiple versions
+
+      # `sprockets.environment` was used for 1.x of `sprockets-rails`
+      # https://github.com/rails/sprockets-rails/issues/227
+      #
+      # References for current values:
+      #
+      # Here is where sprockets are attached with Rails. There is no 'sprockets.environment' mentioned.
+      # https://github.com/rails/sprockets-rails/blob/master/lib/sprockets/railtie.rb
+      #
+      # Finisher hook is the place which should be used as border.
+      # http://guides.rubyonrails.org/configuring.html#initializers
+      #
+      # For detail see Pull Request:
+      # https://github.com/fnando/i18n-js/pull/371
+      initializer "i18n-js.register_preprocessor", after: :engines_blank_point, before: :finisher_hook do
+        # This must be called inside initializer block
+        # For details see comments for `using_asset_pipeline?`
+        next unless JS::Dependencies.using_asset_pipeline?
+
+        # From README of 2.x & 3.x of `sprockets-rails`
+        # It seems the `configure` block is preferred way to call `register_preprocessor`
+        # Not sure if this will break older versions of rails
+        #
+        # https://github.com/rails/sprockets-rails/blob/v2.3.3/README.md
+        # https://github.com/rails/sprockets-rails/blob/v3.0.0/README.md
+        if JS::Dependencies.sprockets_rails_v2_plus?
+          Rails.application.config.assets.configure do |config|
+            config.register_preprocessor("application/javascript", ::I18n::JS::SprocketsExtension)
+          end
+        elsif Rails.application.assets.respond_to?(:register_preprocessor)
+          Rails.application.assets.register_preprocessor("application/javascript", ::I18n::JS::SprocketsExtension)
+        end
+      end
+    end
+
+    # @api private
+    class SprocketsExtension
+      def initialize(filename, &block)
+        @filename = filename
+        @source   = block.call
+      end
+
+      def render(context, empty_hash_wtf)
+        self.class.run(@filename, @source, context)
+      end
+
+      def self.run(filename, source, context)
+        if context.logical_path == "i18n/filtered"
+          ::I18n.load_path.each { |path| context.depend_on(File.expand_path(path)) }
+
+          # Absolute path is required or
+          # Sprockets assumes it's a logical path
+          #
+          # Calling `depend on` with an absent file
+          # will invoke `resolve` and will throw an error in the end
+          if I18n::JS.config_file_exists?
+            context.depend_on(File.expand_path(I18n::JS.config_file_path))
+          end
+        end
+
+        source
+      end
+
+      def self.call(input)
+        filename = input[:filename]
+        source   = input[:data]
+        context  = input[:environment].context_class.new(input)
+
+        result = run(filename, source, context)
+        context.metadata.merge(data: result)
+      end
+    end
+  end
+end

data/lib/i18n/js/fallback_locales.rb

@@ -0,0 +1,70 @@
+module I18n
+  module JS
+    class FallbackLocales
+      attr_reader :fallbacks, :locale
+
+      def initialize(fallbacks, locale)
+        @fallbacks = fallbacks
+        @locale = locale
+      end
+
+      def each
+        locales.each { |locale| yield(locale) }
+      end
+
+      # @return [Array<String, Symbol>]
+      #   An Array of locales to use as fallbacks for given locale.
+      def locales
+        locales = case fallbacks
+                  when true
+                    default_fallbacks
+                  when :default_locale
+                    [::I18n.default_locale]
+                  when Symbol, String
+                    [fallbacks.to_sym]
+                  when Array
+                    ensure_valid_fallbacks_as_array!
+                    fallbacks
+                  when Hash
+                    Array(fallbacks[locale] || default_fallbacks)
+                  else
+                    fail ArgumentError, "fallbacks must be: true, :default_locale an Array or a Hash - given: #{fallbacks}"
+                  end
+
+        locales.map! { |locale| locale.to_sym }
+        locales
+      end
+
+      private
+
+      # @return [Array<String, Symbol>] An Array of locales.
+      def default_fallbacks
+        if using_i18n_fallbacks_module?
+          I18n.fallbacks[locale]
+        else
+          [::I18n.default_locale]
+        end
+      end
+
+      # @return
+      #   true if we can safely use I18n.fallbacks, false otherwise.
+      #
+      # @note
+      #   We should implement this as `I18n.respond_to?(:fallbacks)`, but
+      #   once I18n::Backend::Fallbacks is included, I18n will _always_
+      #   respond to :fallbacks. Even if we switch the backend to one
+      #   without fallbacks!
+      #
+      #   Maybe this should be fixed within I18n.
+      def using_i18n_fallbacks_module?
+        I18n::JS.backend.class.included_modules.include?(I18n::Backend::Fallbacks)
+      end
+
+      def ensure_valid_fallbacks_as_array!
+        return if fallbacks.all? { |e| e.is_a?(String) || e.is_a?(Symbol) }
+
+        fail ArgumentError, "If fallbacks is passed as Array, it must ony include Strings or Symbols. Given: #{fallbacks}"
+      end
+    end
+  end
+end