gettext 2.3.3 → 2.3.4

data/test/{test_mofile.rb → test_mo.rb}

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
-require 'gettext/runtime/mofile'
+require 'gettext/runtime/mo'
 
-class TestMoFile < Test::Unit::TestCase
+class TestMo < Test::Unit::TestCase
   def test_not_exist_msgid
     mo = load_mo("_.mo")
     assert_equal(nil, mo["notexistent"])
@@ -26,6 +26,6 @@ class TestMoFile < Test::Unit::TestCase
   end
 
   def load_mo(file)
-    GetText::MoFile.open("locale/ja/LC_MESSAGES/#{file}", "UTF-8")
+    GetText::MO.open("locale/ja/LC_MESSAGES/#{file}", "UTF-8")
   end
 end

data/test/test_parser.rb

@@ -52,8 +52,8 @@ class TestGetTextParser < Test::Unit::TestCase
     assert_target "\\taaa", ['fixtures/_.rb:96']
     assert_target "Here document1\\nHere document2\\n", ['fixtures/_.rb:100']
     assert_target "Francois Pinard", ['fixtures/_.rb:119'] do |t|
-      assert_match(/proper name/, t.comment)
-      assert_match(/Pronunciation/, t.comment)
+      assert_match(/proper name/, t.extracted_comment)
+      assert_match(/Pronunciation/, t.extracted_comment)
     end
 
     assert_target("No TRANSLATORS comment", ["fixtures/_.rb:122"]) do |t|
@@ -101,7 +101,8 @@ class TestGetTextParser < Test::Unit::TestCase
     assert_plural_target "mmmmmm", "mmm2mmm2", ['fixtures/n_.rb:80']
     assert_plural_target "nnn", "nnn2", ['fixtures/n_.rb:81']
     assert_plural_target "comment", "comments", ['fixtures/n_.rb:97'] do |t|
-      assert_equal "please provide translations for all\n the plural forms!", t.comment
+      assert_equal "please provide translations for all\n the plural forms!",
+                     t.extracted_comment
     end
   end
 
@@ -112,7 +113,7 @@ class TestGetTextParser < Test::Unit::TestCase
     assert_target_in_context "AAA", "CCC", ["fixtures/p_.rb:41"]
     assert_target_in_context "CCC", "BBB", ["fixtures/p_.rb:45"]
     assert_target_in_context "program", "name", ['fixtures/p_.rb:55'] do |t|
-      assert_equal "please translate 'name' in the context of 'program'.\n Hint: the translation should NOT contain the translation of 'program'.", t.comment
+      assert_equal "please translate 'name' in the context of 'program'.\n Hint: the translation should NOT contain the translation of 'program'.", t.extracted_comment
     end
   end
 
@@ -184,11 +185,11 @@ class TestGetTextParser < Test::Unit::TestCase
 
   private
 
-  def assert_target(msgid, sources = nil)
+  def assert_target(msgid, references = nil)
     t = @ary.detect {|elem| elem.msgid == msgid}
     if t
-      if sources
-        assert_equal sources.sort, t.sources.sort, 'Translation target sources do not match.'
+      if references
+        assert_equal references.sort, t.references.sort, 'Translation target references do not match.'
       end
       yield t if block_given?
     else
@@ -196,18 +197,18 @@ class TestGetTextParser < Test::Unit::TestCase
     end
   end
 
-  def assert_plural_target(msgid, plural, sources = nil)
-    assert_target msgid, sources do |t|
+  def assert_plural_target(msgid, plural, references = nil)
+    assert_target msgid, references do |t|
       assert_equal plural, t.msgid_plural, 'Expected plural form'
       yield t if block_given?
     end
   end
 
-  def assert_target_in_context(msgctxt, msgid, sources = nil)
+  def assert_target_in_context(msgctxt, msgid, references = nil)
     t = @ary.detect {|elem| elem.msgid == msgid && elem.msgctxt == msgctxt}
     if t
-      if sources
-        assert_equal sources.sort, t.sources.sort, 'Translation target sources do not match.'
+      if references
+        assert_equal references.sort, t.references.sort, 'Translation target references do not match.'
       end
       yield t if block_given?
     else

data/test/test_po_entry.rb

@@ -0,0 +1,329 @@
+# encoding: utf-8
+
+require 'gettext/tools/parser/ruby'
+
+# Most functionality of PoMessage is thoroughly tested together
+# with the parser and po file generator. Here only tests for some special
+# functionality.
+class TestPOEntry < Test::Unit::TestCase
+
+  def test_context_match
+    tt1 = GetText::POEntry.new(:msgctxt)
+    tt1.msgid = 'hello'
+    tt1.msgctxt = 'world'
+    tt2 = GetText::POEntry.new(:normal)
+    tt2.msgid = 'hello'
+    assert_raise GetText::ParseError do
+      tt1.merge tt2
+    end
+  end
+
+  def test_attribute_accumulation
+    tt = GetText::POEntry.new(:plural)
+    tt.set_current_attribute 'long'
+    tt.set_current_attribute ' tail'
+    tt.advance_to_next_attribute
+    tt.set_current_attribute 'long tails'
+    assert_equal 'long tail', tt.msgid
+    assert_equal 'long tails', tt.msgid_plural
+  end
+
+  class TestSetType < self
+    def test_varid_type
+      entry = GetText::POEntry.new(:normal)
+      type = :plural
+      entry.type = type
+      assert_equal(type, entry.type)
+    end
+
+    def test_invalid_type
+      entry = GetText::POEntry.new(:normal)
+      type = :invalid
+      assert_raise(GetText::POEntry::InvalidTypeError) do
+        entry.type = type
+      end
+      assert_equal(:normal, entry.type)
+    end
+
+    def test_invalid_type_for_initializing
+      assert_raise(GetText::POEntry::InvalidTypeError) do
+        GetText::POEntry.new(:invalid)
+      end
+    end
+  end
+
+  class TestToS < self
+    def test_normal
+      po = GetText::POEntry.new(:normal)
+      po.msgid = 'hello'
+      po.references = ["file1:1", "file2:10"]
+      assert_equal "#: file1:1 file2:10\nmsgid \"hello\"\nmsgstr \"\"\n", po.to_s
+
+      po.msgctxt = 'context'
+      po.msgid_plural = 'hello2'
+      # Ignore these properties.
+      assert_equal "#: file1:1 file2:10\nmsgid \"hello\"\nmsgstr \"\"\n", po.to_s
+    end
+
+    def test_plural
+      po = GetText::POEntry.new(:plural)
+      po.msgid = 'hello'
+      po.msgid_plural = 'hello2'
+      po.references = ["file1:1", "file2:10"]
+      assert_equal "#: file1:1 file2:10\nmsgid \"hello\"\nmsgid_plural \"hello2\"\nmsgstr[0] \"\"\nmsgstr[1] \"\"\n", po.to_s
+
+      po.msgctxt = 'context'
+      # Ignore this property
+      assert_equal "#: file1:1 file2:10\nmsgid \"hello\"\nmsgid_plural \"hello2\"\nmsgstr[0] \"\"\nmsgstr[1] \"\"\n", po.to_s
+    end
+
+    def test_msgctxt
+      po = GetText::POEntry.new(:msgctxt)
+      po.msgctxt = 'context'
+      po.msgid = 'hello'
+      po.references = ["file1:1", "file2:10"]
+      assert_equal "#: file1:1 file2:10\nmsgctxt \"context\"\nmsgid \"hello\"\nmsgstr \"\"\n", po.to_s
+    end
+
+    def test_msgctxt_plural
+      po = GetText::POEntry.new(:msgctxt_plural)
+      po.msgctxt = 'context'
+      po.msgid = 'hello'
+      po.msgid_plural = 'hello2'
+      po.references = ["file1:1", "file2:10"]
+      assert_equal "#: file1:1 file2:10\nmsgctxt \"context\"\nmsgid \"hello\"\nmsgid_plural \"hello2\"\nmsgstr[0] \"\"\nmsgstr[1] \"\"\n", po.to_s
+    end
+
+    def test_exception
+      po = GetText::POEntry.new(:normal)
+      po.references = ["file1:1", "file2:10"]
+      assert_raise(GetText::POEntry::NoMsgidError) {po.to_s}
+
+      po.references = nil
+      assert_raise(GetText::POEntry::NoMsgidError) {po.to_s}
+
+      po = GetText::POEntry.new(:plural)
+      po.msgid = 'hello'
+      po.references = ["file1:1", "file2:10"]
+      assert_raise(GetText::POEntry::NoMsgidPluralError) {po.to_s}
+
+      po = GetText::POEntry.new(:msgctxt)
+      po.msgid = 'hello'
+      po.references = ["file1:1", "file2:10"]
+      assert_raise(GetText::POEntry::NoMsgctxtError) {po.to_s}
+
+      po = GetText::POEntry.new(:msgctxt_plural)
+      po.msgctxt = 'context'
+      po.msgid = 'hello'
+      po.references = ["file1:1", "file2:10"]
+      assert_raise(GetText::POEntry::NoMsgidPluralError) {po.to_s}
+    end
+
+    def test_header
+      po = GetText::POEntry.new(:normal)
+      po.msgid = ""
+      po.msgstr = "This is the header entry."
+      po.references = nil
+      expected_header = <<EOH
+msgid ""
+msgstr "This is the header entry."
+EOH
+      assert_equal(expected_header, po.to_s)
+    end
+
+    def test_msgstr
+      po = GetText::POEntry.new(:normal)
+      po.msgid = "hello"
+      po.msgstr = "Bonjour"
+      po.references = ["file1:1", "file2:10"]
+      expected_entry = <<-EOE
+#: file1:1 file2:10
+msgid "hello"
+msgstr "Bonjour"
+EOE
+      assert_equal(expected_entry, po.to_s)
+    end
+
+    def test_escaped_msgstr
+      po = GetText::POEntry.new(:normal)
+      po.msgid = "He said \"hello.\""
+      po.msgstr = "Il a dit \"bonjour.\""
+      po.references = ["file1:1", "file2:10"]
+      expected_entry = <<-EOE
+#: file1:1 file2:10
+msgid "He said \\\"hello.\\\""
+msgstr "Il a dit \\\"bonjour.\\\""
+EOE
+      assert_equal(expected_entry, po.to_s)
+    end
+
+    def test_escaped_msgstr_with_msgid_plural
+      po = GetText::POEntry.new(:plural)
+      po.msgid = "He said \"hello.\""
+      po.msgid_plural = "They said \"hello.\""
+      po.msgstr = "Il a dit \"bonjour.\"\000Ils ont dit \"bonjour.\""
+      po.references = ["file1:1", "file2:10"]
+      expected_entry = <<-EOE
+#: file1:1 file2:10
+msgid "He said \\\"hello.\\\""
+msgid_plural "They said \\\"hello.\\\""
+msgstr[0] "Il a dit \\\"bonjour.\\\""
+msgstr[1] "Ils ont dit \\\"bonjour.\\\""
+EOE
+      assert_equal(expected_entry, po.to_s)
+    end
+
+    def test_msgstr_with_msgid_plural
+      po = GetText::POEntry.new(:plural)
+      po.msgid = "he"
+      po.msgid_plural = "them"
+      po.msgstr = "il\000ils"
+      po.references = ["file1:1", "file2:10"]
+      expected_entry = <<-EOE
+#: file1:1 file2:10
+msgid "he"
+msgid_plural "them"
+msgstr[0] "il"
+msgstr[1] "ils"
+EOE
+      assert_equal(expected_entry, po.to_s)
+    end
+
+    def test_obsolete_comment
+      po = GetText::POEntry.new(:normal)
+      po.msgid = :last
+      obsolete_comment =<<EOC
+# test.rb:10
+msgid \"hello\"
+msgstr \"Salut\"
+EOC
+      po.comment = obsolete_comment
+
+      expected_obsolete_comment = obsolete_comment.gsub(/^/, "#~ ")
+      assert_equal(expected_obsolete_comment, po.to_s)
+    end
+
+    def test_translator_comment
+      po = GetText::POEntry.new(:normal)
+      po.msgid = "msgid"
+      po.msgstr = "msgstr"
+      po.translator_comment = "It's the translator comment."
+
+      expected_po =<<EOP
+# It's the translator comment.
+msgid \"msgid\"
+msgstr \"msgstr\"
+EOP
+      assert_equal(expected_po, po.to_s)
+    end
+
+    def test_extracted_comment
+      po = GetText::POEntry.new(:normal)
+      po.msgid = "msgid"
+      po.msgstr = "msgstr"
+      po.extracted_comment = "It's the extracted comment."
+
+      expected_po =<<EOP
+#. It's the extracted comment.
+msgid \"msgid\"
+msgstr \"msgstr\"
+EOP
+      assert_equal(expected_po, po.to_s)
+    end
+
+    def test_flag
+      po = GetText::POEntry.new(:normal)
+      po.msgid = "msgid"
+      po.msgstr = "msgstr"
+      po.flag = "It's the flag."
+
+      expected_po =<<EOP
+#, It's the flag.
+msgid \"msgid\"
+msgstr \"msgstr\"
+EOP
+      assert_equal(expected_po, po.to_s)
+    end
+
+    def test_previous
+      po = GetText::POEntry.new(:normal)
+      po.msgid = "msgid"
+      po.msgstr = "msgstr"
+      po.previous = <<EOC
+msgctxt previous_msgctxt
+msgid previous_msgid
+msgid_plural previous_msgid_plural
+EOC
+
+      expected_po =<<EOP
+#| msgctxt previous_msgctxt
+#| msgid previous_msgid
+#| msgid_plural previous_msgid_plural
+msgid \"msgid\"
+msgstr \"msgstr\"
+EOP
+      assert_equal(expected_po, po.to_s)
+    end
+  end
+
+  class TestEscape < self
+    def setup
+      @entry = GetText::POEntry.new(:normal)
+    end
+
+    def test_backslash
+      @entry.msgid = "You should escape '\\' as '\\\\'."
+      assert_equal("You should escape '\\\\' as '\\\\\\\\'.",
+                   @entry.escaped(:msgid))
+    end
+
+    def test_new_line
+      @entry.msgid = "First\nSecond\nThird"
+      assert_equal("First\\nSecond\\nThird",
+                   @entry.escaped(:msgid))
+    end
+  end
+
+  class TestFormatMessage < self
+    def setup
+      @entry = GetText::POEntry.new(:normal)
+    end
+
+    def test_including_newline
+      message = "line 1\n" +
+                  "line 2"
+      expected_message = "\"\"\n" +
+                          "\"line 1\\n\"\n" +
+                          "\"line 2\"\n"
+      assert_equal(expected_message, @entry.format_message(message))
+    end
+
+    def test_not_existed_newline
+      message = "line 1"
+      expected_message = "\"line 1\"\n"
+      assert_equal(expected_message, @entry.format_message(message))
+    end
+  end
+
+  class TestFormatComment < self
+    def setup
+      @entry = GetText::POEntry.new(:normal)
+    end
+
+    def test_one_line_comment
+      comment = "comment"
+      mark = "#"
+      @entry.msgid = "msgid"
+      expected_comment = "# #{comment}\n"
+      assert_equal(expected_comment, @entry.format_comment(mark, comment))
+    end
+
+    def test_multiline_comment
+      comment = "comment1\ncomment2"
+      mark = "#"
+      @entry.msgid = ""
+      expected_comment = "#{comment.gsub(/^/, "#{mark} ")}\n"
+      assert_equal(expected_comment, @entry.format_comment(mark, comment))
+    end
+  end
+end

data/test/test_po_parser.rb

@@ -20,13 +20,13 @@
 
 require "gettext/tools/poparser"
 
-class TestPoParser < Test::Unit::TestCase
+class TestPOParser < Test::Unit::TestCase
   def test_msgstr_not_existing
     po_file = create_po_file(<<-EOP)
 msgid "Hello"
 msgstr ""
 EOP
-    messages = parse_po_file(po_file)
+    messages = parse_po_file(po_file, MO.new)
 
     assert_equal(nil, messages["Hello"])
   end
@@ -38,12 +38,213 @@ msgid_plural "They"
 msgstr[0] ""
 msgstr[1] ""
 EOP
-    messages = parse_po_file(po_file)
+    messages = parse_po_file(po_file, MO.new)
 
     assert_true(messages.has_key?("He\000They"))
     assert_equal(nil, messages["He\000They"])
   end
 
+  class TestPoData < self
+    def test_comment
+      po_file = create_po_file(<<-EOP)
+#: file.rb:10
+msgid "hello"
+msgstr "bonjour"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.msgids.include?("hello"))
+      assert_equal("bonjour", entries["hello"])
+      assert_equal("#: file.rb:10", entries.comment("hello"))
+    end
+
+    def test_msgctxt
+      po_file = create_po_file(<<-EOP)
+msgctxt "pronoun"
+msgid "he"
+msgstr "il"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.msgids.include?("pronoun\004he"))
+      assert_equal("il", entries["pronoun\004he"])
+    end
+
+    def test_msgid_plural
+      po_file = create_po_file(<<-EOP)
+msgid "he"
+msgid_plural "they"
+msgstr[0] "il"
+msgstr[1] "ils"
+EOP
+      entries = parse_po_file(po_file)
+
+      assert_true(entries.msgids.include?("he\000they"))
+      assert_equal("il\000ils", entries["he\000they"])
+    end
+
+    def test_msgctxt_and_msgid_plural
+      po_file = create_po_file(<<-EOP)
+msgctxt "pronoun"
+msgid "he"
+msgid_plural "them"
+msgstr[0] "il"
+msgstr[1] "ils"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.msgids.include?("pronoun\004he\000them"))
+      assert_equal("il\000ils", entries["pronoun\004he\000them"])
+    end
+
+    private
+    def parse_po_file(po_file)
+      super(po_file, GetText::Tools::MsgMerge::PoData.new)
+    end
+  end
+
+  class TestPO < self
+    def test_msgstr
+      po_file = create_po_file(<<-EOP)
+# This is the comment.
+#: file.rb:10
+msgid "hello"
+msgstr "bonjour"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.has_key?(nil, "hello"))
+      assert_equal("bonjour", entries["hello"].msgstr)
+    end
+
+    def test_references
+      po_file = create_po_file(<<-EOP)
+# This is the comment.
+#: file.rb:10
+msgid "hello"
+msgstr "bonjour"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.has_key?(nil, "hello"))
+      assert_equal(["file.rb:10"], entries["hello"].references)
+    end
+
+    def test_translator_comment
+      po_file = create_po_file(<<-EOP)
+# This is the translator comment.
+msgid "hello"
+msgstr "bonjour"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.has_key?(nil, "hello"))
+      entry = entries["hello"]
+      assert_equal("This is the translator comment.", entry.translator_comment)
+    end
+
+    def test_extracted_comment
+      po_file = create_po_file(<<-EOP)
+#. This is the extracted comment.
+msgid "hello"
+msgstr "bonjour"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.has_key?(nil, "hello"))
+      entry = entries["hello"]
+      assert_equal("This is the extracted comment.", entry.extracted_comment)
+    end
+
+    def test_flag
+      po_file = create_po_file(<<-EOP)
+#, flag
+msgid "hello"
+msgstr "bonjour"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.has_key?(nil, "hello"))
+      assert_equal("flag", entries["hello"].flag)
+    end
+
+    def test_previous
+      po_file = create_po_file(<<-EOP)
+#| msgctxt Normal
+#| msgid He
+#| msgid_plural Them
+msgid "he"
+msgid_plural "them"
+msgstr[0] "il"
+msgstr[1] "ils"
+EOP
+      expected_previous = "msgctxt Normal\n" +
+                                  "msgid He\n" +
+                                  "msgid_plural Them"
+      entries = parse_po_file(po_file)
+      assert_true(entries.has_key?(nil, "he"))
+      assert_equal(expected_previous, entries["he"].previous)
+    end
+
+    def test_msgid_plural
+      po_file = create_po_file(<<-EOP)
+# This is the comment.
+#: file.rb:10
+msgid "he"
+msgid_plural "them"
+msgstr[0] "il"
+msgstr[1] "ils"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.has_key?(nil, "he"))
+      assert_equal("them", entries["he"].msgid_plural)
+      assert_equal("il\000ils", entries["he"].msgstr)
+    end
+
+    def test_msgctxt
+      po_file = create_po_file(<<-EOP)
+# This is the comment.
+#: file.rb:10
+msgctxt "pronoun"
+msgid "he"
+msgstr "il"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.has_key?("pronoun", "he"))
+      assert_equal("pronoun", entries["pronoun", "he"].msgctxt)
+    end
+
+    def test_msgctxt_with_msgid_plural
+      po_file = create_po_file(<<-EOP)
+# This is the comment.
+#: file.rb:10
+msgctxt "pronoun"
+msgid "he"
+msgid_plural "them"
+msgstr[0] "il"
+msgstr[1] "ils"
+EOP
+      entries = parse_po_file(po_file)
+      assert_true(entries.has_key?("pronoun", "he"))
+      assert_equal("pronoun", entries["pronoun", "he"].msgctxt)
+      assert_equal("them", entries["pronoun", "he"].msgid_plural)
+      assert_equal("il\000ils", entries["pronoun", "he"].msgstr)
+    end
+
+    def test_fuzzy
+      po_file = create_po_file(<<-EOP)
+#, fuzzy
+#: file.rb:10
+msgid "hello"
+msgstr "bonjour"
+EOP
+      entries = parse_po_file(po_file, :ignore_fuzzy => false)
+
+      assert_true(entries.has_key?("hello"))
+      assert_equal("fuzzy", entries["hello"].flag)
+    end
+
+    private
+    def parse_po_file(po_file, options={:ignore_fuzzy => true})
+      ignore_fuzzy = options[:ignore_fuzzy]
+      parser = GetText::POParser.new
+      parser.ignore_fuzzy = ignore_fuzzy
+      parser.parse_file(po_file.path, PO.new)
+    end
+  end
+
   private
   def create_po_file(content)
     po_file = Tempfile.new("hello.po")
@@ -52,9 +253,9 @@ EOP
     po_file
   end
 
-  def parse_po_file(po_file)
-    parser = GetText::PoParser.new
-    parser.parse_file(po_file.path, MoFile.new)
+  def parse_po_file(po_file, parsed_entries)
+    parser = GetText::POParser.new
+    parser.parse_file(po_file.path, parsed_entries)
   end
 
   class FuzzyTest < self
@@ -115,13 +316,13 @@ EOP
 
     private
     def parse
-      parser = GetText::PoParser.new
+      parser = GetText::POParser.new
       class << parser
         def _(message_id)
           message_id
         end
       end
-      messages = MoFile.new
+      messages = MO.new
       yield parser
       parser.parse_file(@po_file.path, messages)
       messages