yat 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d9ac485a32e21092023db6223824c31061853e7
-  data.tar.gz: ae447c73702dd6a023ef828382e62dee0e617cee
+  metadata.gz: c4e9cfdb16b8ab275ceff26d62dfcfb194862c84
+  data.tar.gz: cb74a19f8be0afe8980dcafa991dab706b90ac4c
 SHA512:
-  metadata.gz: cb0a7c7d198b66e41aefe49507c75972045c50ef794812aa3d2b0949e78650503bb55d3c4177c1b618a0085a6bf64b722607dc71eba38b0798029a7f2733c6f2
-  data.tar.gz: f426a61787f20eb9d313b7f07ad0b34c20dd77c7cc7b293cf96b6846cad9aea9d605707ede419cce113a0760fac28ca2c899317adf1fdd3be33170ad4dec21b6
+  metadata.gz: 8a6350dd4f6341b648dbdfb2bee403f87050bcb97f42db42b26a3aeb3cb7b8f79c2514c6c74d2597492df58e431f8d087e31b6dd6906113c4500094793b040cd
+  data.tar.gz: 41abbaef831db0abe1f688807684703dc999e63c354fc67a2ea50c47dd28ecf90884c90bf57f1cad92a301307a236952136256f5bd9d5ecd6ebfd09d33fa3b52

data/bin/yat

@@ -1,44 +1,53 @@
 #!/usr/bin/env ruby
-# -*- encoding: utf-8 -*-
 require_relative "../lib/yat.rb"
 
+require 'yaml'
 require 'getoptlong'
 
-$CHUNK_SIZE = 10000
+CHUNK_SIZE = 10000
 
 $EXIT_OK = 0
-$EXIT_CMDLINE = 3
-$EXIT_FAIL = 4
-
-raise "provide api key in lib/config.rb file" if YandexTranslator::Options[:key].nil?
+$EXIT_ECMDLINE = 3
+$EXIT_EFAIL = 4
 
 def show_help
   print File.basename(__FILE__, '.rb')
   puts <<-HELP
- [OPTIONS] file1 .. fileN
+  --to LANGUAGE [OPTIONS] [file1 .. fileN]
 
     OPTIONS:
-      --help              print this out
+      --help                print this out
       -h
 
-      --to                LANGUAGE to translate to (e.g. "ru")
+      --quiet               turns off additional output
+
+      --to LANGUAGE         LANGUAGE to translate to (e.g. "ru")
+      
+      --list-languages      prints list of supported languages
+      -l                    --to can be specified to get languages translations
+
+      --key KEY             yandex translator api key
+      -k KEY
+
+      --make-config [FILE]  generate YAML config
+      -m [FILE]             if FILE not given, but -c option provided, it's MissingArgument
+                            used instead
       
-      --list-languages    prints list of supported languages
-      -l                  --to can be specified to get languages translations
+      --config FILE         read in config from FILE
+      -c FILE
+
+      Files are optional: if none given text grabbed from standard input.
+      Text can be provided through piped input (e.g. `echo "test" | yat --to af`)
 
     NOTICE:
     LANGUAGE must be one of https://translate.yandex.ru supported languages
-    abbreviations. 
+    abbreviations. See --list-languages option.
 
   HELP
-end
 
-def list_languages(translator, quiet)
+end
 
-  raise ArgumentError, 
-    "list_languages: #{__FILE__}: #{__LINE__}" \
-    "wrong argument: #{translator}" \
-    unless translator.kind_of? YandexTranslator::GenericTranslator
+def list_languages(translator, quiet, to_lang)
 
   res = translator.getLangs(ui: to_lang || 'en')
 
@@ -61,18 +70,32 @@ begin
     [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
     [ '--to', GetoptLong::REQUIRED_ARGUMENT],
     [ '--list-languages', '-l', GetoptLong::NO_ARGUMENT],
-    [ '--quiet', '-q', GetoptLong::NO_ARGUMENT]
+    [ '--quiet', '-q', GetoptLong::NO_ARGUMENT],
+    [ '--key', '-k', GetoptLong::REQUIRED_ARGUMENT],
+    [ '--make-config', '-m', GetoptLong::OPTIONAL_ARGUMENT],
+    [ '--config', '-c', GetoptLong::REQUIRED_ARGUMENT]
   )
 
   to_lang = nil
   list_languages = false
   quiet = false
+  key = nil
+  make_config = false
+  config_file = nil
+  new_config = nil
 
   opts.each { |opt, arg| 
     case opt
     when '--help'
       show_help
       exit($EXIT_OK)
+    when '--key'
+      key = arg
+    when '--make-config'
+      make_config = true
+      new_config = arg
+    when '--config'
+      config_file = arg
     when '--list-languages'
       list_languages = true
     when '--to'
@@ -82,20 +105,36 @@ begin
     end
   }
 
-  if to_lang.nil?
-    raise GetoptLong::MissingArgument, "Please, specify language for output" 
+  unless config_file.nil?
+    YandexTranslator.configuration = YAML.load(File.read(config_file))
+    YandexTranslator.configuration.api_key = key unless key.nil?
+  else
+    YandexTranslator.configure.api_key = key
+  end
+
+  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
+    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)
+    list_languages(translator, quiet, to_lang)
   end
 
+  if to_lang.nil?
+    raise GetoptLong::MissingArgument, "Please, specify language for output" 
+  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]
+    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
@@ -103,15 +142,24 @@ begin
   end
   $stdout << translator.translate(text: str, lang: to_lang) unless str.empty?
 
-rescue GetoptLong::MissingArgument => exc
-  print "Error: "
-  puts exc.message
-  puts
+rescue GetoptLong::MissingArgument, GetoptLong::InvalidOption
+  $stderr.puts
   show_help
-  exit($EXIT_CMDLINE)
+  exit($EXIT_ECMDLINE)
 
 rescue YandexTranslator::ReturnCodeException => exc
-  print "Error: "
-  puts exc.message
-  exit($EXIT_FAIL)
+  $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}"
+  exit($EXIT_EFAIL)
+
+rescue Errno::ENOENT => exc
+  $stderr.puts exc.message
+  exit($EXIT_ECMDLINE)
 end

data/lib/yat.rb

@@ -1,5 +1,5 @@
 TRANSLATOR_PATH = File.dirname(__FILE__) + "/yat/"
 
-require TRANSLATOR_PATH + "translator"
+['generic', 'json', 'xml'].each { |f| require TRANSLATOR_PATH + "#{f}_translator" }
 require TRANSLATOR_PATH + "config"
 require TRANSLATOR_PATH + "errors"

data/lib/yat/config.rb

@@ -1,8 +1,21 @@
-# -*- encoding: utf-8 -*-
 module YandexTranslator
-  Options = {
-    :key => nil,  #provide api key here
-    :json_path => 'https://translate.yandex.net/api/v1.5/tr.json',
-    :xml_path => 'https://translate.yandex.net/api/v1.5/tr'
-  }
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(self.configuration) rescue self.configuration
+  end
+
+  class Configuration
+    attr_accessor :api_key, :xml_path, :json_path
+
+    def initialize
+      @api_key = nil
+      @json_path = 'https://translate.yandex.net/api/v1.5/tr.json'
+      @xml_path = 'https://translate.yandex.net/api/v1.5/tr'
+    end
+  end
+
 end

data/lib/yat/errors.rb

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

data/lib/yat/generic_translator.rb

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,59 @@
+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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yat
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - enoch0x5a
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-10 00:00:00.000000000 Z
+date: 2015-08-17 00:00:00.000000000 Z
 dependencies: []
 description: translates text files using yandex translator api
 email: 
@@ -21,7 +21,9 @@ files:
 - lib/yat.rb
 - lib/yat/config.rb
 - lib/yat/errors.rb
-- lib/yat/translator.rb
+- lib/yat/generic_translator.rb
+- lib/yat/json_translator.rb
+- lib/yat/xml_translator.rb
 homepage: 
 licenses:
 - MIT
@@ -42,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: yet another yandex translator

data/lib/yat/translator.rb

@@ -1,172 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'net/http'
-
-module YandexTranslator
-  FORMAT_ARRAY = [:xml, :json]
-
-  class GenericTranslator
-    attr_reader :response
-
-    def initialize
-      require_relative 'config.rb'
-    end
-
-    def getLangs(return_as, params)
-      response = make_request(:getLangs, return_as, params)
-      @response = response.body
-      response
-    end
-
-    def detect(return_as, params)
-      response = make_request(:detect, return_as, params)
-      @response = response.body
-      response
-    end
-
-    def translate(return_as, params)
-      response = make_request(:translate, return_as, params)
-      @response = response.body
-      response
-    end
-
-protected
-    def make_request(function, format, params)
-      if not FORMAT_ARRAY.member? format
-        raise ArgumentError, "wrong format: #{format}"
-      end
-      key_hash = {:key => YandexTranslator::Options[:key]}
-      params = params.nil? ? key_hash : key_hash.merge(params)
-      uri = URI(Options["#{format}_path".to_sym])
-      uri.path += "/#{function}"
-      uri.query = URI.encode_www_form(params)
-      Net::HTTP.start(uri.host, uri.port,
-        :use_ssl => uri.scheme == 'https') do |https|
-        request = Net::HTTP::Post.new(uri)
-        response = https.request(request)
-      end
-    end
-
-    def error_check(return_code)
-      return_code = return_code.to_i if return_code.respond_to? :to_i
-      unless return_code.nil? && return_code == 200  #getLangs won't return 200:OK for now :_(
-        raise YandexTranslator::ReturnCodeException, case return_code
-          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
-
-  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"])
-      response["text"]
-    end
-  end  #  class JSONTranslator
-
-  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
-
-      # response = Hash.new
-      # response["code"] = xmldoc.root.attributes["code"]
-      # response["lang"] = xmldoc.root.attributes["lang"]
-
-      # response
-      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
-
-      # response = Hash.new
-      # response["code"] = xmldoc.root.attributes["code"]
-      # response["lang"] = xmldoc.root.attributes["lang"]
-      # response["text"] = xmldoc.elements["Translation/text"].text
-      xmldoc.elements["Translation/text"].text
-
-      # response
-    end
-  end  #  class XMLTranslator
-end  #  module YandexTranslator