voicebase-client-ruby 1.0.14

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3dff5518b93777f4361ef5ae09534b24f26b81fd
+  data.tar.gz: a7b02a83c9ec5b4bca5da34213544f7049e45395
+SHA512:
+  metadata.gz: 722c6172937548128010286413d6a684a1ab6507812a6213091246fe2af74d45fb5fe8eaf9468d4865e1e3510365eea5049931b90a91de21f1635dc4faf58c6f
+  data.tar.gz: 4472a71f64fd1bdd655c2396161da6b0afbfa0046cc6a03ad105a4ee99cbfe15ffd62fe67324d6f8b9ac88b0eab6cb3e6033c69de4c075d505221f0b11d72ed0

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+/.idea/

data/.rspec

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

data/.ruby-gemset

@@ -0,0 +1 @@
+voicebase-client-ruby

data/.ruby-version

@@ -0,0 +1 @@
+2.2.4

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.4
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in voicebase-client-ruby.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,17 @@
+The MIT License (MIT)
+Copyright (c) 2016 User Testing, Inc.
+
+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,91 @@
+# Voicebase Client Ruby
+
+This is a Ruby client to the VoiceBase API Version [1.x](http://www.voicebase.com/developers/), see [API documentation](https://s3.amazonaws.com/vb-developers/VB-api-devguide-v1.1.5.pdf), and [2.x](https://apis.voicebase.com). Some portions of this gem were derived from [voicebase-client-ruby](https://github.com/popuparchive/voicebase-client-ruby).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'voicebase-client-ruby', github: "usertesting/voicebase-client-ruby"
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+### VoiceBase API V1.x:
+
+An example to authenticate with v1 and upload a video file.
+
+```ruby
+require 'voicebase'
+
+client = VoiceBase::Client.new({
+  api_version: "1.1",
+  auth_key: "my-voicebase-key",
+  auth_secret: "my-voicebase-secret",
+})
+
+client.upload_media({
+  media_url: "http://my.media-example.com/media1.mp4",
+  title: "My fancy media",
+  transcription_type: 'machine',
+  external_id: 'abcd1234',
+  machine_ready_callback: "http://my.example.com/success",
+  error_callback: "http://my.example.com/error"
+})
+
+response = get_transcript(external_id: 'abcd1234' format: "json")
+if response.success?
+  transcript_json = JSON.parse(response.transcript)
+end
+
+```
+
+For VoiceBase API V2.x:
+
+```ruby
+require 'voicebase'
+
+client = VoiceBase::Client.new({
+  api_version: "2.0.beta",
+  auth_key: "my-voicebase-key",
+  auth_secret: "my-voicebase-secret",
+})
+
+client.upload_media({
+  media_url: "http://my.media-example.com/media1.mp4",
+  configuration: {
+    transcripts: {
+      engine: "premium"
+    },
+    publish: {
+      callbacks: [{
+        url: "https://example.org/callback",
+        method: "POST",
+        include: ["transcripts", "keywords", "topics", "metadata"]
+      }]
+    }
+  }
+})
+
+client.get_transcript({
+  media_id: "3b5c78e2-868c-4ce7-a0db-087a02db4042"
+}, {'Accept' => 'text/srt'})
+
+...
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/usertesting/voicebase-client-ruby.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "voicebase/client/ruby"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/voicebase.rb

@@ -0,0 +1,22 @@
+require 'json'
+require 'uri'
+require 'httparty'
+require 'active_support/core_ext/module'
+
+require "voicebase/version"
+require "voicebase/helpers"
+
+require "voicebase/v1"
+require "voicebase/v2"
+
+require "voicebase/client"
+require "voicebase/client/token"
+require "voicebase/response"
+
+require "voicebase/json"
+require "voicebase/json/word"
+
+module VoiceBase
+  class AuthenticationError < StandardError; end
+  class ArgumentError < StandardError; end
+end

data/lib/voicebase/client.rb

@@ -0,0 +1,41 @@
+module VoiceBase
+  class Client
+    include HTTParty
+
+    attr_accessor :args
+    attr_accessor :api_host
+    attr_accessor :api_endpoint
+    attr_accessor :api_version
+    attr_accessor :debug
+    attr_accessor :user_agent
+    attr_accessor :cookies
+    attr_accessor :locale
+    attr_accessor :token
+
+    # E.g. "request_status" -> "requestStatus"
+    def self.camelize_name(snake_cased_name)
+      snake_cased_name.to_s.camelize(:lower)
+    end
+
+    def initialize(args = {})
+      @args                = args
+      @api_version         = args[:api_version] || ENV.fetch('VOICEBASE_API_VERSION', '1.1')
+      @auth_key            = args[:auth_key] || ENV['VOICEBASE_API_KEY']
+      @auth_secret         = args[:auth_secret] || ENV['VOICEBASE_API_SECRET']
+      @debug               = !!args[:debug]
+      @user_agent          = args[:user_agent] || "usertesting-client/#{VoiceBase::version}"
+      @locale              = args[:locale] || 'en'  # US English
+
+      if @api_version.to_f < 2.0
+        self.extend(VoiceBase::V1::Client)
+      else
+        self.extend(VoiceBase::V2::Client)
+      end
+    end
+
+    def uri
+      @api_host + @api_endpoint
+    end
+
+  end
+end

data/lib/voicebase/client/token.rb

@@ -0,0 +1,16 @@
+module VoiceBase
+  class Client::Token
+    attr_accessor :token, :created_at, :timeout
+
+    def initialize(token, timeout = Float::INFINITY)
+      raise VoiceBase::AuthenticationError, "Authentication token cannot be empty" unless token
+      @token      = token
+      @created_at = Time.now
+      @timeout    = timeout
+    end
+
+    def expired?
+      Time.now > created_at + (timeout / 1000.to_f)
+    end
+  end
+end

data/lib/voicebase/helpers.rb

@@ -0,0 +1,25 @@
+module VoiceBase
+  module Helpers
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module ClassMethods
+
+      # E.g. "request_status" -> "requestStatus"
+      def camelize_name(snake_cased_name)
+        snake_cased_name.to_s.camelize(:lower)
+      end
+
+    end
+
+    module InstanceMethods
+
+      def camelize_name(snake_cased_name)
+        self.class.camelize_name(snake_cased_name)
+      end
+
+    end
+  end
+end

data/lib/voicebase/json.rb

@@ -0,0 +1,89 @@
+module VoiceBase
+  class JSON
+    include Enumerable
+
+    class ParseError < StandardError; end
+
+    class << self
+
+      def parse(input, options = {})
+        @debug = options.fetch(:debug, false)
+        if input.is_a?(String)
+          parse_string(input)
+        elsif input.is_a?(::File)
+          parse_file(input)
+        else
+          raise "Invalid input. Expected a String or File, got #{input.class.name}."
+        end
+      end
+
+      private
+
+      def parse_file(json_file)
+        parse_string ::File.open(json_file, 'rb') { |f| json_file.read }
+      end
+
+      def parse_string(json_string_data)
+        result = new
+
+        json_hash_data = ::JSON.parse(json_string_data)
+        raise ParseError, "Invalid format" unless json_hash_data.is_a?(Array)
+        json_hash_data.each_with_index do |word_hash, index|
+          word = Word.new(word_hash)
+          result.words << word unless word.empty?
+
+          %w(p c s e w).each do |field|
+            if word.send(field).nil?
+              word.error = "#{index}, Invalid formatting of #{field}, [#{word_hash[field]}]"
+              $stderr.puts word.error if @debug
+            end
+          end
+        end
+        result
+      end
+    end
+
+    attr_writer :words
+
+    def initialize(word_array = nil)
+      raise StandardError, "Must be initialized with words." if word_array.is_a?(Array) && !words.all? {|w| w.is_a?(VoiceBase::JSON::Word)}
+      @words = word_array || []
+    end
+
+    def words
+      @words ||= []
+    end
+
+    def errors
+      @words.map {|w| w.error if w.error}.compact
+    end
+
+    def each(&block)
+      @words.each {|word| block.call(word)}
+    end
+
+    def gt(start_time)
+      VoiceBase::JSON.new(select {|w| w.start_time > start_time})
+    end
+
+    def gteq(start_time)
+      VoiceBase::JSON.new(select {|w| w.start_time >= start_time})
+    end
+
+    def lt(start_time)
+      VoiceBase::JSON.new(select {|w| w.start_time < start_time})
+    end
+
+    def lteq(start_time)
+      VoiceBase::JSON.new(select {|w| w.start_time <= start_time})
+    end
+
+    def to_a
+      @words
+    end
+
+    def to_json
+      map {|w| w.to_hash}.to_json
+    end
+  end
+end

data/lib/voicebase/json/word.rb

@@ -0,0 +1,63 @@
+module VoiceBase
+  class JSON::Word
+    attr_accessor :sequence
+    attr_accessor :start_time
+    attr_accessor :end_time
+    attr_accessor :confidence
+    attr_accessor :word
+    attr_accessor :error
+    attr_accessor :metadata
+
+    alias_method :p, :sequence
+    alias_method :p=, :sequence=
+    alias_method :c, :confidence
+    alias_method :c=, :confidence=
+    alias_method :s, :start_time
+    alias_method :s=, :start_time=
+    alias_method :e, :end_time
+    alias_method :e=, :end_time=
+    alias_method :w, :word
+    alias_method :w=, :word=
+    alias_method :m, :metadata
+    alias_method :m=, :metadata=
+
+    def initialize(options={})
+      options.each do |k,v|
+        self.send("#{k}=",v)
+      end
+    end
+
+    def clone
+      clone = VoiceBase::JSON::Word.new
+      clone.sequence   = sequence
+      clone.start_time = start_time
+      clone.end_time   = end_time
+      clone.confidence = confidence
+      clone.error      = error
+      clone.word       = word
+      clone.metadata   = metadata
+      clone
+    end
+
+    def ==(word)
+      self.sequence   == word.sequence &&
+      self.start_time == word.start_time &&
+      self.end_time   == word.end_time &&
+      self.confidence == word.confidence &&
+      self.word       == word.word &&
+      self.metadata   == word.metadata
+    end
+
+    def empty?
+      sequence.nil? && start_time.nil? && end_time.nil? && (word.nil? || word.empty?)
+    end
+
+    def to_hash
+      {"p": sequence, "c": confidence, "s": start_time, "e": end_time, "w": word}
+    end
+
+    def to_json
+      {"p": sequence, "c": confidence, "s": start_time, "e": end_time, "w": word}.to_json
+    end
+  end
+end

data/lib/voicebase/response.rb

@@ -0,0 +1,35 @@
+module VoiceBase
+  class Response
+    include Helpers
+    attr_accessor :http_response
+
+    delegate :code, :body, :headers, :message, to: :http_response, allow_nil: true
+
+    def initialize(http_response, api_version = "1.1")
+      @http_response = http_response
+      if api_version.to_f < 2
+        self.extend(VoiceBase::V1::Response)
+      else
+        self.extend(VoiceBase::V2::Response)
+      end
+    end
+
+    def ok?
+      http_response.code && http_response.code >= 200 && http_response.code < 300
+    end
+
+    # E.g.
+    #
+    # @response.request_status is derived from the
+    # response hash 'statusMessage' key, or
+    # @response.status_message from 'statusMessage'
+    #
+    def method_missing(method, *args, &block)
+      if result = http_response.parsed_response[camelize_name(method)]
+        result
+      else
+        super
+      end
+    end
+  end
+end

data/lib/voicebase/v1.rb

@@ -0,0 +1,6 @@
+module VoiceBase
+  module V1; end
+end
+
+require "voicebase/v1/client"
+require "voicebase/v1/response"

data/lib/voicebase/v1/client.rb

@@ -0,0 +1,92 @@
+module VoiceBase
+  module V1
+    module Client
+      include Helpers
+
+      TOKEN_TIMEOUT_IN_MS = 1440
+      PARAM_NORMALIZATION = {"Url" => "URL", "Id" => "ID", "Callback" => "CallBack"}
+      ACTIONS             = ['uploadMedia', 'getTranscript', 'deleteFile', 'getFileStatus']
+
+      def self.extended(client, args = {})
+        client.api_host     = client.args[:api_host] || ENV.fetch('VOICEBASE_V1_API_HOST', 'https://api.voicebase.com')
+        client.api_endpoint = client.args[:api_endpoint] || ENV.fetch('VOICEBASE_V1_API_ENDPOINT', '/services')
+      end
+
+      def authenticate!
+        response = VoiceBase::Response.new(
+          self.class.post(uri,
+          query: {
+            version: @api_version, apiKey: @auth_key,
+            password: @auth_secret, action: 'getToken',
+            timeout: TOKEN_TIMEOUT_IN_MS
+          }), api_version)
+        @token = Token.new(response.token, TOKEN_TIMEOUT_IN_MS)
+      rescue NoMethodError => ex
+        raise VoiceBase::AuthenticationError, response.status_message
+      end
+
+      # E.g. @client.upload_media media_url: "https://ut.aws.amazon.com/..."
+      def method_missing(method, args, &block)
+        if actions.include?(camelize_name(method)) && args.size > 0
+          post camelize_keys(args).merge({action: camelize_name(method)})
+        else
+          super
+        end
+      end
+
+      private
+
+      def post(query_params, headers = {})
+        query = default_query(query_params)
+
+        puts "post #{uri} #{query.inspect}, #{default_headers(headers).inspect}" if debug
+        VoiceBase::Response.new(self.class.post(uri,
+          query: query, headers: default_headers(headers)), api_version)
+      end
+
+      def actions
+        ACTIONS
+      end
+
+      def default_query(params = {})
+        params = params.reverse_merge({version: @api_version,
+          apiKey: @auth_key, password: @auth_secret,
+          lang: locale})
+
+        # authenticate using token or key/password?
+        if token && !token.expired?
+          params.merge!({token: token.token})
+        else
+          params.merge!({apiKey: @auth_key, password: @auth_secret})
+        end
+
+        params
+      end
+
+      def default_headers(headers = {})
+        {'User-Agent' => @user_agent, 'Accept' => 'application/json',
+          'Cookie' => @cookies}.reject {|k, v| v.blank?}.merge(headers)
+      end
+
+      def camelize_keys(params)
+        params.inject({}) {|r, e| r[camelize_and_normalize_name(e.first)] = e.last; r }
+      end
+
+      # Parameters are camelized and normalized
+      # according to VoiceBase API.
+      #
+      # E.g.
+      #
+      #  :media_url -> "mediaURL"
+      #  :external_id -> "externalID"
+      #  :error_callback -> "errorCallBack"
+      #
+      def camelize_and_normalize_name(snake_cased_name)
+        result = Client.camelize_name(snake_cased_name.to_s)
+        PARAM_NORMALIZATION.each {|k, v| result.gsub!(/#{k}/, v) }
+        result
+      end
+
+    end
+  end
+end

data/lib/voicebase/v1/response.rb

@@ -0,0 +1,24 @@
+module VoiceBase
+  module V1
+    module Response
+      def self.extended(response)
+      end
+
+      def success?
+        ok? && request_status == "SUCCESS"
+      end
+
+
+      def transcript_ready?
+
+        # this was added because with the V1 API, a value in the returned JSON indicates both a
+        # successful HTTP request, but also a ready transcript. With V2, there's no JSON value
+        # to indicate status. Instead, the HTTP status code indicates request status, and
+        # the state becoming "finished" indicates the transcript it ready.
+
+        success?
+      end
+
+    end
+  end
+end

data/lib/voicebase/v2.rb

@@ -0,0 +1,6 @@
+module VoiceBase
+  module V2; end
+end
+
+require "voicebase/v2/client"
+require "voicebase/v2/response"

data/lib/voicebase/v2/client.rb

@@ -0,0 +1,233 @@
+module VoiceBase
+  module V2
+    module Client
+      BOUNDARY               = "0123456789ABLEWASIEREISAWELBA9876543210"
+      MULTIPART_CONTENT_TYPE = "multipart/form-data; boundary=#{BOUNDARY}"
+
+      def self.extended(client, args = {})
+        client.api_host     = client.args[:host] || ENV.fetch('VOICEBASE_V2_API_HOST', 'https://apis.voicebase.com')
+        client.api_endpoint = client.args[:api_endpoint] || ENV.fetch('VOICEBASE_V2_API_ENDPOINT', '/v2-beta')
+      end
+
+      def authenticate!
+        auth = {:username => @auth_key, :password => @auth_secret}
+        response = VoiceBase::Response.new(
+          self.class.get(
+            uri + '/access/users/admin/tokens',
+            basic_auth: auth,
+            headers: {
+              'User-Agent'   => @user_agent,
+              'Accept'       => 'application/json'
+            }
+          ), api_version)
+        @token = VoiceBase::Client::Token.new(response.tokens.try(:first).try(:[], 'token'))
+      rescue NoMethodError => ex
+        raise VoiceBase::AuthenticationError, response.status_message
+      end
+
+      def upload_media(args = {}, headers = {})
+
+        media_url = require_media_file_or_url(args)
+
+        form_args = {
+            'media' => media_url,
+            'configuration' => {
+                'configuration' => {
+                    'executor' => 'v2'
+                }
+            }
+        }
+
+        # external ID is only partially supported in the V2 API (can't get plain text transcripts or delete media)
+        if args[:external_id]
+          form_args.merge!({
+                               'metadata' => {
+                                   'metadata' => {
+                                       'external' => {
+                                           'id' => "#{args[:external_id]}"
+                                       }
+                                   }
+                               }
+                           })
+        end
+
+        response = self.class.post(
+            uri + '/media',
+            headers: multipart_headers(headers),
+            body: multipart_query(form_args)
+        )
+
+        VoiceBase::Response.new(response, api_version)
+      end
+
+      # I presume this method exists for parity with the V1 API however it is not used by the Orders app
+      def get_media(args = {}, headers = {})
+        raise ArgumentError, "Missing argument :media_id" unless args[:media_id]
+        url = if args[:media_id]
+          uri + "/media/#{args[:media_id]}"
+        elsif args[:external_id]
+          uri + "/media?externalID=#{args[:external_id]}"
+        else
+          raise ArgumentError, "Missing argument :media_url or :media_file"
+        end
+        if args[:external_id]
+          uri + "/media?externalID=#{args[:external_id]}"
+        else
+          raise ArgumentError, "Missing argument :external_id"
+        end
+
+        VoiceBase::Response.new(self.class.get(
+          url, headers: default_headers(headers)
+        ), api_version)
+      end
+
+      def get_json_transcript(args, headers)
+        url = if args[:media_id]
+                uri + "/media/#{args[:media_id]}"
+              else
+                raise ArgumentError, "Missing argument :media_id"
+              end
+
+        response = self.class.get(
+            url,
+            headers: default_headers(headers)
+        )
+
+        VoiceBase::Response.new(response, api_version)
+      end
+
+      def get_text_transcript(args, headers)
+        url = if args[:media_id]
+                uri + "/media/#{args[:media_id]}/transcripts/latest"
+              else
+                raise ArgumentError, "Missing argument :media_id"
+              end
+
+        headers.merge!({ 'Accept' => 'text/plain' })
+
+        response = self.class.get(
+            url,
+            headers: default_headers(headers)
+        )
+
+        response.parsed_response
+      end
+
+      def get_transcript(args = {}, headers = {})
+        if args[:format] == "txt"
+          get_text_transcript(args, headers)
+        else
+          get_json_transcript(args, headers)
+        end
+      end
+
+      # is this used?
+      def get_media_progress(args = {}, headers = {})
+        raise ArgumentError, "Missing argument :media_id" unless args[:media_id]
+        VoiceBase::Response.new(self.class.get(
+          uri + "/media/#{args[:media_id]}/progress",
+          headers: default_headers(headers)
+        ), api_version)
+      end
+
+      def delete_file(args = {}, headers = {})
+        url = if args[:media_id]
+                uri + "/media/#{args[:media_id]}"
+              else
+                raise ArgumentError, "Missing argument :media_id"
+              end
+
+        response = self.class.delete(
+            url,
+            headers: default_headers(headers)
+        )
+
+        VoiceBase::Response.new(response, api_version)
+      end
+
+      private
+
+      def default_headers(headers = {})
+        authenticate! unless token
+        headers = {'Authorization' => "Bearer #{token.token}",
+          'User-Agent' => user_agent}.reject {|k, v| v.blank?}.merge(headers)
+        puts "> headers\n> #{headers}" if debug
+        headers
+      end
+
+      def multipart_headers(headers = {})
+        default_headers(headers.merge({'Content-Type' => MULTIPART_CONTENT_TYPE}))
+      end
+
+      def multipart_query(params)
+        fp = []
+
+        params.each do |k, v|
+          if v.respond_to?(:path) and v.respond_to?(:read) then
+            fp.push(FileParam.new(k, v.path, v.read))
+          elsif v.is_a?(Hash)
+            fp.push(HashParam.new(k, v))
+          else
+            fp.push(StringParam.new(k, v))
+          end
+        end
+
+        query = fp.map {|p| "--" + BOUNDARY + "\r\n" + p.to_multipart }.join("") + "--" + BOUNDARY + "--"
+        puts "> multipart-query\n> #{query}" if debug
+        query
+      end
+
+      def require_media_file_or_url(args = {})
+        media = if args[:media_url]
+          args[:media_url]
+        elsif args[:media_file]
+          args[:media_file]
+        else
+          raise ArgumentError, "Missing argument :media_url or :media_file"
+        end
+      end
+
+      class StringParam
+        attr_accessor :k, :v
+
+        def initialize(k, v)
+          @k, @v = k, v
+        end
+
+        def to_multipart
+          return "Content-Disposition: form-data; name=\"#{CGI::escape(k.to_s)}\"\r\n\r\n#{v}\r\n"
+        end
+      end
+
+      class HashParam
+        attr_accessor :k, :v
+
+        def initialize(k, v)
+          @k, @v = k, v
+        end
+
+        def to_multipart
+          return "Content-Disposition: form-data; name=\"#{CGI::escape(k.to_s)}\"\r\n\r\n#{v.to_json}\r\n"
+        end
+      end
+
+      # Formats the contents of a file or string for inclusion with a multipart
+      # form post
+      class FileParam
+        attr_accessor :k, :filename, :content
+
+        def initialize(k, filename, content)
+          @k, @filename, @content = k, filename, content
+        end
+
+        def to_multipart
+          # If we can tell the possible mime-type from the filename, use the
+          # first in the list; otherwise, use "application/octet-stream"
+          mime_type = MIME::Types.type_for(filename)[0] || MIME::Types["application/octet-stream"][0]
+          return "Content-Disposition: form-data; name=\"#{CGI::escape(k.to_s)}\"; filename=\"#{ filename }\"\r\n" +
+            "Content-Type: #{ mime_type.simplified }\r\n\r\n#{ content }\r\n"
+        end
+      end
+    end
+  end
+end

data/lib/voicebase/v2/response.rb

@@ -0,0 +1,38 @@
+module VoiceBase
+  module V2
+    module Response
+
+      TRANSCRIPT_READY_STATUS = "finished".freeze
+
+      def success?
+
+        # for the V1 API this indicates both a successful HTTP status code and a values of "SUCCESS" in the
+        # returned JSON. with V2, there is no "SUCCESS" value. The combined use was split, adding
+        # #transcript_ready? to both interfaces.
+
+        ok?
+      end
+
+      def media_id
+        voicebase_response['mediaId']
+      end
+
+      def transcript_ready?
+        voicebase_response['media']['status'].casecmp(TRANSCRIPT_READY_STATUS) == 0
+      end
+
+      def transcript
+        # this retrieves the JSON transcript only
+        # the plain text transcript is a plain text non-JSON response
+        voicebase_response['media']['transcripts']['latest']['words']
+      end
+
+      private
+
+      def voicebase_response
+        http_response.parsed_response
+      end
+
+    end
+  end
+end

data/lib/voicebase/version.rb

@@ -0,0 +1,5 @@
+module VoiceBase
+  VERSION = "1.0.14"
+
+  def self.version; VERSION; end
+end

data/voicebase-client-ruby.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'voicebase/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "voicebase-client-ruby"
+  spec.version       = VoiceBase::version
+  spec.authors       = ["Jerry Hogsett"]
+  spec.email         = ["jerry@usertesting.com"]
+
+  spec.summary       = %q{Ruby client for VoiceBase API Version 1.x and 2.x.}
+  spec.description   = %q{Ruby client for VoiceBase API Version 1.x and 2.x that will make both API versions available at the same time.}
+  spec.homepage      = "https://github.com/usertesting/voicebase-client-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "timecop", "~> 0.8"
+
+  spec.add_dependency "httparty"
+  spec.add_dependency "activesupport"
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: voicebase-client-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.14
+platform: ruby
+authors:
+- Jerry Hogsett
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby client for VoiceBase API Version 1.x and 2.x that will make both
+  API versions available at the same time.
+email:
+- jerry@usertesting.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/voicebase.rb
+- lib/voicebase/client.rb
+- lib/voicebase/client/token.rb
+- lib/voicebase/helpers.rb
+- lib/voicebase/json.rb
+- lib/voicebase/json/word.rb
+- lib/voicebase/response.rb
+- lib/voicebase/v1.rb
+- lib/voicebase/v1/client.rb
+- lib/voicebase/v1/response.rb
+- lib/voicebase/v2.rb
+- lib/voicebase/v2/client.rb
+- lib/voicebase/v2/response.rb
+- lib/voicebase/version.rb
+- voicebase-client-ruby.gemspec
+homepage: https://github.com/usertesting/voicebase-client-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Ruby client for VoiceBase API Version 1.x and 2.x.
+test_files: []