slang 0.34.0

data/lib/slang/internal.rb

@@ -0,0 +1,139 @@
+require "bundler/setup"
+
+require "logger"
+require "set"
+require "time"
+require "uri"
+require "zlib"
+
+require "oj"
+
+require "slang/snapshot"
+require "slang/snapshot/locale"
+require "slang/snapshot/template"
+require "slang/snapshot/translation"
+
+require "slang/updater/development"
+require "slang/updater/key_reporter"
+require "slang/updater/production"
+require "slang/updater/shared_state"
+
+require "slang/version"
+
+module Slang
+  USER_AGENT = "slang-rb/#{VERSION}"
+  KEY_REGEX = /\A[0-9a-zA-Z_\-]{20}\z/
+
+  class ConfigurationError < SlangError; end
+  class SnapshotError      < SlangError; end
+  class NetworkError       < SlangError
+    attr_reader :retry_in
+    def initialize(retry_in=nil)
+      @retry_in = retry_in
+    end
+  end
+
+  def self.internal_translate(key, variable_hash)
+    snapshot.translate(locale_code, key, variable_hash)
+  end
+
+  def self.snapshot
+    raise SlangError, "not initialized." unless @initialized
+    @updater.snapshot
+  end
+
+  def self.key_reporter
+    @key_reporter
+  end
+
+  def self.env
+    @env
+  end
+
+  def self.log_error(message)
+    if @logger
+      @logger.error("[SLANG] #{message}")
+    elsif !defined?(Slang::TEST)
+      warn(message)
+    end
+  end
+
+  def self.log_warn(message)
+    if @logger
+      @logger.warn("[SLANG] #{message}")
+    elsif !defined?(Slang::TEST)
+      warn(message)
+    end
+  end
+
+  def self.log_info(message)
+    if @logger
+      @logger.info("[SLANG] #{message}")
+    end
+  end
+
+  def self.log_debug(message)
+    if @logger
+      @logger.debug("[SLANG] #{message}")
+    end
+  end
+
+  def self.env_var(var)
+    value = ENV[var]
+    value if value && !value.empty?
+  end
+
+  def self.init(config={})
+    return false if @initialized
+
+    api_base          = config[:api_base] ? config[:api_base].chomp("/") : nil
+    data_dir          = config[:data_dir] || env_var("SLANG_DATA_DIR") || File.join(defined?(Rails) ? Rails.root : Dir.pwd, "slang_data")
+    developer_key     = config[:developer_key] || env_var("SLANG_DEVELOPER_KEY")
+    embedded_snapshot = config[:embedded_snapshot] || env_var("SLANG_EMBEDDED_SNAPSHOT")
+    env               = config[:env] || env_var("SLANG_ENV") || (defined?(Rails) ? Rails.env : nil) || (config[:developer_key] ? "development" : "production")
+    project_key       = config[:project_key] || env_var("SLANG_PROJECT_KEY")
+
+    @env = env
+    dev_mode = @env =~ /\Adev/i
+    @logger ||= defined?(Rails) ? Rails.logger : nil
+
+    Slang.log_info("Slang v#{Slang::VERSION} starting in #{dev_mode ? 'development' : 'production'} mode (#{env} environment)")
+
+    begin
+      FileUtils.mkdir_p(data_dir, mode: 0755)
+    rescue
+      raise ConfigurationError, "unable to create data dir - #{data_dir}"
+    end
+    raise ConfigurationError, "missing/malformed project key (project_key=#{project_key})" unless project_key =~ KEY_REGEX
+
+    if dev_mode
+      raise ConfigurationError, "missing/malformed developer key (developer_key=#{developer_key})" unless developer_key =~ KEY_REGEX
+      api_base ||= "https://dev.getslang.com"
+      @updater = Updater::Development.new(env, "#{api_base}/snapshot/#{project_key}", data_dir, embedded_snapshot)
+      @updater.dev_key = developer_key
+      @key_reporter = Updater::KeyReporter.new("#{api_base}/keys/#{project_key}", developer_key)
+    else
+      api_base ||= "https://slang-a.akamaihd.net"
+      @updater = Updater::Production.new(env, "#{api_base}/m/#{project_key}", data_dir, embedded_snapshot)
+    end
+
+    Slang.log_info("Slang initialized. All systems go!")
+    @initialized = true
+
+    if puma_preload?
+      Puma.cli_config.options[:before_worker_boot] << Proc.new { Slang.snapshot } # delay to worker start
+      # TODO: unicorn check
+    else
+      Slang.snapshot # trigger background fetch immediately
+    end
+    nil
+  end
+
+private
+
+  def self.puma_preload?
+    defined?(Puma) && defined?(Puma.cli_config) && Puma.cli_config && Puma.cli_config.options[:preload_app] && (Puma.cli_config.options[:workers] > 0)
+  end
+
+end
+require "slang/railtie" if defined?(Rails)

data/lib/slang/railtie.rb

@@ -0,0 +1,16 @@
+module Slang
+
+  class Railtie < Rails::Railtie
+
+    initializer "slang" do
+      ActiveSupport.on_load(:action_view) do
+        include Slang::Helpers
+      end
+      ActiveSupport.on_load(:action_controller) do
+        include Slang::Helpers
+      end
+    end
+
+  end
+
+end

data/lib/slang/snapshot.rb

@@ -0,0 +1,131 @@
+require "slang/snapshot/warnings"
+module Slang
+
+  # A snapshot is a point-in-time state of all known keys and their associated translations.
+  #
+  class Snapshot
+    include Warnings
+
+    attr_reader :id             # String
+    attr_reader :timestamp      # Integer unix-time
+    attr_reader :default_locale # Locale
+    attr_reader :locales        # Hash of :locale_code => Locale
+
+    EMPTY_SNAPSHOT_JSON = '[6,"00000000000000000000",0,"en",[["en",null,"one_other",null]],[]]'
+
+    # Create a snapshot from a serialized JSON string.
+    #
+    def self.from_json(json)
+      Snapshot.new(array_from_json(json))
+    end
+
+    # Create a snapshot array from a serialized JSON string.
+    #
+    def self.array_from_json(json)
+      Oj.strict_load(json.force_encoding(Encoding::UTF_8))
+    end
+
+    # Create a Snapshot object.
+    #
+    # @param [Array]         deserialized snapshot array
+    # @raise [SnapshotError] if a corrupt snapshot is detected
+    #
+    def initialize(array)
+      snapshot_format, @id, @timestamp, default_locale_code, locales_array, translations_array = *array.to_a
+      @locales = {}
+      locales_array.each_with_index do |locale_array, i|
+        locale = Locale.new(locale_array, i)
+        @locales[locale.code] = locale
+        locale.aliases.each { |a| @locales[a] = locale }
+      end
+      @default_locale = @locales[default_locale_code.to_sym] || @locales.first[1]
+      raise SnapshotError, "default locale does not exist" unless @default_locale
+
+      @translations = {}
+      translations_array.each do |translation_array|
+        t = Translation.new(translation_array)
+        @translations[t.key] = t if t.rules
+      end
+      super() # invoke Warnings#initialize
+    end
+
+
+    # Fetch all the translation keys.
+    #
+    # @return [Array<String>] known keys.
+    #
+    def keys
+      @translations.keys
+    end
+
+    # Perform a translation for the given key/locale, with an optional variable map.
+    #
+    # @param [Symbol] locale code
+    # @param [#to_s]  key
+    # @param [Hash]   variable hash
+    #
+    # @return [String] always returns a String (typically a translation)
+    #
+    def translate(locale_code, key, vm)
+      key = key.to_s.downcase
+      variable_map = {}
+      vm.each { |k, v| variable_map[k.to_s.downcase.freeze] = v }
+      if Slang.key_reporter
+        raise ArgumentError, "Slang key name malformed: #{key}" unless key =~ Translation::KEY_REGEX
+        variable_map.each do |k, v|
+          raise ArgumentError, "Slang variable name malformed: #{k}" unless k =~ Template::VARIABLE_NAME_REGEX
+        end
+      end
+      internal_translate(locale_code, key, variable_map)
+    end
+
+  private
+
+    # Internal translate method.
+    #
+    # @param [Symbol] locale code
+    # @param [String] downcased string key
+    # @param [Hash{String => #to_s}] variable map with all keys as downcased strings
+    #
+    # @return [String] translation
+    #
+    def internal_translate(locale_code, key, variable_map)
+      locale = @locales[locale_code] || @default_locale
+
+      # lookup translation
+      translation = @translations[key]
+      result, string, missing_names, selector = translation.evaluate(locale, variable_map) if translation
+      case result
+      when :success
+        # all is good
+      when :missing_interpolation_variables
+        missing_interpolation_variables!(locale, key, selector, missing_names, variable_map)
+      when :missing_rule_variables
+        missing_rule_variables!(locale, key, missing_names, variable_map)
+      when :missing_rule_templates
+        missing_rule_templates!(locale, key, missing_names, variable_map)
+      else # :missing_template or nil
+        missing_key!(locale, key, variable_map)
+        fallback = internal_translate(locale.fallback, key, variable_map) if locale.fallback
+        return fallback if fallback
+        if Slang.key_reporter
+          Slang.log_info("reporting unknown key.. #{key}")
+          Slang.key_reporter.unknown_key(key, variable_map)
+          # development string placeholder
+          var_names = variable_map.keys.sort!
+          string = key.split(".").map! do |component|
+             component.split("_").map! { |c| c.capitalize }.join
+          end.join(" ")
+          unless var_names.empty?
+            string << " (" << var_names.map { |n| "#{n}=#{variable_map[n]}" }.join(", ") << ")"
+          end
+        else
+          # production string placeholder
+          string="{{#{locale.code}:#{key}}}"
+        end
+      end
+      string
+    end
+
+  end # class
+end

data/lib/slang/snapshot/locale.rb

@@ -0,0 +1,35 @@
+module Slang
+  class Snapshot
+
+    # A Locale is an immutable object that holds a locale code (and optional aliases), pluralization rule, and fallback
+    # locale.
+    #
+    class Locale
+
+      attr_reader :code
+      attr_reader :fallback
+      attr_reader :aliases
+      attr_reader :pluralization_method
+      attr_reader :translation_index
+
+      # Create a locale object from the snapshot locale array.
+      #
+      # @param [Array]   snapshot locale array
+      # @param [Integer] index of this locale's translation in translation array
+      #
+      def initialize(locale_array, translation_index)
+        code, fallback, pluralization, _, *aliases = *locale_array
+        @code = code.to_sym
+        @fallback = fallback.to_sym if fallback
+        @pluralization_method = "pluralization_#{pluralization}".to_sym
+        unless Rules.method_defined?(@pluralization_method)
+          Slang.log_warn("Ignoring unknown pluralization rule '#{pluralization}' in locale '#{code}'.")
+          @pluralization_method = :pluralization_unknown
+        end
+        @aliases = aliases.map(&:to_sym)
+        @translation_index = translation_index
+      end
+
+    end # class
+  end
+end

data/lib/slang/snapshot/rules.rb

@@ -0,0 +1,239 @@
+module Slang
+  class Snapshot
+
+    # Rule-logic, mixed into the Translation class.
+    #
+    module Rules
+
+      RULE_TYPES = {
+        "N" => :pluralization,
+        "G" => :gender
+      }
+
+      # Generate rules array from a rule pattern.
+      #
+      # @param [String] rule pattern of the form "var1=N" or "var1=N:var2=G:..."
+      #
+      # @return [Array<Array<(String,Symbol)>>,nil] rules array, nil on error
+      #
+      def rules_from_pattern(rule_pattern)
+        rule_pattern.to_s.split(":").map! do |rule|
+          variable_name, rule_code = rule.split("=")
+          rule_type = RULE_TYPES[rule_code]
+          return nil unless rule_type
+          [ variable_name, rule_type ]
+        end
+      end
+
+      # Invokes the appropriate rule with the given value. This returns one or more template selectors (which may be
+      # combined with other rules) that will specify the appropriate template.
+      #
+      # @param [Symbol] rule-type
+      # @param [Object] rule argument
+      #
+      # @return [Array<String>] template selectors to try, in order
+      #
+      def evaluate_rule(locale, rule_type, value)
+        case rule_type
+        when :pluralization
+          send(locale.pluralization_method, value)
+        when :gender
+          gender(genderize(value))
+        end
+      end
+
+      ### Gender rule
+
+      GENDER_FEMALE = %w(female)
+      GENDER_MALE = %w(male)
+      GENDER_UNKNOWN = %w(unknown)
+
+      # Determine gender rule based on given value.
+      #
+      # @param [Symbol] gender value should be :female, :male, or :unknown
+      #
+      # @return [Array(String)] an 1-element array of the gender.
+      #
+      def gender(value)
+        case value
+        when :female; GENDER_FEMALE
+        when :male;   GENDER_MALE
+        else          GENDER_UNKNOWN
+        end
+      end
+
+      # Attempts to convert value into :female, :male, or :unknown. Any value
+      # whose string form starts with "f" becomes :female, "m" becomes :male,
+      # otherwise :unknown.
+      #
+      # @return [Symbol] :female, :male, or :unknown
+      #
+      def genderize(value)
+        if (value == :female) || (value == :male)
+          value
+        elsif (value == :unknown) || value.nil?
+          :unknown
+        else
+          case value.to_s
+          when /\Af/i; :female
+          when /\Am/i; :male
+          else         :unknown
+          end
+        end
+      end
+
+      ### Pluralization rules
+
+      PLURAL_FEW = %w(few)
+      PLURAL_MANY = %w(many)
+      PLURAL_ONE = %w(one)
+      PLURAL_OTHER = %w(other)
+      PLURAL_TWO = %w(two)
+      PLURAL_ZERO = %w(zero)
+      PLURAL_ZERO_OR_ONE = %w(zero one)
+      PLURAL_ZERO_OR_MANY = %w(zero many)
+      PLURAL_ZERO_OR_OTHER = %w(zero other)
+
+      def pluralization_unknown(n)
+        PLURAL_OTHER
+      end
+
+      # Pluralization rule for languages with non-countable nouns "other",
+      # optionally supports the "zero" case.
+      #
+      # Example languages: Chinese, Japanese, Korean.
+      #
+      # @param [Number] integer or fraction
+      #
+      # @return [Array<String>] template selector(s)
+      #
+      def pluralization_other(n)
+        if n == 0
+          PLURAL_ZERO_OR_OTHER
+        else
+          PLURAL_OTHER
+        end
+      end
+
+      # Pluralization rule for languages with "one" or "other", optionally
+      # supports "zero" case.
+      #
+      # Example languages: English, German, Italian, Portugeuse, Spanish.
+      #
+      # @param [Number] integer or fraction
+      #
+      # @return [Array<String>] template selector(s)
+      #
+      def pluralization_one_other(n)
+        if n == 0
+          PLURAL_ZERO_OR_OTHER
+        elsif n == 1
+          PLURAL_ONE
+        else
+          PLURAL_OTHER
+        end
+      end
+
+      # Pluralization rule for languages with "one" for zero/one, or "other",
+      # optionally supports "zero" case.
+      #
+      # Example languages: French
+      #
+      # @param [Number] integer or fraction
+      #
+      # @return [Array<String>] template selector(s)
+      #
+      def pluralization_zero_and_one_other(n)
+        if n == 0
+          PLURAL_ZERO_OR_ONE
+        elsif n == 1
+          PLURAL_ONE
+        else
+          PLURAL_OTHER
+        end
+      end
+
+      # Pluralization rule for east slavic languages with "one", "few", "many",
+      # "other", optionally supports "zero" case.
+      #
+      # Example languages: RUssian
+      #
+      # @param [Number] integer or fraction
+      #
+      # @return [Array<String>] template selector(s)
+      #
+      def pluralization_east_slavic(n)
+        if n == 0
+          PLURAL_ZERO_OR_MANY
+        else
+          mod10 = n % 10
+          mod100 = n % 100
+          if (mod10 == 1) && (mod100 != 11)
+            PLURAL_ONE
+          elsif ((mod10 >= 2) && (mod10 <= 4)) && !((mod100 >= 12) && (mod100 <= 14))
+            PLURAL_FEW
+          elsif (mod10 == 0) || ((mod10 >= 5) && (mod10 <= 9)) || ((mod100 >= 11) && (mod100 <= 14))
+            PLURAL_MANY
+          else
+            PLURAL_OTHER
+          end
+        end
+      end
+
+      # Pluralization rule for Arabic with "zero", "one", "two", "few", "many",
+      # and "other". Note "zero" case is required.
+      #
+      # Example languages: Arabic.
+      #
+      # @param [Number] integer or fraction
+      #
+      # @return [Array<String>] template selector(s)
+      #
+      def pluralization_arabic(n)
+        if n == 0
+          PLURAL_ZERO
+        elsif n == 1
+          PLURAL_ONE
+        elsif n == 2
+          PLURAL_TWO
+        else
+          mod100 = n % 100
+          if (mod100 >= 3) && (mod100 <= 10)
+            PLURAL_FEW
+          elsif (mod100 >= 11)
+            PLURAL_MANY
+          else
+            PLURAL_OTHER
+          end
+        end
+      end
+
+      # Pluralization rule for Polish with "one", "few", "many", and "other", optionally supports "zero" case.
+      #
+      # @param [Number] integer or fraction
+      #
+      # @return [Array<String>] template selector(s)
+      #
+      def pluralization_polish(n)
+        if Float === n
+          PLURAL_OTHER
+        elsif n == 0
+          PLURAL_ZERO_OR_MANY
+        elsif n == 1
+          PLURAL_ONE
+        else
+          mod10 = n % 10
+          mod100 = n % 100
+          if ((mod10 >= 2) && (mod10 <= 4)) && !((mod100 >= 12) && (mod100 <= 14))
+            PLURAL_FEW
+          elsif ((mod10 == 0) || (mod10 == 1)) || ((mod10 >= 5) && (mod10 <= 9)) || ((mod100 >= 12) && (mod100 <= 14))
+            PLURAL_MANY
+          else
+            PLURAL_OTHER
+          end
+        end
+      end
+
+    end # module
+  end
+end