easy_translate 0.2.1 → 0.3.0

data/lib/easy_translate.rb

@@ -1,73 +1,19 @@
+require File.dirname(__FILE__) + '/easy_translate/detection'
+require File.dirname(__FILE__) + '/easy_translate/translation'
+
 module EasyTranslate
 
-  require 'uri'
-  require 'net/http'
-  
-  require 'rubygems'
-  require 'json'
-  
-  require 'easy_translate/param_builder'
-  require 'easy_translate/translator'
-  
-  API_URL = 'ajax.googleapis.com'
-  API_TRANSLATE_PATH = '/ajax/services/language/translate'
-  API_DETECT_PATH = '/ajax/services/language/detect'
-  API_VERSION = '2.0'
+  autoload :EasyTranslateException, File.dirname(__FILE__) + '/easy_translate/easy_translate_exception'
+  autoload :Request, File.dirname(__FILE__) + '/easy_translate/request'
+
+  autoload :LANGUAGES, File.dirname(__FILE__) + '/easy_translate/languages'
+  autoload :VERSION, File.dirname(__FILE__) + '/easy_translate/version'
+
+  extend Detection # Language Detection
+  extend Translation # Language Translation
+
+  class << self
+    attr_accessor :api_key
+  end
 
-  LANGUAGES = { 
-    'af' => 'afrikaans',
-    'sq' => 'albanian', 
-    'ar' => 'arabic',
-    'be' => 'belarusian',
-    'bg' => 'bulgarian',
-    'ca' => 'catalan',
-    'zh-CN' => 'chinese_simplified',
-    'zh-TW' => 'chinese_traditional',
-    'hr' => 'croatian',
-    'cs' => 'czech',
-    'da' => 'danish',
-    'nl' => 'dutch',
-    'en' => 'english',
-    'et' => 'estonian',
-    'tl' => 'filipino',
-    'fi' => 'finnish',
-    'fr' => 'french',
-    'gl' => 'galician',
-    'de' => 'german',
-    'el' => 'greek',
-    'ht' => 'haitian_creole',
-    'iw' => 'hebrew',
-    'hi' => 'hindi',
-    'hu' => 'hungarian',
-    'is' => 'icelandic',
-    'id' => 'indonesian',
-    'ga' => 'irish',
-    'it' => 'italian',
-    'ja' => 'japanese',
-    'ko' => 'korean',
-    'lv' => 'latvian',
-    'lt' => 'lithuanian',
-    'mk' => 'macedonian',
-    'ms' => 'malay',
-    'mt' => 'maltese',
-    'no' => 'norwegian',
-    'fa' => 'persian',
-    'pl' => 'polish',
-    'pt' => 'portuguese',
-    'ro' => 'romanian',
-    'ru' => 'russian',
-    'sr' => 'serbian',
-    'sk' => 'slovak',
-    'sl' => 'slovenian',
-    'es' => 'spanish',
-    'sw' => 'swahili',
-    'sv' => 'swedish',
-    'th' => 'thai',
-    'tr' => 'turkish',
-    'uk' => 'ukrainian',
-    'vi' => 'vietnamese',
-    'cy' => 'welsh',
-    'yi' => 'yiddish'
-  }
-  
 end

data/lib/easy_translate/detection.rb

@@ -0,0 +1,83 @@
+require 'json'
+require File.dirname(__FILE__) + '/request'
+
+module EasyTranslate
+
+  module Detection
+
+    # Detect language
+    # @param [String, Array] texts - A single string or set of strings to detect for
+    # @param [Hash] options - Extra options to pass along with the request
+    # @return [String, Array] The resultant language or languages
+    def detect(texts, options = nil)
+      request = DetectionRequest.new(texts, options)
+      # Turn the response into an array of detections
+      raw = request.perform_raw
+      detections = JSON.parse(raw)['data']['detections'].map do |res|
+        res.empty? ? nil : res.first['language']
+      end
+      # And then return, if they only asked for one, only give one back
+      request.multi? ? detections : detections.first
+    end
+
+    # A convenience class for wrapping a detection request
+    class DetectionRequest < EasyTranslate::Request
+
+      # Set the texts and options
+      # @param [String, Array] texts - The text (or texts) to translate
+      # @param [Hash] options - Options to override or pass along with the request
+      def initialize(texts, options = nil)
+        self.texts = texts
+        if options
+          @options = options
+          if replacement_api_key = @options.delete(:api_key)
+            @options[:key] = replacement_api_key
+          end
+        end
+      end
+
+      # The params for this request
+      # @return [Hash] the params for the request
+      def params
+        params = super || {}
+        params.merge! @options if @options
+        params
+      end
+
+      # The path for the request
+      # @return [String] The path for the request
+      def path
+        '/language/translate/v2/detect'
+      end
+
+      # The body for the request
+      # @return [String] the body for the request, URL escaped
+      def body
+        @texts.map { |t| "q=#{URI.escape(t)}" }.join '&'
+      end
+
+      # Whether or not this was a request for multiple texts
+      # @return [Boolean]
+      def multi?
+        @multi
+      end
+
+      private
+
+      # Set the texts for this request
+      # @param [String, Array] texts - The text or texts for this request
+      def texts=(texts)
+        if texts.is_a?(String)
+          @multi = false
+          @texts = [texts]
+        else
+          @multi = true
+          @texts = texts
+        end 
+      end
+
+    end
+
+  end
+
+end

data/lib/easy_translate/easy_translate_exception.rb

@@ -0,0 +1,6 @@
+module EasyTranslate
+
+  class EasyTranslateException < StandardError
+  end
+
+end

data/lib/easy_translate/languages.rb

@@ -0,0 +1,58 @@
+module EasyTranslate
+
+  LANGUAGES = { 
+    'af' => 'afrikaans',
+    'sq' => 'albanian', 
+    'ar' => 'arabic',
+    'be' => 'belarusian',
+    'bg' => 'bulgarian',
+    'ca' => 'catalan',
+    'zh-CN' => 'chinese_simplified',
+    'zh-TW' => 'chinese_traditional',
+    'hr' => 'croatian',
+    'cs' => 'czech',
+    'da' => 'danish',
+    'nl' => 'dutch',
+    'en' => 'english',
+    'et' => 'estonian',
+    'tl' => 'filipino',
+    'fi' => 'finnish',
+    'fr' => 'french',
+    'gl' => 'galician',
+    'de' => 'german',
+    'el' => 'greek',
+    'iw' => 'hebrew',
+    'hi' => 'hindi',
+    'hu' => 'hungarian',
+    'is' => 'icelandic',
+    'id' => 'indonesian',
+    'ga' => 'irish',
+    'it' => 'italian',
+    'ja' => 'japanese',
+    'ko' => 'korean',
+    'lv' => 'latvian',
+    'lt' => 'lithuanian',
+    'mk' => 'macedonian',
+    'ms' => 'malay',
+    'mt' => 'maltese',
+    'no' => 'norwegian',
+    'fa' => 'persian',
+    'pl' => 'polish',
+    'pt' => 'portuguese',
+    'ro' => 'romanian',
+    'ru' => 'russian',
+    'sr' => 'serbian',
+    'sk' => 'slovak',
+    'sl' => 'slovenian',
+    'es' => 'spanish',
+    'sw' => 'swahili',
+    'sv' => 'swedish',
+    'th' => 'thai',
+    'tr' => 'turkish',
+    'uk' => 'ukrainian',
+    'vi' => 'vietnamese',
+    'cy' => 'welsh',
+    'yi' => 'yiddish'
+  }
+
+end

data/lib/easy_translate/request.rb

@@ -0,0 +1,63 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+module EasyTranslate
+
+  class Request
+
+    # Body, blank by default
+    # @return [String] The body for this request
+    def body
+      ''
+    end
+
+    # The path for the request
+    # @return [String] The path for this request
+    def path
+      raise NotImplementedError.new('path is not implemented')
+    end
+
+    # The base params for a request
+    # @return [Hash] a hash of the base parameters for any request
+    def params
+      params = {}
+      params[:key] = EasyTranslate.api_key if EasyTranslate.api_key
+      params[:prettyPrint] = 'false' # eliminate unnecessary overhead
+      params
+    end
+
+    # Perform the given request
+    # @return [String] The response String
+    def perform_raw
+      # Get the URI
+      uri = URI.parse("https://www.googleapis.com#{path}?#{param_s}")
+      # Open the HTTP object
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      # Construct the request
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.add_field('X-HTTP-Method-Override', 'GET')
+      request.body = body
+      # Fire and return
+      response = http.request(request)
+      unless response.code == '200'
+        err = JSON.parse(response.body)['error']['errors'].first['message']
+        raise EasyTranslateException.new(err)
+      end
+      response.body
+    end
+
+    private
+
+    # Stringify the params
+    # @return [String] The params as a string
+    def param_s
+      params.map do |k, v|
+        "#{k}=#{v}" unless v.nil?
+      end.compact.join('&')
+    end
+
+  end
+
+end

data/lib/easy_translate/translation.rb

@@ -0,0 +1,109 @@
+require 'json'
+require File.dirname(__FILE__) + '/request'
+
+module EasyTranslate
+
+  module Translation
+
+    # Translate text
+    # @param [String, Array] texts - A single string or set of strings to translate
+    # @option options [String, Symbol] :source - The source language (optional)
+    # @option options [String, Symbol] :target - The target language (required)
+    # @option options [Boolean] :html - Whether or not the supplied string is HTML (optional)
+    # @return [String, Array] Translated text or texts
+    def translate(texts, options = {})
+      request = TranslationRequest.new(texts, options)
+      # Turn the response into an array of translations 
+      raw = request.perform_raw
+      translations = JSON.parse(raw)['data']['translations'].map do |res|
+        res['translatedText']
+      end
+      # And then return, if they only asked for one, only give one back
+      request.multi? ? translations : translations.first
+    end
+
+    # A convenience class for wrapping a translation request
+    class TranslationRequest < EasyTranslate::Request
+      
+      # Set the texts and options
+      # @param [String, Array] texts - the text (or texts) to translate
+      # @param [Hash] options - Options to override or pass along with the request
+      def initialize(texts, options)
+        self.texts = texts
+        self.html = options.delete(:html)
+        @source = options.delete(:from)
+        @target = options.delete(:to)
+        raise ArgumentError.new('No target language provded') unless @target
+        raise ArgumentError.new('Support for multiple targets dropped in V2') if @target.is_a?(Array)
+        if options
+          @options = options
+          if replacement_api_key = @options.delete(:api_key)
+            @options[:key] = replacement_api_key
+          end
+        end
+      end
+
+      # The params for this request
+      # @return [Hash] the params for the request
+      def params
+        params = super || {}
+        params[:source] = lang(@source) unless @source.nil?
+        params[:target] = lang(@target) unless @target.nil?
+        params[:format] = @format unless @format.nil?
+        params.merge! @options if @options
+        params
+      end
+
+      # The path for the request
+      # @return [String] The path for the request
+      def path
+        '/language/translate/v2'
+      end
+
+      # The body for the request
+      # @return [String] the body for the request, URL escaped
+      def body
+        @texts.map { |t| "q=#{URI.escape(t)}" }.join '&'
+      end
+
+      # Whether or not this was a request for multiple texts
+      # @return [Boolean]
+      def multi?
+        @multi
+      end
+
+      private
+
+      # Look up a language in the table (if needed)
+      def lang(orig)
+        look = orig.is_a?(String) ? orig : orig.to_s
+        return look if LANGUAGES[look] # shortcut iteration
+        if val = LANGUAGES.detect { |k, v| v == look }
+          return val.first
+        end
+        look
+      end
+
+      # Set the HTML attribute, if true add a format
+      # @param [Boolean] b - Whether or not the text supplied iS HTML
+      def html=(b)
+        @format = b ? 'html' : nil
+      end
+
+      # Set the texts for this request
+      # @param [String, Array] texts - The text or texts for this request
+      def texts=(texts)
+        if texts.is_a?(String)
+          @multi = false
+          @texts = [texts]
+        else
+          @multi = true
+          @texts = texts
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/easy_translate/version.rb

@@ -1,5 +1,5 @@
 module EasyTranslate
-  
-  VERSION = '0.2.1'
+
+  VERSION = '0.3.0'
 
 end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# Start SimpleCov
+begin
+  require 'simplecov'
+  SimpleCov.start
+rescue LoadError
+  puts 'for coverage please install SimpleCov'
+end
+
+# Require the actual project
+require 'ostruct'
+require File.dirname(__FILE__) + '/../lib/easy_translate'

metadata

@@ -1,97 +1,76 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: easy_translate
-version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 1
-  version: 0.2.1
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - John Crepezzi
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-03-25 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-01-03 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70158452480400 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: json
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70158452480400
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70158452479660 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id002
-description: easy_translate is a wrapper for the google translate API that makes sense programatically, and implements API keys
-email: john@crepezzi.com
+  prerelease: false
+  version_requirements: *70158452479660
+description: easy_translate is a wrapper for the google translate API that makes sense
+  programatically, and implements API keys
+email: john.crepezzi@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- lib/easy_translate/param_builder.rb
-- lib/easy_translate/translator.rb
+files:
+- lib/easy_translate/detection.rb
+- lib/easy_translate/easy_translate_exception.rb
+- lib/easy_translate/languages.rb
+- lib/easy_translate/request.rb
+- lib/easy_translate/translation.rb
 - lib/easy_translate/version.rb
 - lib/easy_translate.rb
-has_rdoc: true
-homepage: http://github.com/seejohnrun/easy_translate/
+- spec/spec_helper.rb
+homepage: https://github.com/seejohnrun/easy_translate
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: easy-translate
-rubygems_version: 1.3.7
+rubyforge_project: 
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Google Translate API Wrapper for Ruby
-test_files: []
-
+test_files:
+- spec/spec_helper.rb

data/lib/easy_translate/param_builder.rb

@@ -1,23 +0,0 @@
-module EasyTranslate
-
-  class ParamBuilder
-
-    def initialize
-      @str = ''
-    end
-
-    def add(param, value)
-      if @str.empty?
-        @str << "#{param.to_s}=#{value}"
-      else
-        @str << "&#{param.to_s}=#{value}"
-      end
-    end
-
-    def to_s
-      @str
-    end
-
-  end
-
-end

data/lib/easy_translate/translator.rb

@@ -1,159 +0,0 @@
-module EasyTranslate
-  
-  class <<self
-    attr_accessor :api_key
-  end
-
-  # Detect the language of a given string of text.
-  # Optional parameters:
-  #   :key - API key for google language (defaults to nil)
-  #   :host_language - language (defaults to 'en')
-  #   :user_ip - the ip of the end user - will help not be mistaken for abuse
-  # Required Parameters:
-  #   the text to detect the language for
-  # Returns:
-  #   the string language code (ie: 'en') of the language
-  # Note:
-  #   This API (since it focuses more on tranlations/ease, does not return 
-  #   confidence ratings)
-  def self.detect(text, options = {})
-    params = base_params(text, options)
-    params.add :q, URI.escape(text)
-    json = api_call EasyTranslate::API_DETECT_PATH, params, :type => :get
-    json['responseData']['language']
-  end
-      
-  # Translate batches of string using Google Translate
-  # Optional parameters:
-  #   :key - API key for google language (defaults to nil)
-  #   :host_language - language (defaults to 'en') (symbol/string)
-  #   :user_ip - the ip of the end user - will help not be mistaken for abuse
-  #   :from - the language to translate from (symbol/string)
-  #   :html - boolean indicating whether the text you're translating is HTML or plaintext
-  # Required Parameters:
-  #   the text(s) to translate (string/array)
-  #   :to - the language(s) to translate to (symbol/string/array)
-  # Returns:
-  #   string / an array of the translated strings
-  def self.translate(text, options)
-    # what type of call is this?
-    multi_call = options[:to].class == Array || text.class == Array
-    all_multi_call = options[:to].class == Array && text.class == Array
-    # translate params if necessary
-    to_lang = (options[:to].class == Array) ? options[:to].map { |to| get_language(to) } : get_language(options[:to])
-    from_lang = get_language(options[:from])
-    # make the call
-    params = base_params(text, options)
-    params.add :format, (options[:html] ? 'html' : 'text')
-    # for each to language, put all of the q's
-    to_lang = [to_lang] if to_lang.is_a?(String)
-    to_lang.each do |tol|
-      escaped_lang_pair = URI.escape "#{from_lang}|#{tol}"
-      # because ruby let's us call .each on a string with newlines
-      text = [text] if text.is_a?(String) # sorry, TODO separate
-      text.each do |t|
-        params.add :q, URI.escape(t)
-        params.add :langpair, escaped_lang_pair
-      end
-    end
-    # TODO cleanup    
-    # get the proper response and return
-    json = api_call EasyTranslate::API_TRANSLATE_PATH, params, :type => :post
-    # single argument is returned
-    if !multi_call
-      single_single(json)
-    # array should be returned
-    elsif multi_call && !all_multi_call
-      single_multiple(json)
-    # the big badass case
-    else
-      multiple_multiple(json, options[:to].size)
-    end
-  end
-  
-  # an exception indicating something went wrong in EasyTranslate
-  class EasyTranslateException < Exception
-  end
-  
-  private
-
-  def self.multiple_multiple(json, translation_count)
-    if json['responseData'].class == Hash
-      [[json['responseData']['translatedText']]]
-    else
-      translations = []
-      responseData = json['responseData'].map { |r| r['responseData']['translatedText'] }
-      per_bucket = responseData.size / translation_count # should always be integer
-      0.upto(translation_count - 1) { |i| translations[i] = responseData.slice(i * per_bucket, per_bucket) }
-    end
-    translations
-  end
-  
-  def self.single_multiple(json)
-    if json['responseData'].class == Hash
-      [json['responseData']['translatedText']]
-    else
-      json['responseData'].map { |j| j['responseData']['translatedText'] }
-    end
-  end
-  
-  def self.single_single(json)
-    json['responseData']['translatedText']
-  end
-  
-  # take in the base parameters for the google translate api
-  def self.base_params(text, options)
-    raise ArgumentError.new('multiple :from not allowed') if options[:from] && options[:from].class == Array
-    raise ArgumentError.new('no string given') if text.empty?
-    key =  options[:key] || EasyTranslate.api_key || nil
-    params = ParamBuilder.new
-    params.add :v, API_VERSION
-    params.add :user_ip, URI.escape(options[:user_ip]) if options.has_key?(:user_ip)
-    params.add :hl, URI.escape(get_language(options[:host_language])) if options.has_key?(:host_language)
-    params.add :key, URI.escape(key) if key
-    # key is standard - but left to individual methods
-    params
-  end
-  
-  # make a call to the api and throw an error on non-200 response
-  # TODO expand error handling
-  def self.api_call(path, params, options = {:type => :get})
-    response = case options[:type]
-      when :get ; api_get_call(path, params)
-      when :post ; api_post_call(path, params)
-      else ; ArgumentError.new('Bad HTTP type')
-    end
-    # if we got a response, use it - otherwise, fail town
-    json = JSON.parse(response) if response
-    raise EasyTranslateException.new(json['responseDetails']) unless json && json['responseStatus'] == 200
-    json
-  end
-
-  def self.api_post_call(path, params)
-    http = Net::HTTP.new(EasyTranslate::API_URL)
-    response = http.post(path, params.to_s)
-    response.body if response
-  end
-    
-  def self.api_get_call(path, params)
-    http = Net::HTTP.new(EasyTranslate::API_URL)
-    response = http.get("#{path}?#{params.to_s}")
-    response.body if response
-  end
-
-  def self.index_func
-    return @index_func if @index_func
-    Hash.instance_methods.include?(:key) ? :key : :index
-  end
-  
-  # a function used to get the lang code of any input.
-  # can take -- :english, 'english', :en, 'en'
-  def self.get_language(lang)
-    return unless lang
-    lang = lang.to_s
-    lang = EasyTranslate::LANGUAGES.include?(lang) ? lang : EasyTranslate::LANGUAGES.send(index_func, lang)
-    raise ArgumentError.new('please supply a valid language') unless lang
-    lang
-  end
-  
-end