verbalizeit 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 96a46207cd03946e6882b755dda04b6d7cacc70f
+  data.tar.gz: 6e21afa7e84b5928c542e1e024c31a5c298a3856
+SHA512:
+  metadata.gz: ad3107664c67a828e43bb800f3b0d9a3d365d91fafbbf38530d4a2d73984aca3b7b197a47a2f32ab1a13e2cf9b420f1b169be40073c77dd5606fa160a69e2aa7
+  data.tar.gz: ab7be31b5b3de30e2e5d0cd5418baaa44fb4e9737c119d44e96cab1748bac214f13ccd5a83f703a110a80efc428553f6dfac71f9b47c7bdff61abf0961e55e6f

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.env

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nathanael Burt
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,150 @@
+# Verbalizeit
+
+The VerbalizeIt gem is a wrapper for [VerbalizeIt’s](https://www.verbalizeit.com) V2 API. Full documentation for the V2 API can be found [here](https://customers.verbalizeit.com/api_documentation). The VerbalizeIt API allows developers to submit files for translation or transcription directly, without using the Customer Dashboard.
+
+## Code Status
+
+[![Circle CI](https://circleci.com/gh/VerbalizeItInc/verbalizeit.svg?style=svg)](https://circleci.com/gh/VerbalizeItInc/verbalizeit)
+[![Code Climate](https://codeclimate.com/github/VerbalizeItInc/verbalizeit/badges/gpa.svg)](https://codeclimate.com/github/VerbalizeItInc/verbalizeit)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'verbalizeit'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install verbalizeit
+
+## Usage
+
+The VerbalizeIt gem supports the same endpoints as the V2 API.
+
+### Authentication
+
+Initialize the VerbalizeIt client with your API key and the API environment. The supported API environments are `:staging` and `:production`.
+
+```ruby
+client = VerbalizeIt::Client.new('my_key', :staging)
+```
+
+### Languages
+
+##### List
+
+Returns an array of `Verbalizeit::Language` objects.
+
+```ruby
+languages = client.languages
+#=> [Verbalizeit::Language,...]
+```
+
+A `Verbalizeit::Language` has a `name` and a `language_region_code`
+
+```ruby
+language = languages.first
+
+language.name
+#=> "English"
+language.language_region_code 
+#=> "eng-US"
+```
+
+### Tasks
+
+##### List
+
+Returns an array of `Verbalizeit::Task` objects. `list_tasks` has three optional parameters: `start`, `limit`, and `status`. By default, the `limit` is set to 10.
+
+```ruby
+client.list_tasks({start: 0, limit: 5, status: 'preview'})
+#=> {
+#  total: 10,
+#  start: 0,
+#  limit: 5,
+#  tasks: [Verbalizeit::Task,...]
+# }
+```
+
+##### Show
+
+Returns a `Verbalizeit::Task` object.
+
+```ruby
+id = 'T2EB60C'
+task = client.get_task(id)
+#=> Verbalizeit::Task
+```
+
+A task has methods for each attribute. See the [tasks show response](https://customers.verbalizeit.com/api_documentation#tasks_show) in the V2 API documentation for a full list of attributes.
+
+```ruby
+task.id
+#=> 'T2EB60C'
+
+task.status
+#=> 'preview'
+
+task.price_amount
+#=> 11.22
+```
+
+##### Create
+
+Creates a new task in the VerbalizeIt system. Returns a `Verbalizeit::Task`.
+
+Required parameters: `operation`, `source_language`, `target_language`, at least one of `file` or `media_resource_url`.
+Optional parameters: `postback_url`, `status_url`, `start`, `rush_order`
+
+Optional parameters, as well as the `file` and `media_resource_url`, are passed in through an options hash.
+
+```ruby
+client.create_task('text_translation', 'eng-US', 'fra-FR', {file: 'file.xliff', postback_url: 'https://www.postback.com'})
+#=> Verbalizeit::Task
+```
+
+##### Start
+
+Starts a created task. Returns a status code of `200`.
+
+```ruby
+id = 'T2EB60C'
+client.start_task(id)
+#=> 200
+```
+
+##### Download Completed File
+
+Returns a struct with the filename and body of a completed file for a task. Only available if the task is in the "complete" state.
+
+```ruby
+id = 'T2EB60C'
+completed_file = client.task_completed_file(id)
+completed_file.filename
+#=> sample.txt
+completed_file.content
+#=> "This is some sample text. \n\n And here is another paragraph"
+```
+
+If you would like to write the file to your local filesytem, you could do something like this.
+
+```ruby
+file = File.open(completed_file.filename, "w")
+file << completed_file.content
+file.close
+```
+
+### Errors
+
+There are 5 types of errors.
+
+* `Verbalizeit::Error::Unauthorized` is raised if the `Verbalizeit::Client` is initialized with an invalid API key, or if the API key does not match the environement. API keys can be created from the customer dashboard under 'API' in the left-hand navigation.
+* `Verbalizeit::Error::UnknownEnvironment` is raised if the client is initialized with an environment that does not exist. The available environments are `:staging` and `:production`.
+* `Verbalizeit::Error::BadRequest` can be raised for a variety of reasons, the error message will help you debug why this is being raised. Common examples would be creating a task with an invalid `operation`, `source_language`, or `target_language`.
+* `Verbalizeit::Error::Forbidden` is raised if the user tries to access a task that does not belong to them.
+* `Verbalizeit::Error::NotFound` is raised if the user tries to access a task that does not exist.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/verbalizeit.rb

@@ -0,0 +1,10 @@
+require "verbalizeit/version"
+require "verbalizeit/client"
+require "verbalizeit/language"
+require "verbalizeit/error"
+require "verbalizeit/task"
+require "verbalizeit/translator"
+
+module Verbalizeit
+  # Your code goes here...
+end

data/lib/verbalizeit/client.rb

@@ -0,0 +1,151 @@
+require 'typhoeus'
+require 'json'
+module Verbalizeit
+  class Client
+
+    attr_reader :languages
+
+    def initialize(api_key, environement)
+      @api_key = api_key
+      @environment = environement
+      @languages = fetch_languages
+    end
+
+    def create_task(source_language, target_language, operation, options = {})
+      body = {
+        source_language: source_language,
+        target_language: target_language,
+        operation: operation,
+        file: options[:file],
+        media_resource_url: options[:media_resource_url],
+        start: "#{options[:start]}",
+        rush_order: "#{options[:rush_order]}",
+        postback_url: options[:postback_url],
+        status_url: options[:status_url]
+      }
+
+      response = Typhoeus.post(tasks_url, body: body, headers: authorization_header)
+
+      if response.code == 200
+        Task.from(parse_body(response.body), self)
+      elsif response.code == 400
+        raise Error::BadRequest, format_errors(response.body)
+      elsif response.code == 401
+        raise Error::Unauthorized
+      end
+    end
+
+    def list_tasks(options = {})
+      params = {
+        start: options[:start],
+        limit: options[:limit] || 10,
+        status: options[:status]
+      }
+      response = Typhoeus.get(tasks_url, params: params, headers: authorization_header)
+
+      if response.code == 200
+        list_tasks_success(response.body)
+      else
+        raise Error::NotImplemented
+      end
+    end
+
+    def get_task(id)
+      response = Typhoeus.get(get_task_url(id), headers: authorization_header)
+      validate_response(response.code)
+      Task.from(parse_body(response.body), self)
+    end
+
+    def start_task(id)
+      response = Typhoeus.post(start_task_url(id), headers: authorization_header)
+      validate_response(response.code)
+      true
+    end
+
+    def task_completed_file(id)
+      response = Typhoeus.get(task_completed_file_url(id), headers: authorization_header)
+      validate_response(response.code)
+
+      # original string => "attachment; filename=\"sample.srt\""
+      filename = response.headers["Content-Disposition"].rpartition("filename=").last
+      struct = Struct.new(:filename, :content)
+      struct.new(filename, response.body)
+    end
+
+    private
+
+    def validate_response(code)
+      if code == 404
+        raise Error::NotFound
+      elsif code == 403
+        raise Error::Forbidden
+      end
+    end
+
+    def list_tasks_success(body)
+      parsed_body = parse_body(body)
+
+      {
+        total: parsed_body["total"],
+        start: parsed_body["start"],
+        limit: parsed_body["limit"],
+        tasks: parsed_body["tasks"].map { |task| Task.from(task, self) }
+      }
+    end
+
+    def fetch_languages
+      response = Typhoeus.get(languages_url, headers: authorization_header)
+
+      if response.code == 200
+        parsed_body = JSON.parse(response.body)
+        parsed_body.map { |language| Language.new(language) }
+      elsif response.code == 401
+        raise Error::Unauthorized
+      end
+    end
+
+    def task_completed_file_url(id)
+      get_task_url(id) << "/completed_file"
+    end
+
+    def start_task_url(id)
+      get_task_url(id) << "/start"
+    end
+
+    def get_task_url(id)
+      tasks_url << "/#{id}"
+    end
+
+    def tasks_url
+      base_url << "tasks"
+    end
+
+    def languages_url
+      base_url << "languages"
+    end
+
+    def base_url
+      case @environment
+        when :staging
+          "https://stagingapi.verbalizeit.com/v2/"
+        when :production
+          "https://api.verbalizeit.com/v2/"
+        else
+          raise Error::UnknownEnvironment, "you may specify :staging or :production"
+      end
+    end
+
+    def authorization_header
+      {"x-api-key" => @api_key}
+    end
+
+    def format_errors(body)
+      parse_body(body).map { |_, errors| errors.map { |type, error| error } }.flatten.join(".")
+    end
+
+    def parse_body(body)
+      JSON.parse(body)
+    end
+
+  end
+end

data/lib/verbalizeit/error.rb

@@ -0,0 +1,21 @@
+module Verbalizeit
+  module Error
+    class UnknownEnvironment < StandardError
+    end
+
+    class Unauthorized < StandardError
+    end
+
+    class BadRequest < StandardError
+    end
+
+    class NotImplemented < StandardError
+    end
+
+    class Forbidden < StandardError
+    end
+
+    class NotFound < StandardError
+    end
+  end
+end

data/lib/verbalizeit/language.rb

@@ -0,0 +1,16 @@
+module Verbalizeit
+  class Language
+
+    attr_reader :name, :language_region_code
+
+    def initialize(attributes)
+      @name = attributes[:name] || attributes["name"]
+      @language_region_code = attributes[:language_region_code] || attributes["language_region_code"]
+    end
+
+    def self.find_by_language_region_code(languages, language_region_code)
+      languages.select {|l| l.language_region_code == language_region_code}.first
+    end
+
+  end
+end

data/lib/verbalizeit/task.rb

@@ -0,0 +1,110 @@
+module Verbalizeit
+  class Task
+
+    def self.from(body, client)
+      new(body, client)
+    end
+
+    def initialize(task, client)
+      @task = task
+      @client = client
+    end
+
+    def id
+      @task["id"]
+    end
+
+    def url
+      @task["url"]
+    end
+
+    def status
+      @task["status"]
+    end
+
+    def rush_order
+      @task["rush_order"]
+    end
+
+    def project_name
+      @task["project_name"]
+    end
+
+    def source_language
+      Language.find_by_language_region_code(@client.languages, @task["source_language"])
+    end
+
+    def target_language
+      Language.find_by_language_region_code(@client.languages, @task["target_language"])
+    end
+
+    def price_currency
+      @task["price_currency"]
+    end
+
+    def price_amount
+      @task["price_amount"]
+    end
+
+    def due_at
+      @task["due_at"]
+    end
+
+    def completed_at
+      @task["completed_at"]
+    end
+
+    def created_at
+      @task["created_at"]
+    end
+
+    def operation
+      @task["operation"]
+    end
+
+    def download_url
+      @task["download_url"]
+    end
+
+    def source_download_url
+      @task["source_download_url"]
+    end
+
+    def source_filename
+      @task["source_filename"]
+    end
+
+    def unit_count
+      @task["unit_count"]
+    end
+
+    def unit_type
+      @task["unit_type"]
+    end
+
+    def translation_units
+      @task["translation_units"]
+    end
+
+    def translation_units_complete
+      @task["translation_units_complete"]
+    end
+
+    def translator
+      Translator.new(@task["translator"])
+    end
+
+    def reviewer
+      Translator.new(@task["reviewer"])
+    end
+
+    def postback_url
+      @task["postback_url"]
+    end
+
+    def status_url
+      @task["status_url"]
+    end
+
+  end
+end