bing_translator 5.1.0 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: daad79b2f54a858f37545758c63e0854ddcbc786
-  data.tar.gz: fa1e9b14c2fe4eed5e54bdc3c2a22e8455f68bff
+SHA256:
+  metadata.gz: 5f88718168ee707a700ed926c13ff7539155d5e94535145c912672520a166f72
+  data.tar.gz: 0d5afc1c573bb1c613a7ca77fc7cc8ae2373477677845b3b21f4e425b6ea2fa1
 SHA512:
-  metadata.gz: ea5a72e3e4726b67f015e1b90c7a2235cb5209fc1a4be0bdecceed69168b7d76ed26376b7756f34a306302846fa0fc129bdf1e5da0e73fa8433c149b873a51a5
-  data.tar.gz: 12d3963621499c04bdee4fde27a287fbac46a9628a1811a4f0e241ab65404a95433bb17d0e711a5d2a0f06966e56bfd514642857a5a8f92a845c975f3f4df08d
+  metadata.gz: 61a293de90f373bbe12a79989c32a416949b557761dcfb3a773b7fb5c2f9a3bb1657bc084661dee065aa603c0497ada6bf3e6fbc66ea17c99a4f2bfb200a7b6f
+  data.tar.gz: 0d9afa36690c92b84987392f5b5ca1d970e5b057144f355fe8733e304a4acc444522159fd0fc8bbc5510c6a2417872972b84aa77124dbfd2d45899e9e2a5a6d1

data/lib/bing_translator.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# encoding: utf-8
+
 # (c) 2011-present. Ricky Elrod <ricky@elrod.me>
 # Released under the MIT license.
 require 'rubygems'
@@ -7,186 +7,165 @@ require 'cgi'
 require 'uri'
 require 'net/http'
 require 'net/https'
-require 'nokogiri'
 require 'json'
-require 'savon'
 
 class BingTranslator
-  WSDL_URI = 'http://api.microsofttranslator.com/V2/soap.svc?wsdl'
-  NAMESPACE_URI = 'http://api.microsofttranslator.com/V2'
-  COGNITIVE_ACCESS_TOKEN_URI = URI.parse('https://api.cognitive.microsoft.com/sts/v1.0/issueToken').freeze
-
   class Exception < StandardError; end
 
-  def initialize(subscription_key, options = {})
-    @skip_ssl_verify = options.fetch(:skip_ssl_verify, false)
-    @subscription_key = subscription_key
-  end
+  class ApiClient
+    API_HOST = 'https://api.cognitive.microsofttranslator.com'.freeze
+    COGNITIVE_ACCESS_TOKEN_URI =
+      URI.parse('https://api.cognitive.microsoft.com/sts/v1.0/issueToken').freeze
 
-  def translate(text, params = {})
-    raise "Must provide :to." if params[:to].nil?
+    def initialize(subscription_key, skip_ssl_verify, read_timeout = 60, open_timeout = 60)
+      @subscription_key = subscription_key
+      @skip_ssl_verify = skip_ssl_verify
+      @read_timeout = read_timeout
+      @open_timeout = open_timeout
+    end
 
-    # Important notice: param order makes sense in SOAP. Do not reorder or delete!
-    params = {
-      'text'        => text.to_s,
-      'from'        => params[:from].to_s,
-      'to'          => params[:to].to_s,
-      'category'    => 'general',
-      'contentType' => params[:content_type] || 'text/plain'
-    }
+    def get(path, params: {}, headers: {}, authorization: false)
+      uri = request_uri(path, params)
+      request = Net::HTTP::Get.new(uri.request_uri, default_headers(authorization).merge(headers))
 
-    result(:translate, params)
-  end
-
-  def translate_array(texts, params = {})
-    raise "Must provide :to." if params[:to].nil?
-
-    # Important notice: param order makes sense in SOAP. Do not reorder or delete!
-    params = {
-      'texts'       => { 'arr:string' => texts },
-      'from'        => params[:from].to_s,
-      'to'          => params[:to].to_s,
-      'category'    => 'general',
-      'contentType' => params[:content_type] || 'text/plain'
-    }
-
-    array_wrap(result(:translate_array, params)[:translate_array_response]).map{|r| r[:translated_text]}
-  end
+      json_response(uri, request)
+    end
 
- def translate_array2(texts, params = {})
-    raise "Must provide :to." if params[:to].nil?
+    def post(path, params: {}, headers: {}, data: {}, authorization: true)
+      uri = request_uri(path, params)
 
-    # Important notice: param order makes sense in SOAP. Do not reorder or delete!
-    params = {
-      'texts'       => { 'arr:string' => texts },
-      'from'        => params[:from].to_s,
-      'to'          => params[:to].to_s,
-      'category'    => 'general',
-      'contentType' => params[:content_type] || 'text/plain'
-    }
+      request = Net::HTTP::Post.new(uri.request_uri, default_headers(authorization).merge(headers))
+      request.body = data
 
-    array_wrap(result(:translate_array2, params)[:translate_array2_response]).map{|r| [r[:translated_text], r[:alignment]]}
-  end
+      json_response(uri, request)
+    end
 
-  def detect(text)
-    params = {
-      'text'     => text.to_s,
-      'language' => '',
-    }
+    private
 
-    if lang = result(:detect, params)
-      lang.to_sym
+    def default_headers(authorization = true)
+      headers = { 'Content-Type' => 'application/json' }
+      headers['Authorization'] = "Bearer #{access_token}" if authorization
+      headers
     end
-  end
 
-  # format:   'audio/wav' [default] or 'audio/mp3'
-  # language: valid translator language code
-  # options:  'MinSize' [default] or 'MaxQuality'
-  def speak(text, params = {})
-    raise "Must provide :language" if params[:language].nil?
+    def json_response(uri, request)
+      http = http_client(uri)
 
-    params = {
-      'text'     => text.to_s,
-      'language' => params[:language].to_s,
-      'format'   => params[:format] || 'audio/wav',
-      'options'  => params[:options] || 'MinSize',
-    }
+      response = http.request(request)
 
-    uri = URI.parse(result(:speak, params))
+      raise Exception.new("Unsuccessful API call: Code: #{response.code}") unless response.code == '200'
+      JSON.parse(response.body)
+    end
 
-    http = Net::HTTP.new(uri.host, uri.port)
-    if uri.scheme == "https"
+    def http_client(uri)
+      http = Net::HTTP.new(uri.host, 443)
       http.use_ssl = true
       http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @skip_ssl_verify
+      http.read_timeout = @read_timeout
+      http.open_timeout = @open_timeout
+      http
     end
-    results = http.get(uri.to_s, {'Authorization' => "Bearer #{get_access_token['access_token']}"})
 
-    if results.response.code.to_i == 200
-      results.body
-    else
-      html = Nokogiri::HTML(results.body)
-      raise Exception, html.xpath("//text()").remove.map(&:to_s).join(' ')
+    def request_uri(path, params)
+      encoded_params = URI.encode_www_form(params.merge('api-version' => '3.0'))
+      uri = URI.parse("#{API_HOST}#{path}")
+      uri.query = encoded_params
+      uri
+    end
+
+    def access_token
+      if @access_token.nil? || Time.now >= @access_token_expiration_time
+        @access_token = request_new_access_token
+      end
+      @access_token
+    end
+
+    def request_new_access_token
+      headers = {
+        'Ocp-Apim-Subscription-Key' => @subscription_key
+      }
+
+      http = Net::HTTP.new(COGNITIVE_ACCESS_TOKEN_URI.host, COGNITIVE_ACCESS_TOKEN_URI.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @skip_ssl_verify
+
+      response = http.post(COGNITIVE_ACCESS_TOKEN_URI.path, '', headers)
+      if response.code != '200'
+        raise Exception.new('Invalid credentials')
+      else
+        @access_token_expiration_time = Time.now + 480
+        response.body
+      end
     end
   end
 
-  def supported_language_codes
-    result(:get_languages_for_translate)[:string]
+  def initialize(subscription_key, options = {})
+    skip_ssl_verify = options.fetch(:skip_ssl_verify, false)
+    read_timeout = options.fetch(:read_timeout, 60)
+    open_timeout = options.fetch(:open_timeout, 60)
+    @api_client = ApiClient.new(subscription_key, skip_ssl_verify, read_timeout, open_timeout)
   end
 
-  def language_names(codes, locale = 'en')
-    response = result(:get_language_names, locale: locale, languageCodes: {'a:string' => codes}) do
-      attributes 'xmlns:a' => 'http://schemas.microsoft.com/2003/10/Serialization/Arrays'
+  def translate(text, params)
+    translate_array([text], params).first
+  end
+
+  def translate_array(texts, params = {})
+    translations = translation_request(texts, params)
+    translations.map do |translation|
+      translation['text'] if translation.is_a?(Hash)
     end
+  end
 
-    response[:string]
+  def translate_array2(texts, params = {})
+    translations = translation_request(texts, params.merge('includeAlignment' => true))
+    translations.map do |translation|
+      [translation['text'], translation['alignment']['proj']] if translation.is_a?(Hash)
+    end
   end
 
-  private
+  def detect(text)
+    data = [{ 'Text' => text }].to_json
 
-  # Get a new access token and set it internally as @access_token
-  #
-  # @return {hash}
-  # Returns existing @access_token if we don't need a new token yet,
-  # or returns the one just obtained.
-  def get_access_token
-    headers = {
-      'Ocp-Apim-Subscription-Key' => @subscription_key
-    }
-
-    http = Net::HTTP.new(COGNITIVE_ACCESS_TOKEN_URI.host, COGNITIVE_ACCESS_TOKEN_URI.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @skip_ssl_verify
-
-    response = http.post(COGNITIVE_ACCESS_TOKEN_URI.path, "", headers)
-
-    @access_token = {
-      'access_token' => response.body,
-      'expires_at' => Time.now + 480
-    }
+    response_json = api_client.post('/detect', data: data)
+    best_detection = response_json.sort_by { |detection| -detection['score'] }.first
+    best_detection['language'].to_sym
   end
 
-  # Performs actual request to Bing Translator SOAP API
-  def result(action, params = {}, &block)    
-    soap_client.call(action, message: build_soap_message(params), &block).body[:"#{action}_response"][:"#{action}_result"]
-  rescue Savon::SOAPFault => e
-    raise Exception, e.message
+  def speak(text, params = {})
+    raise Exception.new('Not supported since 3.0.0')
   end
 
-  # Specify SOAP namespace in tag names (see https://github.com/savonrb/savon/issues/340 )
-  #
-  # @return [Hash]
-  def build_soap_message(params)    
-    Hash[params.map{|k,v| ["v2:#{k}", v]}]
+  def supported_language_codes
+    response_json = api_client.get('/languages',
+                                   params: { scope: 'translation' },
+                                   authorization: false)
+    response_json['translation'].keys
   end
 
-  # Private: Constructs SOAP client
-  #
-  # Construct and store new client when called first time.
-  # Return stored client while access token is fresh.
-  # Construct and store new client when token have been expired.
-  def soap_client
-    return @client if @client and @access_token and @access_token['expires_at'] and
-      Time.now < @access_token['expires_at']
-
-    @client = Savon.client(
-      wsdl: WSDL_URI,
-      namespace: NAMESPACE_URI,
-      namespace_identifier: :v2,
-      namespaces: {
-        'xmlns:arr' =>  'http://schemas.microsoft.com/2003/10/Serialization/Arrays'
-      },
-      headers: {'Authorization' => "Bearer #{get_access_token['access_token']}"},
-    )
+  def language_names(codes, locale = 'en')
+    response_json = api_client.get('/languages',
+                                   params: { scope: 'translation' },
+                                   headers: { 'Accept-Language' => locale },
+                                   authorization: false)
+    codes.map do |code|
+      response = response_json['translation'][code.to_s]
+      response['name'] unless response.nil?
+    end
   end
 
-  # Private: Array#wrap based on ActiveSupport extension
-  def array_wrap(object)
-    if object.nil?
-      []
-    elsif object.respond_to?(:to_ary)
-      object.to_ary || [object]
-    else
-      [object]
+  private
+
+  attr_reader :api_client
+
+  def translation_request(texts, params)
+    raise Exception.new('Must provide :to.') if params[:to].nil?
+
+    data = texts.map { |text| { 'Text' => text } }.to_json
+    response_json = api_client.post('/translate', params: params, data: data)
+    response_json.map do |translation|
+      # There should be just one translation, but who knows...
+      translation['translations'].find { |result| result['to'] == params[:to].to_s }
     end
   end
 end

metadata

@@ -1,57 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: bing_translator
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 6.1.0
 platform: ruby
 authors:
 - Ricky Elrod
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-18 00:00:00.000000000 Z
+date: 2019-03-25 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.8.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.8.1
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.8.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.8.0
-- !ruby/object:Gem::Dependency
-  name: savon
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: '0'
 description: Translate strings using the Bing HTTP API. Requires that you have a Client
   ID and Secret. See README.md for information.
 email: ricky@elrod.me
@@ -80,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Translate using the Bing HTTP API