ofm_gettext 2.0.0 → 2.0.1

data/lib/gettext/runtime/textdomain.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+
+=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,26 @@
+# encoding: utf-8
+
+=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,214 @@
+# encoding: utf-8
+
+=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, _("ngettext: 3rd parmeter is wrong: value = %{number}") % {:number => arg3}
+        end
+        div = arg3
+      else
+        msgid = arg1
+        msgid_plural = arg2
+        raise ArgumentError, _("ngettext: 3rd parameter should be a number, not nil.")  unless arg3
+        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/parser/erb.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+=begin
+  parser/erb.rb - parser for ERB
+
+  Copyright (C) 2005-2009  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby or LGPL.
+=end
+
+require 'erb'
+require 'gettext/tools/parser/ruby'
+
+module GetText
+  module ErbParser
+    extend self
+
+    @config = {
+      :extnames => ['.rhtml', '.erb']
+    }
+
+    # Sets some preferences to parse ERB files.
+    # * config: a Hash of the config. It can takes some values below:
+    #   * :extnames: An Array of target files extension. Default is [".rhtml"].
+    def init(config)
+      config.each{|k, v|
+  @config[k] = v
+      }
+    end
+
+    def parse(file, targets = []) # :nodoc:
+      src = ERB.new(IO.readlines(file).join).src
+      # Remove magic comment prepended by erb in Ruby 1.9.
+      src.sub!(/\A#.*?coding[:=].*?\n/, '') if src.respond_to?(:encode)
+      erb = src.split(/$/)
+      RubyParser.parse_lines(file, erb, targets)
+    end
+
+    def target?(file) # :nodoc:
+      @config[:extnames].each do |v|
+  return true if File.extname(file) == v
+      end
+      false
+    end
+  end
+end
+
+if __FILE__ == $0
+  # ex) ruby glade.rhtml foo.rhtml  bar.rhtml
+  ARGV.each do |file|
+    p GetText::ErbParser.parse(file)
+  end
+end