yat 0.0.4 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4e9cfdb16b8ab275ceff26d62dfcfb194862c84
-  data.tar.gz: cb74a19f8be0afe8980dcafa991dab706b90ac4c
+  metadata.gz: fbcc2afae3d9016de309bd5c26b1febb13866b39
+  data.tar.gz: abe84701ed8d460ffc85045291566834a61072d6
 SHA512:
-  metadata.gz: 8a6350dd4f6341b648dbdfb2bee403f87050bcb97f42db42b26a3aeb3cb7b8f79c2514c6c74d2597492df58e431f8d087e31b6dd6906113c4500094793b040cd
-  data.tar.gz: 41abbaef831db0abe1f688807684703dc999e63c354fc67a2ea50c47dd28ecf90884c90bf57f1cad92a301307a236952136256f5bd9d5ecd6ebfd09d33fa3b52
+  metadata.gz: 20edee48855c245e26da299f55934097bb6ed3a6ffd0389eb7cfa06afc0f2fe163c96ecd9e7c4f2e7f9d926c7662e3d4a3336bd27a7bc55ba3f14562fdda9554
+  data.tar.gz: 1e60d5975dfb2419636611e01244108b7ba4690b929f52408f8a907a2b3e13baa75695c8c5e1a2584ef75cb3ef097f6686f7c26025b3b83f5f883a28ba809392

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1,7 @@
+task :test, [:key] do |t, args|
+  if args.key.nil?
+    $stderr.puts "usage: rake test[<api_key>]" && exit
+  end
+
+  sh "TRANSLATOR_KEY=#{args.key} rspec test/*"
+end

data/bin/yat

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
-require_relative "../lib/yat.rb"
-
+require 'yat.rb'
 require 'yaml'
 require 'getoptlong'
 
@@ -10,6 +9,8 @@ $EXIT_OK = 0
 $EXIT_ECMDLINE = 3
 $EXIT_EFAIL = 4
 
+# Celluloid.logger = nil
+
 def show_help
   print File.basename(__FILE__, '.rb')
   puts <<-HELP
@@ -30,7 +31,7 @@ def show_help
       -k KEY
 
       --make-config [FILE]  generate YAML config
-      -m [FILE]             if FILE not given, but -c option provided, it's MissingArgument
+      -m [FILE]             if FILE not given, but -c option provided, it's argument
                             used instead
       
       --config FILE         read in config from FILE
@@ -47,22 +48,9 @@ def show_help
 
 end
 
-def list_languages(translator, quiet, to_lang)
-
-  res = translator.getLangs(ui: to_lang || 'en')
-
-  unless quiet
-    puts <<-EOF
-
-  //====================\\\\
-  ||Supported LANGUAGES ||
-  \\\\====================//
-
-    EOF
-  end
-
+def get_languages(translator, quiet, to_lang)
+  res = translator.get_languages(ui: to_lang || 'en')
   res["langs"].each { |short, long| puts "#{short}=>#{long} " }
-  exit($EXIT_OK)
 end
 
 begin
@@ -84,7 +72,7 @@ begin
   config_file = nil
   new_config = nil
 
-  opts.each { |opt, arg| 
+  opts.each { |opt, arg|
     case opt
     when '--help'
       show_help
@@ -110,53 +98,44 @@ begin
     YandexTranslator.configuration.api_key = key unless key.nil?
   else
     YandexTranslator.configure.api_key = key
+    
   end
+  
+  raise GetoptLong::MissingArgument, "Please, specify api key" if YandexTranslator.configuration.api_key.nil?
 
   if make_config
     Dir.mkdir(new_config_dir) unless new_config.nil? || Dir.exist?(new_config_dir = File.dirname(new_config))
-    new_config == '-' || new_config = config_file
+
+    new_config = config_file if new_config.nil? || new_config.empty?
+    
     File.open(new_config || config_file, "w") { |file|
       file.write(YAML.dump(YandexTranslator.configuration))
     }
   end
 
-  translator = YandexTranslator::JSONTranslator.new
-
-  if list_languages
-    list_languages(translator, quiet, to_lang)
-  end
-
-  if to_lang.nil?
+  if to_lang.nil? && !list_languages
     raise GetoptLong::MissingArgument, "Please, specify language for output" 
   end
   
+  translator = YandexTranslator::Yat.new
+  if list_languages
+    get_languages(translator, quiet, to_lang)
+    exit($EXIT_OK)
+  end
+  
   str = String.new
 
   ARGF.each_line do |line|
-    while str.length + line.length > CHUNK_SIZE
-      str, line = str + line[0, CHUNK_SIZE], line[CHUNK_SIZE - str.length, line.length]
-      $stdout << translator.translate(text: str, lang: to_lang)
-      str.clear
-    end
-      str += line
+    $stdout << translator.translate(text: line, lang: to_lang)["text"]
   end
-  $stdout << translator.translate(text: str, lang: to_lang) unless str.empty?
 
-rescue GetoptLong::MissingArgument, GetoptLong::InvalidOption
-  $stderr.puts
+rescue GetoptLong::MissingArgument, GetoptLong::InvalidOption => exc
+  $stderr.puts exc.message
   show_help
   exit($EXIT_ECMDLINE)
 
-rescue YandexTranslator::ReturnCodeException => exc
-  $stderr.puts "Error: #{exc.message}"
-  exit($EXIT_EFAIL)
-
-rescue YandexTranslator::ApiFunctionNotSupported => exc
-  $stderr.puts "Error: #{exc.message}"
-  exit($EXIT_EFAIL)
-
-rescue YandexTranslator::NoApiKey => exc
-  $stderr.puts "Error: #{exc.message}"
+rescue Celluloid::TaskTerminated => exc
+  $stderr.puts "!Error: #{exc.message}"
   exit($EXIT_EFAIL)
 
 rescue Errno::ENOENT => exc

data/lib/parsers/json_parser.rb

@@ -0,0 +1,14 @@
+require 'json'
+
+module YandexTranslator
+  class JSONParser
+    include Celluloid
+    include Celluloid::Notifications
+
+    def parse(text, index)
+      response = JSON.parse(text)
+      response["text"] = response["text"].inject {|elm, sum| elm + sum} if response["text"].is_a? Array
+      publish(:parsing_done, response, index)
+    end
+  end
+end

data/lib/parsers/xml_parser.rb

@@ -0,0 +1,40 @@
+require 'rexml/document'
+
+module YandexTranslator
+  class XMLParser
+    include Celluloid
+    include Celluloid::Notifications
+    include REXML
+
+    def parse(text, index)
+      xmldoc = REXML::Document.new(text)
+      response = Hash.new
+
+      if error = xmldoc.elements["Error"]
+        response["code"] = error.attributes['code'].to_i
+        response["message"] = error.attributes['message']
+      end
+
+      unless (element = xmldoc.elements["Langs/dirs"]).nil?
+        response["dirs"] = element.collect { |e|
+          e.text
+        }
+      end
+
+      unless (element = xmldoc.root.attributes["lang"]).nil?
+        response["lang"] = element
+      end
+      unless (element = xmldoc.elements["Langs/langs"]).nil?
+        response["langs"] = Hash.new 
+        element.each { |e|
+          response["langs"][e.attributes["key"]] = e.attributes["value"]
+        }
+      end
+      unless (element = xmldoc.elements["Translation/text"]).nil?
+        response["text"] = element.text
+      end
+
+      publish(:parsing_done, response, index)
+    end
+  end
+end

data/lib/yat.rb

@@ -1,5 +1,129 @@
 TRANSLATOR_PATH = File.dirname(__FILE__) + "/yat/"
+PARSER_PATH = File.dirname(__FILE__) + "/parsers/"
 
-['generic', 'json', 'xml'].each { |f| require TRANSLATOR_PATH + "#{f}_translator" }
+require TRANSLATOR_PATH + "medium"
 require TRANSLATOR_PATH + "config"
 require TRANSLATOR_PATH + "errors"
+require TRANSLATOR_PATH + "connection"
+require PARSER_PATH + "json_parser"
+require PARSER_PATH + "xml_parser"
+
+require 'celluloid/current'
+require 'celluloid/logging'
+
+module YandexTranslator
+  class Yat
+    include Celluloid
+    include Celluloid::Notifications
+    include Celluloid::Internals::Logger
+
+    finalizer :finalize
+    trap_exit :ambulance
+
+    def ambulance(actor, reason)
+      warn "#{actor.inspect} died because of #{reason.inspect}" unless reason.nil?
+      signal :return
+    end
+
+    def finalize
+      @parse_loop.terminate
+      @translator.terminate if @translator.alive?
+    end
+
+    def initialize(format = :json)
+      subscribe(:translator_ready, :__receive_responses)
+      subscribe(:parsing_done, :__return_responses)
+
+      @format = format
+      @responses_num = 0
+      @counter = 0
+      @translator = YandexTranslator::Medium.new_link
+      @parse_loop = self.async.parse_loop
+    end
+
+    def parse_loop
+      loop do
+        responses = wait :got_responses
+        responses.each.with_index { |response, index| parser.async.parse(response.body, index) }
+      end
+    end
+
+    def translate(params)
+      unless params[:text]
+        error "wrong or missing parameters: ':text'"
+        return nil
+      end
+      unless params[:lang]
+        error "wrong or missing parameters: ':lang'"
+        return nil
+      end
+
+      @result = []
+      @translator.async.translate(@format, params)
+      wait :return
+      res = Hash.new("")
+      res = @result.shift
+
+      if @result
+        @result.each do |hash|
+          res["text"] += hash["text"]
+        end
+      end
+      res
+    end
+
+    def get_languages(params = nil)
+      @result = []
+      params ||= Hash.new
+      @translator.async.getLangs(@format, params)
+      wait :return
+      @result.shift
+    end
+
+    def detect(params)
+      unless params[:text]
+        error "text parameter missing"
+        return nil
+      end
+      
+      @result = []
+      @translator.async.detect(@format, params)
+      wait :return
+      @result = @result.shift if @result.size == 1
+      @result
+    end
+
+    def parser
+      case @format
+      when :json
+        JSONParser.new_link
+      when :xml
+        XMLParser.new_link
+      end
+    end
+
+    def __return_responses(topic, response, index)
+
+      if response["message"]
+        error response["message"]
+        @result.push nil
+        signal :return
+        return
+      end
+
+      @counter += 1
+      @result[index] = response
+
+      if @counter == @responses_num
+        @responses_num = @counter = 0
+        signal :return
+      end
+    end
+
+    def __receive_responses(topic, responses)
+      @responses_num = responses.length
+      signal :got_responses, responses
+    end
+
+  end
+end

data/lib/yat/config.rb

@@ -9,12 +9,15 @@ module YandexTranslator
   end
 
   class Configuration
-    attr_accessor :api_key, :xml_path, :json_path
+    attr_accessor :api_key, :xml_path, :json_path, :host, :port, :chunk_size, :maximum_requests
 
     def initialize
+      @chunk_size = 10000
+      @maximum_requests = 10
       @api_key = nil
-      @json_path = 'https://translate.yandex.net/api/v1.5/tr.json'
-      @xml_path = 'https://translate.yandex.net/api/v1.5/tr'
+      @host = "https://translate.yandex.net"
+      @json_path = '/api/v1.5/tr.json'
+      @xml_path = '/api/v1.5/tr'
     end
   end
 

data/lib/yat/connection.rb

@@ -0,0 +1,29 @@
+require 'net/http'
+require 'celluloid/current'
+
+module YandexTranslator
+  
+  class Connection
+    include Celluloid
+    include Celluloid::Notifications
+    
+    # finalizer :finalize
+
+    # def finalize
+    #   p "connection dead!"
+    # end
+
+    def initialize
+      uri = URI(YandexTranslator::configuration.host)
+      @session = Net::HTTP.start(uri.host, uri.port,
+        :use_ssl => uri.scheme == 'https')
+    end
+    
+    def request(uri, request_index, params = nil)
+      response = @session.request(Net::HTTP::Post.new(uri),
+        req = URI.encode_www_form(params || {}))
+
+      publish(:connection_response, request_index, response)
+    end
+  end
+end

data/lib/yat/errors.rb

@@ -1,6 +1,4 @@
-# -*- encoding: utf-8 -*-
 module YandexTranslator
-  class ReturnCodeException < Exception; end
-  class ApiFunctionNotSupported < Exception; end
-  class NoApiKey < Exception; end
+  class ReturnCodeException < StandardError; end
+  class NoApiKey < StandardError; end
 end

data/lib/yat/medium.rb

@@ -0,0 +1,79 @@
+require 'celluloid/current'
+
+module YandexTranslator
+  class Medium
+    include Celluloid
+    include Celluloid::Notifications
+
+    def initialize
+      subscribe(:connection_response, :stash_response)
+
+      @responses = Array.new
+      @response_num = 0
+      @request_index = 0
+      @request_max = YandexTranslator::configuration.maximum_requests
+    end
+
+    [:getLangs, :translate, :detect].each do |method|
+      define_method(method) do |format, params|
+       
+        if params && params.has_key?(:text) && params[:text].length > 0
+          @request_estimate = (
+            Float(params[:text].length) / 
+            YandexTranslator.configuration.chunk_size
+            ).ceil
+
+          split_input(params[:text]).each { |chunk|
+            params[:text] = chunk
+            request(__method__, format, params)
+          }
+        else
+          @request_estimate = 1
+          request(__method__, format, params)
+        end
+      end
+    end
+
+    def stash_response(topic, index, response)
+      signal :continue
+
+      @responses[index] = response
+      @response_num += 1
+
+      if @response_num == @request_estimate
+        publish(:translator_ready, @responses)
+        @request_index = @response_num = 0
+      end
+    end
+
+  protected
+    def request(function, format, params)
+      raise ArgumentError, "wrong format: #{format}" unless (YandexTranslator::configuration.instance_eval("#{format}_path") rescue nil)
+      raise NoApiKey, "provide api key" if (key = YandexTranslator::configuration.api_key).nil?
+
+      params[:key] = YandexTranslator::configuration.api_key
+
+      uri = URI(YandexTranslator::configuration.instance_eval("host + #{format}_path"))
+      uri.path += "/#{function}"
+
+      if @request_index - @response_num == @request_max
+        wait :continue
+      end
+
+      Connection.new_link.async.request(uri, @request_index, params)
+      @request_index += 1
+    end
+    
+    def split_input(input)
+      str = String.new
+      chunks = Array.new
+      chunk_size = YandexTranslator::configuration.chunk_size
+      while str.length + input.length > chunk_size
+        str = input.slice!(0, chunk_size)
+        chunks << str.dup
+        str.clear
+      end
+      chunks << input.dup unless input.nil?
+    end
+  end
+end

data/test/yat_test.rb

@@ -0,0 +1,88 @@
+require_relative '../lib/yat'
+require 'celluloid/test'
+require 'rspec'
+
+raise "provide api key through env variable TRANSLATOR_KEY" if ENV['TRANSLATOR_KEY'].nil?
+
+Celluloid.logger = nil
+UNSUPPORTED_LANGUAGE = 'zz'
+
+YandexTranslator::configure { |config| 
+  config.api_key = ENV['TRANSLATOR_KEY']
+}
+
+shared_examples 'failures' do |translator_format|
+  around(:each) do |example|
+    Celluloid.boot
+    @translator = YandexTranslator::Yat.new(translator_format)
+    example.run
+    @translator.terminate
+    Celluloid.shutdown
+  end
+
+  it 'should fail on wrong api key' do
+    key = 'worng_api_key'
+    key, YandexTranslator::configuration.api_key = YandexTranslator::configuration.api_key, key
+    
+    expect(@translator.get_languages).to be_nil
+    expect(@translator.detect(text: "test")).to be_nil
+    expect(@translator.translate(text: "test", lang: "ru")).to be_nil
+    YandexTranslator::configuration.api_key = key
+  end
+
+  it 'should fail on #detect call without :text specified' do
+    expect(@translator.detect({})).to be_nil
+  end
+
+  it 'should fail on #translate call without :text specified' do
+    expect(@translator.translate(lang: "ru")).to be_nil
+  end
+
+  it 'should fail on #translate call without :lang specified' do
+    expect(@translator.translate(text: "test text")).to be_nil
+  end
+
+  it 'should return error on #translate if unsupported language given' do
+    expect(@translator.translate(text: "test text",
+      lang: UNSUPPORTED_LANGUAGE)).to be_nil
+  end
+
+end
+
+shared_examples 'expected behavior' do |translator_format|
+  # around(:each) do |ex|
+  #   Celluloid.boot
+  #   @translator = YandexTranslator::Yat.new(translator_format)
+  #   ex.run
+  #   @translator.terminate
+  #   Celluloid.shutdown
+  # end
+  it 'should return translation directions array' do
+    expect((@translator.get_languages["dirs"])).to_not be_empty
+  end
+
+  it 'should return translation directions array along with langs hash' do
+    expect(@translator.get_languages(ui: "ru")["langs"]).to_not be_empty
+  end
+
+  it 'should return lang on #detect' do
+    expect(@translator.detect(text: "test")["lang"]).to eq('en')
+  end
+
+  it "should return 'test text' on #translate" do
+    expect(@translator.translate(text: 'тестовый текст', lang: 'en')["text"]).to \
+      eq('test text')
+  end
+end
+
+describe "translator, xml format" do
+  translator_format = :xml
+  include_examples 'failures', translator_format
+  include_examples 'expected behavior', translator_format
+end
+
+describe "translator, json format" do
+  translator_format = :json
+  include_examples 'failures', translator_format
+  include_examples 'expected behavior', translator_format
+end

metadata

@@ -1,29 +1,61 @@
 --- !ruby/object:Gem::Specification
 name: yat
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.5.1
 platform: ruby
 authors:
 - enoch0x5a
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-17 00:00:00.000000000 Z
-dependencies: []
-description: translates text files using yandex translator api
+date: 2015-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+description: translates using yandex translator api
 email: 
 executables:
 - yat
 extensions: []
 extra_rdoc_files: []
 files:
+- Gemfile
+- Rakefile
 - bin/yat
+- lib/parsers/json_parser.rb
+- lib/parsers/xml_parser.rb
 - lib/yat.rb
 - lib/yat/config.rb
+- lib/yat/connection.rb
 - lib/yat/errors.rb
-- lib/yat/generic_translator.rb
-- lib/yat/json_translator.rb
-- lib/yat/xml_translator.rb
+- lib/yat/medium.rb
+- test/yat_test.rb
 homepage: 
 licenses:
 - MIT
@@ -48,4 +80,5 @@ rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: yet another yandex translator
-test_files: []
+test_files:
+- test/yat_test.rb

data/lib/yat/generic_translator.rb

@@ -1,65 +0,0 @@
-require 'net/http'
-
-module YandexTranslator
-
-  class GenericTranslator
-    attr_reader :response
-
-    def initialize
-      @response = nil
-    end
-
-private
-    def method_missing(api_function, *args)
-      @response = make_request(api_function, *args)
-
-      if @response.code == '404'
-        raise YandexTranslator::ApiFunctionNotSupported, "#{api_function}"
-      else
-        GenericTranslator.send(:define_method, api_function) do |*args|
-           make_request(__method__, *args)
-        end
-      end
-      @response
-    end
-
-protected
-    def make_request(function, format, params = nil)
-      raise ArgumentError, "wrong format: #{format}" if YandexTranslator::configuration.instance_eval("#{format}_path").nil?
-
-      raise NoApiKey, "provide api key" if (key = YandexTranslator::configuration.api_key).nil?
-      
-      params[:key] = key 
-
-      uri = URI(YandexTranslator::configuration.instance_eval("#{format}_path"))
-      uri.path += "/#{function}"
-      
-      Net::HTTP.start(uri.host, uri.port,
-        :use_ssl => uri.scheme == 'https') do |https|
-        request = Net::HTTP::Post.new(uri)
-        @response = https.request(request, URI.encode_www_form(params))
-      end
-    end
-
-    def error_check(return_code)
-      unless return_code.nil? || return_code == 200
-        raise YandexTranslator::ReturnCodeException, case return_code.to_i
-          when 401
-            "401: wrong api key"
-          when 402
-            "402: api key blocked"
-          when 403
-            "403: daily request limit exceeded"
-          when 404
-            "404: daily text volume limit exceeded"
-          when 413
-            "413: text size too big"
-          when 422
-            "422: unable to translate"
-          when 501
-            "501: translation direction is not supported"
-        end
-      end
-    end
-  end #  class GenericTranslator
-end

data/lib/yat/json_translator.rb

@@ -1,33 +0,0 @@
-module YandexTranslator
-  require 'json'
-
-  class JSONTranslator < GenericTranslator
-
-    def getLangs(params = nil)
-      response = super(:json, params)
-      response = JSON.parse(response.body)
-      error_check(response["code"])
-      response
-    end
-
-    def detect(params)
-      raise ArgumentError, "text parameter not specified" unless params.has_key?(:text)
-
-      response = super(:json, params)
-      response = JSON.parse(response.body)
-      error_check(response["code"])
-      response["lang"]
-    end
-
-    def translate(params)
-      raise ArgumentError, "text parameter not specified" unless params.has_key?(:text)
-      raise ArgumentError, "lang parameter not specified" unless params.has_key?(:lang)
-      
-      response = super(:json, params)
-      response = JSON.parse(response.body)
-      error_check(response["code"])
-      return response["text"].inject {|elm, sum| elm + sum} if response["text"].is_a? Array
-      response["text"]
-    end
-  end
-end

data/lib/yat/xml_translator.rb

@@ -1,59 +0,0 @@
-module YandexTranslator
-  require 'rexml/document'
-  include REXML
-
-  class XMLTranslator < GenericTranslator
-
-    def getLangs(params = nil)
-
-      response = super(:xml, params)
-
-      xmldoc = REXML::Document.new(response.body)
-
-      if error = xmldoc.elements["Error"]
-        error_check(error.attributes['code'])
-      end
-
-      response = Hash.new
-      response["dirs"] = xmldoc.elements["Langs/dirs"].collect { |e|
-        e.text
-      }
-      unless (langs = xmldoc.elements["Langs/langs"]).nil?
-        response["langs"] = Hash.new 
-        langs.each {|e|
-          response["langs"][e.attributes["key"]] = e.attributes["value"]
-        }
-      end
-      response
-    end
-
-    def detect(params)
-
-      raise ArgumentError, "text parameter not specified" unless params.has_key?(:text)
-
-      response = super(:xml, params)
-      xmldoc = REXML::Document.new(response.body)
-
-      if error = xmldoc.elements["Error"]
-        error_check(error.attributes['code'])
-      end
-
-      xmldoc.root.attributes["lang"]
-    end
-
-    def translate(params)
-
-      raise ArgumentError, "text parameter not specified" unless params.has_key?(:text)
-      raise ArgumentError, "lang parameter not specified" unless params.has_key?(:lang)
-
-      response = super(:xml, params)
-      xmldoc = REXML::Document.new(response.body)
-
-      if error = xmldoc.elements["Error"]
-        error_check(error.attributes['code'])
-      end
-
-      xmldoc.elements["Translation/text"].text
-    end
-  end  #  class XMLTranslator
-end