i18n-translators-tools 0.1.1 → 0.2

data/lib/i18n/backend/translate.rb

@@ -20,9 +20,9 @@ module I18n
       def translate(locale, key, options = {})
         result = super(locale, key, options)
         return result unless result.kind_of?(Hash)
-        return nil unless result[:t]
+        return nil unless result[:t] or result[:translation]
 
-        tr = result[:t]
+        tr = result[:translation] || result[:t]
         values = options.except(*I18n::Backend::Base::RESERVED_KEYS)
 
         tr = resolve(locale, key, tr, options)

data/lib/i18n/backend/ts.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# vi: fenc=utf-8:expandtab:ts=2:sw=2:sts=2
+# 
+# @author: Petr Kovar <pejuko@gmail.com>
+
+module I18n::Backend
+
+  # to use QT linguist TS files you should just include this backend
+  #
+  # I18n::Backend::Simple.send(:include, I18n::Backend::TS)
+  module TS
+  protected
+    def load_ts(fname)
+      locale = ::File.basename(fname, '.ts')
+      tr = I18n::Translate::Translate.new(locale, {:empty => true})
+      data = I18n::Translate::Processor::TS.new(fname, tr).read
+    end
+  end
+end

data/lib/i18n/processor.rb

@@ -37,6 +37,12 @@ module I18n::Translate
       nil
     end
 
+    def self.init(default='yml')
+      @processors.each do |processor|
+        processor.register(default)
+      end
+    end
+
 
     class Template
       FORMAT = []
@@ -50,6 +56,21 @@ module I18n::Translate
       def initialize(fname, tr)
         @filename = fname
         @translate = tr
+        fname =~ %r{/?([^/]+)\.[^\.]+$}i
+        @lang = $1.to_s.strip
+      end
+
+      def self.register(default='yml')
+        self::FORMAT.each do |format|
+          unless I18n::Translate::FORMATS.include?(format)
+            # default format will be first
+            if default == format
+              I18n::Translate::FORMATS.unshift(format)
+            else
+              I18n::Translate::FORMATS << format
+            end
+          end
+        end
       end
 
       def read
@@ -68,7 +89,7 @@ module I18n::Translate
       end
 
       def self.can_handle?(fname)
-        fname =~ %r{\.([^\.]+)$}
+        fname =~ %r{\.([^\.]+)$}i
         self::FORMAT.include?($1)
       end
 
@@ -82,6 +103,35 @@ module I18n::Translate
         data
       end
 
+      def uninspect(str)
+        return nil unless str
+        str.gsub(%r!\\([\\#"abefnrstvx]|u\d{4}|u\{[^\}]+\}|\d{1,3}|x\d{1,2}|cx|C-[a-zA-Z]|M-[a-zA-Z])!) do |m|
+          repl = ""
+          if ['\\', '#', '"'].include?($1)
+            repl = $1
+          else
+            repl = eval("\"\\#{$1}\"")
+          end
+          repl
+        end
+      end
+
+      # convert old and shorthand fields
+      def migrate(data)
+        keys = I18n::Translate.hash_to_keys(data, @translate.options[:separator])
+        keys.each do |key|
+          k, prop = $1, $2 if key =~ /(.*)\.([^\.]+)$/
+          next unless prop or k
+          next unless ["old", "t"].include?(prop)
+          entry = I18n::Translate.find(k, data, @translate.options[:separator])
+          value = entry.delete(prop)
+          prop = (prop == "old") ? "old_default" : "translation"
+          entry[prop] = value
+          I18n::Translate.set(k, entry, data, @translate.options[:separator])
+        end
+        data
+      end
+
       def mode(m)
         mode = m.dup
         mode << ":" << @translate.options[:encoding] if defined?(Encoding)
@@ -96,4 +146,9 @@ end
 require 'i18n/processor/yaml'
 require 'i18n/processor/ruby'
 require 'i18n/processor/gettext'
+require 'i18n/processor/ts'
+require 'i18n/processor/properties'
+
 
+# initialize all registred processors
+I18n::Translate::Processor.init

data/lib/i18n/processor/gettext.rb

@@ -6,7 +6,7 @@
 module I18n::Translate::Processor
 
   class Gettext < Template
-    FORMAT = ['po']
+    FORMAT = ['po', 'pot']
 
   protected
 
@@ -20,6 +20,7 @@ module I18n::Translate::Processor
         # empty line starts new entry
         if line =~ %r{^\s*$}
           if not entry.empty? and key
+            key = entry["default"].dup unless key
             I18n::Translate.set(key, entry, hash, @translate.options[:separator])
           end
           key = nil
@@ -34,9 +35,17 @@ module I18n::Translate::Processor
         when %r{^# (.*)$}
           entry["comment"] = $1.to_s.strip
 
-        # translator's comment
+        # extracted comment
+        when %r{^#\. (.*)$}
+          entry["extracted_comment"] = $1.to_s.strip
+
+        # reference
         when %r{^#: (.*)$}
-          entry["line"] = $1.to_s.strip
+          entry["reference"] = $1.to_s.strip
+          if entry["reference"] =~ %r{^(.*):(\d+)$}
+            entry["file"] = $1.to_s.strip
+            entry["line"] = $2.to_s.strip
+          end
 
         # flag
         when %r{^#, (.*)$}
@@ -47,34 +56,52 @@ module I18n::Translate::Processor
           else
             flags.delete_if{|x| not I18n::Translate::FLAGS.include?(x)}
             entry["flag"] = flags.first unless flags.empty?
+            entry["fuzzy"] = true
           end
 
         # old default
-        when %r{^#\| msgid (.*)$}
-          entry["old"] = $1.to_s.strip
+        when %r{^#\| msgid "(.*)"$}
+          entry["old_default"] = $1.to_s
+          # expect that this entry has no key
+          # if does, will be overwriten later
+          key = entry["old_default"].dup
 
-        # key
+        # key (context)
         when %r{^msgctxt "(.*)"$}
           key = $1.to_s.strip
           last = "key"
 
         # default
         when %r{^msgid "(.*)"$}
-          last = "default"
-          entry[last] = $1.to_s.strip
+          if $1.to_s.strip.empty?
+            last = "po-header"
+          else
+            last = "default"
+            entry[last] = uninspect($1.to_s)
+            key = entry[last].dup unless key
+          end
 
         # translation
         when %r{^msgstr "(.*)"$}
-          last = "t"
-          entry[last] = $1.to_s.strip
+          last = "translation" unless last == "po-header"
+          entry[last] = uninspect($1.to_s)
 
         # string continuation
         when %r{^"(.*)"$}
           if last == "key"
-            key = "#{key}#{$1.to_s.strip}"
+            key = "#{key}#{$1}"
+          elsif last == "po-header"
+            case $1
+            when %r{^Content-Type: text/plain; charset=(.*)$}
+              enc = uninspect($1.to_s).strip
+              @translate.options[:encoding] = enc unless enc.empty?
+            when %r{^X-Language: (.*)$}
+              # skip language is set from filename
+            end
           elsif last
-            entry[last] = "#{entry[last]}#{$1.to_s.strip}"
+            entry[last] = "#{entry[last]}#{uninspect($1)}"
           end
+
         end
       end
 
@@ -87,31 +114,45 @@ module I18n::Translate::Processor
     end
 
 
-    # this export ignores data
     def export(data)
+      target = data[@translate.lang]
       str = ""
       keys = I18n::Translate.hash_to_keys(@translate.default).sort
 
+      str << %~msgid ""\n~
+      str << %~msgstr ""\n~
+      str << %~"Content-Type: text/plain; charset=#{@translate.options[:encoding]}\\n"\n~
+      str << %~"X-Language: #{@translate.lang}\\n"\n~
       keys.each do |key|
         entry = [""]
-        value = @translate.find(key, @translate.target)
+        value = @translate.find(key, target)
         next unless value
 
         if value.kind_of?(String)
-          entry << %~msgctxt #{key.inspect}~
-          entry << %~msgid #{@translate.find(key, @translate.default).to_s.inspect}~
+          # leave out msgctxt if using po strings as a key
+          default = @translate.find(key, @translate.default)
+          entry << %~msgctxt #{key.inspect}~ if key != default
+          entry << %~msgid #{default.to_s.inspect}~
           entry << %~msgstr #{value.to_s.inspect}~
         else
-          entry << %~#  #{value["comment"]}~ unless value["comment"].to_s.empty?
-          entry << %~#: #{value["line"]}~ unless value["line"].to_s.empty?
+          entry << %~#  #{value["comment"].to_s.strip}~ unless value["comment"].to_s.strip.empty?
+          entry << %~#. #{value["extracted_comment"].to_s.strip}~ unless value["extracted_comment"].to_s.strip.empty?
+          if not value["reference"].to_s.strip.empty?
+            entry << %~#: #{value["reference"].to_s.strip}~
+          elsif value["file"] or value["line"]
+            entry << %~#: #{value["file"].to_s.strip}:#{value["line"].to_s.strip}~
+          end
+          key_default = nil
+          key_default = value["default"] if value["default"] == key
+          key_default = value["old_default"] if value["old_default"] == key
           flags = []
-          flags << "fuzzy" if value["fuzzy"]
+          flags << "fuzzy" if (not value["flag"].nil?) and (value["flag"] != "ok")
           flags << value["flag"] unless value["flag"].to_s.strip.empty?
           entry << %~#, #{flags.join(", ")}~ unless flags.empty?
-          entry << %~#| msgid #{value["old"]}~ unless value["old"].to_s.empty?
-          entry << %~msgctxt #{key.inspect}~
+          entry << %~#| msgid #{value["old_default"].to_s.inspect}~ unless value["old_default"].to_s.empty?
+          entry << %~msgctxt #{key.inspect}~ if key != key_default
           entry << %~msgid #{value["default"].to_s.inspect}~
-          entry << %~msgstr #{value["t"].to_s.inspect}~
+          entry << %~msgstr #{value["translation"].to_s.inspect}~
         end
 
         entry << ""

data/lib/i18n/processor/properties.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# vi: fenc=utf-8:expandtab:ts=2:sw=2:sts=2
+# 
+# @author: Petr Kovar <pejuko@gmail.com>
+
+module I18n::Translate::Processor
+
+  class Properties < Template
+    FORMAT = ['properties']
+
+  protected
+
+    def import(data)
+      hash = {}
+
+      key = nil
+      value = nil
+      line_number = 0
+      data.each_line do |line|
+        line_number += 1
+        # skip empty line and comments
+        next if (line =~ %r{^\s*$}) or (line =~ %r{^#.*})
+        
+        case line
+        # multiline string
+        when %r{^([^=]+)\s*=\s*(.*)\\$}
+          key = $1.to_s.strip
+          value = $2.to_s.strip
+
+        # continuous multiline string
+        when %r{^\s*([^=]+)\\$}
+          value << $1.to_s.strip
+
+        # end of continuous string
+        when %r{^\s*([^=]+)$}
+          value << $1.to_s.strip
+          I18n::Translate.set(key, uninspect(value), hash, @translate.options[:separator])
+          value = nil
+
+        # simple key = value
+        when %r{^([^=]+)\s*=\s*(.*)$}
+          key, value = $1.to_s.strip, $2.to_s.strip
+          I18n::Translate.set(key, uninspect(value), hash, @translate.options[:separator])
+        end
+      end
+
+      {@lang => hash}
+    end
+
+
+    # this export ignores data
+    def export(data)
+      target = data[@translate.lang]
+      str = ""
+      keys = I18n::Translate.hash_to_keys(@translate.default).sort
+
+      keys.each do |key|
+        value = @translate.find(key, target)
+        next unless value
+        entry = ""
+
+
+        if value.kind_of?(String)
+          entry = value.strip
+        else
+          entry = value["translation"].to_s.strip
+        end
+
+        # create record in format: key = value
+        str << key << " = " << entry.gsub("\n", "\\n") << "\n"
+      end
+
+      str
+    end
+
+  end
+
+end

data/lib/i18n/processor/ruby.rb

@@ -11,7 +11,7 @@ module I18n::Translate::Processor
   protected
 
     def import(data)
-      eval(data)
+      migrate(eval(data))
     end
 
     # serialize hash to string

data/lib/i18n/processor/ts.rb

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+# vi: fenc=utf-8:expandtab:ts=2:sw=2:sts=2
+# 
+# @author: Petr Kovar <pejuko@gmail.com>
+
+require 'rexml/document'
+require 'cgi'
+
+module I18n::Translate::Processor
+
+  class TS < Template
+    FORMAT = ['ts']
+
+  protected
+
+    def get(xml, path, key=nil)
+      elements = []
+      xml.elements.each(path) {|e| elements << e}
+      element = elements.first
+      ret = ""
+      ret = element.get_text.to_s if element and not key
+      ret = element.attributes[key].to_s.strip if element and key
+      ret.gsub!("&apos;", "'")
+      ret = uninspect(::CGI::unescapeHTML(ret))
+      ret
+    end
+
+    def import(data)
+      hash = {}
+      xml = ::REXML::Document.new(data)
+      lang = @translate.lang
+      lang = get(xml, "TS", "language").to_s.strip if lang.empty?
+      xml.elements.each("//TS/context") do |context|
+        key = get(context, "name")
+        context.elements.each("message") do |message|
+          entry = {}
+          entry["file"] = get(message, "location", "filename").to_s.strip
+          entry["line"] = get(message, "location", "line").to_s.strip
+          unless entry["file"].empty? or entry["line"].empty?
+            entry["reference"] = "#{entry['file']}:#{entry['line']}"
+          end
+          if key.to_s.strip.empty?
+            # this happen if you use linguist on converting po to ts
+            # context is saved as a comment
+            key = get(message, "comment").to_s.strip
+            # if converted from po using linguist, there is one message
+            # without key
+            #raise "No key for message: #{message.to_s}" if key.empty?
+          end
+          entry["default"] = get(message, "source")
+          entry["old_default"] = get(message, "oldsource")
+          entry["extracted_comment"] = get(message, "extracomment").to_s.strip
+          entry["comment"] = get(message, "translatorcomment").to_s.strip
+          entry["translation"] = get(message, "translation")
+          fuzzy = get(message, "translation", "type").to_s.strip
+          entry["fuzzy"] = true unless fuzzy.empty?
+          flag = get(message, "extra-po-flags").to_s.strip
+          entry["flag"] = flag unless flag.empty?
+          entry.delete_if {|k,v| v.to_s.empty?}
+          if key
+            # not key means it can be header of po file converted to ts
+            I18n::Translate.set(key, entry, hash, @translate.options[:separator])
+          end
+          key = nil
+        end
+      end
+      {lang => hash}
+    end
+
+
+    # serialize hash to XML
+    def export(data, indent=0)
+      target = data[@translate.lang]
+      xml = <<EOF
+<?xml version="1.0" encoding="#{@translate.options[:encoding]}"?>
+<!DOCTYPE TS>
+<TS version="2.0" language="#{@translate.lang}">
+EOF
+
+      keys = I18n::Translate.hash_to_keys(@translate.default).sort
+      keys.each do |key|
+        value = @translate.find(key, target)
+        next unless value
+
+        if value.kind_of?(String)
+          fuzzy = (value.to_s.empty?) ? %~ type="unfinished"~ : ""
+          xml += <<EOF
+    <context>
+        <name>#{::CGI.escapeHTML(key)}</name>
+        <message>
+            <source>#{::CGI.escapeHTML(@translate.find(key, @translate.default).to_s)}</source>
+            <translation#{fuzzy}>#{::CGI.escapeHTML(value.to_s)}</translation>
+        </message>
+    </context>
+EOF
+        else
+          fuzzy = ((value["flag"] == "ok") or value["flag"].to_s.strip.empty?) ? "" : %~ type="unfinished"~
+          xml += <<EOF
+    <context>
+        <name>#{::CGI.escapeHTML(key)}</name>
+        <message>
+EOF
+          if value["file"] or value["line"]
+            xml += <<EOF
+            <location filename="#{::CGI.escapeHTML(value["file"].to_s)}" line="#{::CGI.escapeHTML(value["line"].to_s)}" />
+EOF
+          end
+          xml += <<EOF
+            <source>#{::CGI.escapeHTML(value["default"].to_s)}</source>
+EOF
+          unless value["old_default"].to_s.empty?
+            xml += <<EOF
+            <oldsource>#{::CGI.escapeHTML(value["old_default"].to_s)}</oldsource>
+EOF
+          end
+          unless value["extracted_comment"].to_s.empty?
+            xml += <<EOF
+            <extracomment>#{::CGI.escapeHTML(value["extracted_comment"].to_s)}</extracomment>
+EOF
+          end
+          unless value["comment"].to_s.empty?
+            xml += <<EOF
+            <translatorcomment>#{::CGI.escapeHTML(value["comment"].to_s)}</translatorcomment>
+EOF
+          end
+          xml += <<EOF
+            <translation#{fuzzy}>#{::CGI.escapeHTML(value["translation"].to_s)}</translation>
+EOF
+          unless value["flag"].to_s.strip.empty?
+            xml += <<EOF
+            <extra-po-flags>#{::CGI.escapeHTML(value["flag"].to_s.strip)}</extra-po-flags>
+EOF
+          end
+          xml += <<EOF
+        </message>
+    </context>
+EOF
+        end
+      end
+
+      xml += <<EOF
+</TS>
+EOF
+      xml
+    end
+
+  end
+
+end