gengo 0.0.2 → 0.0.3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gengo (0.0.0)
+    gengo (0.0.2)
       json
       mime-types
       multipart-post

data/README.md

@@ -1,41 +1,44 @@
 [![Build Status](https://secure.travis-ci.org/gengo/gengo-ruby.png)](http://travis-ci.org/gengo/gengo-ruby)
+
 Gengo Ruby Library (for the [Gengo API](http://gengo.com/api/))
-========================================================================================================
-Translating your tools and products helps people all over the world access them; this is, of course, a
-somewhat tricky problem to solve. **[Gengo](http://gengo.com/)** is a service that offers human-translation
-(which is often a higher quality than machine translation), and an API to manage sending in work and watching
-jobs. This is a ruby interface to make using the API simpler (some would say incredibly easy).
+======================================================================================================================================================
+Translating your tools and products helps people all over the world access them; this is, of course, a somewhat tricky problem to solve.
+**[Gengo](http://gengo.com/)** is a service that offers human-translation (which is often a higher quality than machine translation), and an API to
+manage sending in work and watching jobs. This is a Ruby interface to make using the API simpler (some would say incredibly easy).
 
 
 Installation & Requirements
--------------------------------------------------------------------------------------------------------
+------------------------------------------------------------------------------------------------------------------------------------------------------
 Installing Gengo is fairly simple:
 
-    gem install gengo
+```sh
+$ gem install gengo
+```
 
 
 Tests - Running Them, etc
-------------------------------------------------------------------------------------------------------
-Gengo has a full suite of tests, however they're not currently automated. Each script in the _examples_
-directory tests a different Gengo API endpoint; run against those if you wish to test for now.
+------------------------------------------------------------------------------------------------------------------------------------------------------
+Gengo has a full suite of tests, however they're not currently automated. Each script in the `examples` directory tests a different Gengo API
+endpoint; run against those if you wish to test for now.
+
 
 Question, Comments, Complaints, Praise?
-------------------------------------------------------------------------------------------------------
-If you have questions or comments and would like to reach us directly, please feel free to do
-so at the following outlets. We love hearing from developers!
+------------------------------------------------------------------------------------------------------------------------------------------------------
+If you have questions or comments and would like to reach us directly, please feel free to do so at the following outlets. We love hearing from
+developers!
 
-Email: api [at] gengo dot com
-Twitter: **[@gengo_dev](http://twitter.com/gengo_dev)**
+* Email: api [at] gengo dot com
+* Twitter: [@gengoit](https://twitter.com/gengoit)
+* IRC: [#gengo](irc://irc.freenode.net/gengo)
 
-If you come across any issues, please file them on the **[Github project issue tracker](https://github.com/gengo/gengo-ruby/issues)**. Thanks!
+If you come across any issues, please file them on the [Github project issue tracker](https://github.com/gengo/gengo-ruby/issues). Thanks!
 
 
 Documentation
-------------------------------------------------------------------------------------------------------
-The usage of the API is very simple - the most important part is getting authenticated. To do this is just
-a few lines of code:
+------------------------------------------------------------------------------------------------------------------------------------------------------
+The usage of the API is very simple - the most important part is getting authenticated. To do this is just a few lines of code:
 
-``` ruby
+```ruby
 require 'gengo'
 
 gengo = Gengo::API.new({
@@ -48,6 +51,6 @@ gengo = Gengo::API.new({
 puts gengo.getAccountBalance()
 ```
 
-With that, you can call any number of methods supported by this library. The entire library is rdoc supported,
-so you can look at more method information there - there's also a full suite of test code/examples, located in the 'examples'
-directory. Enjoy!
+With that, you can call any number of methods supported by this library. The entire library is rdoc supported, so you can look at more method
+information there. There's also a full suite of test code/examples, located in the `examples` directory. Be sure to checkout the [Gengo API
+documentation](http://developers.gengo.com). Enjoy!

data/lib/gengo-ruby/api_handler.rb

@@ -12,422 +12,425 @@ require 'mime/types'
 
 module Gengo
 
-	# The only real class that ever needs to be instantiated.
-	class API
-		attr_accessor :api_host
-		attr_accessor :debug
-		attr_accessor :client_info
-
-		# Creates a new API handler to shuttle calls/jobs/etc over to the Gengo translation API.
-		#
-		# Options:
-		# <tt>opts</tt> - A hash containing the api key, the api secret key, the API version (defaults to 1), whether to use
-		# the sandbox API, and an optional custom user agent to send.
-		def initialize(opts)
-			# Consider this an example of the object you need to pass.
-			@opts = {
-				:public_key => '',
-				:private_key => '',
-				:api_version => '1.1',
-				:sandbox => false,
-				:user_agent => "Gengo Ruby Library; Version #{Gengo::Config::VERSION}; http://gengo.com/;",
-				:debug => false,
-			}.merge(opts)
-
-			# Let's go ahead and separate these out, for clarity...
-			@debug = @opts[:debug]
-			@api_host = (@opts[:sandbox] == true ? Gengo::Config::SANDBOX_API_HOST : Gengo::Config::API_HOST)
-
-			# More of a public "check this" kind of object.
-			@client_info = {"VERSION" => Gengo::Config::VERSION}
-		end
-
-        # Use CGI escape to escape a string
-		def urlencode(string)
-			CGI::escape(string)
-		end
-
-		# Creates an HMAC::SHA1 signature, signing the timestamp with the private key.
-		def signature_of(ts)
-			OpenSSL::HMAC.hexdigest 'sha1', @opts[:private_key], ts
-		end
-
-		# The "GET" method; handles requesting basic data sets from Gengo and converting
-		# the response to a Ruby hash/object.
-		#
-		# Options:
-		# <tt>endpoint</tt> - String/URL to request data from.
-		# <tt>params</tt> - Data necessary for request (keys, etc). Generally taken care of by the requesting instance.
-		def get_from_gengo(endpoint, params = {})
-			# Do this small check here...
-            is_delete = params.delete(:is_delete)
-            is_download_file = params.delete(:is_download)
-
-            # The first part of the object we're going to encode and use in our request to Gengo. The signing process
-			# is a little annoying at the moment, so bear with us...
-			query = params.reduce({}) {|hash_thus_far, (param_key, param_value)|
-              hash_thus_far.merge(
-                  param_key.to_sym => param_value.to_s
-              )
-            }
-
-            query[:api_key] = @opts[:public_key]
-            query[:ts] = Time.now.gmtime.to_i.to_s
-
-			endpoint << "?api_sig=" + signature_of(query[:ts])
-			endpoint << '&' + query.map { |k, v| "#{k}=#{urlencode(v)}" }.join('&')
-
-            uri = "/v#{@opts[:api_version]}/" + endpoint
-            headers = {
-                'Accept' => 'application/json',
-                'User-Agent' => @opts[:user_agent]
-            }
-
-            if is_delete
-                req = Net::HTTP::Delete.new(uri, headers)
-            else
-                req = Net::HTTP::Get.new(uri, headers)
-            end
-
-			http = Net::HTTP.start(@api_host, 80)
-            if @debug
-              http.set_debug_output($stdout)
-            end
-            http.read_timeout = 5*60
-            resp = http.request(req)
-
-			if is_download_file.nil?
-              json = JSON.parse(resp.body)
-              if json['opstat'] != 'ok'
-                  raise Gengo::Exception.new(json['opstat'], json['err']['code'].to_i, json['err']['msg'])
-              end
-
-              # Return it if there are no problems, nice...
-              return json
-            else
-              return resp.body
-            end
-
-		end
-
-		# The "POST" method; handles shuttling up encoded job data to Gengo
-		# for translation and such. Somewhat similar to the above methods, but depending on the scenario
-		# can get some strange exceptions, so we're gonna keep them fairly separate for the time being. Consider
-		# for a merger down the road...
-		#
-		# Options:
-		# <tt>endpoint</tt> - String/URL to post data to.
-		# <tt>params</tt> - Data necessary for request (keys, etc). Generally taken care of by the requesting instance.
-		def send_to_gengo(endpoint, params = {})
-
-		  # Check if this is a put
-      is_put = params.delete(:is_put)
+  # The only real class that ever needs to be instantiated.
+  class API
+    attr_accessor :api_host
+    attr_accessor :debug
+    attr_accessor :client_info
+
+    # Creates a new API handler to shuttle calls/jobs/etc over to the Gengo translation API.
+    #
+    # Options:
+    # <tt>opts</tt> - A hash containing the api key, the api secret key, the API version (defaults to 1), whether to use
+    # the sandbox API, and an optional custom user agent to send.
+    def initialize(opts)
+      # Consider this an example of the object you need to pass.
+      @opts = {
+        :public_key => '',
+        :private_key => '',
+        :api_version => '2',
+        :sandbox => false,
+        :user_agent => "Gengo Ruby Library; Version #{Gengo::Config::VERSION}; http://gengo.com/;",
+        :debug => false,
+      }.merge(opts)
+
+      # Let's go ahead and separate these out, for clarity...
+      @debug = @opts[:debug]
+      @api_host = (@opts[:sandbox] == true ? Gengo::Config::SANDBOX_API_HOST : Gengo::Config::API_HOST)
+
+      # More of a public "check this" kind of object.
+      @client_info = {"VERSION" => Gengo::Config::VERSION}
+    end
+
+    # Use CGI escape to escape a string
+    def urlencode(string)
+      CGI::escape(string)
+    end
+
+    # Creates an HMAC::SHA1 signature, signing the timestamp with the private key.
+    def signature_of(ts)
+      OpenSSL::HMAC.hexdigest 'sha1', @opts[:private_key], ts
+    end
+
+    # The "GET" method; handles requesting basic data sets from Gengo and converting
+    # the response to a Ruby hash/object.
+    #
+    # Options:
+    # <tt>endpoint</tt> - String/URL to request data from.
+    # <tt>params</tt> - Data necessary for request (keys, etc). Generally taken care of by the requesting instance.
+    def get_from_gengo(endpoint, params = {})
+      # Do this small check here...
+      is_delete = params.delete(:is_delete)
+      is_download_file = params.delete(:is_download)
+
+      # The first part of the object we're going to encode and use in our request to Gengo. The signing process
+      # is a little annoying at the moment, so bear with us...
+      query = params.reduce({}) do |hash_thus_far, (param_key, param_value)|
+        hash_thus_far.merge(param_key.to_sym => param_value.to_s)
+      end
 
-			query = {
-				:api_key => @opts[:public_key],
-				:data => params.to_json.gsub('"', '\"'),
-				:ts => Time.now.gmtime.to_i.to_s
-			}
-
-			url = URI.parse("http://#{@api_host}/v#{@opts[:api_version]}/#{endpoint}")
-			http = Net::HTTP.new(url.host, url.port)
-            http.read_timeout = 5*60
-			if is_put
-			  request = Net::HTTP::Put.new(url.path)
-		  else
-			  request = Net::HTTP::Post.new(url.path)
-		  end
-
-			request.add_field('Accept', 'application/json')
-			request.add_field('User-Agent', @opts[:user_agent])
-
-			request.content_type = 'application/x-www-form-urlencoded'
-			request.body = {
-				"api_sig" => signature_of(query[:ts]),
-				"api_key" => urlencode(@opts[:public_key]),
-				"data" => urlencode(params.to_json.gsub('\\', '\\\\')),
-				"ts" => query[:ts].to_i.to_s
-			}.map { |k, v| "#{k}=#{v}" }.flatten.join('&')
-
-			if @debug
-				http.set_debug_output($stdout)
-			end
-
-			resp = http.request(request)
-
-			case resp
-				when Net::HTTPSuccess, Net::HTTPRedirection
-					json = JSON.parse(resp.body)
-
-					if json['opstat'] != 'ok'
-						raise Gengo::Exception.new(json['opstat'], json['err']['code'].to_i, json['err']['msg'])
-					end
-
-					# Return it if there are no problems, nice...
-					json
-				else
-					resp.error!
-			end
-		end
-
-		# The "UPLOAD" method; handles sending a file to the quote method
-		#
-		# Options:
-		# <tt>endpoint</tt> - String/URL to post data to.
-		# <tt>params</tt> - Data necessary for request (keys, etc). Generally taken care of by the requesting instance.
-		def upload_to_gengo(endpoint, params = {})
-
-		  # prepare the file_hash and append file_key to each job payload
-          files_hash = params[:jobs].each_value.reduce({}) do |hash_thus_far, job_values|
-            if job_values[:file_path]
-                job_mime_type = MIME::Types.type_for(job_values[:file_path]).first.content_type
-                file_hash_key = "file_#{hash_thus_far.length.to_s}".to_sym
-                job_values[:file_key] = file_hash_key
-                hash_thus_far[file_hash_key] = UploadIO.new(File.open(job_values[:file_path]), job_mime_type, File.basename(job_values[:file_path]))
-            end
-            hash_thus_far
-          end
-
-          url = URI.parse("http://#{@api_host}/v#{@opts[:api_version]}/#{endpoint}")
-
-          http = Net::HTTP.new(url.host, url.port)
-          http.read_timeout = 5*60
-
-          call_timestamp = Time.now.gmtime.to_i.to_s
-
-			the_hash = files_hash.merge({
-				"api_sig" => signature_of(call_timestamp),
-				"api_key" => @opts[:public_key],
-				"data" =>params.to_json.gsub('\\', '\\\\'),
-				"ts" => call_timestamp
-			})
-
-			request = Net::HTTP::Post::Multipart.new(url.path, the_hash, {'Accept' => 'application/json', 'User-Agent' => @opts[:user_agent] })
-
-			if @debug
-				http.set_debug_output($stdout)
-			end
-
-			resp = http.request(request)
-
-			case resp
-				when Net::HTTPSuccess, Net::HTTPRedirection
-					json = JSON.parse(resp.body)
-
-					if json['opstat'] != 'ok'
-						raise Gengo::Exception.new(json['opstat'], json['err']['code'].to_i, json['err']['msg'])
-					end
-
-					# Return it if there are no problems, nice...
-					json
-				else
-					resp.error!
-			end
-		end
-
-        # Returns a Ruby-hash of the stats for the current account. No arguments required!
-        #
-        # Options:
-        # <tt>None</tt> - N/A
-        def getAccountStats(params = {})
-          self.get_from_gengo('account/stats', params)
-        end
+      query[:api_key] = @opts[:public_key]
+      query[:ts] = Time.now.gmtime.to_i.to_s
 
-        # Returns a Ruby-hash of the balance for the authenticated account. No args required!
-        #
-        # Options:
-        # <tt>None</tt> - N/A
-        def getAccountBalance(params = {})
-          self.get_from_gengo('account/balance', params)
-        end
+      endpoint << "?api_sig=" + signature_of(query[:ts])
+      endpoint << '&' + query.map { |k, v| "#{k}=#{urlencode(v)}" }.join('&')
 
-        # Posts a translation job over to Gengo, returns a response indicating whether the submission was
-        # successful or not. Param list is quite expansive here, pay attention...
-        #
-        # Options:
-        # <tt>job</tt> - A job is a hash of data describing what you want translated. See the examples included for
-        # more information on what this should be. (type/slug/body_src/lc_src/lc_tgt/tier/auto_approve/comment/callback_url/custom_data)
-        def postTranslationJob(params = {})
-          self.send_to_gengo('translate/job', params)
-        end
+      uri = "/v#{@opts[:api_version]}/" + endpoint
+      headers = {
+        'Accept' => 'application/json',
+        'User-Agent' => @opts[:user_agent]
+      }
 
-        # Much like the above, but takes a hash titled "jobs" that is multiple jobs, each with their own unique key.
-        #
-        # Options:
-        # <tt>jobs</tt> - "Jobs" is a hash containing further hashes; each further hash is a job. This is best seen in the example code.
-        def postTranslationJobs(params = {})
-          self.send_to_gengo('translate/jobs', params)
-        end
+      if is_delete
+        req = Net::HTTP::Delete.new(uri, headers)
+      else
+        req = Net::HTTP::Get.new(uri, headers)
+      end
 
-        # Updates an already submitted job.
-        #
-        # Options:
-        # <tt>id</tt> - The ID of a job to update.
-        # <tt>action</tt> - A hash describing the update to this job. See the examples for further documentation.
-        def updateTranslationJob(params = {})
-          params[:is_put] = true
-          self.send_to_gengo('translate/job/:id'.gsub(':id', params.delete(:id).to_s), params)
-        end
+      http = Net::HTTP.start(@api_host, 80)
+      if @debug
+        http.set_debug_output($stdout)
+      end
+      http.read_timeout = 5*60
+      resp = http.request(req)
 
-        # Updates a group of already submitted jobs.
-        #
-        # Options:
-        # <tt>jobs</tt> - An Array of job objects to update (job objects or ids)
-        # <tt>action</tt> - A String describing the update to this job. "approved", "rejected", etc - see Gengo docs.
-        def updateTranslationJobs(params = {})
-          params[:is_put] = true
-          self.send_to_gengo('translate/jobs', {:jobs => params[:jobs], :action => params[:action]})
+      if is_download_file.nil?
+        json = JSON.parse(resp.body)
+        if json['opstat'] != 'ok'
+          raise Gengo::Exception.new(json['opstat'], json['err']['code'].to_i, json['err']['msg'])
         end
 
-        # Given an ID, pulls down information concerning that job from Gengo.
-        #
-        # <tt>id</tt> - The ID of a job to check.
-        # <tt>pre_mt</tt> - Optional, get a machine translation if the human translation is not done.
-        def getTranslationJob(params = {})
-          self.get_from_gengo('translate/job/:id'.gsub(':id', params.delete(:id).to_s), params)
-        end
+        # Return it if there are no problems, nice...
+        return json
+      else
+        return resp.body
+      end
 
-        # Pulls down a list of recently submitted jobs, allows some filters.
-        #
-        # <tt>status</tt> - Optional. "unpaid", "available", "pending", "reviewable", "approved", "rejected", or "canceled".
-        # <tt>timestamp_after</tt> - Optional. Epoch timestamp from which to filter submitted jobs.
-        # <tt>count</tt> - Optional. Defaults to 10.
-        def getTranslationJobs(params = {})
-          if params[:ids] and params[:ids].kind_of?(Array)
-            params[:ids] = params[:ids].map { |i| i.to_s() }.join(',')
-            self.get_from_gengo('translate/jobs/:ids'.gsub(':ids', params.delete(:ids)))
-          else
-            self.get_from_gengo('translate/jobs', params)
-          end
-        end
+    end
 
-        # Pulls a group of jobs that were previously submitted together.
-        #
-        # <tt>id</tt> - Required, the ID of a job that you want the batch/group of.
-        def getTranslationJobBatch(params = {})
-          self.get_from_gengo('translate/jobs/group/:group_id'.gsub(':group_id', params.delete(:group_id).to_s), params)
-        end
+    # The "POST" method; handles shuttling up encoded job data to Gengo
+    # for translation and such. Somewhat similar to the above methods, but depending on the scenario
+    # can get some strange exceptions, so we're gonna keep them fairly separate for the time being. Consider
+    # for a merger down the road...
+    #
+    # Options:
+    # <tt>endpoint</tt> - String/URL to post data to.
+    # <tt>params</tt> - Data necessary for request (keys, etc). Generally taken care of by the requesting instance.
+    def send_to_gengo(endpoint, params = {})
 
-        # Pulls a group of jobs that were previously submitted together.
-        #
-        # <tt>id</tt> - Required, the ID of a job that you want the batch/group of.
-        def getTranslationOrderJobs(params = {})
-          self.get_from_gengo('translate/order/:order_id'.gsub(':order_id', params.delete(:order_id).to_s), params)
-        end
+      # Check if this is a put
+      is_put = params.delete(:is_put)
 
-        # Mirrors the bulk Translation call, but just returns an estimated cost.
-        def determineTranslationCost(params = {})
-          is_upload = params.delete(:is_upload)
+      query = {
+        :api_key => @opts[:public_key],
+        :data => params.to_json.gsub('"', '\"'),
+        :ts => Time.now.gmtime.to_i.to_s
+      }
+
+      url = URI.parse("http://#{@api_host}/v#{@opts[:api_version]}/#{endpoint}")
+      http = Net::HTTP.new(url.host, url.port)
+      http.read_timeout = 5*60
+      if is_put
+        request = Net::HTTP::Put.new(url.path)
+      else
+        request = Net::HTTP::Post.new(url.path)
+      end
 
-          if is_upload
-            self.upload_to_gengo('translate/service/quote/file', params)
-          else
-            self.send_to_gengo('translate/service/quote', params)
-          end
-        end
+      request.add_field('Accept', 'application/json')
+      request.add_field('User-Agent', @opts[:user_agent])
 
-        # Post a comment for a translator or Gengo on a job.
-        #
-        # Options:
-        # <tt>id</tt> - The ID of the job you're commenting on.
-        # <tt>comment</tt> - The comment to put on the job.
-        def postTranslationJobComment(params = {})
-          self.send_to_gengo('translate/job/:id/comment'.gsub(':id', params.delete(:id).to_s), params)
-        end
+      request.content_type = 'application/x-www-form-urlencoded'
+      request.body = {
+        "api_sig" => signature_of(query[:ts]),
+        "api_key" => urlencode(@opts[:public_key]),
+        "data" => urlencode(params.to_json.gsub('\\', '\\\\')),
+        "ts" => query[:ts].to_i.to_s
+      }.map { |k, v| "#{k}=#{v}" }.flatten.join('&')
 
-        # Get all comments (the history) from a given job.
-        #
-        # Options:
-        # <tt>id</tt> - The ID of the job to get comments for.
-        def getTranslationJobComments(params = {})
-          self.get_from_gengo('translate/job/:id/comments'.gsub(':id', params.delete(:id).to_s), params)
-        end
+      if @debug
+        http.set_debug_output($stdout)
+      end
 
-        # Returns the feedback you've submitted for a given job.
-        #
-        # Options:
-        # <tt>id</tt> - The ID of the translation job you're retrieving comments from.
-        def getTranslationJobFeedback(params = {})
-          self.get_from_gengo('translate/job/:id/feedback'.gsub(':id', params.delete(:id).to_s), params)
-        end
+      resp = http.request(request)
 
-        # Gets a list of the revision resources for a job. Revisions are created each time a translator updates the text.
-        #
-        # Options:
-        # <tt>id</tt> - The ID of the translation job you're getting revisions from.
-        def getTranslationJobRevisions(params = {})
-          self.get_from_gengo('translate/job/:id/revisions'.gsub(':id', params.delete(:id).to_s), params)
-        end
+      case resp
+      when Net::HTTPSuccess, Net::HTTPRedirection
+        json = JSON.parse(resp.body)
 
-        # Get a specific revision to a job.
-        #
-        # Options:
-        # <tt>id</tt> - The ID of the translation job you're getting revisions from.
-        # <tt>rev_id</tt> - The ID of the revision you're looking up.
-        def getTranslationJobRevision(params = {})
-          self.get_from_gengo('translate/job/:id/revisions/:revision_id'.gsub(':id', params.delete(:id).to_s).gsub(':revision_id', params.delete(:rev_id).to_s), params)
+        if json['opstat'] != 'ok'
+          raise Gengo::Exception.new(json['opstat'], json['err']['code'].to_i, json['err']['msg'])
         end
 
-        # Returns a preview image for a job.
-        #
-        # Options:
-        # <tt>id</tt> - The ID of the job you want a preview image of.
-        def getTranslationJobPreviewImage(params = {})
-          params[:is_download] = true
-          self.get_from_gengo('translate/job/:id/preview'.gsub(':id', params.delete(:id).to_s), params)
-        end
+        # Return it if there are no problems, nice...
+        json
+      else
+        resp.error!
+      end
+    end
+
+    # The "UPLOAD" method; handles sending a file to the quote method
+    #
+    # Options:
+    # <tt>endpoint</tt> - String/URL to post data to.
+    # <tt>params</tt> - Data necessary for request (keys, etc). Generally taken care of by the requesting instance.
+    def upload_to_gengo(endpoint, params = {})
+
+      # prepare the file_hash and append file_key to each job payload
+      files_hash = params[:jobs].each_value.reduce({}) do |hash_thus_far, job_values|
+      if job_values[:file_path]
+        job_mime_type = MIME::Types.type_for(job_values[:file_path]).first.content_type
+        file_hash_key = "file_#{hash_thus_far.length.to_s}".to_sym
+        job_values[:file_key] = file_hash_key
+        hash_thus_far[file_hash_key] = UploadIO.new(File.open(job_values[:file_path]), job_mime_type, File.basename(job_values[:file_path]))
+      end
+        hash_thus_far
+      end
 
-        # Deletes a job.
-        #
-        # Options:
-        # <tt>id</tt> - The ID of the job you want to delete.
-        def deleteTranslationJob(params = {})
-                params[:is_delete] = true
-          self.get_from_gengo('translate/job/:id'.gsub(':id', params.delete(:id).to_s), params)
-        end
+      url = URI.parse("http://#{@api_host}/v#{@opts[:api_version]}/#{endpoint}")
 
-        # Deletes multiple jobs.
-        #
-        # Options:
-        # <tt>ids</tt> - An Array of job IDs you want to delete.
-        def deleteTranslationJobs(params = {})
-          if params[:ids] and params[:ids].kind_of?(Array)
-            params[:job_ids] = params[:ids].map { |i| i.to_s() }.join(',')
-            params.delete(:ids)
-          end
-
-                params[:is_delete] = true
-          self.get_from_gengo('translate/jobs', params)
-        end
+      http = Net::HTTP.new(url.host, url.port)
+      http.read_timeout = 5*60
 
-        # Gets information about currently supported language pairs.
-        #
-        # Options:
-        # <tt>lc_src</tt> - Optional language code to filter on.
-        def getServiceLanguagePairs(params = {})
-                self.get_from_gengo('translate/service/language_pairs', params)
-        end
+      call_timestamp = Time.now.gmtime.to_i.to_s
 
-        # Pulls down currently supported languages.
-        def getServiceLanguages(params = {})
-          self.get_from_gengo('translate/service/languages', params)
-        end
+      the_hash = files_hash.merge({
+        "api_sig" => signature_of(call_timestamp),
+        "api_key" => @opts[:public_key],
+        "data" =>params.to_json.gsub('\\', '\\\\'),
+        "ts" => call_timestamp
+      })
 
-        # Gets list of glossaries that belongs to the authenticated user
-        def getGlossaryList(params = {})
-            self.get_from_gengo('translate/glossary', params)
-        end
+      request = Net::HTTP::Post::Multipart.new(url.path, the_hash, {'Accept' => 'application/json', 'User-Agent' => @opts[:user_agent] })
 
-        # Gets one glossary that belongs to the authenticated user
-        def getGlossary(params = {})
-            self.get_from_gengo('translate/glossary/:id'.gsub(':id', params.delete(:id).to_s), params)
-        end
+      if @debug
+        http.set_debug_output($stdout)
+      end
+
+      resp = http.request(request)
+
+      case resp
+      when Net::HTTPSuccess, Net::HTTPRedirection
+        json = JSON.parse(resp.body)
 
-        # Downloads one glossary that belongs to the authenticated user
-        def getGlossaryFile(params = {})
-            params[:is_download] = true
-            self.get_from_gengo('translate/glossary/download/:id'.gsub(':id', params.delete(:id).to_s), params)
+        if json['opstat'] != 'ok'
+          raise Gengo::Exception.new(json['opstat'], json['err']['code'].to_i, json['err']['msg'])
         end
+
+        # Return it if there are no problems, nice...
+        json
+      else
+        resp.error!
+      end
+    end
+
+    # Returns a Ruby-hash of the stats for the current account. No arguments required!
+    #
+    # Options:
+    # <tt>None</tt> - N/A
+    def getAccountStats(params = {})
+      self.get_from_gengo('account/stats', params)
+    end
+
+    # Returns a Ruby-hash of the balance for the authenticated account. No args required!
+    #
+    # Options:
+    # <tt>None</tt> - N/A
+    def getAccountBalance(params = {})
+      self.get_from_gengo('account/balance', params)
+    end
+
+    # Much like the above, but takes a hash titled "jobs" that is multiple jobs, each with their own unique key.
+    #
+    # Options:
+    # <tt>jobs</tt> - "Jobs" is a hash containing further hashes; each further hash is a job. This is best seen in the example code.
+    def postTranslationJobs(params = {})
+      self.send_to_gengo('translate/jobs', params)
+    end
+
+    # Updates an already submitted job.
+    #
+    # Options:
+    # <tt>id</tt> - The ID of a job to update.
+    # <tt>action</tt> - A hash describing the update to this job. See the examples for further documentation.
+    def updateTranslationJob(params = {})
+      params[:is_put] = true
+      self.send_to_gengo('translate/job/:id'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Updates a group of already submitted jobs.
+    #
+    # Options:
+    # <tt>jobs</tt> - An Array of job objects to update (job objects or ids)
+    # <tt>action</tt> - A String describing the update to this job. "approved", "rejected", etc - see Gengo docs.
+    def updateTranslationJobs(params = {})
+      params[:is_put] = true
+      self.send_to_gengo('translate/jobs', {:jobs => params[:jobs], :action => params[:action]})
+    end
+
+    # Given an ID, pulls down information concerning that job from Gengo.
+    #
+    # <tt>id</tt> - The ID of a job to check.
+    # <tt>pre_mt</tt> - Optional, get a machine translation if the human translation is not done.
+    def getTranslationJob(params = {})
+      self.get_from_gengo('translate/job/:id'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Pulls down a list of recently submitted jobs, allows some filters.
+    #
+    # <tt>status</tt> - Optional. "unpaid", "available", "pending", "reviewable", "approved", "rejected", or "canceled".
+    # <tt>timestamp_after</tt> - Optional. Epoch timestamp from which to filter submitted jobs.
+    # <tt>count</tt> - Optional. Defaults to 10.
+    def getTranslationJobs(params = {})
+      if params[:ids] and params[:ids].kind_of?(Array)
+        params[:ids] = params[:ids].map { |i| i.to_s() }.join(',')
+        self.get_from_gengo('translate/jobs/:ids'.gsub(':ids', params.delete(:ids)))
+      else
+        self.get_from_gengo('translate/jobs', params)
+      end
+    end
+
+    # Pulls a group of jobs that were previously submitted together.
+    #
+    # <tt>id</tt> - Required, the ID of a job that you want the batch/group of.
+    def getTranslationJobBatch(params = {})
+      self.get_from_gengo('translate/jobs/group/:group_id'.gsub(':group_id', params.delete(:group_id).to_s), params)
+    end
+
+    # Pulls a group of jobs that were previously submitted together.
+    #
+    # <tt>id</tt> - Required, the ID of a job that you want the batch/group of.
+    def getTranslationOrderJobs(params = {})
+      self.get_from_gengo('translate/order/:order_id'.gsub(':order_id', params.delete(:order_id).to_s), params)
+    end
+
+    # Mirrors the bulk Translation call, but just returns an estimated cost.
+    def determineTranslationCost(params = {})
+      is_upload = params.delete(:is_upload)
+      if is_upload
+        self.upload_to_gengo('translate/service/quote/file', params)
+      else
+        self.send_to_gengo('translate/service/quote', params)
       end
+    end
+
+    # Mirrors the bulk Translation call, but just returns an estimated cost.
+    def getTranslationQuote(params = {})
+      determineTranslationCost(params)
+    end
+
+    # Post a comment for a translator or Gengo on a job.
+    #
+    # Options:
+    # <tt>id</tt> - The ID of the job you're commenting on.
+    # <tt>comment</tt> - The comment to put on the job.
+    def postTranslationJobComment(params = {})
+      self.send_to_gengo('translate/job/:id/comment'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Get all comments (the history) from a given job.
+    #
+    # Options:
+    # <tt>id</tt> - The ID of the job to get comments for.
+    def getTranslationJobComments(params = {})
+      self.get_from_gengo('translate/job/:id/comments'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Returns the feedback you've submitted for a given job.
+    #
+    # Options:
+    # <tt>id</tt> - The ID of the translation job you're retrieving comments from.
+    def getTranslationJobFeedback(params = {})
+      self.get_from_gengo('translate/job/:id/feedback'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Gets a list of the revision resources for a job. Revisions are created each time a translator updates the text.
+    #
+    # Options:
+    # <tt>id</tt> - The ID of the translation job you're getting revisions from.
+    def getTranslationJobRevisions(params = {})
+      self.get_from_gengo('translate/job/:id/revisions'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Get a specific revision to a job.
+    #
+    # Options:
+    # <tt>id</tt> - The ID of the translation job you're getting revisions from.
+    # <tt>rev_id</tt> - The ID of the revision you're looking up.
+    def getTranslationJobRevision(params = {})
+      self.get_from_gengo('translate/job/:id/revisions/:revision_id'.gsub(':id', params.delete(:id).to_s).gsub(':revision_id', params.delete(:rev_id).to_s), params)
+    end
+
+    # Returns a preview image for a job.
+    #
+    # Options:
+    # <tt>id</tt> - The ID of the job you want a preview image of.
+    def getTranslationJobPreviewImage(params = {})
+      params[:is_download] = true
+      self.get_from_gengo('translate/job/:id/preview'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Deletes an order, cancelling all available jobs.
+    #
+    # This method is EXPERIMENTAL
+    #
+    # Options:
+    # <tt>id</tt> - The ID of the order you want to delete.
+    def deleteTranslationOrder(params = {})
+      params[:is_delete] = true
+      self.get_from_gengo('translate/order/:id'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Deletes a job.
+    #
+    # Options:
+    # <tt>id</tt> - The ID of the job you want to delete.
+    def deleteTranslationJob(params = {})
+      params[:is_delete] = true
+      self.get_from_gengo('translate/job/:id'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Deletes multiple jobs.
+    #
+    # Options:
+    # <tt>ids</tt> - An Array of job IDs you want to delete.
+    def deleteTranslationJobs(params = {})
+      if params[:ids] and params[:ids].kind_of?(Array)
+        params[:job_ids] = params[:ids].map { |i| i.to_s() }.join(',')
+        params.delete(:ids)
+      end
+
+      params[:is_delete] = true
+      self.get_from_gengo('translate/jobs', params)
+    end
+
+    # Gets information about currently supported language pairs.
+    #
+    # Options:
+    # <tt>lc_src</tt> - Optional language code to filter on.
+    def getServiceLanguagePairs(params = {})
+      self.get_from_gengo('translate/service/language_pairs', params)
+    end
+
+    # Pulls down currently supported languages.
+    def getServiceLanguages(params = {})
+      self.get_from_gengo('translate/service/languages', params)
+    end
+
+    # Gets list of glossaries that belongs to the authenticated user
+    def getGlossaryList(params = {})
+      self.get_from_gengo('translate/glossary', params)
+    end
+
+    # Gets one glossary that belongs to the authenticated user
+    def getGlossary(params = {})
+      self.get_from_gengo('translate/glossary/:id'.gsub(':id', params.delete(:id).to_s), params)
+    end
+
+    # Downloads one glossary that belongs to the authenticated user
+    def getGlossaryFile(params = {})
+      params[:is_download] = true
+      self.get_from_gengo('translate/glossary/download/:id'.gsub(':id', params.delete(:id).to_s), params)
+    end
+  end
 
 end

data/lib/gengo-ruby/gengo_exception.rb

@@ -1,15 +1,15 @@
 module Gengo
-	# Base Exception class and such.
-	class Gengo::Exception < ::StandardError
-		attr_accessor :opstat, :code, :msg
+  # Base Exception class and such.
+  class Gengo::Exception < ::StandardError
+    attr_accessor :opstat, :code, :msg
 
-		# Pretty self explanatory stuff here...
-		def initialize(opstat, code, msg)
-			@opstat = opstat
-			@code = code
-			@msg = msg
+    # Pretty self explanatory stuff here...
+    def initialize(opstat, code, msg)
+      @opstat = opstat
+      @code = code
+      @msg = msg
 
-			puts msg
-		end
-	end
+      puts msg
+    end
+  end
 end

data/lib/gengo.rb

@@ -3,13 +3,13 @@ require 'gengo-ruby/api_handler'
 require 'gengo-ruby/gengo_exception'
 
 module Gengo
-	# Store global config objects here - e.g, urls, etc.
-	module Config
-		# API url endpoints; replace the version at function call time to
-		# allow for function-by-function differences in versioning.
-		API_HOST = 'api.gengo.com'
-		SANDBOX_API_HOST = 'api.sandbox.gengo.com'
+  # Store global config objects here - e.g, urls, etc.
+  module Config
+    # API url endpoints; replace the version at function call time to
+    # allow for function-by-function differences in versioning.
+    API_HOST = 'api.gengo.com'
+    SANDBOX_API_HOST = 'api.sandbox.gengo.com'
 
-		VERSION = '0.0.0'
-	end
+    VERSION = '0.0.0'
+  end
 end

metadata

@@ -1,22 +1,23 @@
 --- !ruby/object:Gem::Specification 
 name: gengo
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Matthew Romaine
 - Shawn Smith
+- Issam Zeibak
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2012-11-19 00:00:00 Z
+date: 2013-04-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -135,8 +136,8 @@ files:
 - Rakefile
 - README.md
 homepage: http://developers.gengo.com
-licenses: []
-
+licenses: 
+- New BSD
 post_install_message: 
 rdoc_options: []