gettext 2.3.9 → 3.0.0

data/test/tools/test_msgmerge.rb

@@ -21,284 +21,9 @@
 require 'gettext/tools/msgmerge'
 
 class TestToolsMsgMerge < Test::Unit::TestCase
-  class TestPoData < self
-    def setup
-      @po_data = GetText::Tools::MsgMerge::PoData.new
-    end
-
-    def test_msgids
-      @po_data["hello"] = "bonjour"
-      @po_data["he"] = "il"
-
-      assert_equal(["he", "hello"], @po_data.msgids.sort)
-    end
-
-    def test_each_msgids
-      @po_data["hello"] = "bonjour"
-      @po_data["he"] = "il"
-      @po_data[""] = "header"
-      @po_data[:last] = ""
-
-      msgids = []
-      @po_data.each_msgid do |msgid|
-        msgids << msgid
-      end
-      assert_equal(["he", "hello"], msgids.sort)
-    end
-
-    class TestAddToExistingEntry < self
-      def test_msgctxt
-        msgctxt = "msgctxt"
-        msgid = "msgid"
-        original_string = "#{msgctxt}\004#{msgid}"
-        msgstr = "msgstr"
-
-        po_data = GetText::Tools::MsgMerge::PoData.new
-        po_data[original_string] = msgstr
-
-        assert_equal(msgctxt, po_data.po[msgctxt, msgid].msgctxt)
-      end
-
-      def test_msgid_plural
-        msgid = "msgid"
-        msgid_plural = "msgid_plural"
-        original_string = "#{msgid}\000#{msgid_plural}"
-        msgstr = "msgstr"
-
-        po_data = GetText::Tools::MsgMerge::PoData.new
-        po_data[msgid] = msgstr
-        assert_equal(nil, po_data.po[msgid].msgid_plural)
-
-        po_data[original_string] = msgstr
-        assert_equal(msgid_plural, po_data.po[msgid].msgid_plural)
-      end
-
-      def test_msgctxt_and_msgid_plural
-        msgctxt = "msgctxt"
-        msgid = "msgid"
-        msgid_plural = "msgid_plural"
-        original_string = "#{msgctxt}\004#{msgid}\000#{msgid_plural}"
-        msgstr = "msgstr"
-
-        po_data = GetText::Tools::MsgMerge::PoData.new
-        po_data[original_string] = msgstr
-
-        assert_equal(msgctxt, po_data.po[msgctxt, msgid].msgctxt)
-        assert_equal(msgid_plural, po_data.po[msgctxt, msgid].msgid_plural)
-      end
-    end
-
-    class TestGeneratePo < self
-      def test_comment_and_msgid_and_msgstr
-        header_entry_comment = "# header entry comment."
-        header_entry = "header\nentry\n"
-        comment = "#: test.rb:10"
-        msgid = "Hello"
-        msgstr = "Salut"
-
-        po = GetText::Tools::MsgMerge::PoData.new
-        po.set_comment("", header_entry_comment)
-        po[""] = header_entry
-        po[msgid] = msgstr
-        po.set_comment(msgid, comment)
-
-        expected_header_entry = ""
-        header_entry.each_line do |line|
-          expected_header_entry << "\"#{line.chomp}\\n\"\n"
-        end
-        expected_header_entry = expected_header_entry.chomp
-        expected_po = <<EOP
-#{header_entry_comment}
-msgid \"\"
-msgstr \"\"
-#{expected_header_entry}
-
-#{comment}
-msgid \"#{msgid}\"
-msgstr \"#{msgstr}\"
-EOP
-        assert_equal(expected_po, po.generate_po)
-      end
-
-      def test_obsolete_comment
-        obsolete_comment =<<EOC
-# test.rb:10
-msgid \"Hello\"
-msgstr \"Salut\"
-EOC
-        header_entry_comment = "# header entry comment."
-        header_entry = "header entry"
-
-        po = GetText::Tools::MsgMerge::PoData.new
-        po.set_comment("", header_entry_comment)
-        po[""] = header_entry
-        po.set_comment(:last, obsolete_comment)
-
-        expected_obsolete_comment = <<-EOC
-# test.rb:10
-#~ msgid "Hello"
-#~ msgstr "Salut"
-EOC
-        expected_obsolete_comment = expected_obsolete_comment.chomp
-
-        expected_po = <<EOP
-#{header_entry_comment}
-msgid \"\"
-msgstr \"#{header_entry}\"
-
-#{expected_obsolete_comment}
-EOP
-        assert_equal(expected_po, po.generate_po)
-      end
-
-      def test_msgid_plural_and_empty_msgstr
-        msgid = "Singular message\000Plural message"
-
-        @po_data[""] = "Plural-Forms: nplurals=2; plural=n != 1;\\n"
-        @po_data[msgid] = "\000"
-        @po_data.set_comment(msgid, "# plural message")
-        actual_po = @po_data.generate_po_entry(msgid)
-        expected_po = <<'EOE'
-# plural message
-msgid "Singular message"
-msgid_plural "Plural message"
-msgstr[0] ""
-msgstr[1] ""
-EOE
-        assert_equal(expected_po, actual_po)
-      end
-    end
-
-    class TestGeneratePOEntry < self
-      def test_msgid_plural
-        msgid = "Singular message\000Plural message"
-
-        @po_data[msgid] = "Singular translation\000Plural translation"
-        @po_data.set_comment(msgid, "# plural message")
-        actual_po = @po_data.generate_po_entry(msgid)
-        expected_po = <<'EOE'
-# plural message
-msgid "Singular message"
-msgid_plural "Plural message"
-msgstr[0] "Singular translation"
-msgstr[1] "Plural translation"
-EOE
-        assert_equal(expected_po, actual_po)
-      end
-
-      def test_msgctxt
-        msg_id = "Context\004Translation"
-        @po_data[msg_id] = "Translated"
-        @po_data.set_comment(msg_id, "# no comment")
-
-        entry = @po_data.generate_po_entry(msg_id)
-        assert_equal(<<-'EOE', entry)
-# no comment
-msgctxt "Context"
-msgid "Translation"
-msgstr "Translated"
-EOE
-      end
-    end
-  end
-
-  class TestSplitMsgid < self
-    def test_existed_msgctxt_and_msgid_plural
-      msgctxt = "msgctxt"
-      msgid = "msgid"
-      msgid_plural = "msgid_plural"
-
-      assert_equal([msgctxt, msgid, msgid_plural],
-                   split_msgid("#{msgctxt}\004#{msgid}\000#{msgid_plural}"))
-    end
-
-    def test_existed_msgctxt_only
-      msgctxt = "msgctxt"
-      msgid = "msgid"
-
-      assert_equal([msgctxt, msgid, nil],
-                   split_msgid("#{msgctxt}\004#{msgid}"))
-    end
-
-    def test_existed_msgid_plural_only
-      msgid = "msgid"
-      msgid_plural = "msgid_plural"
-
-      assert_equal([nil, msgid, msgid_plural],
-                   split_msgid("#{msgid}\000#{msgid_plural}"))
-    end
-
-    def test_not_existed
-      msgid = "msgid"
-
-      assert_equal([nil, msgid, nil], split_msgid(msgid))
-    end
-
-    def test_empty_msgid
-      msgid = ""
-
-      assert_equal([nil, msgid, nil], split_msgid(msgid))
-    end
-
-    def test_last_symbol_msgid
-      msgid = :last
-
-      assert_equal([nil, msgid, nil], split_msgid(msgid))
-    end
-
-    private
-    def split_msgid(msgid)
-      po_data = GetText::Tools::MsgMerge::PoData.new
-      po_data.send(:split_msgid, msgid)
-    end
-  end
-
-  class TestParseComment < self
-    def setup
-      @po_data = GetText::Tools::MsgMerge::PoData.new
-      @entry = @po_data.send(:generate_entry, "test")
-    end
-
-    def test_translator_comment
-      comment = "# translator comment"
-      parsed_comment = parse_comment(comment).translator_comment
-      assert_equal("translator comment\n", parsed_comment)
-    end
-
-    def test_extracted_comment
-      comment = "#. extracted comment"
-      parsed_comment = parse_comment(comment).extracted_comment
-      assert_equal("extracted comment\n", parsed_comment)
-    end
-
-    def test_references
-      comment = "#: reference.rb:10"
-      parsed_comment = parse_comment(comment).references
-      assert_equal(["reference.rb:10"], parsed_comment)
-    end
-
-    def test_flag
-      comment = "#, fuzzy"
-      parsed_comment = parse_comment(comment).flag
-      assert_equal("fuzzy\n", parsed_comment)
-    end
-
-    def test_previous
-      comment = "#| msgid the previous msgid"
-      parsed_comment = parse_comment(comment).previous
-      assert_equal("msgid the previous msgid\n", parsed_comment)
-    end
-
-    private
-    def parse_comment(comment)
-      @po_data.send(:parse_comment, comment, @entry)
-    end
-  end
-
   class TestMerger < self
     def setup
       @merger = GetText::Tools::MsgMerge::Merger.new
-      @po_data = GetText::Tools::MsgMerge::PoData.new
       @po = GetText::PO.new
       @pot = GetText::PO.new
     end
@@ -521,7 +246,7 @@ EOC
     def generate_entry(options)
       msgctxt = options[:msgctxt]
       msgid_plural = options[:msgid_plural]
-      type = @po_data.send(:detect_entry_type, msgctxt, msgid_plural)
+      type = detect_entry_type(msgctxt, msgid_plural)
 
       entry = GetText::POEntry.new(type)
       entry.translator_comment = options[:translator_comment]
@@ -536,6 +261,22 @@ EOC
       entry.comment = options[:comment]
       entry
     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
   end
 
   class TestMerge < self

data/test/tools/test_po.rb

@@ -18,7 +18,7 @@
 # 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 "gettext/tools/po"
+require "gettext/po"
 
 class TestPO < Test::Unit::TestCase
   def setup

data/test/tools/test_xgettext.rb

@@ -43,24 +43,20 @@ class TestToolsXGetText < Test::Unit::TestCase
     FileUtils.mkdir_p(File.dirname(@rhtml_file_path))
   end
 
-  def test_relative_reference
+  private
+  def generate(ruby_source, *command_line_options)
     File.open(@rb_file_path, "w") do |rb_file|
-      rb_file.puts(<<-EOR)
-_("Hello")
-EOR
+      rb_file.puts(ruby_source)
     end
 
-    @xgettext.run("--output", @pot_file_path, @rb_file_path)
+    command_line = ["--output", @pot_file_path]
+    command_line += command_line_options
+    command_line += [@rb_file_path]
+    @xgettext.run(*command_line)
 
-    assert_equal(<<-EOP, File.read(@pot_file_path))
-#{header}
-#: ../lib/xgettext.rb:1
-msgid "Hello"
-msgstr ""
-EOP
+    File.read(@pot_file_path)
   end
 
-  private
   def header(options=nil)
     options ||= {}
     package_name = options[:package_name] || "PACKAGE"
@@ -94,10 +90,35 @@ msgstr ""
 EOH
   end
 
+  class TestReference < self
+    def test_relative
+      pot_content = generate(<<-EOR)
+_("Hello")
+EOR
+      assert_equal(<<-EOP, pot_content)
+#{header}
+#: ../lib/xgettext.rb:1
+msgid "Hello"
+msgstr ""
+EOP
+    end
+
+    def test_same_message
+      pot_content = generate(<<-EOR)
+_("Hello")
+_("Hello")
+EOR
+      assert_equal(<<-EOP, pot_content)
+#{header}
+#: ../lib/xgettext.rb:1 ../lib/xgettext.rb:2
+msgid "Hello"
+msgstr ""
+EOP
+    end
+  end
+
   class TestEncoding < self
     def test_different_encoding_from_current_locale
-      need_encoding
-
       rhtml = <<-EOR
 <%#-*- coding: sjis -*-%>
 <html>
@@ -110,36 +131,34 @@ EOH
 </html>
 EOR
       File.open(@rhtml_file_path, "w") do |rhtml_file|
-        rhtml_file.puts(encode(rhtml, "sjis"))
+        rhtml_file.puts(rhtml.encode("sjis"))
       end
 
       @xgettext.run("--output", @pot_file_path, @rhtml_file_path)
 
       encoding = "UTF-8"
       pot_content = File.read(@pot_file_path)
-      set_encoding(pot_content, encoding)
+      pot_content.force_encoding(encoding)
       expected_content = <<-EOP
 #{header}
 #: ../templates/xgettext.rhtml:7
 msgid "わたし"
 msgstr ""
 EOP
-      expected_content = encode(expected_content, encoding)
+      expected_content = expected_content.encode(encoding)
       assert_equal(expected_content, pot_content)
     end
 
     def test_multiple_encodings
-      need_encoding
-
       File.open(@rb_file_path, "w") do |rb_file|
-        rb_file.puts(encode(<<-EOR, "euc-jp"))
+        rb_file.puts(<<-EOR.encode("euc-jp"))
 # -*- coding: euc-jp -*-
 _("こんにちは")
 EOR
       end
 
       File.open(@rhtml_file_path, "w") do |rhtml_file|
-        rhtml_file.puts(encode(<<-EOR, "cp932"))
+        rhtml_file.puts(<<-EOR.encode("cp932"))
 <%# -*- coding: cp932 -*-%>
 <h1><%= _("わたし") %></h1>
 EOR
@@ -149,7 +168,7 @@ EOR
 
       encoding = "UTF-8"
       pot_content = File.read(@pot_file_path)
-      set_encoding(pot_content, encoding)
+      pot_content.force_encoding(encoding)
       expected_content = <<-EOP
 #{header}
 #: ../lib/xgettext.rb:2
@@ -160,128 +179,180 @@ msgstr ""
 msgid "わたし"
 msgstr ""
 EOP
-      expected_content = encode(expected_content, encoding)
+      expected_content = expected_content.encode(encoding)
       assert_equal(expected_content, pot_content)
     end
   end
 
   class TestTranslatorComment < self
     def test_n_
-      rb = <<-RB
+      pot_content = generate(<<-RB, "--add-comments=TRANSLATORS:")
 n_members = 1
 # TRANSLATORS: Use this message as test
 n_("I will go!",
    "We will go!",
    n_members)
-
-_("No comment")
 RB
-      File.open(@rb_file_path, "w") do |rb_file|
-        rb_file.puts(rb)
-      end
-
-      @xgettext.run("--output", @pot_file_path, @rb_file_path)
-
-      encoding = "UTF-8"
-      pot_content = File.read(@pot_file_path)
-      set_encoding(pot_content, encoding)
       expected_content = <<-POT
 #{header}
-#. Use this message as test
+#. TRANSLATORS: Use this message as test
 #: ../lib/xgettext.rb:3
 msgid "I will go!"
 msgid_plural "We will go!"
 msgstr[0] ""
 msgstr[1] ""
-
-#: ../lib/xgettext.rb:7
-msgid "No comment"
-msgstr ""
 POT
-      expected_content = encode(expected_content, encoding)
       assert_equal(expected_content, pot_content)
     end
+
+    def test_no_add_comments
+      pot_content = generate(<<-RUBY)
+# TRNALSTORS: There is no translator's tag
+_("Message")
+      RUBY
+
+      assert_equal(<<-POT, pot_content)
+#{header}
+#: ../lib/xgettext.rb:2
+msgid "Message"
+msgstr ""
+      POT
+    end
+
+    def test_add_comments_without_tag
+      pot_content = generate(<<-RUBY, "--add-comments")
+# There is no translator's tag but all
+# comments are included.
+_("Message")
+      RUBY
+
+      assert_equal(<<-POT, pot_content)
+#{header}
+#. There is no translator's tag but all
+#. comments are included.
+#: ../lib/xgettext.rb:3
+msgid "Message"
+msgstr ""
+      POT
+    end
+
+    def test_not_started_with_tag
+      pot_content = generate(<<-RUBY, "--add-comments=TRANSLATORS:")
+# This comment isn't started with "TRANSLATORS:" tag
+_("Message")
+      RUBY
+
+      assert_equal(<<-POT, pot_content)
+#{header}
+#: ../lib/xgettext.rb:2
+msgid "Message"
+msgstr ""
+      POT
+    end
+
+    def test_not_first_line_is_started_with_tag
+      pot_content = generate(<<-RUBY, "--add-comments=TRANSLATORS:")
+# The first line.
+# TRANSLATORS: The second line.
+# The third line.
+_("Message")
+      RUBY
+
+      assert_equal(<<-POT, pot_content)
+#{header}
+#. TRANSLATORS: The second line.
+#. The third line.
+#: ../lib/xgettext.rb:4
+msgid "Message"
+msgstr ""
+      POT
+    end
+
+    def test_indented
+      pot_content = generate(<<-RUBY, "--add-comments")
+# The following lines are indented
+#   * indented1
+#   * indented2
+_("Message")
+      RUBY
+
+      assert_equal(<<-POT, pot_content)
+#{header}
+#. The following lines are indented
+#. * indented1
+#. * indented2
+#: ../lib/xgettext.rb:4
+msgid "Message"
+msgstr ""
+      POT
+    end
+
+    def test_multiple
+      pot_content = generate(<<-RUBY, "--add-comments=TRANSLATORS:")
+# TRANSLATORS: The first comment
+_("Message")
+
+# TRANSLATORS: The second comment
+_("Message")
+      RUBY
+
+      assert_equal(<<-POT, pot_content)
+#{header}
+#. TRANSLATORS: The first comment
+#. TRANSLATORS: The second comment
+#: ../lib/xgettext.rb:2 ../lib/xgettext.rb:5
+msgid "Message"
+msgstr ""
+      POT
+    end
   end
 
   class TestCommandLineOption < self
     def test_package_name
-      File.open(@rb_file_path, "w") do |rb_file|
-        rb_file.puts(":hello")
-      end
-
       package_name = "test-package"
-      @xgettext.run("--output", @pot_file_path,
-                    "--package-name", package_name,
-                    @rb_file_path)
+      pot_content = generate(":hello", "--package-name", package_name)
 
       options = {:package_name => package_name}
       expected_header = "#{header(options)}\n"
-      assert_equal(expected_header, File.read(@pot_file_path))
+      assert_equal(expected_header, pot_content)
     end
 
     def test_package_version
-      File.open(@rb_file_path, "w") do |rb_file|
-        rb_file.puts(":hello")
-      end
-
       package_version = "1.2.3"
-      @xgettext.run("--output", @pot_file_path,
-                    "--package-version", package_version,
-                    @rb_file_path)
+      pot_content = generate(":hello", "--package-version", package_version)
 
       options = {:package_version => package_version}
       expected_header = "#{header(options)}\n"
-      assert_equal(expected_header, File.read(@pot_file_path))
+      assert_equal(expected_header, pot_content)
     end
 
     def test_report_msgid_bugs_to
-      File.open(@rb_file_path, "w") do |rb_file|
-        rb_file.puts(":hello")
-      end
-
       msgid_bugs_address = "me@example.com"
-      @xgettext.run("--output", @pot_file_path,
-                    "--msgid-bugs-address", msgid_bugs_address,
-                    @rb_file_path)
+      pot_content = generate(":hello",
+                             "--msgid-bugs-address", msgid_bugs_address)
 
       options = {:msgid_bugs_address => msgid_bugs_address}
       expected_header = "#{header(options)}\n"
-      assert_equal(expected_header, File.read(@pot_file_path))
+      assert_equal(expected_header, pot_content)
     end
 
     def test_copyright_holder
-      File.open(@rb_file_path, "w") do |rb_file|
-        rb_file.puts(":hello")
-      end
-
       copyright_holder = "me"
-      @xgettext.run("--output", @pot_file_path,
-                    "--copyright-holder", copyright_holder,
-                    @rb_file_path)
+      pot_content = generate(":hello", "--copyright-holder", copyright_holder)
 
       options = {:copyright_holder => copyright_holder}
       expected_header = "#{header(options)}\n"
-      assert_equal(expected_header, File.read(@pot_file_path))
+      assert_equal(expected_header, pot_content)
     end
 
     def test_to_code
-      need_encoding
-
-      File.open(@rb_file_path, "w") do |rb_file|
-        rb_file.puts(<<-EOR)
+      output_encoding = "EUC-JP"
+      pot_content = generate(<<-EOR, "--output-encoding", output_encoding)
 # -*- coding: utf-8 -*-
 
 _("わたし")
 EOR
-      end
-
-      output_encoding = "EUC-JP"
-      @xgettext.run("--output", @pot_file_path,
-                    "--output-encoding", output_encoding,
-                    @rb_file_path)
-
-      actual_pot = File.read(@pot_file_path)
-      set_encoding(actual_pot, output_encoding)
+      pot_content.force_encoding(output_encoding)
 
       options = {:to_code => output_encoding}
       expected_pot = <<-EOP
@@ -290,9 +361,9 @@ EOR
 msgid "わたし"
 msgstr ""
 EOP
-      expected_pot = encode(expected_pot, output_encoding)
+      expected_pot = expected_pot.encode(output_encoding)
 
-      assert_equal(expected_pot, actual_pot)
+      assert_equal(expected_pot, pot_content)
     end
   end
 
@@ -313,6 +384,22 @@ EOP
       xgettext.parse(["index.html"])
     end
 
+    def test_old_style_parser
+      parser = Object.new
+      def parser.target?(path)
+        true
+      end
+      def parser.parse(path)
+        # It doesn't receive options argument as the second argument
+        [["Message"]]
+      end
+
+      GetText::Tools::XGetText.add_parser(parser)
+      xgettext = GetText::Tools::XGetText.new
+      assert_equal([POEntry.new_from_ary(["Message"])],
+                   xgettext.parse(["index.html"]))
+    end
+
     def test_instance_method
       @xgettext.add_parser(mock_html_parser)
       @xgettext.parse(["index.html"])
@@ -330,60 +417,4 @@ EOP
       html_parser
     end
   end
-
-  class TestRGetText < self
-    def setup
-      @now = Time.now
-      @warning_message = "Warning: This method is obsolete. " +
-                           "Please use GetText::Tools::XGetText.run."
-    end
-
-    def test_warning
-      mock(GetText::RGetText).warn(@warning_message) {}
-
-      File.open(@rb_file_path, "w") do |rb_file|
-      end
-      GetText::RGetText.run(@rb_file_path, @pot_file_path)
-    end
-
-    class TestArguments < self
-      def test_input_file_and_output_file
-        stub(GetText::RGetText).warn(@warning_message) {}
-
-        File.open(@rb_file_path, "w") do |rb_file|
-          rb_file.puts(<<-EOR)
-_("Hello")
-EOR
-        end
-        GetText::RGetText.run(@rb_file_path, @pot_file_path)
-
-        assert_equal(expected_pot_content, File.read(@pot_file_path))
-      end
-
-      def test_argv
-        stub(GetText::RGetText).warn(@warning_message) {}
-
-        File.open(@rb_file_path, "w") do |rb_file|
-          rb_file.puts(<<-EOR)
-_("Hello")
-EOR
-        end
-
-        ARGV.replace([@rb_file_path, "--output",  @pot_file_path])
-        GetText::RGetText.run
-
-        assert_equal(expected_pot_content, File.read(@pot_file_path))
-      end
-
-      private
-      def expected_pot_content
-        <<-EOP
-#{header}
-#: ../lib/xgettext.rb:1
-msgid "Hello"
-msgstr ""
-EOP
-      end
-    end
-  end
 end