RubyGems - i18n-js - Versions diffs - 3.2.1 → 4.2.2 - Mend

@@ -1,59 +0,0 @@
-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?) &&
-            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? || 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 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 DELETED Viewed

@@ -1,87 +0,0 @@
-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 DELETED Viewed

@@ -1,70 +0,0 @@
-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

data/lib/i18n/js/formatters/base.rb DELETED Viewed

@@ -1,23 +0,0 @@
-module I18n
-  module JS
-    module Formatters
-      class Base
-        def initialize(js_extend: false, namespace: nil, pretty_print: false)
-          @js_extend    = js_extend
-          @namespace    = namespace
-          @pretty_print = pretty_print
-        end
-        protected
-        def format_json(translations)
-          if @pretty_print
-            ::JSON.pretty_generate(translations)
-          else
-            translations.to_json
-          end
-        end
-      end
-    end
-  end
-end

data/lib/i18n/js/formatters/js.rb DELETED Viewed

@@ -1,31 +0,0 @@
-require "i18n/js/formatters/base"
-module I18n
-  module JS
-    module Formatters
-      class JS < Base
-        def format(translations)
-          contents = header
-          translations.each do |locale, translations_for_locale|
-            contents << line(locale, format_json(translations_for_locale))
-          end
-          contents
-        end
-        protected
-        def header
-          %(#{@namespace}.translations || (#{@namespace}.translations = {});\n)
-        end
-        def line(locale, translations)
-          if @js_extend
-            %(#{@namespace}.translations["#{locale}"] = I18n.extend((#{@namespace}.translations["#{locale}"] || {}), #{translations});\n)
-          else
-            %(#{@namespace}.translations["#{locale}"] = #{translations};\n)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/i18n/js/formatters/json.rb DELETED Viewed

@@ -1,13 +0,0 @@
-require "i18n/js/formatters/base"
-module I18n
-  module JS
-    module Formatters
-      class JSON < Base
-        def format(translations)
-          format_json(translations)
-        end
-      end
-    end
-  end
-end

data/lib/i18n/js/middleware.rb DELETED Viewed

@@ -1,82 +0,0 @@
-require "fileutils"
-module I18n
-  module JS
-    class Middleware
-      def initialize(app)
-        @app = app
-        clear_cache
-      end
-      def call(env)
-        @cache = nil
-        verify_locale_files!
-        @app.call(env)
-      end
-      private
-      def cache_path
-        @cache_path ||= cache_dir.join("i18n-js.yml")
-      end
-      def cache_dir
-        @cache_dir ||= Rails.root.join("tmp/cache")
-      end
-      def cache
-        @cache ||= begin
-          if cache_path.exist?
-            YAML.load_file(cache_path) || {}
-          else
-            {}
-          end
-        end
-      end
-      def clear_cache
-        # `File.delete` will raise error when "multiple worker"
-        # Are running at the same time, like in a parallel test
-        #
-        # `FileUtils.rm_f` is tested manually
-        #
-        # See https://github.com/fnando/i18n-js/issues/436
-        FileUtils.rm_f(cache_path) if File.exist?(cache_path)
-      end
-      def save_cache(new_cache)
-        # path could be a symbolic link
-        FileUtils.mkdir_p(cache_dir) unless File.exists?(cache_dir)
-        File.open(cache_path, "w+") do |file|
-          file << new_cache.to_yaml
-        end
-      end
-      # Check if translations should be regenerated.
-      # ONLY REGENERATE when these conditions are met:
-      #
-      # # Cache file doesn't exist
-      # # Translations and cache size are different (files were removed/added)
-      # # Translation file has been updated
-      #
-      def verify_locale_files!
-        valid_cache = []
-        new_cache = {}
-        valid_cache.push cache_path.exist?
-        valid_cache.push ::I18n.load_path.uniq.size == cache.size
-        ::I18n.load_path.each do |path|
-          changed_at = File.mtime(path).to_i
-          valid_cache.push changed_at == cache[path]
-          new_cache[path] = changed_at
-        end
-        return if valid_cache.all?
-        save_cache(new_cache)
-        ::I18n::JS.export
-      end
-    end
-  end
-end

data/lib/i18n/js/private/hash_with_symbol_keys.rb DELETED Viewed

@@ -1,36 +0,0 @@
-module I18n
-  module JS
-    # @api private
-    module Private
-      # Hash with string keys converted to symbol keys
-      # Used for handling values read on YAML
-      #
-      # @api private
-      class HashWithSymbolKeys < ::Hash
-        # An instance can only be created by passing in another hash
-        def initialize(hash)
-          raise TypeError unless hash.is_a?(::Hash)
-          hash.each_key do |key|
-            # Objects like `Integer` does not have `to_sym`
-            new_key = key.respond_to?(:to_sym) ? key.to_sym : key
-            self[new_key] = hash[key]
-          end
-          self.default = hash.default if hash.default
-          self.default_proc = hash.default_proc if hash.default_proc
-          freeze
-        end
-        # From AS Core extension
-        def slice(*keys)
-          hash = keys.each_with_object(Hash.new) do |k, hash|
-            hash[k] = self[k] if has_key?(k)
-          end
-          self.class.new(hash)
-        end
-      end
-    end
-  end
-end

data/lib/i18n/js/segment.rb DELETED Viewed

@@ -1,75 +0,0 @@
-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, :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
-        @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.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
-        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 }
-      end
-    end
-  end
-end

data/lib/i18n/js/utils.rb DELETED Viewed

@@ -1,65 +0,0 @@
-module I18n
-  module JS
-    module Utils
-      PLURAL_KEYS = %i[zero one two few many other].freeze
-      # Based on deep_merge by Stefan Rusterholz, see <http://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 as-is without merging. This prevents mixing locales with different pluralization schemes.
-      # 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.
-      MERGER = proc do |_key, v1, v2|
-        if Hash === v2 && (v2.keys - PLURAL_KEYS).empty?
-          v2
-        elsif Hash === v1 && Hash === v2
-          v1.merge(v2, &MERGER)
-        else
-          v2.nil? ? v1 : v2
-        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.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
-    end
-  end
-end

data/lib/i18n/js/version.rb DELETED Viewed

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