experteer-gettext 2.0.4

data/lib/gettext/textdomain.rb

@@ -0,0 +1,179 @@
+=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.
+
+  $Id$
+=end
+
+require 'gettext/core_ext/string'
+require 'gettext/mofile'
+require 'gettext/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/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.
+
+=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/textdomain_manager.rb

@@ -0,0 +1,212 @@
+=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.
+
+=end
+
+require 'gettext/class_info'
+require 'gettext/textdomain'
+require 'gettext/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/rgettext.rb

@@ -0,0 +1,236 @@
+#! /usr/bin/env ruby
+=begin
+  rgettext.rb - Generate a .pot file.
+
+  Copyright (C) 2003-2009  Masao Mutoh
+  Copyright (C) 2001,2002  Yasushi Shoji, Masao Mutoh
+ 
+      Yasushi Shoji   <yashi at atmark-techno.com>
+      Masao Mutoh     <mutomasa at gmail.com>
+ 
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+
+require 'optparse'
+require 'gettext'
+require 'rbconfig'
+
+module GetText
+
+  module RGetText #:nodoc:
+    extend GetText
+
+    bindtextdomain("rgettext")
+
+    # constant values
+    VERSION = GetText::VERSION
+    DATE = %w($Date: 2008/08/06 17:35:52 $)[1]
+    MAX_LINE_LEN = 70
+
+    @ex_parsers = []
+    [
+      ["glade.rb", "GladeParser"],
+      ["erb.rb", "ErbParser"],
+#      ["active_record.rb", "ActiveRecordParser"],
+#      ["ripper.rb", "RipperParser"],
+      ["ruby.rb", "RubyParser"] # Default parser.
+    ].each do |f, klass|
+      begin
+        require "gettext/parser/#{f}"
+        @ex_parsers << GetText.const_get(klass)
+      rescue
+        $stderr.puts _("'%{klass}' is ignored.") % {:klass => klass}
+        $stderr.puts $! if $DEBUG
+      end
+    end
+
+    module_function
+
+    # Add an option parser
+    # the option parser module requires to have target?(file) and parser(file, ary) method.
+    # 
+    #  require 'gettext/rgettext'
+    #  module FooParser
+    #    module_function
+    #    def target?(file)
+    #      File.extname(file) == '.foo'  # *.foo file only.
+    #    end
+    #    def parse(file, ary)
+    #      :
+    #      return ary # [["msgid1", "foo.rb:200"], ["msgid2", "bar.rb:300", "baz.rb:400"], ...]
+    #    end
+    #  end
+    #  
+    #  GetText::RGetText.add_parser(FooParser)
+    def add_parser(klass)
+      @ex_parsers.insert(0, klass)
+    end
+
+    def generate_pot_header # :nodoc:
+      time = Time.now.strftime("%Y-%m-%d %H:%M")
+      off = Time.now.utc_offset
+      sign = off <= 0 ? '-' : '+'
+      time += sprintf('%s%02d%02d', sign, *(off.abs / 60).divmod(60))
+
+      <<TITLE
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\\n"
+"POT-Creation-Date: #{time}\\n"
+"PO-Revision-Date: #{time}\\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
+"Language-Team: LANGUAGE <LL@li.org>\\n"
+"MIME-Version: 1.0\\n"
+"Content-Type: text/plain; charset=UTF-8\\n"
+"Content-Transfer-Encoding: 8bit\\n"
+"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\\n"
+TITLE
+    end
+
+    def generate_pot(ary) # :nodoc:
+      str = ""
+      ary.each do |target|
+        # extracted comments
+        if target.extracted_comment
+          target.extracted_comment.split("\n").each do |comment_line|
+            str << "\n#. #{comment_line.strip}"
+          end
+        end
+
+        # references
+        curr_pos = MAX_LINE_LEN
+        target.occurrences.each do |e|
+          if curr_pos + e.size > MAX_LINE_LEN
+            str << "\n#:"
+            curr_pos = 3
+          else
+            curr_pos += (e.size + 1)
+          end
+          str << " " << e
+        end
+
+        # msgctxt, msgid, msgstr
+        str << "\nmsgctxt \"" << target.msgctxt << "\"" if target.msgctxt
+        str << "\nmsgid \"" << target.escaped(:msgid) << "\"\n"
+        if target.plural
+          str << "msgid_plural \"" << target.escaped(:plural) << "\"\n"
+          str << "msgstr[0] \"\"\n"
+          str << "msgstr[1] \"\"\n"
+        else
+          str << "msgstr \"\"\n"
+        end
+      end
+      str
+    end
+
+    def parse(files) # :nodoc:
+      ary = []
+      files.each do |file|
+        begin
+          @ex_parsers.each do |klass|
+            if klass.target?(file)
+              ary = klass.parse(file, ary)
+              break
+            end
+          end
+        rescue
+          puts "Error parsing " + file
+          raise
+        end
+      end
+      ary
+    end
+
+    def check_options # :nodoc:
+      output = STDOUT
+
+      opts = OptionParser.new
+      opts.banner = _("Usage: %s input.rb [-r parser.rb] [-o output.pot]") % $0
+      opts.separator("")
+      opts.separator(_("Extract translatable strings from given input files."))
+      opts.separator("")
+      opts.separator(_("Specific options:"))
+
+      opts.on("-o", "--output=FILE", _("write output to specified file")) do |out|
+        unless FileTest.exist? out
+          output = File.new(File.expand_path(out), "w+")
+        else
+          $stderr.puts(_("File '%s' already exists.") % out)
+          exit 1
+        end
+      end
+
+      opts.on("-r", "--require=library", _("require the library before executing rgettext")) do |out|
+        require out
+      end
+
+      opts.on("-d", "--debug", _("run in debugging mode")) do
+        $DEBUG = true
+      end
+
+      opts.on_tail("--version", _("display version information and exit")) do
+        puts "#{$0} #{VERSION} (#{DATE})"
+        puts "#{File.join(Config::CONFIG["bindir"], Config::CONFIG["RUBY_INSTALL_NAME"])} #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+        exit
+      end
+
+      opts.parse!(ARGV)
+
+      if ARGV.size == 0
+        puts opts.help
+        exit 1
+      end
+
+      [ARGV, output]
+    end
+
+    def run(targetfiles = nil, out = STDOUT)  # :nodoc:
+      if targetfiles.is_a? String
+        targetfiles = [targetfiles]
+      elsif ! targetfiles
+        targetfiles, out = check_options
+      end
+
+      if targetfiles.size == 0
+        raise ArgumentError, _("no input files")
+      end
+
+      if out.is_a? String
+        File.open(File.expand_path(out), "w+") do |file|
+          file.puts generate_pot_header
+          file.puts generate_pot(parse(targetfiles))
+        end
+      else
+        out.puts generate_pot_header
+        out.puts generate_pot(parse(targetfiles))
+      end
+      self
+    end
+  end
+  extend self
+  # Creates a po-file from targetfiles(ruby-script-files, .rhtml files, glade-2 XML files), 
+  # then output the result to out. If no parameter is set, it behaves same as command line tools(rgettet). 
+  #
+  # This function is a part of GetText.create_pofiles.
+  # Usually you don't need to call this function directly.
+  #
+  # * targetfiles: An Array of po-files or nil.
+  # * out: output IO or output path.
+  # * Returns: self
+  def rgettext(targetfiles = nil, out = STDOUT)
+    RGetText.run(targetfiles, out)
+    self
+  end
+end
+
+if $0 == __FILE__
+  GetText.rgettext
+#  GetText.rgettext($0, "tmp.txt")
+end