grosser-gettext 2.0.0

data/lib/gettext/textdomain.rb

@@ -0,0 +1,225 @@
+=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       <mutoh@highway.ne.jp>
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id$
+=end
+
+require 'gettext/core_ext/string'
+require 'gettext/mofile'
+require 'rbconfig'
+
+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 :locale_paths
+    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
+    # The default locale paths.
+    CONFIG_PREFIX = Config::CONFIG['prefix'].gsub(/\/local/, "")
+    DEFAULT_LOCALE_PATHS = [
+      "#{Config::CONFIG['datadir']}/locale/%{lang}/LC_MESSAGES/%{name}.mo",
+      "#{Config::CONFIG['datadir'].gsub(/\/local/, "")}/locale/%{lang}/LC_MESSAGES/%{name}.mo",
+      "#{CONFIG_PREFIX}/share/locale/%{lang}/LC_MESSAGES/%{name}.mo",
+      "#{CONFIG_PREFIX}/local/share/locale/%{lang}/LC_MESSAGES/%{name}.mo"
+    ].uniq
+
+    # 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)
+      DEFAULT_LOCALE_PATHS.unshift(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, @topdir, @output_charset = name, topdir, output_charset
+
+      @locale_paths = []
+      if ENV["GETTEXT_PATH"]
+        ENV["GETTEXT_PATH"].split(/,/).each {|i| 
+          @locale_paths += ["#{i}/%{lang}/LC_MESSAGES/%{name}.mo", "#{i}/%{lang}/%{name}.mo"]
+        }
+      elsif @topdir
+        @locale_paths += ["#{@topdir}/%{lang}/LC_MESSAGES/%{name}.mo", "#{@topdir}/%{lang}/%{name}.mo"]
+      end
+
+      unless @topdir
+        @locale_paths += DEFAULT_LOCALE_PATHS
+    
+        if defined? Gem
+          $:.each do |path|
+            if /(.*)\/lib$/ =~ path
+              @locale_paths += [
+                                "#{$1}/data/locale/%{lang}/LC_MESSAGES/%{name}.mo", 
+                                "#{$1}/data/locale/%{lang}/%{name}.mo", 
+                                "#{$1}/locale/%{lang}/%{name}.mo"]
+            end
+          end
+        end
+      end
+   
+      @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
+
+    # 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 : nil
+        cond ||= "n != 1"
+        ret = [msg.split("\000"), cond]
+      else
+        ret = [[msg], "0"]
+      end
+      ret
+    end
+
+    def clear
+      @mofiles = {}
+    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
+
+      search_files = []
+
+      lang_candidates = lang.to_posix.candidates
+      @locale_paths.each do |dir|
+        lang_candidates.each{|tag|
+          fname = dir % {:lang => tag, :name => @name}
+          if $DEBUG
+            search_files << fname unless search_files.include?(fname)
+          end
+          if File.exist?(fname)
+            warn "GetText::TextDomain#load_mo: mo-file is #{fname}" if $DEBUG
+
+            charset = @output_charset || lang.charset || Locale.charset || "UTF-8"
+            mofile = MOFile.open(fname, charset)
+            break
+          end
+        }
+        break if mofile
+      end
+
+      if mofile
+        @mofiles[lang_key] = mofile
+      else
+        @mofiles[lang_key] = :empty
+        if $DEBUG
+          warn "MO file is not found in"
+          search_files.each do |v|
+            warn "  #{v}"
+          end
+        end
+      end
+      mofile
+    end
+
+  end
+end

data/lib/gettext/textdomain_manager.rb

@@ -0,0 +1,218 @@
+require 'gettext/textdomain'
+require 'gettext/class_info'
+require 'locale/util/memoizable'
+
+module GetText
+  class TextDomainManager
+    include Locale::Util::Memoizable
+
+    @@cached  = ! $DEBUG
+    @@textdomain_pool = {}
+    @@textdomain_manager_pool = {}
+
+    @@output_charset = nil
+    @@gettext_classes = []
+
+    # Gets all textdomains.
+    def self.textdomain_pool(domainname)
+      @@textdomain_pool[domainname]
+    end
+
+    def self.get(obj) #:nodoc:
+      klass = ClassInfo.normalize_class(obj)
+      ret = @@textdomain_manager_pool[klass]
+      unless ret
+        ret = TextDomainManager.new
+        @@textdomain_manager_pool[klass] = ret
+      end
+      ret
+    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 self.cached=(val)
+      @@cached = val
+      @@textdomain_pool.each do |key, textdomain|
+        textdomain.cached = val
+      end
+    end
+    
+    # Return the cached value.
+    def self.cached?
+      @@cached
+    end
+
+    # Gets the output charset.
+    def self.output_charset
+      @@output_charset 
+    end
+
+    # Sets the output charset.The program can have a output charset.
+    def self.output_charset=(charset)
+      @@output_charset = charset
+      @@textdomain_pool.each do |key, textdomain|
+        textdomain.charset = charset
+      end
+    end
+   
+    # bind textdomain to the class.
+    def self.bind_to(klass, domainname, options = {})
+      warn "Bind the domain '#{domainname}' to '#{klass}'. " if $DEBUG
+
+      path = options[:path] if options[:path]
+      charset = options[:output_charset] || self.output_charset
+
+      # Create a new textdomain into the pool.
+      textdomain = @@textdomain_pool[domainname]
+      unless textdomain
+        textdomain = TextDomain.new(domainname, path, charset)
+      end
+      @@textdomain_pool[domainname] = textdomain
+
+      target_klass = ClassInfo.normalize_class(klass)
+
+      get(target_klass).add(textdomain, options[:supported_language_tags])
+
+      @@gettext_classes << target_klass unless @@gettext_classes.include? target_klass
+
+      textdomain
+    end
+ 
+    #
+    # Instance methods
+    #
+
+    # Returns the textdoman in the instance.
+    attr_reader :textdomains, :supported_language_tags
+  
+    def initialize
+      @textdomains = []
+      @supported_language_tags = nil
+    end
+
+    def add(textdomain, supported_language_tags)
+      @textdomains.insert(0, textdomain) unless @textdomains.include? textdomain
+      @supported_language_tags = supported_language_tags if supported_language_tags
+    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 = '|')
+      lang = Locale.candidates(:supported_language_tags => @supported_language_tags, 
+                               :type => :posix)[0]
+      translate_singluar_message_to(lang, klass, msgid, div)
+    end
+
+    def translate_singluar_message_to(lang, klass, msgid, div = '|') #:nodoc:
+      msg = nil
+      # Find messages from related classes.
+      ClassInfo.related_classes(klass, @@gettext_classes).each do |target|
+        msg = nil
+        self.class.get(target).textdomains.each do |textdomain|
+          msg = textdomain.translate_singluar_message(lang, msgid)
+          break if msg
+        end
+        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
+      msg
+    end
+    memoize :translate_singluar_message_to
+
+    # 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 = "|")
+      lang = Locale.candidates(:supported_language_tags => @supported_language_tags,
+                               :type => :posix)[0]
+      
+      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
+
+      msgs = nil
+      # Find messages from related classes.
+      ClassInfo.related_classes(klass, @@gettext_classes).each do |target|
+        msgs = nil
+        self.class.get(target).textdomains.each do |textdomain|
+          msgs = textdomain.translate_plural_message(lang, msgid, msgid_plural)
+          break if msgs
+        end
+        break if msgs
+      end
+      
+      # If not found, return msgid.
+      unless msgs
+        msgs = [[msgid, msgid_plural], "n != 1"]
+      end
+
+      msgstrs = msgs[0]
+      if div and msgstrs[0] == msgid
+        if index = msgstrs[0].rindex(div)
+          msgstrs[0] = msgstrs[0][(index + 1)..-1]
+        end
+      end
+
+      # Return the singular or plural message.
+      plural = eval(msgs[1])
+      if plural.kind_of?(Numeric)
+        ret = msgstrs[plural]
+      else
+        ret = plural ? msgstrs[1] : msgstrs[0]
+      end
+      ret
+    end
+    
+    # for testing.
+    def self.clear_all_textdomains
+      @@textdomain_pool = {}
+      @@textdomain_manager_pool = {}
+      @@gettext_classes = []
+    end
+  end
+end

data/lib/gettext/tools.rb

@@ -0,0 +1,177 @@
+=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.
+=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/mofile'
+require 'fileutils'
+
+module GetText
+  bindtextdomain "rgettext"
+
+  BOM_UTF8 = [0xef, 0xbb, 0xbf].pack("c3")
+
+  module_function
+
+  # Currently, GNU msgmerge doesn't accept BOM. 
+  # This mesthod remove the UTF-8 BOM from the po-file.
+  def remove_bom(path)  #:nodoc:
+    bom = IO.read(path, 3)
+    if bom == BOM_UTF8
+      data = IO.read(path)
+      File.open(path, "w") do |out|
+        out.write(data[3..-1])
+      end
+    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. 
+  #
+  # The def.po file is an existing PO file with translations which will be taken 
+  # over to the newly created file as long as they still match; comments will be preserved,
+  # but extracted comments and file positions will be discarded. 
+  #
+  # The ref.pot file is the last created PO file with up-to-date source references but
+  # old translations, or a PO Template file (generally created by rgettext);
+  # any translations or comments in the file will be discarded, however dot
+  # comments and file positions will be preserved.  Where an exact match
+  # cannot be found, fuzzy matching is used to produce better results.
+  #
+  # Usually you don't need to call this function directly. Use GetText.update_pofiles instead.
+  #
+  # * defpo: a po-file. translations referring to old sources
+  # * refpo: a po-file. references to new sources
+  # * app_version: the application information which appears "Project-Id-Version: #{app_version}" in the pot/po-files.
+  # * Returns: self 
+  def msgmerge(defpo, refpo, app_version, options)
+    verbose = options.delete(:verbose) || false
+    puts "msgmerge called" if verbose
+    $stderr.print defpo + " "
+    cmd = ENV["MSGMERGE_PATH"] || "msgmerge"
+
+    cont = ""
+    if FileTest.exist? defpo
+      `#{cmd} --help`
+      unless $? && $?.success?
+        raise _("`%{cmd}' can not be found. \nInstall GNU Gettext then set PATH or MSGMERGE_PATH correctly.") % {:cmd => cmd}
+      end
+      remove_bom(defpo)
+
+      cmd_params = (options.delete(:msgmerge) || {}).map do |o|
+        o.kind_of?(Symbol) ? "--#{o}".gsub('_','-') : o.to_s
+      end.join(' ')
+
+      to_run = "#{cmd} #{cmd_params} #{defpo} #{refpo}"
+      puts "\nrunning #{to_run}" if verbose
+      cont = `#{to_run}`
+    else
+      File.open(refpo) do |io| 
+        cont = io.read
+      end
+    end
+    if cont.empty?
+      failed_filename = refpo + "~"
+      FileUtils.cp(refpo, failed_filename)
+      $stderr.puts _("Failed to merge with %{defpo}") % {:defpo => defpo}
+      $stderr.puts _("New .pot was copied to %{failed_filename}") %{:failed_filename => failed_filename}
+      raise _("Check these po/pot-files. It may have syntax errors or something wrong.")
+    else
+      cont.sub!(/(Project-Id-Version\:).*$/, "\\1 #{app_version}\\n\"")
+      File.open(defpo, "w") do |out|
+        out.write(cont)
+      end
+    end
+    self
+  end
+
+  # Creates mo-files using #{po_root}/#{lang}/*.po an put them to 
+  # #{targetdir}/#{targetdir_rule}/. 
+  #
+  # This is a convenience function of GetText.rmsgfmt for plural target files. 
+  # * options: options as a Hash.
+  #   * verbose: true if verbose mode, otherwise false
+  #   * po_root: the root directory of po-files.
+  #   * mo_root: the target root directory where the mo-files are stored.
+  #   * mo_path_rule: the target directory for each mo-files.
+  def create_mofiles(options = {})
+    opts = {:verbose => false, :po_root => "./po", :mo_root => "./data/locale", 
+      :mo_path_rule => "%{lang}/LC_MESSAGES"}
+    opts.merge!(options)
+
+    modir = File.join(opts[:mo_root], opts[:mo_path_rule])
+    Dir.glob(File.join(opts[:po_root], "*/*.po")) do |file|
+      lang, basename = /\/([^\/]+?)\/(.*)\.po/.match(file[opts[:po_root].size..-1]).to_a[1,2]
+      outdir = modir % {:lang => lang}
+      FileUtils.mkdir_p(outdir) unless File.directory?(outdir)
+      $stderr.print %Q[#{file} -> #{File.join(outdir, "#{basename}.mo")} ... ] if opts[:verbose]
+      begin
+        rmsgfmt(file, File.join(outdir, "#{basename}.mo"))
+      rescue Exception => e
+        $stderr.puts "Error." if opts[:verbose]
+        raise e
+      end
+      $stderr.puts "Done." if opts[: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". 
+  #
+  # *Note* "msgmerge" tool is included in GNU GetText. So you need to install GNU GetText. 
+  #
+  # See <HOWTO maintain po/mo files(http://www.yotabanana.com/hiki/ruby-gettext-howto-manage.html)> for more detals.
+  # * domainname: the textdomain name.
+  # * targetfiles: An Array of target files or nil (See GetText.rgettext for more details).
+  # * app_version: the application information which appears "Project-Id-Version: #{app_version}" in the pot/po-files.
+  # * options: a hash with following possible settings
+  #     :lang    - update files only for one language - the language specified by this option
+  #     :po_root - the root directory of po-files
+  #     :msgmerge - an array with the options, passed through to the gnu msgmerge tool
+  #                 symbols are automatically translated to options with dashes,
+  #                 example: [:no_wrap, :no_fuzzy_matching, :sort_output] translated to '--no-fuzzy-matching --sort-output'
+  #     :verbose - true to show verbose messages. default is false.
+  #
+  # 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
+    po_root = options.delete(:po_root) || "po"
+    only_one_language = options.delete(:lang)
+    refpot = "tmp.pot"
+    rgettext(files, refpot)
+
+    FileUtils.mkdir_p(po_root) unless FileTest.exist? po_root
+    msgmerge("#{po_root}/#{textdomain}.pot", refpot, app_version, options.dup)
+
+    if only_one_language
+      msgmerge("#{po_root}/#{only_one_language}/#{textdomain}.po", refpot, app_version, options.dup)
+    else
+      Dir.glob("#{po_root}/*/#{textdomain}.po"){ |f|
+        lang = /#{po_root}\/(.*)\//.match(f).to_a[1]
+        msgmerge("#{po_root}/#{lang}/#{textdomain}.po", refpot, app_version, options.dup)
+      }
+    end
+
+    File.delete(refpot)
+  end
+end
+
+if __FILE__ == $0
+  GetText.update_pofiles("foo", ARGV, "foo 1.1.0")
+end