fast_gettext 1.8.0 → 2.0.0

data/lib/fast_gettext/mo_file.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 require 'fast_gettext/vendor/mofile'
 module FastGettext
   # Responsibility:
   #  - abstract mo files for Mo Repository
   class MoFile
-    PLURAL_SEPERATOR = "\000"
+    PLURAL_SEPARATOR = "\000"
+    CONTEXT_SEPARATOR = "\004"
 
     # file => path or FastGettext::GetText::MOFile
-    def initialize(file, options={})
+    def initialize(file, options = {})
       @filename = file
       load_data if options[:eager_load]
     end
@@ -15,17 +18,21 @@ module FastGettext
       data[key]
     end
 
-    #returns the plural forms or all singular translations that where found
+    # returns the plural forms or all singular translations that where found
     # Car, Cars => [Auto,Autos] or []
     def plural(*msgids)
-      split_plurals(self[msgids*PLURAL_SEPERATOR].to_s)
+      split_plurals(self[msgids * PLURAL_SEPARATOR].to_s)
     end
 
     def pluralisation_rule
-      #gettext uses 0 as default rule, which would turn off all pluralisation, very clever...
-      #additionally parsing fails when directly accessing po files, so this line was taken from gettext/mofile
-      (data['']||'').split("\n").each do |line|
-        return lambda{|n|eval($2)} if /^Plural-Forms:\s*nplurals\s*\=\s*(\d*);\s*plural\s*\=\s*([^;]*)\n?/ =~ line
+      # gettext uses 0 as default rule, which would turn off all pluralisation, very clever...
+      # additionally parsing fails when directly accessing po files, so this line was taken from gettext/mofile
+      (data[''] || '').split("\n").each do |line|
+        if /^Plural-Forms:\s*nplurals\s*\=\s*(\d*);\s*plural\s*\=\s*([^;]*)\n?/ =~ line
+          return ->(n) do # rubocop:disable Lint/UnusedBlockArgument
+            eval($2) # rubocop:disable Security/Eval
+          end
+        end
       end
       nil
     end
@@ -36,35 +43,37 @@ module FastGettext
     end
 
     def self.empty
-      MoFile.new(File.join(File.dirname(__FILE__),'vendor','empty.mo'))
+      MoFile.new(File.join(File.dirname(__FILE__), 'vendor', 'empty.mo'))
     end
 
     private
 
     def load_data
-      @data = if @filename.is_a? FastGettext::GetText::MOFile
-        @filename
-      else
-        FastGettext::GetText::MOFile.open(@filename, "UTF-8")
-      end
+      @data =
+        if @filename.is_a? FastGettext::GetText::MOFile
+          @filename
+        else
+          FastGettext::GetText::MOFile.open(@filename, "UTF-8")
+        end
       make_singular_and_plural_available
     end
 
-    #(if plural==singular, prefer singular)
+    # (if plural==singular, prefer singular)
     def make_singular_and_plural_available
       data = {}
-      @data.each do |key,translation|
-        next unless key.include? PLURAL_SEPERATOR
+      @data.each do |key, translation|
+        next unless key.include? PLURAL_SEPARATOR
+
         singular, plural = split_plurals(key)
         translation = split_plurals(translation)
         data[singular] ||= translation[0]
         data[plural] ||= translation[1]
       end
-      @data.merge!(data){|key,old,new| old}
+      @data.merge!(data) { |_key, old, _new| old }
     end
 
     def split_plurals(singular_plural)
-      singular_plural.split(PLURAL_SEPERATOR)
+      singular_plural.split(PLURAL_SEPARATOR)
     end
   end
 end

data/lib/fast_gettext/po_file.rb

@@ -1,29 +1,20 @@
+# frozen_string_literal: true
+
 require 'fast_gettext/mo_file'
 module FastGettext
   # Responsibility:
   #  - abstract po files for Po Repository
   class PoFile < MoFile
-    def initialize(file, options={})
+    def initialize(file, options = {})
       @options = options
       super
     end
 
-    def self.to_mo_file(file, options={})
+    def self.to_mo_file(file, options = {})
       MoFile.new(parse_po_file(file, options))
     end
 
-    protected
-
-    def load_data
-      @data = if @filename.is_a? FastGettext::GetText::MOFile
-        @filename
-      else
-        FastGettext::PoFile.parse_po_file(@filename, @options)
-      end
-      make_singular_and_plural_available
-    end
-
-    def self.parse_po_file(file, options={})
+    def self.parse_po_file(file, options = {})
       require 'fast_gettext/vendor/poparser'
       parser = FastGettext::GetText::PoParser.new
 
@@ -35,5 +26,17 @@ module FastGettext
       parser.parse_file(file, mo_file)
       mo_file
     end
+
+    protected
+
+    def load_data
+      @data =
+        if @filename.is_a? FastGettext::GetText::MOFile
+          @filename
+        else
+          FastGettext::PoFile.parse_po_file(@filename, @options)
+        end
+      make_singular_and_plural_available
+    end
   end
 end

data/lib/fast_gettext/storage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fast_gettext/cache'
 
 module FastGettext
@@ -12,11 +14,15 @@ module FastGettext
       end
     end
 
+    DEFAULT_PLURALIZATION_RULE = ->(i) { i != 1 }
+
     [:available_locales, :_locale, :text_domain, :pluralisation_rule].each do |method_name|
-      key = "fast_gettext_#{method_name}".to_sym
-      define_method "#{method_name}=" do |value|
-        switch_cache if Thread.current[key] != Thread.current[key]=value
-      end
+      key = "fast_gettext_#{method_name}"
+      eval <<-RUBY, nil, __FILE__, __LINE__ + 1 # rubocop:disable Security/Eval
+        def #{method_name}=(value)
+          switch_cache if Thread.current[:#{key}] != Thread.current[:#{key}] = value
+        end
+      RUBY
     end
 
     def _locale
@@ -24,11 +30,11 @@ module FastGettext
     end
     private :_locale, :_locale=
 
-
     def available_locales
       locales = Thread.current[:fast_gettext_available_locales] || default_available_locales
       return unless locales
-      locales.map{|s|s.to_s}
+
+      locales.map(&:to_s)
     end
 
     # cattr_accessor with defaults
@@ -37,7 +43,7 @@ module FastGettext
       [:default_text_domain, "nil"],
       [:cache_class, "FastGettext::Cache"]
     ].each do |name, default|
-      eval <<-Ruby
+      eval <<-RUBY, nil, __FILE__, __LINE__ + 1 # rubocop:disable Security/Eval
         @@#{name} = #{default}
         def #{name}=(value)
           @@#{name} = value
@@ -47,7 +53,7 @@ module FastGettext
         def #{name}
           @@#{name}
         end
-      Ruby
+      RUBY
     end
 
     def text_domain
@@ -57,7 +63,7 @@ module FastGettext
     # if overwritten by user( FastGettext.pluralisation_rule = xxx) use it,
     # otherwise fall back to repo or to default lambda
     def pluralisation_rule
-      Thread.current[:fast_gettext_pluralisation_rule] ||  current_repository.pluralisation_rule || lambda{|i| i!=1}
+      Thread.current[:fast_gettext_pluralisation_rule] || current_repository.pluralisation_rule || DEFAULT_PLURALIZATION_RULE
     end
 
     def cache
@@ -69,8 +75,8 @@ module FastGettext
       translation_repositories.values.each(&:reload)
     end
 
-    #global, since re-parsing whole folders takes too much time...
-    @@translation_repositories={}
+    # global, since re-parsing whole folders takes too much time...
+    @@translation_repositories = {} # rubocop:disable Style/ClassVars
     def translation_repositories
       @@translation_repositories
     end
@@ -97,7 +103,7 @@ module FastGettext
     end
 
     def locale
-      _locale || ( default_locale || (available_locales||[]).first || 'en' )
+      _locale || (default_locale || (available_locales || []).first || 'en')
     end
 
     def locale=(new_locale)
@@ -107,15 +113,15 @@ module FastGettext
     # for chaining: puts set_locale('xx') == 'xx' ? 'applied' : 'rejected'
     # returns the current locale, not the one that was supplied
     # like locale=(), whoes behavior cannot be changed
-    def set_locale(new_locale)
+    def set_locale(new_locale) # rubocop:disable Naming/AccessorMethodName
       new_locale = best_locale_in(new_locale)
       self._locale = new_locale
       locale
     end
 
-    @@default_locale = nil
+    @@default_locale = nil # rubocop:disable Style/ClassVars
     def default_locale=(new_locale)
-      @@default_locale = best_locale_in(new_locale)
+      @@default_locale = best_locale_in(new_locale) # rubocop:disable Style/ClassVars
       switch_cache
     end
 
@@ -123,17 +129,17 @@ module FastGettext
       @@default_locale
     end
 
-    #Opera: de-DE,de;q=0.9,en;q=0.8
-    #Firefox de-de,de;q=0.8,en-us;q=0.5,en;q=0.3
-    #IE6/7 de
-    #nil if nothing matches
+    # Opera: de-DE,de;q=0.9,en;q=0.8
+    # Firefox de-de,de;q=0.8,en-us;q=0.5,en;q=0.3
+    # IE6/7 de
+    # nil if nothing matches
     def best_locale_in(locales)
       formatted_sorted_locales(locales).each do |candidate|
-        return candidate if not available_locales
+        return candidate unless available_locales
         return candidate if available_locales.include?(candidate)
-        return candidate[0..1] if available_locales.include?(candidate[0..1])#available locales include a langauge
+        return candidate[0..1] if available_locales.include?(candidate[0..1]) # available locales include a langauge
       end
-      return nil#nothing found im sorry :P
+      nil # nothing found im sorry :P
     end
 
     # temporarily switch locale for a block
@@ -146,27 +152,27 @@ module FastGettext
       set_locale current_locale
     end
 
-    #turn off translation if none was defined to disable all resulting errors
+    # turn off translation if none was defined to disable all resulting errors
     def silence_errors
       require 'fast_gettext/translation_repository/base'
-      translation_repositories[text_domain] ||= TranslationRepository::Base.new('x', :path => 'locale')
+      translation_repositories[text_domain] ||= TranslationRepository::Base.new('x', path: 'locale')
     end
 
     private
 
     # de-de,DE-CH;q=0.9 -> ['de_DE','de_CH']
     def formatted_sorted_locales(locales)
-      found = weighted_locales(locales).reject{|x|x.empty?}.sort_by{|l|l.last}.reverse #sort them by weight which is the last entry
-      found.flatten.map{|l| format_locale(l)}
+      found = weighted_locales(locales).reject(&:empty?).sort_by(&:last).reverse # sort them by weight which is the last entry
+      found.flatten.map { |l| format_locale(l) }
     end
 
-    #split the locale and seperate it into different languages
-    #de-de,de;q=0.9,en;q=0.8 => [['de-de','de','0.5'], ['en','0.8']]
+    # split the locale and seperate it into different languages
+    # de-de,de;q=0.9,en;q=0.8 => [['de-de','de','0.5'], ['en','0.8']]
     def weighted_locales(locales)
-      locales = locales.to_s.gsub(/\s/,'')
+      locales = locales.to_s.gsub(/\s/, '')
       found = [[]]
       locales.split(',').each do |part|
-        if part =~ /;q=/ #contains language and weight ?
+        if part =~ /;q=/ # contains language and weight ?
           found.last << part.split(/;q=/)
           found.last.flatten!
           found << []
@@ -177,9 +183,9 @@ module FastGettext
       found
     end
 
-    #de-de -> de_DE
+    # de-de -> de_DE
     def format_locale(locale)
-      locale.sub(/^([a-zA-Z]{2,3})[-_]([a-zA-Z]{2,3})$/){$1.downcase+'_'+$2.upcase}
+      locale.sub(/^([a-zA-Z]{2,3})[-_]([a-zA-Z]{2,3})$/) { $1.downcase + '_' + $2.upcase }
     end
 
     def switch_cache

data/lib/fast_gettext/translation.rb

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
 module FastGettext
+  TRANSLATION_METHODS = [:_, :n_, :s_, :p_, :ns_, :np_].freeze
+  NIL_BLOCK = -> { nil }
+
   # this module should be included
   # Responsibility:
   #  - direct translation queries to the current repository
@@ -6,153 +11,114 @@ module FastGettext
   #  - understand / enforce namespaces
   #  - decide which plural form is used
   module Translation
-    extend self
-
-    #make it usable in class definition, e.g.
-    # class Y
-    #   include FastGettext::Translation
-    #   @@x = _('y')
-    # end
-    def self.included(klas)  #:nodoc:
-      klas.extend self
-    end
-
-    def _(key, &block)
-      FastGettext.cached_find(key) or (block ? block.call : key)
+    def _(key)
+      FastGettext.cached_find(key) || (block_given? ? yield : key)
     end
 
-    #translate pluralized
+    # translate pluralized
     # some languages have up to 4 plural forms...
     # n_(singular, plural, plural form 2, ..., count)
     # n_('apple','apples',3)
-    def n_(*keys, &block)
-      count = keys.pop
+    def n_(*keys, count)
       translations = FastGettext.cached_plural_find(*keys)
-
       selected = FastGettext.pluralisation_rule.call(count)
-      selected = (selected ? 1 : 0) unless selected.is_a? Numeric #convert booleans to numbers
+      selected = (selected ? 1 : 0) unless selected.is_a? Numeric # convert booleans to numbers
 
+      # If we have a translation return it
       result = translations[selected]
-      if result
-        result
-      elsif keys[selected]
-        _(keys[selected])
-      else
-        block ? block.call : keys.last
-      end
+      return result if result
+
+      # If we have a block always use it in place of a translation
+      return yield if block_given?
+
+      # Fall back to the best fit translated key if it's there
+      _(keys[selected] || keys.last)
     end
 
-    #translate with namespace, use namespect to find key
-    # 'Car','Tire' -> Tire if no translation could be found
-    # p_('Car','Tire') <=> s_('Car|Tire')
-    def p_(namespace, key, separator=nil, &block)
-      msgid = "#{namespace}#{separator||NAMESPACE_SEPARATOR}#{key}"
-      FastGettext.cached_find(msgid) or (block ? block.call : key)
+    # translate with namespace
+    # 'Car', 'Tire' -> Tire if no translation could be found
+    # p_('Car', 'Tire') == s_('Car|Tire')
+    def p_(namespace, key, separator = nil)
+      msgid = "#{namespace}#{separator || CONTEXT_SEPARATOR}#{key}"
+
+      translation = FastGettext.cached_find(msgid)
+      return translation if translation
+
+      block_given? ? yield : key
     end
 
-    #translate, but discard namespace if nothing was found
+    # translate, but discard namespace if nothing was found
     # Car|Tire -> Tire if no translation could be found
-    def s_(key, separator=nil, &block)
-      translation = FastGettext.cached_find(key) and return translation
-      block ? block.call : key.split(separator||NAMESPACE_SEPARATOR).last
+    def s_(key, separator = nil)
+      translation = FastGettext.cached_find(key)
+      return translation if translation
+
+      block_given? ? yield : key.split(separator || NAMESPACE_SEPARATOR).last
     end
 
-    #tell gettext: this string need translation (will be found during parsing)
+    # tell gettext: this string need translation (will be found during parsing)
     def N_(translate)
       translate
     end
 
-    #tell gettext: this string need translation (will be found during parsing)
+    # tell gettext: this string need translation (will be found during parsing)
     def Nn_(*keys)
       keys
     end
 
-    def ns_(*args, &block)
-      translation = n_(*args, &block)
-      # block is called once again to compare result
-      block && translation == block.call ? translation : translation.split(NAMESPACE_SEPARATOR).last
-    end
-  end
+    # translate pluralized with separator
+    def ns_(*args)
+      translation = n_(*args, &NIL_BLOCK)
+      return translation if translation
 
-  # this module should be included for multi-domain support
-  module TranslationMultidomain
-    extend self
-
-    #make it usable in class definition, e.g.
-    # class Y
-    #   include FastGettext::TranslationMultidomain
-    #   @@x = d_('domain', 'y')
-    # end
-    def self.included(klas)  #:nodoc:
-      klas.extend self
-    end
+      return yield if block_given?
 
-    # helper block for changing domains
-    def _in_domain domain
-      old_domain = FastGettext.text_domain
-      FastGettext.text_domain = domain
-      yield if block_given?
-    ensure
-      FastGettext.text_domain = old_domain
+      n_(*args).split(NAMESPACE_SEPARATOR).last
     end
 
-    # gettext functions to translate in the context of given domain
-    def d_(domain, key, &block)
-      _in_domain domain do
-        FastGettext::Translation._(key, &block)
-      end
-    end
-
-    def dn_(domain, *keys, &block)
-      _in_domain domain do
-        FastGettext::Translation.n_(*keys, &block)
-      end
-    end
+    # translate pluralized with context
+    def np_(context, plural_one, *args, separator: nil)
+      nargs = ["#{context}#{separator || CONTEXT_SEPARATOR}#{plural_one}"] + args
+      translation = n_(*nargs, &NIL_BLOCK)
+      return translation if translation
 
-    def ds_(domain, key, separator=nil, &block)
-      _in_domain domain do
-        FastGettext::Translation.s_(key, separator, &block)
-      end
-    end
-
-    def dns_(domain, *keys, &block)
-      _in_domain domain do
-        FastGettext::Translation.ns_(*keys, &block)
-      end
-    end
+      return yield if block_given?
 
-    # gettext functions to translate in the context of any domain
-    # (note: if mutiple domains contains key, random translation is returned)
-    def D_(key)
-      FastGettext.translation_repositories.each_key do |domain|
-        result = FastGettext::TranslationMultidomain.d_(domain, key) {nil}
-        return result unless result.nil?
-      end
-      key
+      n_(plural_one, *args)
     end
+  end
 
-    def Dn_(*keys)
-      FastGettext.translation_repositories.each_key do |domain|
-        result = FastGettext::TranslationMultidomain.dn_(domain, *keys) {nil}
-        return result unless result.nil?
-      end
-      keys[-3].split(keys[-2]||NAMESPACE_SEPARATOR).last
-    end
+  module TranslationAliased
+    include Translation
+    TRANSLATION_METHODS.each { |m| alias_method "#{m.to_s.delete('_')}gettext", m }
+  end
 
-    def Ds_(key, separator=nil)
-      FastGettext.translation_repositories.each_key do |domain|
-        result = FastGettext::TranslationMultidomain.ds_(domain, key, separator) {nil}
-        return result unless result.nil?
-      end
-      key.split(separator||NAMESPACE_SEPARATOR).last
-    end
+  # this module should be included for multi-domain support
+  module TranslationMultidomain
+    include Translation
 
-    def Dns_(*keys)
-      FastGettext.translation_repositories.each_key do |domain|
-        result = FastGettext::TranslationMultidomain.dns_(domain, *keys) {nil}
-        return result unless result.nil?
-      end
-      keys[-2].split(NAMESPACE_SEPARATOR).last
+    # gettext functions to translate in the context of given domain
+    TRANSLATION_METHODS.each do |method|
+      eval <<-RUBY, nil, __FILE__, __LINE__ + 1 # rubocop:disable Security/Eval
+        # translate in given domain
+        def d#{method}(domain, *args, &block)
+          FastGettext.with_domain(domain) { #{method}(*args, &block) }
+        end
+
+        # translate with whatever domain finds a translation
+        def D#{method}(*args, &block)
+          repos = FastGettext.translation_repositories
+          last = repos.size - 1
+          repos.each_key.each_with_index do |domain, i|
+            if i == last
+              return d#{method}(domain, *args, &block)
+            else
+              result = d#{method}(domain, *args, &NIL_BLOCK)
+              return result if result
+            end
+          end
+        end
+      RUBY
     end
   end
 end