translatomatic 0.1.3 → 0.2.0

data/lib/translatomatic/http_request.rb

@@ -1,162 +0,0 @@
-require 'securerandom'
-require 'net/http'
-
-module Translatomatic
-  # HTTP request
-  # wrapper for Net::HTTP functionality
-  class HTTPRequest
-
-    # @return [String] the text to use to denote multipart boundaries. By
-    #   default, a random hexadecimal string is used.
-    attr_accessor :multipart_boundary
-
-    # @param url [String,URI] URL of the request
-    # @return [Translatomatic::HTTPRequest] Create a new request
-    def initialize(url)
-      @uri = url.respond_to?(:host) ? url : URI.parse(url)
-      @multipart_boundary = SecureRandom.hex(16)
-    end
-
-    # Start the HTTP request. Yields a http object.
-    # @param options [Hash<Symbol,Object>] Request options
-    # @return [Object] Result of the block
-    def start(options = {})
-      options = options.merge(use_ssl: @uri.scheme == "https")
-      result = nil
-      Net::HTTP.start(@uri.host, @uri.port, options) do |http|
-        @http = http
-        result = yield http
-      end
-      @http = nil
-      result
-    end
-
-    # Send a HTTP GET request
-    # @param query [Hash<String,String>] Optional query parameters
-    # @return [Net::HTTP::Response]
-    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
-
-    # Send an HTTP POST request
-    # @param body [String,Hash] Body of the request
-    # @return [Net::HTTP::Response]
-    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)
-        # set_form_data does url encoding
-        request.set_form_data(body)
-      else
-        request.body = body
-      end
-      request.content_type = content_type if content_type
-
-      send_request(request)
-    end
-
-    # Create a file parameter for a multipart POST request
-    # @return [FileParam] A new file parameter
-    def file(*args)
-      FileParam.new(*args)
-    end
-
-    # Create a parameter for a multipart POST request
-    # @return [Param] A new parameter
-    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
-
-      # @return [String] Representation of this parameter as it appears
-      #   within a multipart post request.
-      def to_s
-        return header(header_data) + "\r\n#{value}\r\n"
-      end
-
-      private
-
-      def initialize(key:, value:)
-        @key = key
-        @value = value
-      end
-
-      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
-
-      # (see Param#to_s)
-      def to_s
-        return header(header_data) +
-          header("Content-Type": mime_type) + "\r\n#{content}\r\n"
-      end
-
-      private
-
-      def initialize(key:, filename:, content:, mime_type:)
-        @key = key
-        @filename = filename
-        @content = content
-        @mime_type = mime_type
-      end
-
-      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)
-      if @http
-        response = @http.request(req)
-      else
-        response = start { |http| http.request(req) }
-      end
-      raise response.body unless response.kind_of? Net::HTTPSuccess
-      response
-    end
-
-  end # class
-end   # module

data/lib/translatomatic/string.rb

@@ -1,188 +0,0 @@
-module Translatomatic
-  # A string object with an associated locale.
-  class String
-
-    # @return [String] The string
-    attr_reader :value
-
-    # @return [Translatomatic::Locale] The string's locale
-    attr_reader :locale
-
-    # @return [Translatomatic::String] If this string is a substring of
-    #   another string, returns the original string. Otherwise, returns nil.
-    attr_reader :parent
-
-    # @return [Number] If this string is a substring of another string,
-    #   returns the starting offset of this string in the original.
-    attr_reader :offset
-
-    def initialize(value, locale, options = {})
-      @value = value.to_s || ''
-      @locale = Translatomatic::Locale.parse(locale)
-      @offset = options[:offset] || 0
-      @parent = options[:parent]
-    end
-
-    # @return [String] The value of the string
-    def to_s
-      @value
-    end
-
-    # @return [Number] The length of the string
-    def length
-      @value.length
-    end
-
-    # @return [boolean] True if the string is empty
-    def empty?
-      @value.empty?
-    end
-
-    # Invokes value.match
-    # @param pattern [Regexp,String] The regex pattern to match
-    # @return [MatchData] Object describing the match, or nil if no match
-    def match(pattern)
-      @value.match(pattern)
-    end
-
-    # @return [boolean] true if this string is a substring of another string
-    def substring?
-      @parent ? true : false
-    end
-
-    # @return [Symbol] The type of string, corresponding to TMX segtype.
-    # @see http://xml.coverpages.org/tmxSpec971212.html#SEGTYPE
-    def type
-      if sentences.length >= 2
-        :paragraph
-      else
-        script = script_data
-        @value.strip.match(/#{script.delimiter}\s*$/) ? :sentence : :phrase
-      end
-    end
-
-    # Find all sentences in the string
-    # @return [Array<Translatomatic::String] List of sentences
-    def sentences
-      substrings(sentence_regex)
-    end
-
-    # Find all substrings matching the given regex
-    # @return [Array<Translatomatic::String] List of substrings
-    def substrings(regex)
-      matches = matches(@value, regex)
-      strings = []
-      matches.each do |match|
-        substring = match.to_s
-        # find leading and trailing whitespace
-        next if substring.length == 0
-
-        parts = substring.match(/\A(\s*)(.*?)(\s*)\z/m).to_a
-        value = parts[2]
-        offset = match.offset(0)[0]
-        offset += parts[1].length  # leading whitespace
-        strings << self.class.new(value, locale, offset: offset, parent: self)
-      end
-
-      # return [self] if there's only one substring and it's equal to self
-      strings.length == 1 && strings[0].eql?(self) ? [self] : strings
-    end
-
-    # @return [boolean] true if other is a {Translatomatic::String} with
-    #   the same value and locale.
-    def eql?(other)
-      other.kind_of?(Translatomatic::String) && other.hash == hash
-    end
-
-    # (see #eql?)
-    def ==(other)
-      eql?(other)
-    end
-
-    # @!visibility private
-    def hash
-      [value, locale].hash
-    end
-
-    private
-
-    # @!visibility private
-    class Script
-      attr_reader :language
-      attr_reader :delimiter      # sentence delimiter
-      attr_reader :trailing_space # delimiter requires trailing space or eol
-      attr_reader :left_to_right  # script direction
-
-      def initialize(language:, delimiter:, trailing_space:, direction:)
-        @language = language
-        @delimiter = delimiter
-        @trailing_space = trailing_space
-        @left_to_right = direction == :ltr
-        raise "invalid direction" unless [:ltr, :rtl].include?(direction)
-      end
-    end
-
-    SCRIPT_DATA = [
-      # [language, delimiter, trailing space, direction]
-      # japanese, no space after
-      ["ja", "\u3002", false, :ltr],
-      # chinese, no space after
-      ["zh", "\u3002", false, :ltr],  # can be written any direction
-       # armenian, space after
-      ["hy", ":", true, :ltr],
-      # hindi, space after
-      ["hi", "।", true, :ltr],
-      # urdu, space after, right to left
-      ["ur", "\u06d4", true, :rtl],
-      # thai, spaces used to separate sentences
-      ["th", "\\s", false, :ltr],
-      # arabic, right to left
-      ["ar", "\\.", true, :rtl],
-      # hebrew, right to left
-      ["he", "\\.", true, :rtl],
-      # all other languages
-      ["default", "\\.", true, :ltr],
-    ]
-
-    class << self
-      attr_reader :script_data
-    end
-
-    begin
-      script_data = {}
-      SCRIPT_DATA.each do |lang, delimiter, trailing, ltr|
-        script = Script.new(language: lang, delimiter: delimiter,
-          trailing_space: trailing, direction: ltr)
-        script_data[lang] = script
-      end
-      @script_data = script_data
-    end
-
-    def matches(s, re)
-      start_at = 0
-      matches = []
-      while(m = s.match(re, start_at))
-        break if m.to_s.empty?
-        matches.push(m)
-        start_at = m.end(0)
-      end
-      matches
-    end
-
-    def sentence_regex
-      script = script_data
-      if script.trailing_space
-        regex = /.*?(?:#{script.delimiter}\s+|\z)/m
-      else
-        # no trailing space after delimiter
-        regex = /.*?(?:#{script.delimiter}|\z)/m
-      end
-    end
-
-    def script_data
-      data = self.class.script_data
-      data[locale.language] || data["default"]
-    end
-
-  end
-end

data/lib/translatomatic/translation_result.rb

@@ -1,86 +0,0 @@
-require 'set'
-
-module Translatomatic
-  # Stores results of a translation
-  class TranslationResult
-
-    # @return [Translatomatic::ResourceFile::Base] The resource file
-    attr_reader :file
-
-    # @return [Hash<String,String>] Translation results
-    attr_reader :properties
-
-    # @return [Locale] The locale of the original strings
-    attr_reader :from_locale
-
-    # @return [Locale] The target locale
-    attr_reader :to_locale
-
-    # @return [Set<String>] Untranslated strings
-    attr_reader :untranslated
-
-    # Create a translation result
-    # @param file [Translatomatic::ResourceFile::Base] A resource file
-    # @param to_locale [Locale] The target locale
-    def initialize(file, to_locale)
-      @file = file
-      @value_to_keys = {}
-      @untranslated = Set.new
-      @from_locale = file.locale
-      @to_locale = to_locale
-
-      # duplicate strings
-      @properties = file.properties.transform_values { |i| i.dup }
-
-      @properties.each do |key, value|
-        # split property value into sentences
-        string = string(value, from_locale)
-        string.sentences.each do |sentence|
-          @untranslated << sentence
-          keylist = (@value_to_keys[sentence.to_s] ||= [])
-          keylist << key
-        end
-      end
-    end
-
-    # Update result with a list of translated strings.
-    # @param translations [Array<Translatomatic::Translation>] Translations
-    # @return [void]
-    def update_strings(translations)
-      # sort translation list by largest offset first so that we replace
-      # from the end of the string to the front, so substring offsets
-      # are correct in the target string.
-
-      #translations.sort_by! do |translation|
-      #  t1 = translation.original
-      #  t1.respond_to?(:offset) ? -t1.offset : 0
-      #end
-      translations.sort_by! { |t| -t.original.offset }
-
-      translations.each do |translation|
-        update(translation.original, translation.result)
-      end
-    end
-
-    private
-
-    include Translatomatic::Util
-
-    def update(original, translated)
-      keys = @value_to_keys[original.to_s]
-      raise "no key mapping for text '#{original}'" unless keys
-      keys.each do |key|
-        #value = @properties[key]
-        if original.kind_of?(Translatomatic::String) && original.substring?
-          #log.debug("#{value[original.offset, original.length]} -> #{translated}")
-          @properties[key][original.offset, original.length] = translated
-        else
-          #log.debug("#{key} -> #{translated}")
-          @properties[key] = translated
-        end
-      end
-
-      @untranslated.delete(original) unless translated.nil?
-    end
-  end
-end

data/lib/translatomatic/translation_stats.rb

@@ -1,31 +0,0 @@
-# Translation statistics
-class Translatomatic::TranslationStats
-  include Translatomatic::Util
-
-  # @return [Array<Translatomatic::Translation>] A list of all translations
-  attr_reader :translations
-
-  # @return [Number] The number of translations that came from the database.
-  attr_reader :from_db
-
-  # @return [Number] The number of translations that came from the translator.
-  attr_reader :from_translator
-
-  # @return [Number] The number of untranslated strings
-  attr_reader :untranslated
-
-  private
-
-  def initialize(translations)
-    @translations = translations.values
-    @from_db = @translations.count { |i| i.from_database && i.result }
-    @from_translator = @translations.count { |i| !i.from_database && i.result }
-    @untranslated = @translations.count { |i| i.result == nil }
-  end
-
-  def to_s
-    t("file_translator.total_translations", total: @translations.length,
-      from_db: @from_db, from_translator: @from_translator,
-      untranslated: @untranslated)
-  end
-end