translatomatic 0.1.0 → 0.1.1

data/lib/translatomatic/escaped_unicode.rb

@@ -1,90 +1,90 @@
-# Module to encode and decode unicode chars.
-# This code is highly influced by Florian Frank's JSON gem
-# @see https://github.com/jnbt/java-properties
-# @see https://github.com/flori/json/
-
-module Translatomatic::EscapedUnicode
-
-  # Decodes all unicode chars from escape sequences
-  # @param text [String]
-  # @return [String] The encoded text for chaining
-  def self.unescape(text)
-    string = text.dup
-    string = string.gsub(%r((?:\\[uU](?:[A-Fa-f\d]{4}))+)) do |c|
-      c.downcase!
-      bytes = EMPTY_8BIT_STRING.dup
-      i = 0
-      while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
-        bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
-        i += 1
-      end
-      bytes.encode("utf-8", "utf-16be")
-    end
-    string.force_encoding(::Encoding::UTF_8)
-
-    text.replace string
-    text
-  end
-
-  # Decodes all unicode chars into escape sequences
-  # @param text [String]
-  # @return [String] The decoded text for chaining
-  def self.escape(text)
-    string = text.dup
-    string.force_encoding(::Encoding::ASCII_8BIT)
-    string.gsub!(/["\\\x0-\x1f]/n) { |c| MAP[c] || c }
-    string.gsub!(/(
-      (?:
-        [\xc2-\xdf][\x80-\xbf]    |
-        [\xe0-\xef][\x80-\xbf]{2} |
-        [\xf0-\xf4][\x80-\xbf]{3}
-        )+ |
-        [\x80-\xc1\xf5-\xff]       # invalid
-        )/nx) { |c|
-          c.size == 1 and raise "Invalid utf8 byte: '#{c}'"
-          s = c.encode("utf-16be", "utf-8").unpack('H*')[0]
-          s.force_encoding(::Encoding::ASCII_8BIT)
-          s.gsub!(/.{4}/n, '\\\\u\&')
-          s.force_encoding(::Encoding::UTF_8)
-        }
-    string.force_encoding(::Encoding::UTF_8)
-    text.replace string
-    text
-  end
-
-  private
-
-  MAP = {
-    "\x0" => '\u0000',
-    "\x1" => '\u0001',
-    "\x2" => '\u0002',
-    "\x3" => '\u0003',
-    "\x4" => '\u0004',
-    "\x5" => '\u0005',
-    "\x6" => '\u0006',
-    "\x7" => '\u0007',
-    "\xb" => '\u000b',
-    "\xe" => '\u000e',
-    "\xf" => '\u000f',
-    "\x10" => '\u0010',
-    "\x11" => '\u0011',
-    "\x12" => '\u0012',
-    "\x13" => '\u0013',
-    "\x14" => '\u0014',
-    "\x15" => '\u0015',
-    "\x16" => '\u0016',
-    "\x17" => '\u0017',
-    "\x18" => '\u0018',
-    "\x19" => '\u0019',
-    "\x1a" => '\u001a',
-    "\x1b" => '\u001b',
-    "\x1c" => '\u001c',
-    "\x1d" => '\u001d',
-    "\x1e" => '\u001e',
-    "\x1f" => '\u001f',
-  }
-
-  EMPTY_8BIT_STRING = ''
-  EMPTY_8BIT_STRING.force_encoding(::Encoding::ASCII_8BIT)
-
-end
+# Module to encode and decode unicode chars.
+# This code is highly influced by Florian Frank's JSON gem
+# @see https://github.com/jnbt/java-properties
+# @see https://github.com/flori/json/
+
+module Translatomatic::EscapedUnicode
+
+  # Decodes all unicode chars from escape sequences
+  # @param text [String]
+  # @return [String] The encoded text for chaining
+  def self.unescape(text)
+    string = text.dup
+    string = string.gsub(%r((?:\\[uU](?:[A-Fa-f\d]{4}))+)) do |c|
+      c.downcase!
+      bytes = EMPTY_8BIT_STRING.dup
+      i = 0
+      while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
+        bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
+        i += 1
+      end
+      bytes.encode("utf-8", "utf-16be")
+    end
+    string.force_encoding(::Encoding::UTF_8)
+
+    text.replace string
+    text
+  end
+
+  # Decodes all unicode chars into escape sequences
+  # @param text [String]
+  # @return [String] The decoded text for chaining
+  def self.escape(text)
+    string = text.dup
+    string.force_encoding(::Encoding::ASCII_8BIT)
+    string.gsub!(/["\\\x0-\x1f]/n) { |c| MAP[c] || c }
+    string.gsub!(/(
+      (?:
+        [\xc2-\xdf][\x80-\xbf]    |
+        [\xe0-\xef][\x80-\xbf]{2} |
+        [\xf0-\xf4][\x80-\xbf]{3}
+        )+ |
+        [\x80-\xc1\xf5-\xff]       # invalid
+        )/nx) { |c|
+          c.size == 1 and raise "Invalid utf8 byte: '#{c}'"
+          s = c.encode("utf-16be", "utf-8").unpack('H*')[0]
+          s.force_encoding(::Encoding::ASCII_8BIT)
+          s.gsub!(/.{4}/n, '\\\\u\&')
+          s.force_encoding(::Encoding::UTF_8)
+        }
+    string.force_encoding(::Encoding::UTF_8)
+    text.replace string
+    text
+  end
+
+  private
+
+  MAP = {
+    "\x0" => '\u0000',
+    "\x1" => '\u0001',
+    "\x2" => '\u0002',
+    "\x3" => '\u0003',
+    "\x4" => '\u0004',
+    "\x5" => '\u0005',
+    "\x6" => '\u0006',
+    "\x7" => '\u0007',
+    "\xb" => '\u000b',
+    "\xe" => '\u000e',
+    "\xf" => '\u000f',
+    "\x10" => '\u0010',
+    "\x11" => '\u0011',
+    "\x12" => '\u0012',
+    "\x13" => '\u0013',
+    "\x14" => '\u0014',
+    "\x15" => '\u0015',
+    "\x16" => '\u0016',
+    "\x17" => '\u0017',
+    "\x18" => '\u0018',
+    "\x19" => '\u0019',
+    "\x1a" => '\u001a',
+    "\x1b" => '\u001b',
+    "\x1c" => '\u001c',
+    "\x1d" => '\u001d',
+    "\x1e" => '\u001e',
+    "\x1f" => '\u001f',
+  }
+
+  EMPTY_8BIT_STRING = ''
+  EMPTY_8BIT_STRING.force_encoding(::Encoding::ASCII_8BIT)
+
+end

data/lib/translatomatic/extractor/base.rb

@@ -0,0 +1,14 @@
+module Translatomatic::Extractor
+  class Base
+
+    def initialize(path)
+      @path = path.kind_of?(Pathname) ? path : Pathname.new(path)
+      @contents = @path.read
+    end
+
+    def extract
+      @contents.scan(/\"(.*?[^\\])"|'(.*?[^\\])'/).flatten.compact
+    end
+
+  end
+end

data/lib/translatomatic/extractor/ruby.rb

@@ -0,0 +1,5 @@
+module Translatomatic::Extractor
+  class Ruby < Base
+
+  end # class
+end   # module

data/lib/translatomatic/extractor.rb

@@ -0,0 +1,4 @@
+module Translatomatic::Extractor; end
+
+require 'translatomatic/extractor/base'
+require 'translatomatic/extractor/ruby'

data/lib/translatomatic/http_request.rb

@@ -0,0 +1,133 @@
+require 'securerandom'
+require 'net/http'
+
+module Translatomatic
+  class HTTPRequest
+
+    attr_accessor :multipart_boundary
+
+    def initialize(url)
+      @uri = url.respond_to?(:host) ? url : URI.parse(url)
+      @multipart_boundary = SecureRandom.hex(16)
+    end
+
+    def start(options = {})
+      options = options.merge(use_ssl: @uri.scheme == "https")
+      Net::HTTP.start(@uri.host, @uri.port, options) do |http|
+        @http = http
+        yield http
+      end
+      @http = nil
+    end
+
+    def get(query = nil)
+      uri = @uri
+      if query
+        uri = @uri.dup
+        uri.query = URI.encode_www_form(query)
+      end
+      request = Net::HTTP::Get.new(uri)
+      request['User-Agent'] = USER_AGENT
+      send_request(request)
+    end
+
+    def post(body, options = {})
+      request = Net::HTTP::Post.new(@uri)
+      request['User-Agent'] = USER_AGENT
+      content_type = options[:content_type]
+
+      if options[:multipart]
+        content_type = "multipart/form-data; boundary=#{@multipart_boundary}"
+        request.body = multipartify(body)
+      elsif body.kind_of?(Hash)
+        request.set_form_data(body)
+      else
+        request.body = body
+      end
+      request.content_type = content_type if content_type
+
+      send_request(request)
+    end
+
+    def file(*args)
+      FileParam.new(*args)
+    end
+
+    def param(*args)
+      Param.new(*args)
+    end
+
+    private
+
+    USER_AGENT = "Translatomatic #{VERSION} (+#{URL})"
+
+    # Formats a basic string key/value pair for a multipart post
+    class Param
+      attr_accessor :key, :value
+
+      def initialize(key:, value:)
+        @key = key
+        @value = value
+      end
+
+      def to_s
+        return header(header_data) + "\r\n#{value}\r\n"
+      end
+
+      private
+
+      def header_data
+        name = CGI::escape(key.to_s)
+        { "Content-Disposition": "form-data", name: %Q("#{name}") }
+      end
+
+      def header(options)
+        out = []
+        idx = 0
+        options.each do |key, value|
+          separator = idx == 0 ? ": " : "="
+          out << "#{key}#{separator}#{value}"
+          idx += 1
+        end
+        out.join("; ") + "\r\n"
+      end
+    end
+
+    # Formats the contents of a file or string for a multipart post
+    class FileParam < Param
+      attr_accessor :filename, :content, :mime_type
+
+      def initialize(key:, filename:, content:, mime_type:)
+        @key = key
+        @filename = filename
+        @content = content
+        @mime_type = mime_type
+      end
+
+      def to_s
+        return header(header_data) +
+          header("Content-Type": mime_type) + "\r\n#{content}\r\n"
+      end
+
+      private
+
+      def header_data
+        super.merge({ filename: %Q("#{filename}") })
+      end
+    end
+
+    def multipartify(parts)
+      string_parts = parts.collect do |p|
+        "--" + @multipart_boundary + "\r\n" + p.to_s
+      end
+      string_parts.join("") + "--" + @multipart_boundary + "--\r\n"
+    end
+
+    def send_request(req)
+      response = @http.request(req)
+      raise response.body unless response.kind_of? Net::HTTPSuccess
+      response
+    end
+
+  end # class
+end   # module

data/lib/translatomatic/locale.rb

@@ -0,0 +1,52 @@
+class Translatomatic::Locale
+
+  attr_reader :language
+  attr_reader :script
+  attr_reader :region
+
+  def self.parse(tag, validate = true)
+    locale = tag.kind_of?(Translatomatic::Locale) ? tag : new(tag)
+    validate && !locale.valid? ? nil : locale
+  end
+
+  def self.default
+    DEFAULT_LOCALE
+  end
+
+  def initialize(tag)
+    data = I18n::Locale::Tag::Rfc4646.tag(tag)
+    if data
+      @language = data.language
+      @script = data.script
+      @region = data.region
+    end
+  end
+
+  def valid?
+    # test if lang is a valid ISO 639-1 language
+    VALID_LANGUAGES.include?(language)
+  end
+
+  def to_s
+    [language, script, region].compact.join("-")
+  end
+
+  def eql?(other)
+    other.kind_of?(Translatomatic::Locale) && other.hash == hash
+  end
+
+  def ==(other)
+    eql?(other)
+  end
+
+  def hash
+    [language, script, region].hash
+  end
+
+  private
+
+  # list of 2 letter country codes
+  VALID_LANGUAGES = ::I18nData.languages.keys.collect { |i| i.downcase }.sort
+  DEFAULT_LOCALE = parse(I18n.default_locale)
+
+end

data/lib/translatomatic/logger.rb

@@ -0,0 +1,28 @@
+class Translatomatic::Logger
+  attr_accessor :progressbar
+
+  def initialize
+    @logger = Logger.new(STDOUT)
+    @logger.level = ENV['DEBUG'] ? Logger::DEBUG : Logger::INFO
+    @logger.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+  end
+
+  def method_missing(name, *args)
+    handle_logger_method(name, args) if @logger.respond_to?(name)
+  end
+
+  def finish
+    @progressbar.finish if @progressbar
+  end
+
+  private
+
+  def handle_logger_method(name, args)
+    @progressbar.clear if @progressbar
+    @logger.send(name, *args)
+    @progressbar.refresh(force: true) if @progressbar && !@progressbar.stopped?
+  end
+
+end

data/lib/translatomatic/model/locale.rb

@@ -1,22 +1,21 @@
-module Translatomatic
-  module Model
-    class Locale < ActiveRecord::Base
-      has_many :texts, class_name: "Translatomatic::Model::Text"
-      validates_presence_of :language
-      validates_uniqueness_of :language, scope: [:script, :region]
-
-      class << self
-        include Translatomatic::Util
-      end
-
-      # create a locale record from an I18n::Locale::Tag object or string
-      def self.from_tag(tag)
-        tag = parse_locale(tag) if tag.kind_of?(String)
-        find_or_create_by!({
-          language: tag.language, script: tag.script, region: tag.region
-        })
-      end
-
-    end
-  end
-end
+module Translatomatic
+  module Model
+    class Locale < ActiveRecord::Base
+      has_many :texts, class_name: "Translatomatic::Model::Text"
+      validates_presence_of :language
+      validates_uniqueness_of :language, scope: [:script, :region]
+
+      # create a locale record from an I18n::Locale::Tag object or string
+      def self.from_tag(tag)
+        tag = Translatomatic::Locale.parse(tag)
+        find_or_create_by!({
+          language: tag.language, script: tag.script, region: tag.region
+        })
+      end
+
+      def to_s
+        [language, script, region].compact.join("-")
+      end
+    end
+  end
+end

data/lib/translatomatic/model/text.rb

@@ -1,13 +1,17 @@
-module Translatomatic
-  module Model
-    class Text < ActiveRecord::Base
-      belongs_to :locale, class_name: "Translatomatic::Model::Locale"
-      belongs_to :from_text, class_name: "Translatomatic::Model::Text"
-      has_many :translations, class_name: "Translatomatic::Model::Text",
-        foreign_key: :from_text_id, dependent: :delete_all
-
-      validates_presence_of :value
-      validates_presence_of :locale
-    end
-  end
-end
+module Translatomatic
+  module Model
+    class Text < ActiveRecord::Base
+      belongs_to :locale, class_name: "Translatomatic::Model::Locale"
+      belongs_to :from_text, class_name: "Translatomatic::Model::Text"
+      has_many :translations, class_name: "Translatomatic::Model::Text",
+        foreign_key: :from_text_id, dependent: :delete_all
+
+      validates_presence_of :value
+      validates_presence_of :locale
+
+      def is_translated?
+        !from_text_id.nil?
+      end
+    end
+  end
+end

data/lib/translatomatic/model.rb

@@ -1,4 +1,4 @@
-module Translatomatic::Model; end
-
-require 'translatomatic/model/locale'
-require 'translatomatic/model/text'
+module Translatomatic::Model; end
+
+require 'translatomatic/model/locale'
+require 'translatomatic/model/text'

data/lib/translatomatic/option.rb

@@ -1,24 +1,24 @@
-module Translatomatic
-  class Option
-    attr_reader :name, :required, :use_env, :description
-
-    def initialize(data = {})
-      @name = data[:name]
-      @required = data[:required]
-      @use_env = data[:use_env]
-      @description = data[:desc]
-      @data = data
-    end
-
-    def to_hash
-      @data
-    end
-  end
-
-  module DefineOptions
-    private
-    def define_options(*options)
-      @options = options.collect { |i| Translatomatic::Option.new(i) }
-    end
-  end
-end
+module Translatomatic
+  class Option
+    attr_reader :name, :required, :use_env, :description
+
+    def initialize(data = {})
+      @name = data[:name]
+      @required = data[:required]
+      @use_env = data[:use_env]
+      @description = data[:desc]
+      @data = data
+    end
+
+    def to_hash
+      @data
+    end
+  end
+
+  module DefineOptions
+    private
+    def define_options(*options)
+      @options = options.collect { |i| Translatomatic::Option.new(i) }
+    end
+  end
+end

data/lib/translatomatic/progress_updater.rb

@@ -0,0 +1,15 @@
+# implements Converter listener
+class Translatomatic::ProgressUpdater
+  def initialize(progressbar)
+    @progressbar = progressbar
+  end
+
+  def translated_texts(texts)
+    @progressbar.progress += texts.length
+  end
+
+  def untranslated_texts(texts)
+    @progressbar.total -= texts.length
+  end
+
+end