translatomatic 0.1.3 → 0.2.0

data/lib/translatomatic/http.rb

@@ -0,0 +1,13 @@
+module Translatomatic
+  # HTTP request functionality
+  module HTTP
+    # @private
+    USER_AGENT = "Translatomatic #{VERSION} (+#{URL})".freeze
+  end
+end
+
+require 'translatomatic/http/exception'
+require 'translatomatic/http/param'
+require 'translatomatic/http/file_param'
+require 'translatomatic/http/request'
+require 'translatomatic/http/client'

data/lib/translatomatic/http/client.rb

@@ -0,0 +1,144 @@
+require 'http-cookie'
+
+module Translatomatic
+  module HTTP
+    # HTTP client
+    class Client
+      def initialize(options = {})
+        @redirects = 0
+        @jar = ::HTTP::CookieJar.new
+        @retry_delay = options[:retry_delay] || 2
+      end
+
+      # Send an HTTP GET request
+      # @param url [String,URI] URL of the request
+      # @param query [Hash<String,String>] Optional query parameters
+      # @param options [Hash<Symbol,Object>] Request options
+      # @return [Net::HTTP::Response]
+      def get(url, query = nil, options = {})
+        send_request_with_method(:get, url, options.merge(query: query))
+      end
+
+      # Send an HTTP POST request
+      # @param url [String,URI] URL of the request
+      # @param body [String,Hash] Body of the request
+      # @param options [Hash<Symbol,Object>] Request options
+      # @return [Net::HTTP::Response]
+      def post(url, body, options = {})
+        send_request_with_method(:post, url, options.merge(body: body))
+      end
+
+      # Send an HTTP HEAD request
+      # @param url [String,URI] URL of the request
+      # @param options [Hash<Symbol,Object>] Request options
+      # @return [Net::HTTP::Response]
+      def head(url, options = {})
+        send_request_with_method(:head, url, options)
+      end
+
+      # Send an HTTP DELETE request
+      # @param url [String,URI] URL of the request
+      # @param options [Hash<Symbol,Object>] Request options
+      # @return [Net::HTTP::Response]
+      def delete(url, options = {})
+        send_request_with_method(:delete, url, options)
+      end
+
+      # Start an HTTP request. Yields the http object.
+      # @param url [String,URI] URL of the request, requires host and port
+      # @return [Object] The result of the yielded block
+      def start(url, _options = {})
+        uri = url.respond_to?(:host) ? url : URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        # http.set_debug_output(Translatomatic.config.logger) if ENV['DEBUG']
+        result = http.start do
+          @http = http
+          yield http
+        end
+        @http = nil
+        result
+      end
+
+      private
+
+      include Util
+
+      MAX_REDIRECTS = 5
+      RETRIABLE = [Net::HTTPServerError, Net::HTTPTooManyRequests].freeze
+      RETRIABLE_CODES = [408].freeze
+
+      # Retry requests on server errors
+      class HttpRetryExecutor < RetryExecutor
+        def retriable?(exception)
+          http_exception?(exception) && retriable_exception?(exception)
+        end
+
+        def http_exception?(exception)
+          exception.is_a?(Translatomatic::HTTP::Exception)
+        end
+
+        def retriable_exception?(exception)
+          RETRIABLE.any? { |i| exception.response.kind_of?(i) } ||
+            RETRIABLE_CODES.include?(exception.response.code.to_i)
+        end
+      end
+
+      def send_request_with_method(method, url, options = {})
+        cookies = ::HTTP::Cookie.cookie_value(@jar.cookies(url))
+        options = options.merge(cookies: cookies) if cookies.present?
+        request = Request.new(method, url, options)
+        send_request(request)
+      end
+
+      def send_request(req)
+        executor = HttpRetryExecutor.new(retry_delay: @retry_delay)
+        executor.run { handle_response(send_request_http(req)) }
+      end
+
+      def send_request_http(req)
+        if @http
+          log.debug("HTTP request: #{req.http_request.uri}")
+          @http.request(req.http_request)
+        else
+          start(req.uri) { |_http| send_request_http(req) }
+        end
+      end
+ 
+      def save_cookies(response)
+        cookies = response.get_fields('set-cookie')
+        return unless cookies
+        cookies.each { |i| @jar.parse(i, response.uri) }
+      end
+
+      def handle_response(response)
+        log.debug("HTTP response: #{response.code} #{response.msg}")
+
+        case response
+        when Net::HTTPSuccess
+          @redirects = 0
+          save_cookies(response)
+          response
+        when Net::HTTPRedirection
+          @redirects += 1
+          raise 'Maximum redirects exceeded' if @redirects > MAX_REDIRECTS
+          new_uri = redirect_uri(response)
+          get(new_uri, nil)
+        else
+          # error
+          @redirects = 0
+          raise Translatomatic::HTTP::Exception, response
+        end
+      end
+
+      def redirect_uri(response)
+        location = URI.parse(response['Location'])
+        if location.relative?
+          response.uri + response.location
+        else
+          location
+        end
+      end
+    end
+  end
+end

data/lib/translatomatic/http/exception.rb

@@ -0,0 +1,43 @@
+module Translatomatic
+  module HTTP
+    # Exception used for unexpected http responses
+    class Exception < StandardError
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      # Exception string
+      def to_s
+        error_from_response(@response) || default_error
+      end
+
+      private
+
+      def default_error
+        "error #{@response.code}"
+      end
+
+      def error_from_response(response)
+        if response.content_type == 'text/html'
+          error_from_html(response.body)
+        elsif response.body.present?
+          response.body
+        end
+      end
+
+      def error_from_html(body)
+        doc = Nokogiri::HTML(body)
+        texts = doc.search('//text()')
+        msg = texts.find { |i| error_from_string(i.content) }
+        msg ? error_from_string(msg.content) : nil
+      end
+
+      def error_from_string(string)
+        match = string.match(/(?:Message|Error):\s*(.*)/i)
+        match ? match[1] : nil
+      end
+    end
+  end
+end

data/lib/translatomatic/http/file_param.rb

@@ -0,0 +1,27 @@
+module Translatomatic
+  module HTTP
+    # 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
+
+      # (see Param#to_s)
+      def to_s
+        header(header_data) +
+          header('Content-Type' => mime_type) + "\r\n#{content}\r\n"
+      end
+
+      private
+
+      def header_data
+        super.merge(filename: %("#{filename}"))
+      end
+    end
+  end
+end

data/lib/translatomatic/http/param.rb

@@ -0,0 +1,37 @@
+module Translatomatic
+  module HTTP
+    # 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
+
+      # @return [String] Representation of this parameter as it appears
+      #   within a multipart post request.
+      def to_s
+        header(header_data) + "\r\n#{value}\r\n"
+      end
+
+      private
+
+      def header_data
+        name = CGI.escape(key.to_s)
+        { 'Content-Disposition' => 'form-data', name: %("#{name}") }
+      end
+
+      def header(options)
+        out = []
+        idx = 0
+        options.each do |key, value|
+          separator = idx.zero? ? ': ' : '='
+          out << "#{key}#{separator}#{value}"
+          idx += 1
+        end
+        out.join('; ') + "\r\n"
+      end
+    end
+  end
+end

data/lib/translatomatic/http/request.rb

@@ -0,0 +1,91 @@
+require 'securerandom'
+require 'net/http'
+
+module Translatomatic
+  module HTTP
+    # HTTP request
+    # wrapper for Net::HTTP functionality
+    class Request
+      # @return [String] the text to use to denote multipart boundaries. By
+      #   default, a random hexadecimal string is used.
+      attr_accessor :multipart_boundary
+
+      # @return [String] the HTTP body
+      attr_accessor :body
+
+      # @return [URI] the URI of the request
+      attr_reader :uri
+
+      # @return [String] the HTTP method
+      attr_reader :method
+
+      # @param method [Symbol] HTTP method
+      # @param url [String,URI] URL of the request
+      # @return [Translatomatic::HTTPRequest] Create a new request
+      def initialize(method, url, options = {})
+        @method = method
+        @options = options
+        @uri = url.respond_to?(:host) ? url.dup : URI.parse(url)
+        query = options[:query]
+        @uri.query = URI.encode_www_form(query) if query
+        @multipart_boundary = generate_multipart_boundary
+        @body = @options[:body]
+      end
+
+      # @return [Object] The request object for use with Net::HTTP
+      def http_request
+        @request ||= create_request
+      end
+
+      private
+
+      def generate_multipart_boundary
+        SecureRandom.hex(16)
+      end
+
+      def multipartify(parts)
+        string_parts = parts.collect do |i|
+          part = paramify(i)
+          '--' + @multipart_boundary + "\r\n" + part.to_s
+        end
+        string_parts.join('') + '--' + @multipart_boundary + "--\r\n"
+      end
+
+      def paramify(object)
+        return object if object.is_a?(Param) || object.is_a?(FileParam)
+        raise 'invalid multipart parameter' unless object.is_a?(Hash)
+        object[:filename] ? FileParam.new(object) : Param.new(object)
+      end
+
+      def create_request
+        klass = Net::HTTP.const_get(@method.to_s.classify)
+        request = klass.new(@uri)
+        request['User-Agent'] = USER_AGENT
+
+        (@options[:headers] || {}).each do |key, value|
+          request[key] = value
+        end
+
+        request['Cookie'] = @options[:cookies] if @options[:cookies]
+
+        content_type = @options[:content_type]
+
+        if body
+          if @options[:multipart] || body.is_a?(Array)
+            boundary = "boundary=#{@multipart_boundary}"
+            content_type = 'multipart/form-data; ' + boundary
+            request.body = multipartify(body)
+          elsif body.is_a?(Hash)
+            # set_form_data does url encoding
+            request.set_form_data(body)
+          else
+            request.body = body
+          end
+        end
+
+        request.content_type = content_type if content_type
+        request
+      end
+    end
+  end
+end

data/lib/translatomatic/i18n.rb

@@ -0,0 +1,43 @@
+require 'i18n'
+require 'rails_i18n' # date/time/currency formats
+
+module Translatomatic
+  # I18n initialisation and translation fallback handling
+  class I18n
+    class << self
+      # Get string translation
+      # @param key translation key
+      def t(key, options = {})
+        tkey = "translatomatic.#{key}"
+        raise "missing translation: #{tkey}" unless ::I18n.exists?(tkey)
+
+        ::I18n.t(tkey, options.merge(locale: t_locale(options)))
+      end
+
+      # Localises dates and numbers to local formatting
+      # @param object [Object] Object to localise
+      def l(object, options = {})
+        ::I18n.l(object, options)
+      end
+
+      private
+
+      FALLBACK_LOCALE = 'en'.freeze
+
+      def init_i18n(root_path)
+        locale_path = File.join(root_path, 'config', 'locales')
+        ::I18n.load_path += Dir[File.join(locale_path, '**', '*.yml')]
+      end
+
+      def t_locale(options)
+        locale = options[:locale] || Locale.default.to_s
+        locale = FALLBACK_LOCALE unless ::I18n.locale_available?(locale)
+        locale
+      end
+    end
+
+    begin
+      init_i18n(File.join(__dir__, '..', '..'))
+    end
+  end
+end

data/lib/translatomatic/locale.rb

@@ -1,76 +1,88 @@
-# Represents a locale
-# @see https://en.wikipedia.org/wiki/Locale_(computer_software)
-class Translatomatic::Locale
+require 'i18n_data'
 
-  # @return [String] ISO 639-1 language
-  attr_reader :language
+module Translatomatic
+  # Represents a locale
+  # @see https://en.wikipedia.org/wiki/Locale_(computer_software)
+  class Locale
+    # @return [String] ISO 639-1 language
+    attr_reader :language
 
-  # @return [String] ISO 15924 script
-  attr_reader :script
+    # @return [String] ISO 15924 script
+    attr_reader :script
 
-  # @return [String] ISO 3166-1 alpha-2 country code
-  attr_reader :region
+    # @return [String] ISO 3166-1 alpha-2 country code
+    attr_reader :region
 
-  # Parse the given tag
-  # @param tag [String] A string representing a locale
-  # @param validate [boolean] If true, return nil if the locale is invalid
-  # @return [Locale] A locale object
-  def self.parse(tag, validate = true)
-    return nil if tag.nil?
+    class << self
+      # @return [Locale] The default locale
+      attr_accessor :default
 
-    locale = tag
-    unless tag.kind_of?(Translatomatic::Locale)
-      tag = tag.to_s.gsub(/_/, '-')
-      locale = new(tag)
-    end
-    validate && !locale.valid? ? nil : locale
-  end
+      # Parse the given tag
+      # @param tag [String] A string representing a locale
+      # @param validate [boolean] If true, return nil if the locale is invalid
+      # @return [Locale] A locale object
+      def parse(tag, validate = true)
+        return nil if tag.nil?
 
-  # @return [Locale] the default locale
-  def self.default
-    parse(Translatomatic.config.default_locale)
-  end
+        locale = tag
+        unless tag.is_a?(Translatomatic::Locale)
+          tag = tag.to_s.tr('_', '-')
+          locale = new(tag)
+        end
+        validate && !locale.valid? ? nil : locale
+      end
 
-  # @return [Locale] create a new locale object
-  def initialize(tag)
-    data = I18n::Locale::Tag::Rfc4646.tag(tag)
-    if data
-      @language = data.language
-      @script = data.script
-      @region = data.region
+      # @return [Array<String>] A list of ISO 639-1 language codes
+      def language_codes
+        VALID_LANGUAGES
+      end
     end
-  end
 
-  # @return true if language is a valid ISO 639-1 language
-  def valid?
-    VALID_LANGUAGES.include?(language)
-  end
+    # @return [Locale] create a new locale object
+    def initialize(tag)
+      data = ::I18n::Locale::Tag::Rfc4646.tag(tag)
+      if data
+        @language = data.language
+        @script = data.script
+        @region = data.region
+      end
+    end
 
-  # @return [String] Locale as a string
-  def to_s
-    [language, script, region].compact.join("-")
-  end
+    # @return true if language is a valid ISO 639-1 language
+    def valid?
+      VALID_LANGUAGES.include?(language)
+    end
 
-  # @param other [Object] Another object
-  # @return [boolean] true if the other object is a {Translatomatic::Locale}
-  #   object and has equal language, script and region.
-  def eql?(other)
-    other.kind_of?(Translatomatic::Locale) && other.hash == hash
-  end
+    # @return [String] Locale as a string
+    def to_s
+      [language, script, region].compact.join('-')
+    end
 
-  # (see #eql?)
-  def ==(other)
-    eql?(other)
-  end
+    # @param other [Object] Another object
+    # @return [boolean] true if the other object is a {Translatomatic::Locale}
+    #   object and has equal language, script and region.
+    def eql?(other)
+      other.is_a?(Translatomatic::Locale) && other.hash == hash
+    end
 
-  # @!visibility private
-  def hash
-    [language, script, region].hash
-  end
+    # (see #eql?)
+    def ==(other)
+      eql?(other)
+    end
 
-  private
+    # @!visibility private
+    def hash
+      [language, script, region].hash
+    end
 
-  # list of 2 letter country codes
-  VALID_LANGUAGES = ::I18nData.languages.keys.collect { |i| i.downcase }.sort
+    # list of 2 letter country codes
+    VALID_LANGUAGES = ::I18nData.languages.keys.collect(&:downcase).sort.freeze
+    private_constant :VALID_LANGUAGES
 
+    begin
+      # get default locale from the environment
+      lang = (ENV['LANG'] || '').split(/\./)[0]
+      self.default = parse(lang) || parse('en')
+    end
+  end
 end