grosser-gettext 2.0.0

data/lib/gettext/tools/rgettext.rb

@@ -0,0 +1,275 @@
+#! /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     <mutoh at highway.ne.jp>
+ 
+  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 |key|
+        msgid = key.shift
+        curr_pos = MAX_LINE_LEN
+        key.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
+        msgid.gsub!(/"/, '\"')
+        msgid.gsub!(/\r/, '')
+        if msgid.include?("\004")
+          msgctxt, msgid = msgid.split(/\004/)
+          str << "\nmsgctxt \"" << msgctxt << "\"\n"
+        else
+          str << "\n"
+        end
+        if msgid.include?("\000")
+          ids = msgid.split(/\000/)
+          str << "msgid \"" << ids[0] << "\"\n"
+          str << "msgid_plural \"" << ids[1] << "\"\n"
+          str << "msgstr[0] \"\"\n"
+          str << "msgstr[1] \"\"\n"
+        else
+          str << "msgid \"" << msgid << "\"\n"
+          str << "msgstr \"\"\n"
+        end
+      end
+      str
+    end
+
+    def normalize(ary)  # :nodoc:
+      used_plural_msgs = []
+      ary.select{|item| item[0].include? "\000"}.each do |plural_msg|
+        next if used_plural_msgs.include?(plural_msg[0])
+
+        key = plural_msg[0].split("\000")[0]
+
+        ary.dup.each do |single_msg|
+          if single_msg[0] == key or
+              (single_msg[0] =~ /^#{Regexp.quote(key)}\000/ and 
+               single_msg[0] != plural_msg[0])
+            if single_msg[0] != key 
+              warn %Q[Warning: n_("#{plural_msg[0].gsub(/\000/, '", "')}") and n_("#{single_msg[0].gsub(/\000/, '", "')}") are duplicated. First msgid was used.] 
+              used_plural_msgs << single_msg[0]
+            end
+
+            single_msg[1..-1].each do |line_info|
+              plural_msg << line_info
+              fname = line_info.split(/:/)[0]
+              sorted = plural_msg[1..-1].select{|l| l.split(/:/)[0].include?(fname)}.collect{|l| 
+                aline = l.split(/:/)
+                [aline[0], aline[1] =~ /[0-9]+/ ? aline[1].to_i : aline[1]]
+              }.sort.collect{|l| "#{l[0]}:#{l[1]}"}
+              plural_msg.delete_if{|i| sorted.include?(i)}
+              sorted.each {|i|
+                plural_msg << i
+              }
+            end
+            ary.delete(single_msg)
+          end
+        end
+      end
+      ary.collect{|i| i.uniq}
+    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 occurs in " + file
+          raise
+        end
+      end
+      normalize(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
+
+  module_function
+  # Creates a po-file from targetfiles(ruby-script-files, ActiveRecord, .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.
+  #
+  # *Note* for ActiveRecord, you need to run your database server and configure the config/database.yml
+  # correctly before execute this function.
+  #
+  # * 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

data/lib/gettext/tools/rmsgfmt.rb

@@ -0,0 +1,84 @@
+=begin
+  rmsgfmt.rb - Generate a .mo
+
+  Copyright (C) 2003-2009 Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+
+require 'optparse'
+require 'fileutils'
+require 'gettext'
+require 'gettext/poparser'
+require 'rbconfig'
+
+module GetText
+
+  module RMsgfmt  #:nodoc:
+    extend GetText 
+
+    bindtextdomain "rgettext"
+
+    module_function
+    def run(targetfile = nil, output_path = nil) # :nodoc:
+      unless targetfile
+	targetfile, output_path = check_options
+      end
+      unless targetfile
+	raise ArgumentError, _("no input files")
+      end
+      unless output_path
+	output_path = "messages.mo"
+      end
+
+      parser = PoParser.new
+      data = MOFile.new
+      parser.parse(File.open(targetfile).read, data)
+      data.save_to_file(output_path)
+    end
+
+    def check_options # :nodoc:
+      output = nil
+
+      opts = OptionParser.new
+      opts.banner = _("Usage: %s input.po [-o output.mo]" % $0)
+      opts.separator("")
+      opts.separator(_("Generate binary message catalog from textual translation description."))
+      opts.separator("")
+      opts.separator(_("Specific options:"))
+
+      opts.on("-o", "--output=FILE", _("write output to specified file")) do |out|
+	output = out
+      end
+
+      opts.on_tail("--version", _("display version information and exit")) do
+	puts "#{$0} #{GetText::VERSION}"
+	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[0], output]
+    end
+  end
+
+  module_function
+  # Creates a mo-file from a targetfile(po-file), then output the result to out. 
+  # If no parameter is set, it behaves same as command line tools(rmsgfmt).
+  # * targetfile: An Array of po-files or nil.
+  # * output_path: output path.
+  # * Returns: the MOFile object.
+  def rmsgfmt(targetfile = nil, output_path = nil)
+    RMsgfmt.run(targetfile, output_path)
+  end
+end
+
+if $0 == __FILE__ then
+  GetText.rmsgfmt
+end

data/lib/gettext/tools/rmsgmerge.rb

@@ -0,0 +1,505 @@
+=begin
+  rmsgmerge.rb - Merge old .po to new .po
+
+  Copyright (C) 2005-2009 Masao Mutoh
+  Copyright (C) 2005,2006 speakillof
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+
+require 'optparse'
+require 'gettext'
+require 'gettext/poparser'
+require 'rbconfig'
+
+module GetText
+    
+  module RMsgMerge
+    
+    class PoData  #:nodoc:  
+      
+      attr_reader :msgids
+      
+      def initialize
+        @msgid2msgstr = {}
+        @msgid2comment = {}
+        @msgids = []
+      end
+      
+      def set_comment(msgid_or_sym, comment)
+        @msgid2comment[msgid_or_sym] = comment      
+      end
+      
+      def msgstr(msgid)
+        @msgid2msgstr[msgid]
+      end
+      
+      def comment(msgid)
+        @msgid2comment[msgid]
+      end
+      
+      def [](msgid)
+        @msgid2msgstr[msgid]
+      end
+      
+      def []=(msgid, msgstr)
+        # Retain the order
+        unless @msgid2msgstr[msgid]
+          @msgids << msgid
+        end
+        
+        @msgid2msgstr[msgid] = msgstr
+      end
+      
+      def each_msgid
+        arr = @msgids.delete_if{|i| Symbol === i or i == ''}
+        arr.each do |i|
+          yield i
+        end
+      end
+      
+      def msgid?(msgid)
+        !(Symbol === msgid) and  @msgid2msgstr[msgid] and (msgid != '')
+      end
+      
+      # Is it necessary to implement this method?
+      def search_msgid_fuzzy(msgid, used_msgids)
+        nil
+      end
+      
+      def nplural
+        unless @msgid2msgstr['']
+          return 0
+        else
+          if /\s*nplural\s*=\s*(\d+)/ =~ @msgid2msgstr['']
+            return $1.to_i
+          else
+            return 0
+          end
+          
+        end
+      end
+      
+      def generate_po
+        str = ''
+        str << generate_po_header
+        
+        self.each_msgid do |id|
+          str << self.generate_po_entry(id)          
+        end
+        
+        str << @msgid2comment[:last]        
+        str        
+      end
+      
+      def generate_po_header
+        str = ""
+        
+        str << @msgid2comment[''].strip << "\n"
+        str << 'msgid ""'  << "\n"                
+        str << 'msgstr ""' << "\n"
+        msgstr = @msgid2msgstr[''].gsub(/"/, '\"').gsub(/\r/, '')
+        msgstr = msgstr.gsub(/^(.*)$/, '"\1\n"')
+        str << msgstr
+        str << "\n"
+        
+        str
+      end
+      
+      def generate_po_entry(msgid)
+        str = ""
+        str << @msgid2comment[msgid]
+        if str[-1] != "\n"[0]
+          str << "\n"
+        end
+        
+        id = msgid.gsub(/"/, '\"').gsub(/\r/, '')
+        msgstr = @msgid2msgstr[msgid].gsub(/"/, '\"').gsub(/\r/, '')
+
+        if id.include?("\000")
+          ids = id.split(/\000/)          
+          str << "msgid " << __conv(ids[0]) << "\n"
+          ids[1..-1].each do |single_id|
+            str << "msgid_plural " << __conv(single_id) << "\n"
+          end
+          
+          msgstr.split("\000").each_with_index do |m, n|
+            str << "msgstr[#{n}] " << __conv(m) << "\n"
+          end
+        else
+          str << "msgid "  << __conv(id) << "\n"
+          str << "msgstr " << __conv(msgstr) << "\n"
+        end
+        
+        str << "\n"
+        str
+      end
+      
+      def __conv(str)
+        s = ''
+
+        if str.count("\n") > 1
+          s << '""' << "\n"
+          s << str.gsub(/^(.*)$/, '"\1\n"')
+        else
+          s << '"' << str.sub("\n", "\\n") << '"'
+        end
+        
+        s.rstrip
+      end
+      
+    end
+    
+    class Merger #:nodoc:
+      
+      # From GNU gettext source.
+      # 
+      # Merge the reference with the definition: take the #. and
+      #	#: comments from the reference, take the # comments from
+	  # the definition, take the msgstr from the definition.  Add
+	  # this merged entry to the output message list.      
+      DOT_COMMENT_RE = /\A#\./
+      SEMICOLON_COMMENT_RE = /\A#\:/
+      FUZZY_RE = /\A#\,/
+      NOT_SPECIAL_COMMENT_RE = /\A#([^:.,]|\z)/
+      
+      CRLF_RE = /\r?\n/
+      POT_DATE_EXTRACT_RE = /POT-Creation-Date:\s*(.*)?\s*$/
+      POT_DATE_RE = /POT-Creation-Date:.*?$/
+      
+      def merge(definition, reference)
+        # deep copy
+        result = Marshal.load( Marshal.dump(reference) )        
+        
+        used = []        
+        merge_header(result, definition)
+
+        result.each_msgid do |msgid|
+          if definition.msgid?(msgid)
+            used << msgid
+            merge_message(msgid, result, msgid, definition)
+          elsif other_msgid = definition.search_msgid_fuzzy(msgid, used)
+            used << other_msgid
+            merge_fuzzy_message(msgid, result, other_msgid, definition) 
+          elsif msgid.index("\000") and ( reference.msgstr(msgid).gsub("\000", '') == '' )
+            # plural
+            result[msgid] = "\000" * definition.nplural
+          else
+            change_reference_comment(msgid, result)
+          end          
+        end
+        
+        ###################################################################
+        # msgids which are not used in reference are handled as obsolete. #
+        ################################################################### 
+        last_comment = result.comment(:last) || ''
+        definition.each_msgid do |msgid|
+          unless used.include?(msgid)
+            last_comment << "\n"
+            last_comment << definition.generate_po_entry(msgid).strip.gsub(/^/, '#. ')
+            last_comment << "\n"
+          end
+        end
+        result.set_comment(:last, last_comment)
+        
+        result
+      end
+      
+      def merge_message(msgid, target, def_msgid, definition)
+        merge_comment(msgid, target, def_msgid, definition)
+        
+        ############################################
+        # check mismatch of msgid and msgid_plural #
+        ############################################
+        def_msgstr = definition[def_msgid]
+        if msgid.index("\000")
+          if def_msgstr.index("\000")
+            # OK
+            target[msgid] = def_msgstr			
+          else
+            # NG
+            s = ''            
+            definition.nplural.times {
+              s << def_msgstr
+              s << "\000"
+            }
+            target[msgid] = s
+          end
+        else
+          if def_msgstr.index("\000")
+            # NG
+            target[msgid] = def_msgstr.split("\000")[0]
+          else
+            # OK
+            target[msgid] = def_msgstr
+          end
+        end
+      end
+      
+      # for the future
+      def merge_fuzzy_message(msgid, target, def_msgid, definition)
+        merge_message(msgid, target, def_msgid, definition)
+      end
+      
+      def merge_comment(msgid, target, def_msgid, definition)
+        ref_comment = target.comment(msgid)
+        def_comment = definition.comment(def_msgid)
+        
+        normal_comment = []
+        dot_comment = []
+        semi_comment = []
+        is_fuzzy = false
+        
+        def_comment.split(CRLF_RE).each do |l| 
+          if NOT_SPECIAL_COMMENT_RE =~ l
+            normal_comment << l
+          end           
+        end
+        
+        ref_comment.split(CRLF_RE).each do |l|
+          if DOT_COMMENT_RE =~ l 
+            dot_comment << l
+          elsif SEMICOLON_COMMENT_RE =~ l
+            semi_comment << l
+          elsif FUZZY_RE =~ l
+            is_fuzzy = true
+          end
+        end
+        
+        str = format_comment(normal_comment, dot_comment, semi_comment, is_fuzzy)
+        target.set_comment(msgid, str)
+      end
+      
+      def change_reference_comment(msgid, podata)
+        normal_comment = []
+        dot_comment = []
+        semi_comment = []
+        is_fuzzy = false
+        
+        podata.comment(msgid).split(CRLF_RE).each do |l|
+          if DOT_COMMENT_RE =~ l 
+            dot_comment << l
+          elsif SEMICOLON_COMMENT_RE =~ l
+            semi_comment << l
+          elsif FUZZY_RE =~ l
+            is_fuzzy = true
+          else
+            normal_comment << l
+          end
+        end
+        
+        str = format_comment(normal_comment, dot_comment, semi_comment, is_fuzzy)
+        podata.set_comment(msgid, str)        
+      end
+      
+      def format_comment(normal_comment, dot_comment, semi_comment, is_fuzzy)
+        str = ''
+        
+        str << normal_comment.join("\n").gsub(/^#(\s*)/){|sss|
+          if $1 == ""
+            "# "
+          else
+            sss
+          end
+        }
+        if normal_comment.size > 0
+          str << "\n"
+        end
+        
+        str << dot_comment.join("\n").gsub(/^#.(\s*)/){|sss|
+          if $1 == ""
+            "#. "
+          else
+            sss
+          end
+        }
+        if dot_comment.size > 0
+          str << "\n"
+        end
+        
+        str << semi_comment.join("\n").gsub(/^#:\s*/, "#: ")
+        if semi_comment.size > 0
+          str << "\n"
+        end
+        
+        if is_fuzzy
+          str << "#, fuzzy\n"
+        end
+        
+        str
+      end
+      
+      def merge_header(target, definition)
+        merge_comment('', target, '', definition)
+        
+        msg = target.msgstr('')
+        def_msg = definition.msgstr('')
+        if POT_DATE_EXTRACT_RE =~ msg
+          time = $1
+          def_msg = def_msg.sub(POT_DATE_RE, "POT-Creation-Date: #{time}")
+        end
+        
+        target[''] = def_msg
+      end
+      
+    end
+    
+  end  
+  
+end
+
+module GetText::RMsgMerge #:nodoc:
+
+  class Config #:nodoc:
+    
+    attr_accessor :defpo, :refpot, :output, :fuzzy, :update
+    
+    # update mode options
+    attr_accessor :backup, :suffix
+    
+=begin      
+The result is written back to def.po.
+      --backup=CONTROL        make a backup of def.po
+      --suffix=SUFFIX         override the usual backup suffix
+The version control method may be selected via the --backup option or through
+the VERSION_CONTROL environment variable.  Here are the values:
+  none, off       never make backups (even if --backup is given)
+  numbered, t     make numbered backups
+  existing, nil   numbered if numbered backups exist, simple otherwise
+  simple, never   always make simple backups
+The backup suffix is `~', unless set with --suffix or the SIMPLE_BACKUP_SUFFIX
+environment variable.
+=end      
+      
+    def initialize
+      @output = STDOUT
+      @fuzzy = nil
+      @update = nil
+      @backup = ENV["VERSION_CONTROL"]
+      @suffix= ENV["SIMPLE_BACKUP_SUFFIX"] || "~"
+      @input_dirs = ["."]
+    end
+    
+  end
+  
+end
+
+module GetText
+  
+  module RMsgMerge
+    extend GetText
+
+    bindtextdomain("rgettext")
+    
+    # constant values
+    VERSION = GetText::VERSION
+    DATE = %w($Date: 2007/07/21 15:03:05 $)[1]
+    
+    module_function
+
+    def check_options(config)
+      opts = OptionParser.new
+      opts.banner = _("Usage: %s def.po ref.pot [-o output.pot]") % $0
+      #opts.summary_width = 80
+      opts.separator("")
+      opts.separator(_("Merges two Uniforum style .po files together. The def.po file is an existing PO file with translations. The ref.pot file is the last created PO file with up-to-date source references. ref.pot is generally created by rgettext."))
+      opts.separator("")
+      opts.separator(_("Specific options:"))
+      
+      opts.on("-o", "--output=FILE", _("write output to specified file")) do |out|
+        unless FileTest.exist? out
+          config.output = out
+        else
+          #$stderr.puts(_("File '%s' has already existed.") % out)
+          #exit 1
+        end
+      end
+      
+      #opts.on("-F", "--fuzzy-matching")
+      
+      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 != 2
+        puts opts.help
+        exit 1
+      end
+      
+      config.defpo = ARGV[0]
+      config.refpot = ARGV[1]
+    end
+    
+    def run(reference = nil, definition = nil, out = STDOUT)
+      config = GetText::RMsgMerge::Config.new
+      config.refpot = reference
+      config.defpo = definition
+      config.output = out
+      
+      check_options(config)
+      
+      if config.defpo.nil?
+        raise ArgumentError, _("definition po is not given.")
+      elsif config.refpot.nil? 
+        raise ArgumentError, _("reference pot is not given.")
+      end
+      
+      parser = PoParser.new
+      defstr = nil
+      refstr = nil      
+      File.open(config.defpo){|f| defstr = f.read}
+      File.open(config.refpot){|f| refstr = f.read}
+      defpo = parser.parse(defstr, PoData.new, false)
+      refpot = parser.parse(refstr, PoData.new, false)
+      
+      m = Merger.new
+      result = m.merge(defpo, refpot)      
+      p result if $DEBUG
+      print result.generate_po if $DEBUG
+      
+      begin
+        if out.is_a? String
+          File.open(File.expand_path(out), "w+") do |file|
+            file.write(result.generate_po)
+          end
+        else
+          out.puts(result.generate_po)
+        end
+      ensure
+        out.close
+      end
+    end    
+    
+  end
+  
+end
+
+
+
+module GetText
+  
+  module_function
+
+  # Experimental
+  def rmsgmerge(reference = nil, definition = nil, out = STDOUT)
+    RMsgMerge.run(reference, definition, out)
+  end
+
+end
+
+
+
+if $0 == __FILE__ then
+  require 'pp'
+  
+  #parser = GetText::RMsgMerge::PoParser.new;
+  #parser = GetText::PoParser.new;
+  #pp parser.parse(ARGF.read)
+  
+  GetText.rmsgmerge
+end