zencoder 1.0.7 → 2.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Zencoder
+
+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.markdown

@@ -0,0 +1,184 @@
+# Zencoder
+
+The gem for interacting with the API on [Zencoder](http://zencoder.com).
+
+See [http://zencoder.com/docs/api](http://zencoder.com/docs/api) for more details on the API.
+
+Tested on the following versions of Ruby:
+
+* Ruby 1.8.6-p399
+* Ruby 1.8.7-p174
+* Ruby 1.9.1-p378
+* Ruby 1.9.2-preview3
+* Ruby Enterprise Edition 1.8.7-2010.02
+* Rubinius 1.0.1-20100603
+* jRuby 1.5.1
+
+## Getting Started
+
+The first thing you'll need to interact with the Zencoder API is your API key. You can use your API key in one of two ways. The first, and in our opinion the best, is to set it and forget it on the Zencoder module like so:
+
+    Zencoder.api_key = 'abcd1234'
+
+Alternatively you can pass your API key in every request, but who wants to do that?
+
+We'll include examples of both ways throughout this document.
+
+## Responses
+
+All calls in the Zencoder library either raise Zencoder::HTTPError or return a Zencoder::Response.
+
+A Zencoder::Response can be used as follows:
+
+    response = Zencoder::Job.list
+    response.success?     # => true if the response code was 200 through 299
+    response.code         # => 200
+    response.body         # => the JSON-parsed body or raw body if unparseable
+    response.raw_body     # => the body pre-JSON-parsing
+    response.raw_response # => the raw Net::HTTP or Typhoeus response (see below for how to use Typhoeus)
+
+## Jobs
+
+There's more you can do on jobs than anything else in the API. The following methods are available: `list`, `create`, `details`, `progress`, `resubmit`, `cancel`, `delete`.
+
+### list
+
+By default the jobs listing is paginated with 50 jobs per page and sorted by ID in descending order. You can pass two parameters to control the paging: `page` and `per_page`.
+
+    Zencoder::Job.list
+    Zencoder::Job.list(:per_page => 10)
+    Zencoder::Job.list(:per_page => 10, :page => 2)
+    Zencoder::Job.list(:per_page => 10, :page => 2, :api_key => 'abcd1234')
+
+### create
+
+The hash you pass to the `create` method should be encodable to the [JSON you would pass to the Job creation API call on Zencoder](http://zencoder.com/docs/api/#encoding-job).
+
+    Zencoder::Job.create({:input => 's3://bucket/key.mp4'})
+    Zencoder::Job.create({:input => 's3://bucket/key.mp4',
+                          :outputs => [{:label => 'vp8 for the web',
+                                        :url => 's3://bucket/key_output.webm'}]})
+    Zencoder::Job.create({:input => 's3://bucket/key.mp4', :api_key => 'abcd1234'})
+
+### details
+
+The number passed to `details` is the ID of a Zencoder job.
+
+    Zencoder::Job.details(1)
+    Zencoder::Job.details(1, :api_key => 'abcd1234')
+
+### resubmit
+
+The number passed to `resubmit` is the ID of a Zencoder job.
+
+    Zencoder::Job.resubmit(1)
+    Zencoder::Job.resubmit(1, :api_key => 'abcd1234')
+
+### cancel
+
+The number passed to `cancel` is the ID of a Zencoder job.
+
+    Zencoder::Job.cancel(1)
+    Zencoder::Job.cancel(1, :api_key => 'abcd1234')
+
+### delete
+
+The number passed to `delete` is the ID of a Zencoder job.
+
+    Zencoder::Job.delete(1)
+    Zencoder::Job.delete(1, :api_key => 'abcd1234')
+
+## Outputs
+
+### progress
+
+Please note that the number passed to `progress` is the output file ID.
+
+    Zencoder::Output.progress(1)
+    Zencoder::Output.progress(1, :api_key => 'abcd1234')
+
+## Notifications
+
+### list
+
+By default the jobs listing is paginated with 50 jobs per page and sorted by ID in descending order. You can pass three parameters to control the paging: `page`, `per_page`, and `since_id`. Passing `since_id` will return notifications for jobs created after the job with the given ID.
+
+    Zencoder::Notification.list
+    Zencoder::Notification.list(:per_page => 10)
+    Zencoder::Notification.list(:per_page => 10, :page => 2)
+    Zencoder::Notification.list(:per_page => 10, :page => 2, :since_id => 20)
+    Zencoder::Notification.list(:api_key => 'abcd1234')
+
+## Accounts
+
+### create
+
+The hash you pass to the `create` method should be encodable to the [JSON you would pass to the Account creation API call on Zencoder](http://zencoder.com/docs/api/#accounts). No API key is required for this call, of course.
+
+    Zencoder::Account.create({:terms_of_service => 1,
+                              :email => 'bob@example.com'})
+    Zencoder::Account.create({:terms_of_service => 1,
+                              :email => 'bob@example.com',
+                              :password => 'abcd1234',
+                              :affiliate_code => 'abcd1234'})
+
+### details
+
+    Zencoder::Account.details
+    Zencoder::Account.details(:api_key => 'abcd1234')
+
+### integration
+
+This will put your account into integration mode (site-wide).
+
+    Zencoder::Account.integration
+    Zencoder::Account.integration(:api_key => 'abcd1234')
+
+### live
+
+This will put your account into live mode (site-wide).
+
+    Zencoder::Account.live
+    Zencoder::Account.live(:api_key => 'abcd1234')
+
+## Advanced HTTP
+
+### Alternate HTTP Libraries
+
+By default this library will use Net::HTTP to make all API calls. You can change the backend or add your own:
+
+    require 'typhoeus'
+    Zencoder::HTTP.http_backend = Zencoder::HTTP::Typhoeus
+
+    require 'my_favorite_http_library'
+    Zencoder::HTTP.http_backend = MyFavoriteHTTPBackend
+
+See the HTTP backends in this library to get started on your own.
+
+### Advanced Options
+
+A secondary options hash can be passed to any method call which will then be passed on to the HTTP backend. You can pass `timeout` (in milliseconds), `headers`, and `params` (will be added to the query string) to any of the backends. If you are using Typhoeus, see their documentation for further options.
+
+    Zencoder::Job.list(:timeout => 1000) # Timeout is 1 second.
+
+### Default Options
+
+Default options are passed to the HTTP backend. These can be retrieved and modified.
+
+    Zencoder::HTTP.default_options = {:timeout => 3000,
+                                      :headers => {'Accept' => 'application/json',
+                                                   'Content-Type' => 'application/json'}}
+
+### SSL
+
+The Net::HTTP backend will do its best to locate your local SSL certs to allow SSL verification. For a list of paths that are checked, see `Zencoder::HTTP::NetHTTP.root_cert_paths`. Feel free to add your own at runtime.
+
+    Zencoder::HTTP::NetHTTP.root_cert_paths << '/my/custom/cert/path'
+
+## Advanced JSON
+
+### Alternate JSON Libraries
+
+This library uses the `multi_json` gem to encode and decode JSON. It uses the `json_pure` gem by default for compatibility with different ruby implementations. You can change the JSON engine for MultiJson:
+
+    MultiJson.engine = :yajl

data/Rakefile

@@ -1,24 +1,36 @@
-# -*- ruby -*-
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
 
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
 
-require 'rake/clean'
-require 'rubygems'
-require 'hoe'
-CLEAN.include %w(**/*.orig)
-Hoe.plugins.delete :rubyforge
-Hoe.plugin :hg
+task :default => :test
+
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
 
-Hoe.spec 'zencoder' do
-  developer('McClain Looney', 'm@loonsoft.com')
-  extra_deps <<  %w(rest-client >=1.5.1)
-  extra_deps <<  %w(json >=1.4.3)
-  extra_dev_deps << %w(shoulda >=2.10.0)
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "zencoder-rb #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-task :install =>:package do
-  $:<< 'lib'
-  require 'zencoder'
-  puts `GEM_HOME=~/.gem/ruby/1.8 gem install pkg/zencoder-#{Zencoder::VERSION}.gem`
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+    test.rcov_opts << '--exclude "gems/*"'
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install rcov"
+  end
 end
-# vim: syntax=ruby
-#

data/lib/zencoder.rb

@@ -1,32 +1,26 @@
-require 'rubygems'
-require 'json'
-require 'rest_client'
-require 'recipes'
-# A simple interface for dealing with the zencoder api. Currently just submits jobs. More features to come some day.
-#
-# Example:
-#   
-#   Zencoder.submit_job('somebigapikeynumberthing','s3://bucket/path/to/file.mov', ZencoderAPI::Recipes.iphone({:override=>value}))
-class Zencoder
-  include ZencoderAPI
-  
-  # Currently https://app.zencoder.com/api This means you have to have ssl built into your ruby!
-  API_URL = 'https://app.zencoder.com/api'
-  
-  VERSION = '1.0.7' #:nodoc:
-  # Submits a job to zencoder. 
-  # The recipe should be an instance or array of instances of ZencoderAPI::Recipe
-  # Exceptions are not handled, but rather propagated upwards.
-  #
-  # If a block is provided, it is yielded the job configuration as a hash.
-  # Recipes is an array of Recipe objects.
-  # opts can be used to override toplevel Zencoder api options
-  class <<self
-    def submit_job(apikey, src, recipes, opts={})
-      jorb = {:api_key=>apikey, :input => src, :output=>[recipes].flatten.map(&:to_hash)}
-      jorb.merge!(opts)
-      yield jorb if block_given?
-      JSON.parse(RestClient.post(API_URL+'/jobs', jorb.to_json, {:content_type=>:json, :accept=>:json}))
-    end
-  end
+# Standard Library
+require 'cgi'
+require 'net/https'
+require 'timeout'
+
+# Gems
+require 'multi_json'
+
+begin
+  MultiJson.engine
+rescue LoadError
+  require 'json'
 end
+
+# Zencoder
+require 'zencoder/zencoder'
+require 'zencoder/http'
+require 'zencoder/http/net_http'
+require 'zencoder/http/typhoeus'
+require 'zencoder/errors'
+require 'zencoder/job'
+require 'zencoder/output'
+require 'zencoder/account'
+require 'zencoder/notification'
+require 'zencoder/response'
+require 'zencoder/version'

data/lib/zencoder/account.rb

@@ -0,0 +1,24 @@
+module Zencoder::Account
+
+  extend Zencoder
+
+  def self.create(params={}, options={})
+    Zencoder::HTTP.post("#{Zencoder.base_url}/account", MultiJson.encode(params), options)
+  end
+
+  def self.details(options={})
+    params = {:api_key  => options.delete(:api_key) || Zencoder.api_key}
+    Zencoder::HTTP.get("#{Zencoder.base_url}/account", merge_params(options, params))
+  end
+
+  def self.integration(options={})
+    params = {:api_key  => options.delete(:api_key) || Zencoder.api_key}
+    Zencoder::HTTP.get("#{Zencoder.base_url}/account/integration", merge_params(options, params))
+  end
+
+  def self.live(options={})
+    params = {:api_key  => options.delete(:api_key) || Zencoder.api_key}
+    Zencoder::HTTP.get("#{Zencoder.base_url}/account/live", merge_params(options, params))
+  end
+
+end

data/lib/zencoder/errors.rb

@@ -0,0 +1,5 @@
+class Zencoder::Error < StandardError
+end
+
+class Zencoder::HTTPError < Zencoder::Error
+end

data/lib/zencoder/http.rb

@@ -0,0 +1,56 @@
+module Zencoder::HTTP
+
+  class << self
+    attr_accessor :default_options
+    attr_writer :http_backend
+  end
+
+  self.default_options = {:timeout => 10000,
+                          :headers => {'Accept' => 'application/json',
+                                       'Content-Type' => 'application/json'}}
+
+  def self.http_backend
+    @http_backend ||= Zencoder::HTTP::NetHTTP
+  end
+
+  def self.post(url, body, options={})
+    perform_method(:post, url, options.merge(:body => body))
+  end
+
+  def self.put(url, body, options={})
+    perform_method(:put, url, options.merge(:body => body))
+  end
+
+  def self.get(url, options={})
+    perform_method(:get, url, options)
+  end
+
+  def self.delete(url, options={})
+    perform_method(:delete, url, options)
+  end
+
+
+protected
+
+  def self.perform_method(method, url, options)
+    process_response http_backend.send(method, url, self.default_options.merge(options))
+  rescue StandardError => e
+    raise Zencoder::HTTPError, "#{e.class} - #{e.message}"
+  end
+
+  def self.process_response(http_backend_response)
+    response = Zencoder::Response.new
+    response.code = http_backend_response.code
+
+    begin
+      response.body = MultiJson.decode(http_backend_response.body.to_s)
+    rescue StandardError # Hack! Returns different exceptions depending on the JSON engine
+      response.body = http_backend_response.body
+    end
+
+    response.raw_body = http_backend_response.body
+    response.raw_response = http_backend_response
+    response
+  end
+
+end

data/lib/zencoder/http/net_http.rb

@@ -0,0 +1,142 @@
+# Ruby's Net/HTTP Sucks
+# Borrowed root cert checking from http://redcorundum.blogspot.com/2008/03/ssl-certificates-and-nethttps.html
+
+module Zencoder::HTTP::NetHTTP
+
+  class << self
+    attr_accessor :root_cert_paths
+  end
+
+  self.root_cert_paths = ['/etc/ssl/certs',
+                          '/var/ssl',
+                          '/usr/share/ssl',
+                          '/usr/ssl',
+                          '/etc/ssl',
+                          '/usr/local/openssl',
+                          '/usr/lib/ssl',
+                          '/System/Library/OpenSSL',
+                          '/etc/openssl',
+                          '/usr/local/ssl',
+                          '/etc/pki/tls']
+
+  def self.post(url, options={})
+    uri = URI.parse(url)
+    add_params_to_query_string(uri, options[:params])
+
+    request = Net::HTTP::Post.new(path_with_query_string(uri))
+
+    add_headers(request, options[:headers])
+    add_body(request, options[:body])
+
+    request_with_timeout(http_with_ssl(uri), request, options[:timeout])
+  end
+
+  def self.put(url, options={})
+    uri = URI.parse(url)
+    add_params_to_query_string(uri, options[:params])
+
+    request = Net::HTTP::Put.new(path_with_query_string(uri))
+
+    add_headers(request, options[:headers])
+    add_body(request, options[:body])
+
+    request_with_timeout(http_with_ssl(uri), request, options[:timeout])
+  end
+
+  def self.get(url, options={})
+    uri = URI.parse(url)
+    add_params_to_query_string(uri, options[:params])
+
+    request = Net::HTTP::Get.new(path_with_query_string(uri))
+
+    add_headers(request, options[:headers])
+
+    request_with_timeout(http_with_ssl(uri), request, options[:timeout])
+  end
+
+  def self.delete(url, options={})
+    uri = URI.parse(url)
+    add_params_to_query_string(uri, options[:params])
+
+    request = Net::HTTP::Delete.new(path_with_query_string(uri))
+
+    add_headers(request, options[:headers])
+
+    request_with_timeout(http_with_ssl(uri), request, options[:timeout])
+  end
+
+
+protected
+
+  def self.http_with_ssl(uri)
+    http = Net::HTTP.new(uri.host, uri.port)
+
+    if uri.scheme == 'https'
+      http.use_ssl = true
+
+      if root_cert_path = locate_root_cert_path
+        http.ca_path = root_cert_path
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.verify_depth = 5
+      else
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+
+    http
+  end
+
+  def self.path_with_query_string(uri)
+    if uri.path.empty?
+      uri.path = '/'
+    end
+
+    if uri.query.to_s.empty?
+      uri.path
+    else
+      uri.path + '?' + uri.query.to_s
+    end
+  end
+
+  def self.locate_root_cert_path
+    root_cert_paths.detect do |root_cert_path|
+      File.directory?(root_cert_path)
+    end
+  end
+
+  def self.add_headers(request, headers)
+    if headers
+      headers.each do |header, value|
+        request.add_field(header.to_s, value.to_s)
+      end
+    end
+  end
+
+  def self.add_body(request, body)
+    if body
+      request.body = body
+    end
+  end
+
+  def self.add_params_to_query_string(uri, params)
+    if params
+      params_as_query = params.map{|k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"}.join('&')
+      if uri.query.to_s.empty?
+        uri.query = params_as_query
+      else
+        uri.query = [uri.query.to_s, params_as_query].join('&')
+      end
+    end
+  end
+
+  def self.request_with_timeout(http, request, timeout)
+    if timeout
+      Timeout.timeout(timeout / 1000.0) do
+        http.request(request)
+      end
+    else
+      http.request(request)
+    end
+  end
+
+end

data/lib/zencoder/http/typhoeus.rb

@@ -0,0 +1,19 @@
+module Zencoder::HTTP::Typhoeus
+
+  def self.post(url, options={})
+    Typhoeus::Request.post(url, options)
+  end
+
+  def self.put(url, options={})
+    Typhoeus::Request.put(url, options)
+  end
+
+  def self.get(url, options={})
+    Typhoeus::Request.get(url, options)
+  end
+
+  def self.delete(url, options={})
+    Typhoeus::Request.delete(url, options)
+  end
+
+end

data/lib/zencoder/job.rb

@@ -0,0 +1,40 @@
+module Zencoder::Job
+
+  extend Zencoder
+
+  def self.create(params={}, options={})
+    params_with_api_key = {:api_key => Zencoder.api_key}.merge(params)
+    Zencoder::HTTP.post("#{Zencoder.base_url}/jobs",
+                         MultiJson.encode(params_with_api_key),
+                         options)
+  end
+
+  def self.list(options={})
+    params = {:api_key  => options.delete(:api_key) || Zencoder.api_key,
+              :page     => options.delete(:page) || 1,
+              :per_page => options.delete(:per_page) || 50 }
+
+    Zencoder::HTTP.get("#{Zencoder.base_url}/jobs", merge_params(options, params))
+  end
+
+  def self.details(job_id, options={})
+    params = {:api_key => options.delete(:api_key) || Zencoder.api_key}
+    Zencoder::HTTP.get("#{Zencoder.base_url}/jobs/#{job_id}", merge_params(options, params))
+  end
+
+  def self.resubmit(job_id, options={})
+    params = {:api_key => options.delete(:api_key) || Zencoder.api_key}
+    Zencoder::HTTP.get("#{Zencoder.base_url}/jobs/#{job_id}/resubmit", merge_params(options, params))
+  end
+
+  def self.cancel(job_id, options={})
+    params = {:api_key => options.delete(:api_key) || Zencoder.api_key}
+    Zencoder::HTTP.get("#{Zencoder.base_url}/jobs/#{job_id}/cancel", merge_params(options, params))
+  end
+
+  def self.delete(job_id, options={})
+    params = {:api_key => options.delete(:api_key) || Zencoder.api_key}
+    Zencoder::HTTP.delete("#{Zencoder.base_url}/jobs/#{job_id}", merge_params(options, params))
+  end
+
+end

data/lib/zencoder/notification.rb

@@ -0,0 +1,13 @@
+module Zencoder::Notification
+
+  extend Zencoder
+
+  def self.list(options={})
+    params = {:api_key  => options.delete(:api_key) || Zencoder.api_key,
+              :page     => options.delete(:page) || 1,
+              :per_page => options.delete(:per_page) || 50 }
+
+    Zencoder::HTTP.get("#{Zencoder.base_url}/notifications", merge_params(options, params))
+  end
+
+end

data/lib/zencoder/output.rb

@@ -0,0 +1,10 @@
+module Zencoder::Output
+
+  extend Zencoder
+
+  def self.progress(output_id, options={})
+    params = {:api_key => options.delete(:api_key) || Zencoder.api_key}
+    Zencoder::HTTP.get("#{Zencoder.base_url}/outputs/#{output_id}/progress", merge_params(options, params))
+  end
+
+end

data/lib/zencoder/response.rb

@@ -0,0 +1,23 @@
+class Zencoder::Response
+
+  attr_accessor :code, :body, :raw_body, :raw_response
+
+  def initialize(options={})
+    options.each do |k, v|
+      send("#{k}=", v) if respond_to?("#{k}=")
+    end
+  end
+
+  def success?
+    code.to_i > 199 && code.to_i < 300
+  end
+
+  def errors
+    if body.is_a?(Hash)
+      Array(body['errors']).compact
+    else
+      []
+    end
+  end
+
+end

data/lib/zencoder/version.rb

@@ -0,0 +1,3 @@
+module Zencoder
+  VERSION = '2.0.0'
+end

data/lib/zencoder/zencoder.rb

@@ -0,0 +1,22 @@
+module Zencoder
+
+  class << self
+    attr_accessor :base_url
+    attr_accessor :api_key
+  end
+
+  self.base_url = 'https://app.zencoder.com/api'
+
+
+protected
+
+  def merge_params(options, params)
+    if options[:params]
+      options[:params] = options[:params].merge(params)
+      options
+    else
+      options.merge(:params => params)
+    end
+  end
+
+end

metadata

@@ -3,50 +3,46 @@ name: zencoder
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
-  - 1
+  - 2
   - 0
-  - 7
-  version: 1.0.7
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
-- McClain Looney
+- Nathan Sutton
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-06-10 00:00:00 -05:00
+date: 2010-06-21 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rest-client
+  name: multi_json
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 1
-        - 5
-        - 1
-        version: 1.5.1
+        - 0
+        version: "0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: json
+  name: json_pure
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 1
-        - 4
-        - 3
-        version: 1.4.3
+        - 0
+        version: "0"
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: gemcutter
+  name: shoulda
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
@@ -54,69 +50,64 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 5
-        - 0
-        version: 0.5.0
+        version: "0"
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  name: mocha
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 2
-        - 10
         - 0
-        version: 2.10.0
+        version: "0"
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: webmock
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 2
-        - 5
         - 0
-        version: 2.5.0
+        version: "0"
   type: :development
   version_requirements: *id005
-description: |-
-  A small library for interacting with Zencoder.com services.
-  
-  See http://www.Zencoder.com for more details.
-email: 
-- m@loonsoft.com
+description: Zencoder <http://zencoder.com> integration library.
+email: nate@zencoder.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
+extra_rdoc_files: []
+
 files: 
-- History.txt
-- Manifest.txt
-- README.txt
-- Rakefile
-- lib/recipes.rb
+- lib/zencoder/account.rb
+- lib/zencoder/errors.rb
+- lib/zencoder/http/net_http.rb
+- lib/zencoder/http/typhoeus.rb
+- lib/zencoder/http.rb
+- lib/zencoder/job.rb
+- lib/zencoder/notification.rb
+- lib/zencoder/output.rb
+- lib/zencoder/response.rb
+- lib/zencoder/version.rb
+- lib/zencoder/zencoder.rb
 - lib/zencoder.rb
-- test/test_zencoder.rb
+- LICENSE
+- README.markdown
+- Rakefile
 has_rdoc: true
-homepage: http://www.bitbucket.org/mml/zencoder
+homepage: http://github.com/zencoder/zencoder-rb
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --main
-- README.txt
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -139,6 +130,6 @@ rubyforge_project: zencoder
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: A small library for interacting with Zencoder.com services
-test_files: 
-- test/test_zencoder.rb
+summary: Zencoder <http://zencoder.com> integration library.
+test_files: []
+

data/History.txt

@@ -1,33 +0,0 @@
-=== 1.0.0 / 2010-04-29
-
-* 1 major enhancement
-
-  * Birthday!
-
-=== 1.0.1 / 2010-04-29
-
-* Updated readme
-
-=== 1.0.2 / 2010-04-29
-
-* Fixed manifest
-
-=== 1.0.3 / 2010-04-29
-
-* First actual working version. probably should have held off on pushing the others to gemcutter. c'est la vie.
-
-=== 1.0.4 / 2010-05-03
-
-* Jobid hash now returned from the rest request to the api. Useful for receiving callbacks & such
-
-=== 1.0.5 / 2010-05-20
-
-* Pulled some recipes contributed by Brian Maddy
-
-=== 1.0.6 / 2010-05-28
-
-* Added support for toplevel options. {:test=>1} for example. This breaks the old api. The recipes argument to submit_job() must be present, and an optional :opts hash will be merged into the toplevel Zencoder request hash.
-
-=== 1.0.7 / 2010-06-10
-
-* Merged in changes from Cory Preus for compatibility with upstream API changes.

data/Manifest.txt

@@ -1,7 +0,0 @@
-History.txt
-Manifest.txt
-README.txt
-Rakefile
-lib/recipes.rb
-lib/zencoder.rb
-test/test_zencoder.rb

data/README.txt

@@ -1,101 +0,0 @@
-= Zencoder
-
-* http://www.bitbucket.org/mml/zencoder
-
-== DESCRIPTION:
-
-A small library for interacting with Zencoder.com services.
-
-See http://www.Zencoder.com for more details.
-
-== FEATURES/PROBLEMS:
-
-* None yet
-
-== SYNOPSIS:
-
-Zencoder.submit_job('somebigapikeynumberthing','s3://bucket/path/to/file.mov', ZencoderAPI::Recipes.iphone({:override=>value}))
-
-== REQUIREMENTS:
-
-* rest-client
-
-== INSTALL:
-
-* Get your api key from Zencoder.com, and install the gem.
-
-== DEVELOPERS:
-
-Here's the biggest input i could generate using the awesome Zencoder api builder. Note that it's nonsensical, as
-it turns on both skip audio and skip video flags.
-{
-  "test": 1,
-    "input": "s3://mybucket/foo",
-    "output": [
-    {
-      "label": "iphone",
-      "base_url": "s3://mybucket/",
-      "filename": "packet/7/movie.flv",
-      "width": 600,
-      "height": 300,
-      "quality": 3,
-      "speed": 3,
-      "upscale": 1,
-      "stretch": 1,
-      "frame_rate": 29.997,
-      "max_frame_rate": 30,
-      "keyframe_interval": 30,
-      "video_bitrate": 500,
-      "bitrate_cap": 600,
-      "buffer_size": 500,
-      "h264_profile": "high",
-      "h264_level": 2.2,
-      "skip_video": 1,
-      "audio_codec": "aac",
-      "audio_bitrate": 200,
-      "audio_channels": 2,
-      "audio_sample_rate": 128,
-      "skip_audio": 1,
-      "thumbnails": {
-        "number": 30,
-        "size": "100x100",
-        "base_url": "s3://thumbnails",
-        "prefix": "fname_prefix"
-      },
-      "notifications": [
-        "http://callback",
-      "m@loonsoft.com"
-        ],
-      "start_clip": 20,
-      "clip_length": 30
-    }
-  ],
-    "api_key": "your apikey"
-}
-
-
-
-== LICENSE:
-
-(The MIT License)
-
-  Copyright (c) 2010 McClain Looney
-
-  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/lib/recipes.rb

@@ -1,78 +0,0 @@
-
-module ZencoderAPI #:nodoc:
-
-
-  # This class implements a couple of bogus recipes, mainly as an example of usage. Recipe isntances can be passed in to Zencoder#submit_job
-  class Recipe
-    @@keys = [:label, :base_url, :filename, :width, :height, :size, :quality, :speed, 
-      :upscale, :stretch, :frame_rate, :max_frame_rate, :keyframe_interval, 
-      :video_bitrate, :bitrate_cap, :buffer_size, :h264_profile, :h264_level, 
-      :skip_video, :audio_codec, :audio_bitrate, :audio_channels, :audio_sample_rate, 
-      :skip_audio, :start_clip, :clip_length, :thumbnails, :notifications, :tuning, 
-      :autolevel, :audio_quality, :deblock, :public, :denoise, :video_codec]
-
-    @@thumb_keys = [:number, :size, :base_url, :prefix]
-
-    # constructor. accepts a name for the recipe, and a hash of params. The constructor will try to verify that you aren't doing
-    # something it doesn't know about, though does no further validation.
-    def initialize(name, params )
-      params = params.inject(Hash.new) do |m,v|
-        m[v.first.to_s.to_sym]=v.last
-        m
-      end
-      raise RecipeError.new("no recipe parameters?") if params.empty?
-      raise RecipeError.new("unknown recipe parameter '#{params.keys - @@keys}' ") unless (params.keys - @@keys).empty?
-      if params[:thumbnails]
-        raise RecipeError.new("unknown thumb keys #{params[:thumbnails].keys - @@thumb_keys}") unless (params[:thumbnails].keys - @@thumb_keys).empty?
-      end
-      @o = params
-    end
-
-    def to_hash
-      @o
-    end
-
-    def to_json(*arg) #:nodoc:
-      @o.to_json(*arg)
-    end
-  end
-
-  # Raised if something goes wrong with a recipe configuration
-  class RecipeError < Exception; end
-
-  # Some example recipes.
-  module Recipes
-    #A sample iphone recipe. if you have a better one, send me a patch.
-    def self.iphone(params={})
-      raise "Base_url unset." unless params['base_url']
-      defaults = { 
-        "label"=> "iphone",
-        "size"=> "480x320",
-        "frame_rate"=> 24,
-        "max_frame_rate"=> 24,
-        "video_bitrate"=> 40,
-        "bitrate_cap"=> 100
-      }
-
-      params = defaults.merge(params)
-
-      Recipe.new(:iphone, params)
-    end
-    
-    # A sample web recipe. if you have a better one, send me a patch.
-    def self.web(params={})
-      raise "Base_url unset." unless params['base_url']
-      defaults = { 
-        "label"=> "web",
-        "width"=> 240,
-        "frame_rate"=> 24,
-        "max_frame_rate"=> 24,
-        "video_bitrate"=> 40,
-        "bitrate_cap"=> 100
-      }
-      params = defaults.merge(params)
-
-      Recipe.new(:web, params)
-    end
-  end
-end

data/test/test_zencoder.rb

@@ -1,122 +0,0 @@
-require 'rubygems'
-require "test/unit"
-require "zencoder"
-require 'shoulda'
-require 'mocha'
-require 'ruby-debug'
-
-class TestZencoder < Test::Unit::TestCase
-
-  context "the zn lib" do 
-    setup do
-      @src='s3://test_development/spark.avi'
-      @api = 'https://app.zencoder.com'
-      @apikey = ENV['ZC_APIKEY']
-      @base_url = 's3://test_development/zencoder_asset'
-      @recipe = ZencoderAPI::Recipes.iphone('base_url' =>@base_url)
-      @recipe2 = ZencoderAPI::Recipes.web('base_url' =>@base_url,
-        :thumbnails => {
-          :number => 1,
-          :size => "75x75"})
-      assert_not_nil @apikey, "export ZC_APIKEY before you run the tests"
-    end
-    context "posting a new job" do
-      setup do
-        @resp  =<<-EOS
-        {"id":36119,"outputs":[{"url":"s3://test_development/zencoder_asset/cf398a309f648f99c41a2c0573f40baf.mp4","label":"iphone","id":36174},{"url":"s3://test_development/zencoder_asset/253fae410b1262ef3a76296cbfdb8b44.mp4","label":"web","id":36175}]}
-        EOS
-      end
-
-      should "return jobid" do 
-        RestClient.expects(:post).returns(@resp)
-        h = Zencoder.submit_job(@apikey, @src, [@recipe, @recipe2])
-        assert_equal Hash, h.class
-      end
-
-      should "be able to submit a job with opts" do
-        RestClient.expects(:post).with(kind_of(String), kind_of(String), kind_of(Hash)){|x,y,z| 
-          assert_equal x, 'https://app.zencoder.com/api/jobs'
-          body =  JSON.parse(y)
-          assert_equal body['input'], @src
-          assert_equal @base_url, body['output'][0]['base_url']
-          assert_equal @base_url, body['output'][1]['base_url']
-          assert_equal 'web', body['output'][1]['label']
-          assert_equal 'iphone', body['output'][0]['label']
-          assert_equal @apikey, body['api_key']
-          assert_equal 1, body['test']
-          assert_equal :json, z[:content_type]
-          assert_equal :json, z[:accept]
-          true
-        }.returns(@resp)
-        Zencoder.submit_job(@apikey, @src, [@recipe, @recipe2], :test => 1)
-      end
-
-      should "be able to submit a job" do
-        RestClient.expects(:post).with(kind_of(String), kind_of(String), kind_of(Hash)){|x,y,z| 
-          assert_equal x, 'https://app.zencoder.com/api/jobs'
-          body =  JSON.parse(y)
-          assert_equal body['input'], @src
-          assert_equal body['output'][0]['base_url'], @base_url
-          assert_equal body['output'][1]['base_url'], @base_url
-          assert_equal body['output'][1]['label'], 'web'
-          assert_equal body['output'][0]['label'], 'iphone'
-          assert_equal body['api_key'], @apikey
-          assert_nil body['test']
-          assert_equal z[:content_type], :json
-          assert_equal z[:accept], :json
-          true
-        }.returns(@resp)
-        Zencoder.submit_job(@apikey, @src, [@recipe, @recipe2])
-      end
-      should "be able to muck the config " do
-        RestClient.expects(:post).with(kind_of(String), kind_of(String), kind_of(Hash)){|x,y,z|
-          body = JSON.parse(y)
-          assert_equal body['foo'],'bar'
-          true
-        }.returns(@resp)
-        Zencoder.submit_job(@apikey, @src, @recipe) do |config|
-          config[:foo]='bar'
-          assert config[:output].first.is_a? Hash
-        end
-      end
-      should "be able to submit a job with 1 recipe" do
-        RestClient.expects(:post).with(kind_of(String), kind_of(String), kind_of(Hash)){|x,y,z| 
-          assert_equal x, 'https://app.zencoder.com/api/jobs'
-          body =  JSON.parse(y)
-          assert_equal body['input'], @src
-          assert_equal body['output'][0]['base_url'], @base_url
-          assert_equal body['output'][0]['label'], 'iphone'
-          assert_equal body['api_key'], @apikey
-          assert_equal z[:content_type], :json
-          assert_equal z[:accept], :json
-          true
-        }.returns(@resp)
-        Zencoder.submit_job(@apikey, @src, @recipe)
-      end
-    end
-    should "raise error when given bad data" do
-      assert_raise ZencoderAPI::RecipeError do
-        ZencoderAPI::Recipes.web('base_url' =>@base_url, :bad_key => 'wtf?')
-      end
-      assert_raise ZencoderAPI::RecipeError do
-        ZencoderAPI::Recipes.web('base_url' =>@base_url, :thumbnails => {:bad_key => 'wtf?'})
-      end
-    end
-    context "with the following request" do 
-      setup do 
-        @params = JSON.parse(IO.readlines('test/fixtures/sample_request.json').to_s)
-        @params['output'] = @params['output'][0]
-        # Change string keys to symbols, no HashWithIndifferentAccess
-        @params['output']['thumbnails'].each_pair do |key, value|
-          @params['output']['thumbnails'][key.to_sym] = value
-          @params['output']['thumbnails'].delete(key)
-        end
-      end
-      should "have the output keys" do
-        assert_nothing_raised do
-          ZencoderAPI::Recipes.web({'base_url' => @base_url}.merge(@params['output']))
-        end
-      end
-    end 
-  end
-end