fair-gettext 2.0.1 → 2.0.2

data/lib/gettext/runtime/textdomain.rb

@@ -0,0 +1,177 @@
+=begin
+  textdomain.rb - GetText::Textdomain
+
+  Copyright (C) 2001-2009  Masao Mutoh
+  Copyright (C) 2001-2003  Masahiro Sakai
+
+      Masahiro Sakai    <s01397ms@sfc.keio.ac.jp>
+      Masao Mutoh       <mutomasa at gmail.com>
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby or LGPL.
+=end
+
+require 'gettext/core_ext/string'
+require 'gettext/runtime/mofile'
+require 'gettext/runtime/locale_path'
+
+module GetText
+  # GetText::TextDomain class manages mo-files of a textdomain.
+  #
+  # Usually, you don't need to use this class directly.
+  #
+  # Notice: This class is unstable. APIs will be changed.
+  class TextDomain
+
+    attr_reader :output_charset
+    attr_reader :mofiles
+    attr_reader :name
+
+    @@cached = ! $DEBUG
+    # Cache the mo-file or not.
+    # Default is true. If $DEBUG is set then false.
+    def self.cached?
+      @@cached
+    end
+
+    # Set to cache the mo-file or not.
+    # * val: true if cached, otherwise false.
+    def self.cached=(val)
+      @@cached = val
+    end
+
+    # Add default locale path. Usually you should use GetText.add_default_locale_path instead.
+    # * path: a new locale path. (e.g.) "/usr/share/locale/%{lang}/LC_MESSAGES/%{name}.mo"
+    #   ('locale' => "ja_JP", 'name' => "textdomain")
+    # * Returns: the new DEFAULT_LOCALE_PATHS
+    def self.add_default_locale_path(path)
+      warn "Deprecated. Use GetText::LocalePath.add_default_rule instead."
+      LocalePath.add_default_rule(path)
+    end
+
+    # Creates a new GetText::TextDomain.
+    # * name: the textdomain name.
+    # * topdir: the locale path ("%{topdir}/%{lang}/LC_MESSAGES/%{name}.mo") or nil.
+    # * output_charset: output charset.
+    # * Returns: a newly created GetText::TextDomain object.
+    def initialize(name, topdir = nil, output_charset = nil)
+      @name, @output_charset = name, output_charset
+
+      @locale_path = LocalePath.new(@name, topdir)
+      @mofiles = {}
+    end
+    
+    # Translates the translated string.
+    # * lang: Locale::Tag::Simple's subclass.
+    # * msgid: the original message.
+    # * Returns: the translated string or nil.
+    def translate_singluar_message(lang, msgid)
+      return "" if msgid == "" or msgid.nil?
+
+      lang_key = lang.to_s
+
+      mofile = nil
+      if self.class.cached?
+        mofile = @mofiles[lang_key]
+      end
+      unless mofile
+        mofile = load_mo(lang)
+      end
+     
+      if (! mofile) or (mofile ==:empty)
+        return nil
+      end
+
+      msgstr = mofile[msgid]
+      if msgstr and (msgstr.size > 0)
+        msgstr
+      elsif msgid.include?("\000")
+        # Check "aaa\000bbb" and show warning but return the singluar part.
+        ret = nil
+        msgid_single = msgid.split("\000")[0]
+        mofile.each{|key, val| 
+          if key =~ /^#{Regexp.quote(msgid_single)}\000/
+            # Usually, this is not caused to make po-files from rgettext.
+            warn %Q[Warning: n_("#{msgid_single}", "#{msgid.split("\000")[1]}") and n_("#{key.gsub(/\000/, '", "')}") are duplicated.]
+            ret = val
+            break
+          end
+        }
+        ret
+      else
+        ret = nil
+        mofile.each{|key, val| 
+          if key =~ /^#{Regexp.quote(msgid)}\000/
+            ret = val.split("\000")[0]
+            break
+          end
+        }
+        ret
+      end
+    end
+
+    DEFAULT_PLURAL_CALC = Proc.new{|n| n != 1}
+    DEFAULT_SINGLE_CALC = Proc.new{|n| 0}
+
+    # Translates the translated string.
+    # * lang: Locale::Tag::Simple's subclass.
+    # * msgid: the original message.
+    # * msgid_plural: the original message(plural).
+    # * Returns: the translated string as an Array ([[msgstr1, msgstr2, ...], cond]) or nil.
+    def translate_plural_message(lang, msgid, msgid_plural)   #:nodoc:
+      key = msgid + "\000" + msgid_plural
+      msg = translate_singluar_message(lang, key)
+      ret = nil
+      if ! msg
+        ret = nil
+      elsif msg.include?("\000")
+        # [[msgstr[0], msgstr[1], msgstr[2],...], cond]
+        mofile = @mofiles[lang.to_posix.to_s]
+        cond = (mofile and mofile != :empty) ? mofile.plural_as_proc : DEFAULT_PLURAL_CALC
+        ret = [msg.split("\000"), cond]
+      else
+        ret = [[msg], DEFAULT_SINGLE_CALC]
+      end
+      ret
+    end
+
+    # Clear cached mofiles.
+    def clear
+      @mofiles = {}
+    end
+
+    # Set output_charset.
+    # * charset: output charset.
+    def output_charset=(charset)
+      @output_charset = charset
+      clear
+    end
+
+    private
+    # Load a mo-file from the file.
+    # lang is the subclass of Locale::Tag::Simple.
+    def load_mo(lang)
+      lang = lang.to_posix unless lang.kind_of? Locale::Tag::Posix
+      lang_key = lang.to_s
+
+      mofile = @mofiles[lang_key]
+      if mofile
+        if mofile == :empty
+          return :empty
+        elsif ! self.class.cached?
+          mofile.update!
+        end
+        return mofile
+      end
+
+      path = @locale_path.current_path(lang)
+
+      if path
+        charset = @output_charset || lang.charset || Locale.charset || "UTF-8"
+        @mofiles[lang_key] = MOFile.open(path, charset)
+      else
+        @mofiles[lang_key] = :empty
+      end
+    end
+  end
+end

data/lib/gettext/runtime/textdomain_group.rb

@@ -0,0 +1,24 @@
+=begin
+  gettext/textdomain_group - GetText::TextDomainGroup class
+
+  Copyright (C) 2009  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby or LGPL.
+
+=end
+
+module GetText
+
+  class TextDomainGroup
+    attr_reader :textdomains
+    
+    def initialize
+      @textdomains = []
+    end
+
+    def add(textdomain)
+      @textdomains.unshift(textdomain) unless @textdomains.include? textdomain
+    end
+  end
+end

data/lib/gettext/runtime/textdomain_manager.rb

@@ -0,0 +1,211 @@
+=begin
+  gettext/textdomain_manager - GetText::TextDomainManager class
+
+  Copyright (C) 2009  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby or LGPL.
+
+=end
+
+require 'gettext/runtime/class_info'
+require 'gettext/runtime/textdomain'
+require 'gettext/runtime/textdomain_group'
+
+module GetText
+
+  module TextDomainManager
+
+    @@textdomain_pool = {}
+    @@textdomain_group_pool = {}
+
+    @@output_charset = nil
+    @@gettext_classes = []
+
+    @@singular_message_cache = {}
+    @@plural_message_cache = {}
+    @@cached = ! $DEBUG
+
+    extend self
+    
+    # Find textdomain by name
+    def textdomain_pool(domainname)
+      @@textdomain_pool[domainname]
+    end
+
+    # Set the value whether cache messages or not. 
+    # true to cache messages, otherwise false.
+    #
+    # Default is true. If $DEBUG is false, messages are not checked even if
+    # this value is true.
+    def cached=(val)
+      @@cached = val
+      TextDomain.cached = val
+    end
+    
+    # Return the cached value.
+    def cached?
+      TextDomain.cached?
+    end
+
+    # Gets the output charset.
+    def output_charset
+      @@output_charset 
+    end
+    
+    # Sets the output charset.The program can have a output charset.
+    def output_charset=(charset)
+      @@output_charset = charset
+      @@textdomain_pool.each do |key, textdomain|
+        textdomain.output_charset = charset
+      end
+    end
+    
+    # bind textdomain to the class.
+    def bind_to(klass, domainname, options = {})
+      warn "Bind the domain '#{domainname}' to '#{klass}'. " if $DEBUG
+
+      charset = options[:output_charset] || self.output_charset
+      textdomain = create_or_find_textdomain(domainname,options[:path],charset)
+      target_klass = ClassInfo.normalize_class(klass)
+      create_or_find_textdomain_group(target_klass).add(textdomain)
+      @@gettext_classes << target_klass unless @@gettext_classes.include? target_klass
+      
+      textdomain
+    end
+    
+    def each_textdomains(klass) #:nodoc:
+      lang = Locale.candidates[0]
+      ClassInfo.related_classes(klass, @@gettext_classes).each do |target|
+        msg = nil
+        if group = @@textdomain_group_pool[target]
+          group.textdomains.each do |textdomain|
+            yield textdomain, lang
+          end
+        end
+      end
+    end
+
+    # Translates msgid, but if there are no localized text, 
+    # it returns a last part of msgid separeted "div" or whole of the msgid with no "div".
+    #
+    # * msgid: the message id.
+    # * div: separator or nil.
+    # * Returns: the localized text by msgid. If there are no localized text, 
+    #   it returns a last part of msgid separeted "div".
+    def translate_singluar_message(klass, msgid, div = nil)
+      klass = ClassInfo.normalize_class(klass)
+      key = [Locale.current, klass, msgid, div].hash
+      msg = @@singular_message_cache[key]
+      return msg if msg and @@cached
+      # Find messages from related classes.
+      each_textdomains(klass) do |textdomain, lang|
+        msg = textdomain.translate_singluar_message(lang, msgid)
+        break if msg
+      end
+      
+      # If not found, return msgid.
+      msg ||= msgid
+      if div and msg == msgid
+        if index = msg.rindex(div)
+          msg = msg[(index + 1)..-1]
+        end
+      end
+      @@singular_message_cache[key] = msg
+    end
+    
+    # This function is similar to the get_singluar_message function 
+    # as it finds the message catalogs in the same way. 
+    # But it takes two extra arguments for plural form.
+    # The msgid parameter must contain the singular form of the string to be converted. 
+    # It is also used as the key for the search in the catalog. 
+    # The msgid_plural parameter is the plural form. 
+    # The parameter n is used to determine the plural form. 
+    # If no message catalog is found msgid1 is returned if n == 1, otherwise msgid2. 
+    # And if msgid includes "div", it returns a last part of msgid separeted "div".
+    #
+    # * msgid: the singular form with "div". (e.g. "Special|An apple", "An apple")
+    # * msgid_plural: the plural form. (e.g. "%{num} Apples")
+    # * n: a number used to determine the plural form.
+    # * div: the separator. Default is "|".
+    # * Returns: the localized text which key is msgid_plural if n is plural(follow plural-rule) or msgid.
+    #   "plural-rule" is defined in po-file.
+    #
+    # or
+    #
+    # * [msgid, msgid_plural] : msgid and msgid_plural an Array
+    # * n: a number used to determine the plural form.
+    # * div: the separator. Default is "|".
+    def translate_plural_message(klass, arg1, arg2, arg3 = "|", arg4 = "|")
+      klass = ClassInfo.normalize_class(klass)
+      # parse arguments
+      if arg1.kind_of?(Array)
+        msgid = arg1[0]
+        msgid_plural = arg1[1]
+        n = arg2
+        if arg3 and arg3.kind_of? Numeric
+          raise ArgumentError, _("3rd parmeter is wrong: value = %{number}") % {:number => arg3}
+        end
+        div = arg3
+      else
+        msgid = arg1
+        msgid_plural = arg2
+        n = arg3
+        div = arg4
+      end
+
+      key = [Locale.current, klass, msgid, msgid_plural, div].hash
+      msgs = @@plural_message_cache[key]
+      unless (msgs and @@cached)
+        # Find messages from related classes.
+        msgs = nil
+        each_textdomains(klass) do |textdomain, lang|
+          msgs = textdomain.translate_plural_message(lang, msgid, msgid_plural)
+          break if msgs
+        end
+        
+        msgs = [[msgid, msgid_plural], TextDomain::DEFAULT_PLURAL_CALC] unless msgs
+        
+        msgstrs = msgs[0]
+        if div and msgstrs[0] == msgid and index = msgstrs[0].rindex(div)
+          msgstrs[0] = msgstrs[0][(index + 1)..-1]
+        end
+        @@plural_message_cache[key] = msgs
+      end
+      
+      # Return the singular or plural message.
+      msgstrs = msgs[0]
+      plural = msgs[1].call(n)
+      return msgstrs[plural] if plural.kind_of?(Numeric)
+      return plural ? msgstrs[1] : msgstrs[0]
+    end
+
+    # for testing.
+    def clear_all_textdomains
+      @@textdomain_pool = {}
+      @@textdomain_group_pool = {}
+      @@gettext_classes = []
+      clear_caches
+    end
+
+    # for testing.
+    def clear_caches
+      @@singular_message_cache = {}
+      @@plural_message_cache = {}
+    end
+
+    def create_or_find_textdomain_group(klass) #:nodoc:
+      group = @@textdomain_group_pool[klass]
+      return group if group
+      
+      @@textdomain_group_pool[klass] = TextDomainGroup.new
+    end
+    
+    def create_or_find_textdomain(name, path, charset)#:nodoc:
+      textdomain = @@textdomain_pool[name]
+      return textdomain if textdomain
+      
+      @@textdomain_pool[name] = TextDomain.new(name, path, charset)
+    end
+  end
+end

data/lib/gettext/tools.rb

@@ -1,29 +1,29 @@
 =begin
   tools.rb - Utility functions
-
+ 
   Copyright (C) 2005-2008 Masao Mutoh
-
+ 
   You may redistribute it and/or modify it under the same
   license terms as Ruby or LGPL.
 =end
-
+ 
 require 'rbconfig'
 if /mingw|mswin|mswin32/ =~ RUBY_PLATFORM
   ENV['PATH'] = %w(bin lib).collect{|dir|
     "#{Config::CONFIG["prefix"]}\\lib\\GTK\\#{dir};"
   }.join('') + ENV['PATH']
 end
-
+ 
 require 'gettext/tools/rgettext'
 require 'gettext/tools/rmsgfmt'
 require 'gettext/runtime/mofile'
 require 'fileutils'
-
+ 
 module GetText
   bindtextdomain "rgettext"
-
+ 
   BOM_UTF8 = [0xef, 0xbb, 0xbf].pack("c3")
-
+ 
   # Currently, GNU msgmerge doesn't accept BOM. 
   # This mesthod remove the UTF-8 BOM from the po-file.
   def remove_bom(path)  #:nodoc:
@@ -33,7 +33,7 @@ module GetText
       File.open(path, "w") {|f| f.write(data)}
     end
   end
-
+ 
   # Merges two Uniforum style .po files together. 
   #
   # *Note* This function requires "msgmerge" tool included in GNU GetText. So you need to install GNU GetText. 
@@ -58,7 +58,7 @@ module GetText
     verbose = options.delete(:verbose)
     puts "msgmerge called" if verbose
     $stderr.print defpo + " "
-
+ 
     content = merge_po_files(defpo,refpo,options.delete(:msgmerge),verbose)
     
     if content.empty?
@@ -76,7 +76,7 @@ module GetText
     
     self
   end
-
+ 
   # Creates mo-files using #{po_root}/#{lang}/*.po an put them to 
   # #{targetdir}/#{targetdir_rule}/. 
   #
@@ -88,7 +88,7 @@ module GetText
   #   * mo_path_rule: the target directory for each mo-files.
   def create_mofiles(options = {})
     options = {:po_root => "./po"}.merge(options)
-
+ 
     Dir.glob(File.join(options[:po_root], "*/*.po")) do |po_file|
       mo_file = mo_file_from_po_file(po_file,options)
       $stderr.print %Q[#{po_file} -> #{mo_file} ... ] if options[:verbose]
@@ -97,8 +97,8 @@ module GetText
       $stderr.puts "Done." if options[:verbose]
     end
   end
-
-
+ 
+ 
   # At first, this creates the #{po_root}/#{domainname}.pot file using GetText.rgettext.
   # In the second step, this updates(merges) the #{po_root}/#{domainname}.pot and all of the
   # #{po_root}/#{lang}/#{domainname}.po files under "po_root" using "msgmerge". 
@@ -120,60 +120,67 @@ module GetText
   # Example: GetText.update_pofiles("myapp", Dir.glob("lib/*.rb"), "myapp 1.0.0", :verbose => true)
   def update_pofiles(textdomain, files, app_version, options = {})
     puts options.inspect if options[:verbose]
-
-    #write found messages to tmp.pot
+ 
+    #write found messages to tmp.pot and private_tmp.pot
     temp_pot = "tmp.pot"
-    rgettext(files, temp_pot)
-
-    #merge tmp.pot and existing pot
+    private_temp_pot = "private_tmp.pot"
+    rgettext(files, temp_pot, private_temp_pot)
+    
+    #merge tmp.pot and private_tmp.pot with existing pot
     po_root = options.delete(:po_root) || "po"
     FileUtils.mkdir_p(po_root)
     msgmerge("#{po_root}/#{textdomain}.pot", temp_pot, app_version, options.dup)
-
+    msgmerge("#{po_root}/private_#{textdomain}.pot", private_temp_pot, app_version, options.dup)
+ 
     #update local po-files
     only_one_language = options.delete(:lang)
     if only_one_language
       msgmerge("#{po_root}/#{only_one_language}/#{textdomain}.po", temp_pot, app_version, options.dup)
+      msgmerge("#{po_root}/#{only_one_language}/private_#{textdomain}.po", private_temp_pot, app_version, options.dup)
     else
       Dir.glob("#{po_root}/*/#{textdomain}.po") do |po_file|
         msgmerge(po_file, temp_pot, app_version, options.dup)
       end
+      Dir.glob("#{po_root}/*/private_#{textdomain}.po") do |po_file|
+        msgmerge(po_file, private_temp_pot, app_version, options.dup)
+      end
     end
-
+ 
     File.delete(temp_pot)
+    File.delete(private_temp_pot)
   end
-
+ 
   private
-
+ 
   # Merge 2 po files, using msgmerge
   def merge_po_files(po_a,po_b,msgmerge_options=[],verbose=false)
     return File.read(po_b) unless FileTest.exist? po_a
-
+ 
     cmd = ENV["MSGMERGE_PATH"] || "msgmerge"
     ensure_command_exists(cmd)
-
+ 
     remove_bom(po_a)
-
+ 
     cmd_params = array_to_cli_options(msgmerge_options)
     to_run = "#{cmd} #{cmd_params} #{po_a} #{po_b}"
     puts "\nrunning #{to_run}" if verbose
     `#{to_run}`
   end
-
+ 
   # convert an array of String/Symbol to cli options
   def array_to_cli_options(array)
     [*array].map do |o|
       o.kind_of?(Symbol) ? "--#{o}".gsub('_','-') : o.to_s
     end.join(' ')
   end
-
+ 
   def ensure_command_exists(cmd)
     `#{cmd} --help`
     unless $? && $?.success?
       raise _("`%{cmd}' can not be found. \nInstall GNU Gettext then set PATH or MSGMERGE_PATH correctly.") % {:cmd => cmd}
     end
   end
-
+ 
   # where lies the mo file for a given po_file
   # generare directory unless it exists
   def mo_file_from_po_file(po_file,options)
@@ -183,13 +190,13 @@ module GetText
     }.merge(options)
     
     lang, textdomain = %r[/([^/]+?)/(.*)\.po].match(po_file[options[:po_root].size..-1]).to_a[1,2]
-
+ 
     mo_dir_rule = File.join(options[:mo_root], options[:mo_path_rule])
     mo_dir = mo_dir_rule % {:lang => lang}
     File.join(mo_dir, "#{textdomain}.mo")
   end
 end
-
+ 
 if __FILE__ == $0
   GetText.update_pofiles("foo", ARGV, "foo 1.1.0")
-end
+end