gettext 2.3.9 → 3.0.0

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

@@ -1,8 +1,9 @@
-# encoding: utf-8
+# -*- coding: utf-8 -*-
 
 =begin
   parser/glade.rb - parser for Glade-2
 
+  Copyright (C) 2013       Kouhei Sutou <kou@clear-code.com>
   Copyright (C) 2004,2005  Masao Mutoh
 
   You may redistribute it and/or modify it under the same
@@ -13,47 +14,69 @@ require 'cgi'
 require 'gettext'
 
 module GetText
-  module GladeParser
+  class GladeParser
     extend GetText
-    extend self
 
     bindtextdomain("gettext")
 
+    class << self
+      XML_RE = /<\?xml/
+      GLADE_RE = /glade-2.0.dtd/
+
+      def target?(file) # :nodoc:
+        data = IO.readlines(file)
+        if XML_RE =~ data[0] and GLADE_RE =~ data[1]
+          true
+        else
+          if File.extname(file) == '.glade'
+            raise _("`%{file}' is not glade-2.0 format.") % {:file => file}
+          end
+          false
+        end
+      end
+
+      def parse(path, options={})
+        parser = new(path, options)
+        parser.parse
+      end
+    end
+
     TARGET1 = /<property.*translatable="yes">(.*)/
     TARGET2 = /(.*)<\/property>/
 
-    def parse(file) # :nodoc:
-      lines = IO.readlines(file)
-      parse_lines(file, lines)
+    def initialize(path, options={})
+      @path = path
+      @options = options
+    end
+
+    def parse # :nodoc:
+      File.open(@path) do |file|
+        parse_source(file)
+      end
     end
 
-    #from ary of lines.
-    def parse_lines(file, lines) # :nodoc:
+    private
+    def parse_source(input) # :nodoc:
       targets = []
-      cnt = 0
       target = false
-      line_no = 0
+      start_line_no = nil
       val = nil
 
-      loop do
-        line = lines.shift
-        break unless line
-
-        cnt += 1
+      input.each_line.with_index do |line, i|
         if TARGET1 =~ line
-          line_no = cnt
+          start_line_no = i + 1
           val = $1 + "\n"
           target = true
           if TARGET2 =~ $1
             val = $1
-            add_target(val, file, line_no, targets)
+            add_target(val, start_line_no, targets)
             val = nil
             target = false
           end
         elsif target
           if TARGET2 =~ line
             val << $1
-            add_target(val, file, line_no, targets)
+            add_target(val, start_line_no, targets)
             val = nil
             target = false
           else
@@ -64,29 +87,14 @@ module GetText
       targets
     end
 
-    XML_RE = /<\?xml/
-    GLADE_RE = /glade-2.0.dtd/
-
-    def target?(file) # :nodoc:
-      data = IO.readlines(file)
-      if XML_RE =~ data[0] and GLADE_RE =~ data[1]
-  true
-      else
-  if File.extname(file) == '.glade'
-    raise _("`%{file}' is not glade-2.0 format.") % {:file => file}
-  end
-  false
-      end
-    end
-
-    def add_target(val, file, line_no, targets) # :nodoc:
+    def add_target(val, line_no, targets) # :nodoc:
       return unless val.size > 0
       assoc_data = targets.assoc(val)
       val = CGI.unescapeHTML(val)
       if assoc_data
-        targets[targets.index(assoc_data)] = assoc_data << "#{file}:#{line_no}"
+        targets[targets.index(assoc_data)] = assoc_data << "#{@path}:#{line_no}"
       else
-        targets << [val.gsub(/\n/, '\n'), "#{file}:#{line_no}"]
+        targets << [val.gsub(/\n/, '\n'), "#{@path}:#{line_no}"]
       end
       targets
     end

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

@@ -2,6 +2,7 @@
 =begin
   parser/ruby.rb - parser for ruby script
 
+  Copyright (C) 2013       Kouhei Sutou <kou@clear-code.com>
   Copyright (C) 2003-2009  Masao Mutoh
   Copyright (C) 2005       speakillof
   Copyright (C) 2001,2002  Yasushi Shoji, Masao Mutoh
@@ -11,9 +12,9 @@
 
 =end
 
-require 'irb/ruby-lex.rb'
-require 'stringio'
-require 'gettext/tools/po_entry'
+require "irb/ruby-lex"
+require "stringio"
+require "gettext/po_entry"
 
 module GetText
   class RubyLexX < RubyLex  # :nodoc: all
@@ -31,7 +32,7 @@ module GetText
           end
 
           if @here_header
-            s = s.sub(/\A.*?\n/, '').sub(/^.*\n\Z/, '')
+            s = s.sub(/\A.*?\n/, "").sub(/^.*\n\Z/, "")
           else
             begin
               s = eval(s)
@@ -85,7 +86,7 @@ module GetText
     # Supports parsing by setting attributes by and by.
     def set_current_attribute(str)
       param = @param_type[@param_number]
-      raise ParseError, 'no more string parameters expected' unless param
+      raise ParseError, "no more string parameters expected" unless param
       set_value(param, str)
     end
 
@@ -107,32 +108,116 @@ module GetText
     end
   end
 
-  module RubyParser
-    extend self
+  class RubyParser
+    ID = ["gettext", "_", "N_", "sgettext", "s_"]
+    PLURAL_ID = ["ngettext", "n_", "Nn_", "ns_", "nsgettext"]
+    MSGCTXT_ID = ["pgettext", "p_"]
+    MSGCTXT_PLURAL_ID = ["npgettext", "np_"]
 
-    ID = ['gettext', '_', 'N_', 'sgettext', 's_']
-    PLURAL_ID = ['ngettext', 'n_', 'Nn_', 'ns_', 'nsgettext']
-    MSGCTXT_ID = ['pgettext', 'p_']
-    MSGCTXT_PLURAL_ID = ['npgettext', 'np_']
+    class << self
+      def target?(file)  # :nodoc:
+        true # always true, as the default parser.
+      end
 
-    # (Since 2.1.0) the 2nd parameter is deprecated
-    # (and ignored here).
-    # And You don't need to keep the poentries as unique.
+      # Parses Ruby script located at `path`.
+      #
+      # This is a short cut method. It equals to `new(path,
+      # options).parse`.
+      #
+      # @param (see #initialize)
+      # @option (see #initialize)
+      # @return (see #parse)
+      # @see #initialize
+      # @see #parse
+      def parse(path, options={})
+        parser = new(path, options)
+        parser.parse
+      end
+    end
 
-    def parse(path)  # :nodoc:
-      source = IO.read(path)
+    #
+    # @example `:comment_tag` option: String tag
+    #   path = "hello.rb"
+    #   # content:
+    #   #   # TRANSLATORS: This is a comment to translators.
+    #   #   _("Hello")
+    #   #
+    #   #   # This is a comment for programmers.
+    #   #   # TRANSLATORS: This is a comment to translators.
+    #   #   # This is also a comment to translators.
+    #   #   _("World")
+    #   #
+    #   #   # This is a comment for programmers.
+    #   #   # This is also a comment for programmers
+    #   #   # because all lines don't start with "TRANSRATORS:".
+    #   #   _("Bye")
+    #   options = {:comment_tag => "TRANSLATORS:"}
+    #   parser = GetText::RubyParser.new(path, options)
+    #   parser.parse
+    #   # => [
+    #   #   POEntry<
+    #   #     :msgid => "Hello",
+    #   #     :extracted_comment =>
+    #   #       "TRANSLATORS: This is a comment to translators.",
+    #   #   >,
+    #   #   POEntry<
+    #   #     :msgid => "World",
+    #   #     :extracted_comment =>
+    #   #       "TRANSLATORS: This is a comment to translators.\n" +
+    #   #       "This is also a comment to translators.",
+    #   #   >,
+    #   #   POEntry<
+    #   #     :msgid => "Bye",
+    #   #     :extracted_comment => nil,
+    #   #   >,
+    #   # ]
+    #
+    # @example `:comment_tag` option: nil tag
+    #   path = "hello.rb"
+    #   # content:
+    #   #   # This is a comment to translators.
+    #   #   # This is also a comment for translators.
+    #   #   _("Hello")
+    #   options = {:comment_tag => nil}
+    #   parser = GetText::RubyParser.new(path, options)
+    #   parser.parse
+    #   # => [
+    #   #   POEntry<
+    #   #     :msgid => "Hello",
+    #   #     :extracted_comment =>
+    #   #       "This is a comment to translators.\n" +
+    #   #       " This is also a comment for translators.",
+    #   #   >,
+    #   # ]
+    #
+    # @param path [String] Ruby script path to be parsed
+    # @param options [Hash] Options
+    # @option options [String, nil] :comment_tag The tag to
+    #   detect comments to be extracted. The extracted comments are
+    #   used to deliver messages to translators from programmers.
+    #
+    #   If the tag is String and a line in a comment start with the
+    #   tag, the line and the following lines are extracted.
+    #
+    #   If the tag is nil, all comments are extracted.
+    def initialize(path, options={})
+      @path = path
+      @options = options
+    end
 
-      if source.respond_to?(:encode)
-        encoding = detect_encoding(source) || source.encoding
+    # Extracts messages from @path.
+    #
+    # @return [Array<POEntry>] Extracted messages
+    def parse
+      source = IO.read(@path)
 
-        source.force_encoding(encoding)
-      end
+      encoding = detect_encoding(source) || source.encoding
+      source.force_encoding(encoding)
 
-      parse_lines(path, source.each_line.to_a)
+      parse_source(source)
     end
 
     def detect_encoding(source)
-      return nil unless source.respond_to?(:force_encoding)
       binary_source = source.dup.force_encoding("ASCII-8BIT")
       if /\A.*coding\s*[=:]\s*([[:alnum:]\-_]+)/ =~ binary_source
         $1.gsub(/-(?:unix|mac|dos)\z/, "")
@@ -141,9 +226,9 @@ module GetText
       end
     end
 
-    def parse_lines(path, lines)  # :nodoc:
+    def parse_source(source)
       po = []
-      file = StringIO.new(lines.join + "\n")
+      file = StringIO.new(source)
       rl = RubyLexX.new
       rl.set_input(file)
       rl.skip_space = true
@@ -151,7 +236,7 @@ module GetText
 
       po_entry = nil
       line_no = nil
-      last_comment = ''
+      last_comment = ""
       reset_comment = false
       ignore_next_comma = false
       rl.parse do |tk|
@@ -160,7 +245,7 @@ module GetText
           ignore_next_comma = false
           case tk
           when RubyToken::TkIDENTIFIER, RubyToken::TkCONSTANT
-            if store_po_entry(po, po_entry, path, line_no, last_comment)
+            if store_po_entry(po, po_entry, line_no, last_comment)
               last_comment = ""
             end
             if ID.include?(tk.name)
@@ -186,14 +271,14 @@ module GetText
               po_entry.advance_to_next_attribute if po_entry
             end
           else
-            if store_po_entry(po, po_entry, path, line_no, last_comment)
+            if store_po_entry(po, po_entry, line_no, last_comment)
               po_entry = nil
               last_comment = ""
             end
           end
         rescue
           $stderr.print "\n\nError"
-          $stderr.print " parsing #{path}:#{tk.line_no}\n\t #{lines[tk.line_no - 1]}" if tk
+          $stderr.print " parsing #{@path}:#{tk.line_no}\n\t #{source.lines.to_a[tk.line_no - 1]}" if tk
           $stderr.print "\n #{$!.inspect} in\n"
           $stderr.print $!.backtrace.join("\n")
           $stderr.print "\n"
@@ -204,10 +289,9 @@ module GetText
         when RubyToken::TkCOMMENT_WITH_CONTENT
           last_comment = "" if reset_comment
           if last_comment.empty?
-            # new comment from programmer to translator?
             comment1 = tk.value.lstrip
-            if comment1 =~ /^TRANSLATORS\:/
-              last_comment = $'
+            if comment_to_be_extracted?(comment1)
+              last_comment << comment1
             end
           else
             last_comment += "\n"
@@ -222,14 +306,10 @@ module GetText
       po
     end
 
-    def target?(file)  # :nodoc:
-      true # always true, as the default parser.
-    end
-
     private
-    def store_po_entry(po, po_entry, file_name, line_no, last_comment) #:nodoc:
+    def store_po_entry(po, po_entry, line_no, last_comment) #:nodoc:
       if po_entry && po_entry.msgid
-        po_entry.references << file_name + ":" + line_no
+        po_entry.references << @path + ":" + line_no
         po_entry.add_comment(last_comment) unless last_comment.empty?
         po << po_entry
         true
@@ -237,5 +317,14 @@ module GetText
         false
       end
     end
+
+    def comment_to_be_extracted?(comment)
+      return false unless @options.has_key?(:comment_tag)
+
+      tag = @options[:comment_tag]
+      return true if tag.nil?
+
+      /\A#{Regexp.escape(tag)}/ === comment
+    end
   end
 end

data/lib/gettext/tools/task.rb

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013  Kouhei Sutou <kou@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 "rake"
+require "gettext/tools"
+
+module GetText
+  module Tools
+    class Task
+      include GetText
+      include Rake::DSL
+
+      attr_accessor :locales, :po_base_directory, :mo_base_directory, :domain
+      attr_accessor :namespace_prefix, :files
+      # @return [Array<String>] Command line options for extracting messages
+      #   from sources.
+      # @see GetText::Tools::XGetText
+      # @see `rxgettext --help`
+      attr_reader :xgettext_options
+      def initialize(spec)
+        @spec = spec
+        @locales = []
+        @po_base_directory = "po"
+        @mo_base_directory = "."
+        @files = target_files
+        @domain = @spec.name
+        @namespace_prefix = nil
+        @xgettext_options = []
+        yield(self) if block_given?
+        @locales = detect_locales if @locales.empty?
+        raise("must set locales: #{inspect}") if @locales.empty?
+        define
+      end
+
+      private
+      def define
+        define_file_tasks
+        if namespace_prefix
+          namespace_recursive namespace_prefix do
+            define_named_tasks
+          end
+        else
+          define_named_tasks
+        end
+      end
+
+      def define_file_tasks
+        unless files.empty?
+          pot_dependencies = files.dup
+          unless File.exist?(po_base_directory)
+            directory po_base_directory
+            pot_dependencies << po_base_directory
+          end
+          file pot_file => pot_dependencies do
+            command_line = [
+              "--package-name", @spec.name,
+              "--package-version", @spec.version.to_s,
+              "--output", pot_file,
+            ]
+            command_line.concat(@xgettext_options)
+            command_line.concat(files)
+            GetText::Tools::XGetText.run(*command_line)
+          end
+        end
+
+        locales.each do |locale|
+          _po_file = po_file(locale)
+          unless files.empty?
+            po_dependencies = [pot_file]
+            _po_directory = po_directory(locale)
+            unless File.exist?(_po_directory)
+              directory _po_directory
+              po_dependencies << _po_directory
+            end
+            file _po_file => po_dependencies do
+              if File.exist?(_po_file)
+                GetText::Tools::MsgMerge.run(po_file(locale), pot_file,
+                                             "--output", _po_file)
+              else
+                GetText::Tools::MsgInit.run("--input", pot_file,
+                                            "--output", _po_file,
+                                            "--locale", locale.to_s)
+              end
+            end
+          end
+
+          mo_dependencies = [_po_file]
+          _mo_directory = mo_directory(locale)
+          unless File.exist?(_mo_directory)
+            directory _mo_directory
+            mo_dependencies << _mo_directory
+          end
+          _mo_file = mo_file(locale)
+          file _mo_file => mo_dependencies do
+            GetText::Tools::MsgFmt.run(_po_file, "--output", _mo_file)
+          end
+        end
+      end
+
+      def define_named_tasks
+        namespace :gettext do
+          namespace :pot do
+            desc "Create #{pot_file}"
+            task :create => pot_file
+          end
+
+          namespace :po do
+            update_tasks = []
+            @locales.each do |locale|
+              namespace locale do
+                desc "Update #{po_file(locale)}"
+                task :update => po_file(locale)
+                update_tasks << (current_scope + ["update"]).join(":")
+              end
+            end
+
+            desc "Update *.po"
+            task :update => update_tasks
+          end
+
+          namespace :mo do
+            update_tasks = []
+            @locales.each do |locale|
+              namespace locale do
+                desc "Update #{mo_file(locale)}"
+                task :update => mo_file(locale)
+                update_tasks << (current_scope + ["update"]).join(":")
+              end
+            end
+
+            desc "Update *.mo"
+            task :update => update_tasks
+          end
+        end
+
+        desc "Update *.mo"
+        task :gettext => (current_scope + ["gettext", "mo", "update"]).join(":")
+      end
+
+      def pot_file
+        File.join(po_base_directory, "#{domain}.pot")
+      end
+
+      def po_directory(locale)
+        File.join(po_base_directory, locale.to_s)
+      end
+
+      def po_file(locale)
+        File.join(po_directory(locale), "#{domain}.po")
+      end
+
+      def mo_directory(locale)
+        File.join(mo_base_directory, "locale", locale.to_s, "LC_MESSAGES")
+      end
+
+      def mo_file(locale)
+        File.join(mo_directory(locale), "#{domain}.mo")
+      end
+
+      def target_files
+        files = @spec.files.find_all do |file|
+          /\A\.(?:rb|erb|glade)\z/i =~ File.extname(file)
+        end
+        files += @spec.executables.collect do |executable|
+          "bin/#{executable}"
+        end
+        files
+      end
+
+      def detect_locales
+        locales = []
+        return locales unless File.exist?(po_base_directory)
+
+        Dir.open(po_base_directory) do |dir|
+          dir.each do |entry|
+            next unless /\A[a-z]{2}(?:_[A-Z]{2})?\z/ =~ entry
+            next unless File.directory?(File.join(dir.path, entry))
+            locales << entry
+          end
+        end
+        locales
+      end
+
+      def current_scope
+        scope = Rake.application.current_scope
+        if scope.is_a?(Array)
+          scope
+        else
+          if scope.empty?
+            []
+          else
+            [scope.path]
+          end
+        end
+      end
+
+      def namespace_recursive(namespace_spec, &block)
+        first, rest = namespace_spec.split(/:/, 2)
+        namespace first do
+          if rest.nil?
+            block.call
+          else
+            namespace_recursive(rest, &block)
+          end
+        end
+      end
+    end
+  end
+end