gettext 2.3.3 → 2.3.4

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

@@ -13,7 +13,7 @@
 
 require 'irb/ruby-lex.rb'
 require 'stringio'
-require 'gettext/tools/pomessage'
+require 'gettext/tools/po_entry'
 
 module GetText
   class RubyLexX < RubyLex  # :nodoc: all
@@ -79,9 +79,9 @@ module GetText
 
   end
 
-  # Extends PoMessage for RubyParser.
+  # Extends POEntry for RubyParser.
   # Implements a sort of state machine to assist the parser.
-  module PoMessageForRubyParser
+  module POEntryForRubyParser
     # Supports parsing by setting attributes by and by.
     def set_current_attribute(str)
       param = @param_type[@param_number]
@@ -98,8 +98,8 @@ module GetText
       @param_number += 1
     end
   end
-  class PoMessage
-    include PoMessageForRubyParser
+  class POEntry
+    include POEntryForRubyParser
     alias :initialize_old :initialize
     def initialize(type)
       initialize_old(type)
@@ -117,7 +117,7 @@ module GetText
 
     # (Since 2.1.0) the 2nd parameter is deprecated
     # (and ignored here).
-    # And You don't need to keep the pomessages as unique.
+    # And You don't need to keep the poentries as unique.
 
     def parse(path)  # :nodoc:
       source = IO.read(path)
@@ -142,14 +142,14 @@ module GetText
     end
 
     def parse_lines(path, lines)  # :nodoc:
-      pomessages = []
+      po = []
       file = StringIO.new(lines.join + "\n")
       rl = RubyLexX.new
       rl.set_input(file)
       rl.skip_space = true
       #rl.readed_auto_clean_up = true
 
-      pomessage = nil
+      po_entry = nil
       line_no = nil
       last_comment = ''
       reset_comment = false
@@ -160,32 +160,32 @@ module GetText
           ignore_next_comma = false
           case tk
           when RubyToken::TkIDENTIFIER, RubyToken::TkCONSTANT
-            store_pomessage(pomessages, pomessage, path, line_no, last_comment)
+            store_po_entry(po, po_entry, path, line_no, last_comment)
             if ID.include?(tk.name)
-              pomessage = PoMessage.new(:normal)
+              po_entry = POEntry.new(:normal)
             elsif PLURAL_ID.include?(tk.name)
-              pomessage = PoMessage.new(:plural)
+              po_entry = POEntry.new(:plural)
             elsif MSGCTXT_ID.include?(tk.name)
-              pomessage = PoMessage.new(:msgctxt)
+              po_entry = POEntry.new(:msgctxt)
             elsif MSGCTXT_PLURAL_ID.include?(tk.name)
-              pomessage = PoMessage.new(:msgctxt_plural)
+              po_entry = POEntry.new(:msgctxt_plural)
             else
-              pomessage = nil
+              po_entry = nil
             end
             line_no = tk.line_no.to_s
           when RubyToken::TkSTRING, RubyToken::TkDSTRING
-            pomessage.set_current_attribute tk.value if pomessage
+            po_entry.set_current_attribute tk.value if po_entry
           when RubyToken::TkPLUS, RubyToken::TkNL
             #do nothing
           when RubyToken::TkINTEGER
             ignore_next_comma = true
           when RubyToken::TkCOMMA
             unless ignore_current_comma
-              pomessage.advance_to_next_attribute if pomessage
+              po_entry.advance_to_next_attribute if po_entry
             end
           else
-            if store_pomessage(pomessages, pomessage, path, line_no, last_comment)
-              pomessage = nil
+            if store_po_entry(po, po_entry, path, line_no, last_comment)
+              po_entry = nil
               last_comment = ""
             end
           end
@@ -217,7 +217,7 @@ module GetText
           reset_comment = true
         end
       end
-      pomessages
+      po
     end
 
     def target?(file)  # :nodoc:
@@ -225,11 +225,11 @@ module GetText
     end
 
     private
-    def store_pomessage(pomessages, pomessage, file_name, line_no, last_comment) #:nodoc:
-      if pomessage && pomessage.msgid
-        pomessage.sources << file_name + ":" + line_no
-        pomessage.add_comment(last_comment) unless last_comment.empty?
-        pomessages << pomessage
+    def store_po_entry(po, po_entry, file_name, line_no, last_comment) #:nodoc:
+      if po_entry && po_entry.msgid
+        po_entry.references << file_name + ":" + line_no
+        po_entry.add_comment(last_comment) unless last_comment.empty?
+        po << po_entry
         true
       else
         false

data/lib/gettext/tools/po.rb

@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012  Haruka Yoshihara <yoshihara@clear-code.com>
+#
+# License: Ruby's or LGPL
+#
+# This library is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# 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_entry"
+
+module GetText
+
+  # PO stores PO entries like Hash. Each key of {POEntry} is msgctxt
+  # and msgid.
+  # PO[msgctxt, msgid] returns the {POEntry} containing msgctxt and
+  # msgid.
+  # If you specify msgid only, msgctxt is treated as nonexistent.
+  #
+  # @since 2.3.4
+  class PO
+    include Enumerable
+
+    class NonExistentEntryError < StandardError
+    end
+
+    # @!attribute [rw] order
+    #   The order is used to sort PO entries(objects of {POEntry}) in
+    #   {#to_s}.
+    #   @param [Symbol] order the name as order by sort.
+    #     Now :reference is allowed only.
+    #   @return [Symbol] the name as order by sort.
+    attr_accessor :order
+
+    def initialize(order=nil)
+      @order = order || :references
+      @entries = {}
+    end
+
+    # Returns {POEntry} containing msgctxt and msgid.
+    # If you specify one argument, it is treated as msgid.
+    # @overload [](msgid)
+    #   @!macro [new] po.[].argument
+    #     @param [String] msgid msgid contained returning {POEntry}.
+    #     @return [POEntry]
+    #   @!macro po.[].argument
+    # @overload [](msgctxt, msgid)
+    #   @!macro po.[].argument
+    #   @param [String] msgid msgid contained returning {POEntry}.
+    def [](msgctxt, msgid=nil)
+      if msgid.nil?
+        msgid = msgctxt
+        msgctxt = nil
+      end
+
+      @entries[[msgctxt, msgid]]
+    end
+
+    # Stores {POEntry} or msgstr binding msgctxt and msgid. If you
+    # specify msgstr, this method creates {POEntry} containing it.
+    # If you specify the two argument, the first argument is treated
+    # as msgid.
+    #
+    # @overload []=(msgid, po_entry)
+    #   @!macro [new] po.store.entry.arguments
+    #     @param [String] msgid msgid binded {POEntry}.
+    #     @param [POEntry] po_entry stored {POEntry}.
+    #   @!macro po.store.entry.arguments
+    # @overload []=(msgctxt, msgid, po_entry)
+    #   @param [String] msgctxt msgctxt binded {POEntry}.
+    #   @!macro po.store.entry.arguments
+    # @overload []=(msgid, msgstr)
+    #   @!macro [new] po.store.msgstr.arguments
+    #     @param [String] msgid msgid binded {POEntry}.
+    #     @param [String] msgstr msgstr contained {POEntry} stored PO.
+    #       This {POEntry} is generated in this method.
+    #   @!macro po.store.msgstr.arguments
+    # @overload []=(msgctxt, msgid, msgstr)
+    #   @param [String] msgctxt msgctxt binded {POEntry}.
+    #   @!macro po.store.msgstr.arguments
+    def []=(*arguments)
+      case arguments.size
+      when 2
+        msgctxt = nil
+        msgid = arguments[0]
+        value = arguments[1]
+      when 3
+        msgctxt = arguments[0]
+        msgid = arguments[1]
+        value = arguments[2]
+      else
+        raise(ArgumentError,
+              "[]=: wrong number of arguments(#{arguments.size} for 2..3)")
+      end
+
+      id = [msgctxt, msgid]
+      if value.instance_of?(POEntry)
+        @entries[id] = value
+        return(value)
+      end
+
+      msgstr = value
+      if @entries.has_key?(id)
+        entry = @entries[id]
+      else
+        if msgctxt.nil?
+          entry = POEntry.new(:normal)
+        else
+          entry = POEntry.new(:msgctxt)
+        end
+        @entries[id] = entry
+      end
+      entry.msgctxt = msgctxt
+      entry.msgid = msgid
+      entry.msgstr = msgstr
+      entry
+    end
+
+    # Returns if PO stores {POEntry} containing msgctxt and msgid.
+    # If you specify one argument, it is treated as msgid and msgctxt
+    # is nil.
+    #
+    # @overload has_key?(msgid)
+    #   @!macro [new] po.has_key?.arguments
+    #     @param [String] msgid msgid contained {POEntry} checked if it be
+    #       stored PO.
+    #   @!macro po.has_key?.arguments
+    # @overload has_key?(msgctxt, msgid)
+    #   @param [String] msgctxt msgctxt contained {POEntry} checked if
+    #     it be stored PO.
+    #   @!macro po.has_key?.arguments
+    def has_key?(*arguments)
+      case arguments.size
+      when 1
+        msgctxt = nil
+        msgid = arguments[0]
+      when 2
+        msgctxt = arguments[0]
+        msgid = arguments[1]
+      else
+        message = "has_key?: wrong number of arguments " +
+                    "(#{arguments.size} for 1..2)"
+        raise(ArgumentError, message)
+      end
+      id = [msgctxt, msgid]
+      @entries.has_key?(id)
+    end
+
+    # Calls block once for each {POEntry} as a block parameter.
+    # @overload each(&block)
+    #   @yield [entry]
+    #   @yieldparam [POEntry] entry {POEntry} in PO.
+    # @overload each
+    #   @return [Enumerator] Returns Enumerator for {POEntry}.
+    def each
+      if block_given?
+        @entries.each do |_, entry|
+          yield(entry)
+        end
+      else
+        @entries.each_value
+      end
+    end
+
+    # For {PoParer}.
+    def set_comment(msgid, comment, msgctxt=nil)
+      id = [msgctxt, msgid]
+      self[*id] = nil unless @entries.has_key?(id)
+      self[*id].comment = comment
+    end
+
+    # Formats each {POEntry} to the format of PO files and returns joined
+    # them.
+    # @see http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html#PO-Files
+    #   The description for Format of PO in GNU gettext manual
+    # @return [String] Formatted and joined PO entries. It is used for
+    #   creating .po files.
+    def to_s
+      po_string = ""
+
+      header_entry = @entries[[nil, ""]]
+      po_string << header_entry.to_s unless header_entry.nil?
+
+      content_entries = @entries.reject do |(msgctxt, msgid), _|
+        msgid == :last or msgid.empty?
+      end
+
+      sort_by_order(content_entries).each do |msgid, entry|
+        po_string << "\n" << entry.to_s
+      end
+
+      if @entries.has_key?([nil, :last])
+        po_string << "\n" << @entries[[nil, :last]].to_s
+      end
+
+      po_string
+    end
+
+    private
+    def sort_by_order(entries)
+      case @order
+      when :references
+        sorted_entries = sort_by_references(entries)
+      when :msgid
+        # TODO: sort by msgid alphabetically.
+      else
+        sorted_entries = entries.to_a
+      end
+    end
+
+    def sort_by_references(entries)
+      entries.each do |_, entry|
+        entry.references = entry.references.sort do |reference, other|
+          compare_references(reference, other)
+        end
+      end
+
+      entries.sort do |msgid_entry, other_msgid_entry|
+        # msgid_entry = [[msgctxt, msgid], POEntry]
+        entry_first_reference = msgid_entry[1].references.first
+        other_first_reference = other_msgid_entry[1].references.first
+        compare_references(entry_first_reference, other_first_reference)
+      end
+    end
+
+    def compare_references(reference, other)
+      entry_source, entry_line_number = split_reference(reference)
+      other_source, other_line_number = split_reference(other)
+
+      if entry_source != other_source
+        entry_source <=> other_source
+      else
+        entry_line_number <=> other_line_number
+      end
+    end
+
+    def split_reference(reference)
+      return ["", -1] if reference.nil?
+      if /\A(.+):(\d+?)\z/ =~ reference
+        [$1, $2.to_i]
+      else
+        [reference, -1]
+      end
+    end
+  end
+end

data/lib/gettext/tools/po_entry.rb

@@ -0,0 +1,355 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2010  masone (Christian Felder) <ema@rh-productions.ch>
+# Copyright (C) 2009  Masao Mutoh
+#
+# License: Ruby's or LGPL
+#
+# This library is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# 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/>.
+
+module GetText
+  class ParseError < StandardError
+  end
+
+  # Contains data related to the expression or sentence that
+  # is to be translated.
+  class POEntry
+    class InvalidTypeError < StandardError
+    end
+
+    class NoMsgidError < StandardError
+    end
+
+    class NoMsgctxtError < StandardError
+    end
+
+    class NoMsgidPluralError < StandardError
+    end
+
+    PARAMS = {
+      :normal => [:msgid, :separator, :msgstr],
+      :plural => [:msgid, :msgid_plural, :separator, :msgstr],
+      :msgctxt => [:msgctxt, :msgid, :msgstr],
+      :msgctxt_plural => [:msgctxt, :msgid, :msgid_plural, :msgstr]
+    }
+
+    class << self
+      def escape(string)
+        string.gsub(/([\\"\n])/) do
+          special_character = $1
+          if special_character == "\n"
+            "\\n"
+          else
+            "\\#{special_character}"
+          end
+        end
+      end
+    end
+
+    @@max_line_length = 70
+
+    # Sets the max line length.
+    def self.max_line_length=(len)
+      @@max_line_length = len
+    end
+
+    # Gets the max line length.
+    def self.max_line_length
+      @@max_line_length
+    end
+
+    # Required
+    attr_reader :type          # :normal, :plural, :msgctxt, :msgctxt_plural
+    attr_accessor :msgid
+    attr_accessor :msgstr
+    # Options
+    attr_accessor :msgid_plural
+    attr_accessor :separator
+    attr_accessor :msgctxt
+    attr_accessor :references    # ["file1:line1", "file2:line2", ...]
+    attr_accessor :translator_comment
+    attr_accessor :extracted_comment
+    attr_accessor :flag
+    attr_accessor :previous
+    attr_accessor :comment
+
+    # Create the object. +type+ should be :normal, :plural, :msgctxt or :msgctxt_plural.
+    def initialize(type)
+      self.type = type
+      @translator_comment = nil
+      @extracted_comment = nil
+      @references = []
+      @flag = nil
+      @previous = nil
+      @msgctxt = nil
+      @msgid = nil
+      @msgid_plural = nil
+      @msgstr = nil
+    end
+
+    # Support for extracted comments. Explanation s.
+    # http://www.gnu.org/software/gettext/manual/gettext.html#Names
+    def add_comment(new_comment)
+      if (new_comment and ! new_comment.empty?)
+        @extracted_comment ||= ""
+        @extracted_comment += new_comment
+      end
+      to_s
+    end
+
+    # Returns a parameter representation suitable for po-files
+    # and other purposes.
+    def escaped(param_name)
+      escape(send(param_name))
+    end
+
+    # Checks if the self has same attributes as other.
+    def ==(other)
+      not other.nil? and
+        type == other.type and
+        msgid == other.msgid and
+        msgstr == other.msgstr and
+        msgid_plural == other.msgid_plural and
+        separator == other.separator and
+        msgctxt == other.msgctxt and
+        translator_comment == other.translator_comment and
+        extracted_comment == other.extracted_comment and
+        references == other.references and
+        flag == other.flag and
+        previous == other.previous and
+        comment == other.comment
+    end
+
+    def type=(type)
+      unless PARAMS.has_key?(type)
+        raise(InvalidTypeError, "\"%s\" is invalid type." % type)
+      end
+      @type = type
+      @param_type = PARAMS[@type]
+    end
+
+    # Checks if the other translation target is mergeable with
+    # the current one. Relevant are msgid and translation context (msgctxt).
+    def mergeable?(other)
+      other && other.msgid == self.msgid && other.msgctxt == self.msgctxt
+    end
+
+    # Merges two translation targets with the same msgid and returns the merged
+    # result. If one is declared as plural and the other not, then the one
+    # with the plural wins.
+    def merge(other)
+      return self unless other
+      raise ParseError, "Translation targets do not match: \n" \
+      "  self: #{self.inspect}\n  other: '#{other.inspect}'" unless self.mergeable?(other)
+      if other.msgid_plural && !self.msgid_plural
+        res = other
+        unless (res.references.include? self.references[0])
+          res.references += self.references
+          res.add_comment(self.extracted_comment)
+        end
+      else
+        res = self
+        unless (res.references.include? other.references[0])
+          res.references += other.references
+          res.add_comment(other.extracted_comment)
+        end
+      end
+      res
+    end
+
+    # Output the po entry for the po-file.
+    def to_s
+      raise(NoMsgidError, "msgid is nil.") unless @msgid
+
+      str = ""
+      # extracted comments
+      if @msgid == :last
+        return format_comment("#~", comment)
+      end
+
+      str << format_translator_comment
+      str << format_extracted_comment
+      str << format_reference_comment
+      str << format_flag_comment
+      str << format_previous_comment
+
+      # msgctxt, msgid, msgstr
+      if msgctxt?
+        if @msgctxt.nil?
+          no_msgctxt_message = "This POEntry is a kind of msgctxt " +
+                                 "but the msgctxt property is nil. " +
+                                 "msgid: #{msgid}"
+          raise(NoMsgctxtError, no_msgctxt_message)
+        end
+        str << "msgctxt \"" << msgctxt << "\"\n"
+      end
+
+      str << "msgid \"" << escaped(:msgid) << "\"\n"
+      if plural?
+        if @msgid_plural.nil?
+          no_plural_message = "This POEntry is a kind of plural " +
+                                "but the msgid_plural property is nil. " +
+                                "msgid: #{msgid}"
+          raise(NoMsgidPluralError, no_plural_message)
+        end
+
+        str << "msgid_plural \"" << escaped(:msgid_plural) << "\"\n"
+
+        if msgstr.nil?
+          str << "msgstr[0] \"\"\n"
+          str << "msgstr[1] \"\"\n"
+        else
+          msgstrs = msgstr.split("\000", -1)
+          msgstrs.each_with_index do |msgstr, index|
+            str << "msgstr[#{index}] \"#{escape(msgstr)}\"\n"
+          end
+        end
+      else
+        str << "msgstr "
+        str << format_message(msgstr)
+      end
+      str
+    end
+
+    def format_translator_comment
+      format_comment("#", translator_comment)
+    end
+
+    def format_extracted_comment
+      format_comment("#.", extracted_comment)
+    end
+
+    def format_reference_comment
+      max_line_length = 70
+      formatted_reference = ""
+      if not references.nil? and not references.empty?
+        formatted_reference << "#:"
+        line_size = 2
+        references.each do |reference|
+          if line_size + reference.size > max_line_length
+            formatted_reference << "\n"
+            formatted_reference <<  "#: #{reference}"
+            line_size = 3 + reference.size
+          else
+            formatted_reference << " #{reference}"
+            line_size += 1 + reference.size
+          end
+        end
+
+        formatted_reference << "\n"
+      end
+      formatted_reference
+    end
+
+    def format_flag_comment
+      format_comment("#,", flag)
+    end
+
+    def format_previous_comment
+      format_comment("#|", previous)
+    end
+
+    def format_comment(mark, comment)
+      return "" if comment.nil?
+
+      formatted_comment = ""
+      comment.each_line do |comment_line|
+        if comment_line == "\n"
+          formatted_comment << "#{mark}\n"
+        else
+          formatted_comment << "#{mark} #{comment_line.strip}\n"
+        end
+      end
+      formatted_comment
+    end
+
+    def format_message(message)
+      formatted_message = ""
+      if not message.nil? and message.include?("\n")
+        formatted_message << "\"\"\n"
+        message.each_line.each do |line|
+          formatted_message << "\"#{escape(line)}\"\n"
+        end
+      else
+        formatted_message << "\"#{escape(message)}\"\n"
+      end
+      formatted_message
+    end
+
+    # Returns true if the type is kind of msgctxt.
+    def msgctxt?
+      [:msgctxt, :msgctxt_plural].include?(@type)
+    end
+
+    # Returns true if the type is kind of plural.
+    def plural?
+      [:plural, :msgctxt_plural].include?(@type)
+    end
+
+    private
+
+    # sets or extends the value of a translation target params like msgid,
+    # msgctxt etc.
+    #   param is symbol with the name of param
+    #   value - new value
+    def set_value(param, value)
+      send "#{param}=", (send(param) || '') + value.gsub(/\n/, '\n')
+    end
+
+    def escape(value)
+      self.class.escape((value || "").gsub(/\r/, ""))
+    end
+
+    public
+    # For backward comatibility. This doesn't support "comment".
+    # ary = [msgid1, "file1:line1", "file2:line"]
+    def self.new_from_ary(ary)
+      ary = ary.dup
+      msgid = ary.shift
+      references = ary
+      type = :normal
+      msgctxt = nil
+      msgid_plural = nil
+
+      if msgid.include? "\004"
+        msgctxt, msgid = msgid.split(/\004/)
+        type = :msgctxt
+      end
+      if msgid.include? "\000"
+        ids = msgid.split(/\000/)
+        msgid = ids[0]
+        msgid_plural = ids[1]
+        if type == :msgctxt
+          type = :msgctxt_plural
+        else
+          type = :plural
+        end
+      end
+      ret = self.new(type)
+      ret.msgid = msgid
+      ret.references = references
+      ret.msgctxt = msgctxt
+      ret.msgid_plural = msgid_plural
+      ret
+    end
+
+    def [](number)
+      param = @param_type[number]
+      raise ParseError, 'no more string parameters expected' unless param
+      send param
+    end
+  end
+
+end