gettext 2.3.3 → 2.3.4

data/lib/gettext/runtime/textdomain.rb

@@ -14,7 +14,7 @@
 =end
 
 require 'gettext/core_ext/string'
-require 'gettext/runtime/mofile'
+require 'gettext/runtime/mo'
 require 'gettext/runtime/locale_path'
 
 module GetText
@@ -72,26 +72,26 @@ module GetText
 
       lang_key = lang.to_s
 
-      mofile = nil
+      mo = nil
       if self.class.cached?
-        mofile = @mofiles[lang_key]
+        mo = @mofiles[lang_key]
       end
-      unless mofile
-        mofile = load_mo(lang)
+      unless mo
+        mo = load_mo(lang)
       end
 
-      if (! mofile) or (mofile ==:empty)
+      if (! mo) or (mo ==:empty)
         return nil
       end
 
-      return mofile[msgid] if mofile.has_key?(msgid)
+      return mo[msgid] if mo.has_key?(msgid)
 
       ret = nil
       if msgid.include?("\000")
         # Check "aaa\000bbb" and show warning but return the singular part.
         msgid_single = msgid.split("\000")[0]
         msgid_single_prefix_re = /^#{Regexp.quote(msgid_single)}\000/
-        mofile.each do |key, val|
+        mo.each do |key, val|
           if msgid_single_prefix_re =~ key
             # Usually, this is not caused to make po-files from rgettext.
             separated_msgid = msgid.gsub(/\000/, '", "')
@@ -106,7 +106,7 @@ module GetText
         end
       else
         msgid_prefix_re = /^#{Regexp.quote(msgid)}\000/
-        mofile.each do |key, val|
+        mo.each do |key, val|
           if msgid_prefix_re =~ key
             ret = val.split("\000")[0]
             break
@@ -132,8 +132,8 @@ module GetText
         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
+        mo = @mofiles[lang.to_posix.to_s]
+        cond = (mo and mo != :empty) ? mo.plural_as_proc : DEFAULT_PLURAL_CALC
         ret = [msg.split("\000"), cond]
       else
         ret = [[msg], DEFAULT_SINGLE_CALC]
@@ -160,21 +160,21 @@ module GetText
       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
+      mo = @mofiles[lang_key]
+      if mo
+        if mo == :empty
           return :empty
         elsif ! self.class.cached?
-          mofile.update!
+          mo.update!
         end
-        return mofile
+        return mo
       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)
+        @mofiles[lang_key] = MO.open(path, charset)
       else
         @mofiles[lang_key] = :empty
       end

data/lib/gettext/tools.rb

@@ -29,7 +29,7 @@ require 'gettext/tools/xgettext'
 require 'gettext/tools/msgfmt'
 require 'gettext/tools/msginit'
 require 'gettext/tools/msgmerge'
-require 'gettext/runtime/mofile'
+require 'gettext/runtime/mo'
 require 'fileutils'
 
 module GetText

data/lib/gettext/tools/msgfmt.rb

@@ -51,8 +51,8 @@ module GetText
       def run(*options) # :nodoc:
         initialize_arguments(*options)
 
-        parser = PoParser.new
-        data = MoFile.new
+        parser = POParser.new
+        data = MO.new
 
         parser.parse_file(@input_file, data)
         data.save_to_file(@output_file)

data/lib/gettext/tools/msginit.rb

@@ -66,14 +66,14 @@ module GetText
         parse_arguments(*arguments)
         validate
 
-        parser = PoParser.new
+        parser = POParser.new
         parser.ignore_fuzzy = false
         pot = parser.parse_file(@input_file,
-                                GetText::Tools::MsgMerge::PoData.new)
+                                GetText::PO.new)
         po = replace_pot_header(pot)
 
         File.open(@output_file, "w") do |f|
-          f.puts(po.generate_po)
+          f.puts(po.to_s)
         end
       end
 
@@ -169,15 +169,16 @@ module GetText
       end
 
       def replace_pot_header(pot) #:nodoc:
-        @entry = pot[""]
-        @comment = pot.comment("")
+        @entry = pot[""].msgstr
+        @comment = pot[""].translator_comment
         @translator = translator_info
 
         replace_entry
         replace_comment
 
-        pot[""] = @entry.chomp
-        pot.set_comment("", @comment)
+        pot[""] = @entry
+        pot[""].translator_comment = @comment
+        pot[""].flag = pot[""].flag.gsub(/\Afuzzy\z/, "")
         pot
       end
 
@@ -239,11 +240,11 @@ module GetText
         replace_description
         replace_first_author
         replace_copyright_year
-        @comment = @comment.gsub(/#, fuzzy/, "")
+        @comment = @comment.gsub(/^fuzzy$/, "")
       end
 
       EMAIL = "EMAIL@ADDRESS"
-      FIRST_AUTHOR_KEY = /^(\s*#\s*) FIRST AUTHOR <#{EMAIL}>, (\d+\.)$/
+      FIRST_AUTHOR_KEY = /^FIRST AUTHOR <#{EMAIL}>, (\d+\.)$/
 
       def replace_last_translator #:nodoc:
         unless @translator.nil?
@@ -273,9 +274,9 @@ module GetText
       def replace_plural_forms #:nodoc:
         plural_entry = plural_forms(@language)
         if PLURAL_FORMS =~ @entry
-          @entry = @entry.gsub(PLURAL_FORMS, "\\1 #{plural_entry}")
+          @entry = @entry.gsub(PLURAL_FORMS, "\\1 #{plural_entry}\n")
         else
-          @entry << "Plural-Forms: #{plural_entry}"
+          @entry << "Plural-Forms: #{plural_entry}\n"
         end
       end
 
@@ -329,7 +330,7 @@ module GetText
         "nplurals=#{nplural}; plural=#{plural_expression};"
       end
 
-      DESCRIPTION_TITLE = /^(\s*#\s*) SOME DESCRIPTIVE TITLE\.$/
+      DESCRIPTION_TITLE = /^SOME DESCRIPTIVE TITLE\.$/
 
       def replace_description #:nodoc:
         language_name = Locale::Info.get_language(@language).name
@@ -342,18 +343,18 @@ module GetText
         @comment = @comment.gsub(DESCRIPTION_TITLE, "\\1 #{description}")
       end
 
-      YEAR_KEY = /^(\s*#\s* FIRST AUTHOR <#{EMAIL}>,) YEAR\.$/
+      YEAR_KEY = /^(FIRST AUTHOR <#{EMAIL}>,) YEAR\.$/
       LAST_TRANSLATOR_KEY = /^(Last-Translator:) FULL NAME <#{EMAIL}>$/
 
       def replace_first_author #:nodoc:
         @comment = @comment.gsub(YEAR_KEY, "\\1 #{year}.")
         unless @translator.nil?
           @comment = @comment.gsub(FIRST_AUTHOR_KEY,
-                                   "\\1 #{@translator}, \\2")
+                                   "#{@translator}, \\1")
         end
       end
 
-      COPYRIGHT_KEY = /(\s*#\s* Copyright \(C\)) YEAR (THE PACKAGE'S COPYRIGHT HOLDER)$/
+      COPYRIGHT_KEY = /^(Copyright \(C\)) YEAR (THE PACKAGE'S COPYRIGHT HOLDER)$/
       def replace_copyright_year #:nodoc:
         @comment = @comment.gsub(COPYRIGHT_KEY, "\\1 #{year} \\2")
       end

data/lib/gettext/tools/msgmerge.rb

@@ -20,64 +20,110 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 require "optparse"
+require "levenshtein"
 require "gettext"
 require "gettext/tools/poparser"
-require "gettext/tools/pomessage"
-
-# TODO: MsgMerge should use PoMessage to generate PO content.
+require "gettext/tools/po"
 
 module GetText
   module Tools
     class MsgMerge
       class PoData  #:nodoc:
 
-        attr_reader :msgids
+        attr_reader :po
 
         def initialize
-          @msgid2msgstr = {}
-          @msgid2comment = {}
-          @msgids = []
+          @po = PO.new
         end
 
-        def set_comment(msgid_or_sym, comment)
-          @msgid2comment[msgid_or_sym] = comment
+        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)
-          @msgid2msgstr[msgid]
+          self[msgid]
         end
 
         def comment(msgid)
-          @msgid2comment[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)
-          @msgid2msgstr[msgid]
+          msgctxt, msgid, _ = split_msgid(msgid)
+          @po[msgctxt, msgid].msgstr
         end
 
-        def []=(msgid, msgstr)
-          # Retain the order
-          unless @msgid2msgstr.has_key?(msgid)
-            @msgids << msgid
+        def []=(msgid, value)
+          msgctxt, msgid, msgid_plural = split_msgid(msgid)
+          id = [msgctxt, msgid]
+
+          if value.instance_of?(POEntry)
+            @po[*id] = value
+            return value
           end
 
-          @msgid2msgstr[msgid] = msgstr
+          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 = @msgids.delete_if do |msgid|
-            msgid.kind_of?(Symbol) or msgid.empty?
+          msgids.each do |id|
+            next if id.kind_of?(Symbol) or id.empty?
+            yield(id)
           end
+        end
 
-          msgids.each do |msgid|
-            yield(msgid)
+        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?
-          @msgid2msgstr.has_key?(msgid)
+          msgctxt, msgid, _ = split_msgid(msgid)
+          @po.has_key?(msgctxt, msgid)
         end
 
         # Is it necessary to implement this method?
@@ -86,9 +132,9 @@ module GetText
         end
 
         def nplurals
-          return 0 if @msgid2msgstr[""].nil?
+          return 0 if @po[""].msgstr.nil?
 
-          if /\s*nplurals\s*=\s*(\d+)/ =~ @msgid2msgstr[""]
+          if /\s*nplurals\s*=\s*(\d+)/ =~ @po[""].msgstr
             return $1.to_i
           else
             return 0
@@ -96,81 +142,12 @@ module GetText
         end
 
         def generate_po
-          str = ""
-          str << generate_po_header
-          str << "\n"
-
-          po_entries = []
-          self.each_msgid do |id|
-            po_entries << self.generate_po_entry(id)
-          end
-
-          unless @msgid2comment[:last].nil?
-            po_entries << "#{@msgid2comment[:last]}\n"
-          end
-
-          str << po_entries.join("\n")
-          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.chomp
-          str << "\n"
-
-          str
+          @po.to_s
         end
 
         def generate_po_entry(msgid)
-          str = ""
-          str << @msgid2comment[msgid]
-          if str[-1] != "\n"[0]
-            str << "\n"
-          end
-
-          id = msgid.gsub(/\r/, "")
-          msgstr = @msgid2msgstr[msgid]
-          if msgstr.nil?
-            msgstr = ""
-          else
-            msgstr = msgstr.gsub(/\r/, "")
-          end
-
-          if id.include?("\004")
-            ids = id.split(/\004/)
-            context = ids[0]
-            id      = ids[1]
-            str << "msgctxt "  << __conv(context) << "\n"
-          end
-
-          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
-
-            if msgstr.empty?
-              nplurals.times do |id_count|
-                str << "msgstr[#{id_count}] " << '""' << "\n"
-              end
-            else
-              msgstr.split("\000", -1).each_with_index do |m, n|
-                str << "msgstr[#{n}] " << __conv(m) << "\n"
-              end
-            end
-          else
-            str << "msgid "  << __conv(id) << "\n"
-            str << "msgstr " << __conv(msgstr) << "\n"
-          end
-
-          str
+          msgctxt, msgid, _ = split_msgid(msgid)
+          @po[msgctxt, msgid].to_s
         end
 
         def __conv(str)
@@ -189,209 +166,235 @@ module GetText
         end
 
         def escape(string)
-          PoMessage.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 POParser::TRANSLATOR_COMMENT_MARK
+              entry.translator_comment << "#{content}\n"
+            when POParser::EXTRACTED_COMMENT_MARK
+              entry.extracted_comment << "#{content}\n"
+            when POParser::REFERENCE_COMMENT_MARK
+              entry.references << content
+            when POParser::FLAG_MARK
+              entry.flag << "#{content}\n"
+            when POParser::PREVIOUS_MSGID_COMMENT_MARK
+              entry.previous << "#{content}\n"
+            else
+              entry.comment << line
+            end
+          end
+          entry
         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)
-          definition.each_msgid do |msgid|
-            msgstr = definition[msgid] || ""
-            definition[msgid] = msgstr
-          end
+          result = GetText::PO.new
 
-          reference.each_msgid do |msgid|
-            msgstr = reference[msgid] || ""
-            reference[msgid] = msgstr
-          end
+          reference.each do |entry|
+            msgid = entry.msgid
+            msgctxt = entry.msgctxt
+            id = [msgctxt, msgid]
 
-          # 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", "").empty?)
-              # plural
-              result[msgid] = ([""] * definition.nplurals).join("\000")
-            else
-              change_reference_comment(msgid, result)
+            if definition.has_key?(*id)
+              result[*id] = merge_entry(definition[*id], entry)
+              next
             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"
+            if msgctxt.nil?
+              same_msgid_entry = find_by_msgid(definition, msgid)
+              if not same_msgid_entry.nil? and not same_msgid_entry.msgctxt.nil?
+                result[nil, msgid] = merge_fuzzy_entry(same_msgid_entry, entry)
+                next
+              end
             end
+
+            fuzzy_entry = find_fuzzy_entry(definition, msgid, msgctxt)
+            unless fuzzy_entry.nil?
+              result[*id] = merge_fuzzy_entry(fuzzy_entry, entry)
+              next
+            end
+
+            result[*id] = entry
           end
-          result.set_comment(:last, last_comment) unless last_comment.empty?
 
+          add_obsolete_entry(result, definition)
           result
         end
 
-        def merge_message(msgid, target, def_msgid, definition)
-          merge_comment(msgid, target, def_msgid, definition)
+        def merge_entry(definition_entry, reference_entry)
+          if definition_entry.msgid.empty? and definition_entry.msgctxt.nil?
+            new_header = merge_header(definition_entry, reference_entry)
+            return new_header
+          end
 
-          ############################################
-          # 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
-              strings = []
-              definition.nplurals.times do
-                strings << def_msgstr
-              end
-              target[msgid] = strings.join("\000")
-            end
-          else
-            if def_msgstr.index("\000")
-              # NG
-              target[msgid] = def_msgstr.split("\000")[0]
-            else
-              # OK
-              target[msgid] = def_msgstr
-            end
+          if definition_entry.flag == "fuzzy"
+            entry = definition_entry
+            entry.flag = "fuzzy"
+            return entry
           end
-        end
 
-        # for the future
-        def merge_fuzzy_message(msgid, target, def_msgid, definition)
-          merge_message(msgid, target, def_msgid, definition)
-        end
+          entry = reference_entry
+          entry.translator_comment = definition_entry.translator_comment
+          entry.previous = nil
 
-        def merge_comment(msgid, target, def_msgid, definition)
-          ref_comment = target.comment(msgid)
-          def_comment = definition.comment(def_msgid)
+          unless definition_entry.msgid_plural == reference_entry.msgid_plural
+            entry.flag = "fuzzy"
+          end
 
-          normal_comment = []
-          dot_comment = []
-          semi_comment = []
-          is_fuzzy = false
+          entry.msgstr = definition_entry.msgstr
+          entry
+        end
 
-          def_comment.split(CRLF_RE).each do |l|
-            if NOT_SPECIAL_COMMENT_RE =~ l
-              normal_comment << l
-            end
+        def merge_header(old_header, new_header)
+          header = old_header
+          if POT_DATE_EXTRACT_RE =~ new_header.msgstr
+            create_date = $1
+            pot_creation_date = "POT-Creation-Date: #{create_date}"
+            header.msgstr = header.msgstr.gsub(POT_DATE_RE, pot_creation_date)
           end
+          header.flag = nil
+          header
+        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 if msgid != ""
-            end
+        def find_by_msgid(entries, msgid)
+          same_msgid_entries = entries.find_all do |entry|
+            entry.msgid == msgid
           end
+          same_msgid_entries = same_msgid_entries.sort_by do |entry|
+            entry.msgctxt
+          end
+          same_msgid_entries.first
+        end
 
-          str = format_comment(normal_comment, dot_comment, semi_comment, is_fuzzy)
-          target.set_comment(msgid, str)
+        def merge_fuzzy_entry(fuzzy_entry, entry)
+          merged_entry = merge_entry(fuzzy_entry, entry)
+          merged_entry.flag = "fuzzy"
+          merged_entry
         end
 
-        def change_reference_comment(msgid, podata)
-          normal_comment = []
-          dot_comment = []
-          semi_comment = []
-          is_fuzzy = false
+        MAX_FUZZY_DISTANCE = 0.5 # XXX: make sure that its value is proper.
 
-          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
+        def find_fuzzy_entry(definition, msgid, msgctxt)
+          min_distance_entry = nil
+          min_distance = MAX_FUZZY_DISTANCE
+
+          same_msgctxt_entries = definition.find_all do |entry|
+            entry.msgctxt == msgctxt
+          end
+          same_msgctxt_entries.each do |entry|
+            distance = Levenshtein.normalized_distance(entry.msgid, msgid)
+            if min_distance > distance
+              min_distance = distance
+              min_distance_entry = entry
             end
           end
 
-          str = format_comment(normal_comment, dot_comment, semi_comment, is_fuzzy)
-          podata.set_comment(msgid, str)
+          min_distance_entry
         end
 
-        def format_comment(normal_comment, dot_comment, semi_comment, is_fuzzy)
-          str = ""
-
-          str << normal_comment.join("\n").gsub(/^#(\s*)/) do |sss|
-            if $1 == ""
-              "# "
-            else
-              sss
-            end
-          end
-          if normal_comment.size > 0
-            str << "\n"
+        def add_obsolete_entry(result, definition)
+          obsolete_entry = generate_obsolete_entry(result, definition)
+          unless obsolete_entry.nil?
+            result[:last] = obsolete_entry
           end
+          result
+        end
 
-          str << dot_comment.join("\n").gsub(/^#.(\s*)/) do |sss|
-            if $1 == ""
-              "#. "
-            else
-              sss
-            end
-          end
-          if dot_comment.size > 0
-            str << "\n"
-          end
+        def generate_obsolete_entry(result, definition)
+          obsolete_entry = nil
 
-          str << semi_comment.join("\n").gsub(/^#:\s*/, "#: ")
-          if semi_comment.size > 0
-            str << "\n"
-          end
+          obsolete_entries = extract_obsolete_entries(result, definition)
+          unless obsolete_entries.empty?
+            obsolete_comment = ""
 
-          if is_fuzzy
-            str << "#, fuzzy\n"
+            obsolete_entries.each do |entry|
+              obsolete_comment << entry.to_s
+            end
+            obsolete_entry = POEntry.new(:normal)
+            obsolete_entry.msgid = :last
+            obsolete_entry.comment = obsolete_comment
           end
-
-          str
+          obsolete_entry
         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}")
+        def extract_obsolete_entries(result, definition)
+          obsolete_entries = []
+          definition.each do |entry|
+            id = [entry.msgctxt, entry.msgid]
+            unless result.has_key?(*id)
+              obsolete_entries << entry
+            end
           end
-
-          target[""] = def_msg
+          obsolete_entries
         end
       end
 
@@ -500,10 +503,10 @@ module GetText
       def run(*options) #:nodoc:
         config = check_command_line_options(*options)
 
-        parser = PoParser.new
+        parser = POParser.new
         parser.ignore_fuzzy = false
-        defpo = parser.parse_file(config.defpo, PoData.new)
-        refpot = parser.parse_file(config.refpot, PoData.new)
+        defpo = parser.parse_file(config.defpo, PO.new)
+        refpot = parser.parse_file(config.refpot, PO.new)
 
         merger = Merger.new
         result = merger.merge(defpo, refpot)
@@ -512,10 +515,10 @@ module GetText
 
         if config.output.is_a?(String)
           File.open(File.expand_path(config.output), "w+") do |file|
-            file.write(result.generate_po)
+            file.write(result.to_s)
           end
         else
-          puts(result.generate_po)
+          puts(result.to_s)
         end
       end
     end