gettext 2.3.9 → 3.0.0

data/lib/gettext/tools.rb

@@ -18,189 +18,8 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'rbconfig'
-if /mingw|mswin|mswin32/ =~ RUBY_PLATFORM
-  ENV['PATH'] = %w(bin lib).collect{|dir|
-    "#{::RbConfig::CONFIG["prefix"]}\\lib\\GTK\\#{dir};"
-  }.join('') + ENV['PATH']
-end
-
 require 'gettext/tools/xgettext'
 require 'gettext/tools/msgfmt'
 require 'gettext/tools/msginit'
 require 'gettext/tools/msgmerge'
-require 'gettext/runtime/mo'
-require 'fileutils'
-
-module GetText
-  bindtextdomain "gettext"
-
-  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:
-    bom = IO.read(path, 3)
-    if bom == BOM_UTF8
-      data = IO.read(path)[3..-1]
-      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.
-  #
-  # 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 rxgettext);
-  # 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)
-    puts "msgmerge called" if verbose
-    $stderr.print defpo + " "
-
-    content = merge_po_files(defpo,refpo,options.delete(:msgmerge),verbose)
-
-    if content.empty?
-      # report failure
-      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
-      # update version and save merged data
-      content.sub!(/(Project-Id-Version\:).*$/, "\\1 #{app_version}\\n\"")
-      File.open(defpo, "w") {|f|f.write(content)}
-    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 multiple 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 = {})
-    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]
-      FileUtils.mkdir_p(File.dirname(mo_file))
-      Tools::MsgFmt.run(po_file, "-o", mo_file)
-      $stderr.puts "Done." if options[:verbose]
-    end
-  end
-
-
-  # At first, this creates the #{po_root}/#{domainname}.pot file using
-  # GetText::XGetText.run.  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, that should be parsed for messages (See GetText::XGetText.run 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 if options[:verbose]
-
-    #write found messages to tmp.pot
-    temp_pot = "tmp.pot"
-    Tools::XGetText.run("-o", temp_pot, *files)
-
-    #merge tmp.pot and 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)
-
-    #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)
-    else
-      Dir.glob("#{po_root}/*/#{textdomain}.po") do |po_file|
-        msgmerge(po_file, temp_pot, app_version, options.dup)
-      end
-    end
-
-    File.delete(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}' cannot 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)
-    options = {
-      :mo_root => "./data/locale",
-      :mo_path_rule => "%{lang}/LC_MESSAGES"
-    }.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
+require 'gettext/mo'

data/lib/gettext/tools/msgfmt.rb

@@ -22,7 +22,7 @@
 require "optparse"
 require "fileutils"
 require "gettext"
-require "gettext/tools/poparser"
+require "gettext/po_parser"
 
 module GetText
   module Tools

data/lib/gettext/tools/msginit.rb

@@ -19,7 +19,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 require "gettext"
-require "gettext/tools/poparser"
+require "gettext/po_parser"
 require "gettext/tools/msgmerge"
 require "locale/info"
 require "optparse"

data/lib/gettext/tools/msgmerge.rb

@@ -23,231 +23,12 @@
 require "optparse"
 require "text"
 require "gettext"
-require "gettext/tools/poparser"
-require "gettext/tools/po"
+require "gettext/po_parser"
+require "gettext/po"
 
 module GetText
   module Tools
     class MsgMerge
-      class PoData  #:nodoc:
-
-        attr_reader :po
-
-        def initialize
-          @po = PO.new
-        end
-
-        def set_comment(msgid, comments, msgctxt=nil)
-          entry = generate_entry(msgid)
-
-          if msgid == :last
-            entry.comment = comments
-            return
-          end
-
-          comments.each_line do |_line|
-            line = _line.chomp
-            entry = parse_comment(line, entry)
-          end
-        end
-
-        def msgstr(msgid)
-          self[msgid]
-        end
-
-        def comment(msgid)
-          msgctxt, msgid, _ = split_msgid(msgid)
-          id = [msgctxt, msgid]
-          entry = @po[*id]
-          return nil if entry.nil?
-
-          formatted_comments = entry.format_translator_comment
-          formatted_comments << entry.format_extracted_comment
-          formatted_comments << entry.format_reference_comment
-          formatted_comments << entry.format_flag_comment
-          formatted_comments << entry.format_previous_comment
-
-          unless entry.comment.nil?
-            formatted_comments = entry.format_comment("#", entry.comment)
-          end
-
-          formatted_comments.chomp
-        end
-
-        def [](msgid)
-          msgctxt, msgid, _ = split_msgid(msgid)
-          @po[msgctxt, msgid].msgstr
-        end
-
-        def []=(msgid, value)
-          msgctxt, msgid, msgid_plural = split_msgid(msgid)
-          id = [msgctxt, msgid]
-
-          if value.instance_of?(POEntry)
-            @po[*id] = value
-            return value
-          end
-
-          msgstr = value
-          if @po.has_key?(*id)
-            @po[*id] = msgstr
-            @po[*id].msgctxt = msgctxt
-            @po[*id].msgid_plural = msgid_plural
-          else
-            type = detect_entry_type(msgctxt, msgid_plural)
-            entry = POEntry.new(type)
-            entry.msgctxt = msgctxt
-            entry.msgid = msgid
-            entry.msgid_plural = msgid_plural
-            entry.msgstr = msgstr
-            @po[*id] = entry
-            entry
-          end
-        end
-
-        def each_msgid
-          msgids.each do |id|
-            next if id.kind_of?(Symbol) or id.empty?
-            yield(id)
-          end
-        end
-
-        def msgids
-          @po.collect do |entry|
-            msgctxt = entry.msgctxt
-            msgid = entry.msgid
-            generate_original_string(msgctxt, msgid)
-          end
-        end
-
-        def msgid?(msgid)
-          return false if msgid.kind_of?(Symbol)
-          return true if msgid.empty?
-          msgctxt, msgid, _ = split_msgid(msgid)
-          @po.has_key?(msgctxt, msgid)
-        end
-
-        # Is it necessary to implement this method?
-        def search_msgid_fuzzy(msgid, used_msgids)
-          nil
-        end
-
-        def nplurals
-          return 0 if @po[""].msgstr.nil?
-
-          if /\s*nplurals\s*=\s*(\d+)/ =~ @po[""].msgstr
-            return $1.to_i
-          else
-            return 0
-          end
-        end
-
-        def generate_po
-          @po.to_s
-        end
-
-        def generate_po_entry(msgid)
-          msgctxt, msgid, _ = split_msgid(msgid)
-          @po[msgctxt, msgid].to_s
-        end
-
-        def __conv(str)
-          s = ""
-
-          if str.count("\n") > 1
-            s << '""' << "\n"
-            str.each_line do |line|
-              s << '"' << escape(line) << '"' << "\n"
-            end
-          else
-            s << '"' << escape(str) << '"'
-          end
-
-          s.rstrip
-        end
-
-        def escape(string)
-          POEntry.escape(string)
-        end
-
-        private
-        def split_msgid(msgid)
-          return [nil, msgid, nil] if msgid == :last
-          return [nil, "", nil] if msgid.empty?
-          msgctxt, msgid = msgid.split("\004", 2)
-          if msgid.nil?
-            msgid = msgctxt
-            msgctxt = nil
-          end
-          msgid, msgid_plural = msgid.split("\000", 2)
-          [msgctxt, msgid, msgid_plural]
-        end
-
-        def generate_original_string(msgctxt, msgid)
-          return msgid if msgid == :last
-          original_string = ""
-          msgid_plural = @po[msgctxt, msgid].msgid_plural
-          original_string << "#{msgctxt}\004" unless msgctxt.nil?
-          original_string << msgid
-          original_string << "\000#{msgid_plural}" unless msgid_plural.nil?
-          original_string
-        end
-
-        def detect_entry_type(msgctxt, msgid_plural)
-          if msgctxt.nil?
-            if msgid_plural.nil?
-              :normal
-            else
-              :plural
-            end
-          else
-            if msgid_plural.nil?
-              :msgctxt
-            else
-              :msgctxt_plural
-            end
-          end
-        end
-
-        def generate_entry(msgid)
-          msgctxt, msgid, _ = split_msgid(msgid)
-          id = [msgctxt, msgid]
-          @po[*id] = nil unless @po.has_key?(*id)
-          entry = @po[*id]
-
-          entry.translator_comment = ""
-          entry.extracted_comment = ""
-          entry.references = []
-          entry.flag = ""
-          entry.previous = ""
-          entry
-        end
-
-        def parse_comment(line, entry)
-          if line == "#"
-            entry.translator_comment << ""
-          elsif /\A(#.)\s*(.*)\z/ =~ line
-            mark = $1
-            content = $2
-            case mark
-            when POEntry::TRANSLATOR_COMMENT_MARK
-              entry.translator_comment << "#{content}\n"
-            when POEntry::EXTRACTED_COMMENT_MARK
-              entry.extracted_comment << "#{content}\n"
-            when POEntry::REFERENCE_COMMENT_MARK
-              entry.references << content
-            when POEntry::FLAG_MARK
-              entry.flag << "#{content}\n"
-            when POEntry::PREVIOUS_COMMENT_MARK
-              entry.previous << "#{content}\n"
-            else
-              entry.comment << line
-            end
-          end
-          entry
-        end
-      end
-
       class Merger #:nodoc:
         # Merge the reference with the definition: take the #. and
         #  #: comments from the reference, take the # comments from

data/lib/gettext/tools/parser/erb.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# -*- coding: utf-8 -*-
 
 =begin
   parser/erb.rb - parser for ERB
@@ -13,40 +13,66 @@ require 'erb'
 require 'gettext/tools/parser/ruby'
 
 module GetText
-  module ErbParser
-    extend self
-
+  class ErbParser
     @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
-      }
+    class << self
+      # 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 target?(file) # :nodoc:
+        @config[:extnames].each do |v|
+          return true if File.extname(file) == v
+        end
+        false
+      end
+
+      # Parses eRuby script located at `path`.
+      #
+      # This is a short cut method. It equals to `new(path,
+      # options).parse`.
+      #
+      # @return [Array<POEntry>] Extracted messages
+      # @see #initialize and #parse
+      def parse(path, options={})
+        parser = new(path, options)
+        parser.parse
+      end
     end
 
     MAGIC_COMMENT = /\A#coding:.*\n/
 
-    def parse(file) # :nodoc:
-      content = IO.read(file)
+    # @param path [String] eRuby script path to be parsed
+    # @param options [Hash]
+    def initialize(path, options={})
+      @path = path
+      @options = options
+    end
+
+    # Extracts messages from @path.
+    #
+    # @return [Array<POEntry>] Extracted messages
+    def parse
+      content = IO.read(@path)
       src = ERB.new(content).src
 
-      if src.respond_to?(:encode)
-        # Force the src encoding back to the encoding in magic comment
-        # or original content.
-        encoding = detect_encoding(src) || content.encoding
-        src.force_encoding(encoding)
+      # Force the src encoding back to the encoding in magic comment
+      # or original content.
+      encoding = detect_encoding(src) || content.encoding
+      src.force_encoding(encoding)
 
-        # Remove magic comment prepended by erb in Ruby 1.9.
-        src = src.gsub(MAGIC_COMMENT, "")
-      end
+      # Remove magic comment prepended by erb in Ruby 1.9.
+      src = src.gsub(MAGIC_COMMENT, "")
 
-      erb = src.split(/$/)
-      RubyParser.parse_lines(file, erb)
+      RubyParser.new(@path, @options).parse_source(src)
     end
 
     def detect_encoding(erb_source)
@@ -56,13 +82,6 @@ module GetText
         nil
       end
     end
-
-    def target?(file) # :nodoc:
-      @config[:extnames].each do |v|
-  return true if File.extname(file) == v
-      end
-      false
-    end
   end
 end