zencoder 2.3.3 → 2.4.0

data/README.markdown

@@ -6,23 +6,57 @@ See [http://zencoder.com/docs/api](http://zencoder.com/docs/api) for more detail
 
 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
+* Ruby 1.8.6-p420
+* Ruby 1.8.7-p249
+* Ruby 1.8.7-p352
+* Ruby 1.9.2-p290
+* Ruby 1.9.3-p0
+* Rubinius 2.0.0dev
+* jRuby 1.6.5
+
+## v2.4 WARNING!!!
+
+Version 2.4 brings some significant changes to the gem, ones which you should be aware of:
+
+* __Removed dependency on `activesupport`.__ This means that the keys of your hashes should all be symbols except in the case of HTTP headers.
+* __Added dependency on `multi_json`__. This gem allows encoding and decoding to and from JSON without all the baggage of `activesupport`.
+* __Removed support for XML requests.__ Since we're doing all the encoding and decoding in the gem, it didn't make sense to support it any longer. You could still conceivably do this with the gem, but you'd need to encode and decode to and from XML yourself and pass appropriate headers. Let us know if this is a problem for you.
+* __Using header authentication by default.__ Zencoder has always allowed the passing of the API key as an HTTP header (`Zencoder-Api-Key`), but in this library we've traditionally merged it in with your requests. In at least one case this would result in messy deserialization and serialization of parameters. Using this alternative authentication method clears up this problem.
+* __Some actions only work on future versions of the API.__ See the section titled `APIv2` below.
+* __Now defaults to API v2.__ If you'd like to continue using API v1, you should change the base_url as outlined in the section titled `APIv2` below.
+* __The Zencoder SSL CA chain is now bundled.__ Previously when you used the default HTTP backend (Net::HTTP), we would try to detect the CA path on your system and use it. This led to some frustration for some users and was generally unreliable. We now bundle our SSL CA chain in the library which should make integration easier. Please note that if you were using `Zencoder::HTTP::NetHTTP.root_cert_paths` or `Zencoder::HTTP::NetHTTP.skip_setting_root_cert_path`, they have been removed.
+
+## APIv2
+
+With the release of version two of the Zencoder API, there are some new methods available to you.
+
+* Zencoder::Job.progress(job\_id)
+* Zencoder::Input.details(input\_id)
+* Zencoder::Input.progress(input\_id)
+* Zencoder::Output.details(output\_id)
+* Zencoder::Report.minutes(:from => "2011-01-01", :to => "2011-03-01")
+
+These new methods will not work with newer versions of the API. Please see the [Zencoder documentation](https://app.zencoder.com/docs) and our [blog post on the subject](http://blog.zencoder.com/2012/01/05/announcing-zencoder-api-v2/) for more information on APIv2.
+
+If you'd like to use the new version of the library but continue using APIv1 until you work through any integration troubles, you can do the following:
+
+```ruby
+Zencoder.base_url = "https://app.zencoder.com/api/v1"
+```
 
 ## 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 three ways. The first and easiest is to set it and forget it on the Zencoder module like so:
 
-    Zencoder.api_key = 'abcd1234'
+```ruby
+Zencoder.api_key = 'abcd1234'
+```
 
 Alternatively, you can use an environment variable:
 
-    ENV['ZENCODER_API_KEY'] = 'abcd1234'
+```ruby
+ENV['ZENCODER_API_KEY'] = 'abcd1234'
+```
 
 You can also pass your API key in every request, but who wants to do that?
 
@@ -32,22 +66,28 @@ All calls in the Zencoder library either raise Zencoder::HTTPError or return a Z
 
 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)
+```ruby
+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)
+```
 
 ### Parameters
 
-When sending API request parameters you can specify them as a non-string object, which we'll then serialize to JSON (by default):
+When sending API request parameters you can specify them as a non-string object, which we'll then serialize to JSON:
 
-    Zencoder::Job.create({:input => 's3://bucket/key.mp4'})
+```ruby
+Zencoder::Job.create({:input => 's3://bucket/key.mp4'})
+```
 
 Or you can specify them as a string, which we'll just pass along as the request body:
 
-    Zencoder::Job.create('{"input": "s3://bucket/key.mp4"}')
+```ruby
+Zencoder::Job.create('{"input": "s3://bucket/key.mp4"}')
+```
 
 ## Jobs
 
@@ -57,63 +97,117 @@ There's more you can do on jobs than anything else in the API. The following met
 
 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). We'll auto-populate your API key if you've set it already.
 
-    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'})
+```ruby
+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'})
+```
 
 This returns a Zencoder::Response object. The body includes a Job ID, and one or more Output IDs (one for every output file created).
 
-    response = Zencoder::Job.create({:input => 's3://bucket/key.mp4'})
-    response.code           # => 201
-    response.body['id']      # => 12345
+```ruby
+response = Zencoder::Job.create({:input => 's3://bucket/key.mp4'})
+response.code            # => 201
+response.body['id']      # => 12345
+```
 
 ### 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')
+```ruby
+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')
+```
 
 ### details
 
 The number passed to `details` is the ID of a Zencoder job.
 
-    Zencoder::Job.details(1)
-    Zencoder::Job.details(1, :api_key => 'abcd1234')
+```ruby
+Zencoder::Job.details(1)
+Zencoder::Job.details(1, :api_key => 'abcd1234')
+```
+
+### progress
+
+The number passed to `progress` is the ID of a Zencoder job.
+
+```ruby
+Zencoder::Job.progress(1)
+Zencoder::Job.progress(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')
+```ruby
+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')
+```ruby
+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')
+```ruby
+Zencoder::Job.delete(1)
+Zencoder::Job.delete(1, :api_key => 'abcd1234')
+```
+
+## Inputs
+
+### details
+
+The number passed to `details` is the ID of a Zencoder input.
+
+```ruby
+Zencoder::Input.details(1)
+Zencoder::Input.details(1, :api_key => 'abcd1234')
+```
+
+### progress
+
+The number passed to `progress` is the ID of a Zencoder input.
+
+```ruby
+Zencoder::Input.progress(1)
+Zencoder::Input.progress(1, :api_key => 'abcd1234')
+```
 
 ## Outputs
 
+### details
+
+The number passed to `details` is the ID of a Zencoder output.
+
+```ruby
+Zencoder::Output.details(1)
+Zencoder::Output.details(1, :api_key => 'abcd1234')
+```
+
 ### progress
 
 *Important:* the number passed to `progress` is the output file ID, not the Job ID.
 
-    Zencoder::Output.progress(1)
-    Zencoder::Output.progress(1, :api_key => 'abcd1234')
+```ruby
+Zencoder::Output.progress(1)
+Zencoder::Output.progress(1, :api_key => 'abcd1234')
+```
 
 ## Notifications
 
@@ -121,11 +215,13 @@ The number passed to `delete` is the ID of a Zencoder job.
 
 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')
+```ruby
+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
 
@@ -133,31 +229,49 @@ By default the jobs listing is paginated with 50 jobs per page and sorted by ID
 
 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'})
+```ruby
+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')
+```ruby
+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')
+```ruby
+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')
+```ruby
+Zencoder::Account.live
+Zencoder::Account.live(:api_key => 'abcd1234')
+```
+
+## Reports
+
+### minutes
+
+This will list the minutes used for your account within a certain, configurable range.
+
+```ruby
+Zencoder::Report.minutes(:from => "2011-10-30", :to => "2011-11-24")
+```
 
 ## Advanced HTTP
 
@@ -165,11 +279,13 @@ This will put your account into live mode (site-wide).
 
 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
+```ruby
+require 'typhoeus'
+Zencoder::HTTP.http_backend = Zencoder::HTTP::Typhoeus
 
-    require 'my_favorite_http_library'
-    Zencoder::HTTP.http_backend = MyFavoriteHTTPBackend
+require 'my_favorite_http_library'
+Zencoder::HTTP.http_backend = MyFavoriteHTTPBackend
+```
 
 See the HTTP backends in this library to get started on your own.
 
@@ -177,55 +293,39 @@ See the HTTP backends in this library to get started on your own.
 
 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. In the following example the timeout is set to one second:
 
-    Zencoder::Job.create({:input => 's3://bucket/key.mp4'}, {:timeout => 1000})
-
-
-### Format
+```ruby
+Zencoder::Job.create({:input => 's3://bucket/key.mp4'}, {:timeout => 1000})
+```
 
-By default we'll send and receive JSON for all our communication. If you would rather use XML then you can pass :format => :xml in the secondary options hash.
-
-    Zencoder::Job.create({:input => 's3://bucket/key.mp4'}, {:format => :xml})
 
 ### SSL Verification
 
-We try to find the files necessary for SSL verification on your system, but sometimes this results in an error. If you'd like to skip SSL verification you can pass an option in the secondary options hash.
+We will use our bundled SSL CA chain for SSL peer verification which should almost always work without a hitch. However, if you'd like to skip SSL verification you can pass an option in the secondary options hash.
 
 **NOTE: WE HIGHLY DISCOURAGE THIS! THIS WILL LEAVE YOU VULNERABLE TO MAN-IN-THE-MIDDLE ATTACKS!**
 
-    Zencoder::Job.create({:input => 's3://bucket/key.mp4'}, {:skip_ssl_verify => true})
+```ruby
+Zencoder::Job.create({:input => 's3://bucket/key.mp4'}, {:skip_ssl_verify => true})
+```
 
 Alternatively you can add it to the default options.
 
-    Zencoder::HTTP.default_options.merge!(:skip_ssl_verify => true)
+```ruby
+Zencoder::HTTP.default_options.merge!(:skip_ssl_verify => true)
+```
 
 ### 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. Let us know if we're missing a common location.
-
-    Zencoder::HTTP::NetHTTP.root_cert_paths << '/my/custom/cert/path'
-
-If the ruby installed on your system is already aware of where your root cert path is and/or you would like us to NOT set it, you can do the following.
-
-    Zencoder::HTTP::NetHTTP.skip_setting_root_cert_path = true
-
-## Advanced JSON and XML
-
-### Alternate JSON and XML Libraries
-
-This library uses the `activesupport` gem to encode and decode JSON. The latest versions of ActiveSupport allow you to change the libraries used to decode JSON and XML.
-
-You can change the JSON decoding backend for ActiveSupport in Rails 2.3 like so:
+```ruby
+Zencoder::HTTP.default_options = {:timeout => 3000,
+                                  :headers => {'Accept' => 'application/json',
+                                               'Content-Type' => 'application/json'}}
+```
 
-    ActiveSupport::JSON.backend = "JSONGem"
+## Advanced JSON
 
-Or change the XML decoding backend for ActiveSupport in Rails 2.3 like so:
+### Alternate JSON Libraries
 
-    ActiveSupport::XmlMini.backend = "Nokogiri"
+This library uses the `multi_json` gem to encode and decode JSON. This fantastic gem lets you swap out the JSON backend at will and includes a working JSON encoder/decoder. You can check the [MultiJson](https://github.com/intridea/multi_json) project for more information on how to accomplish this.

data/lib/zencoder.rb

@@ -3,22 +3,21 @@ require 'cgi'
 require 'net/https'
 require 'timeout'
 
-# ActiveSupport 3.0 with fallback to 2.0
-begin
-  require 'active_support/all' # Screw it
-rescue LoadError
-  require 'active_support' # JSON and XML parsing/encoding
-end
+# JSON serialization
+require 'multi_json'
 
 # Zencoder
-require 'zencoder/extensions'
+require 'zencoder/version'
+require 'zencoder/serializer'
 require 'zencoder/zencoder'
-require 'zencoder/base'
+require 'zencoder/resource'
 require 'zencoder/http/net_http'
 require 'zencoder/http/typhoeus'
 require 'zencoder/http'
 require 'zencoder/errors'
+require 'zencoder/report'
 require 'zencoder/job'
+require 'zencoder/input'
 require 'zencoder/output'
 require 'zencoder/account'
 require 'zencoder/notification'

data/lib/zencoder/account.rb

@@ -1,23 +1,20 @@
 module Zencoder
-  class Account < Base
+  class Account < Resource
 
     def self.create(params={}, options={})
-      HTTP.post("#{options[:base_url] || base_url}/account", encode(params, options[:format]), options)
+      post("/account", params, options)
     end
 
     def self.details(options={})
-      params = {:api_key  => options.delete(:api_key) || api_key}
-      HTTP.get("#{options[:base_url] || base_url}/account", merge_params(options, params))
+      get("/account", options)
     end
 
     def self.integration(options={})
-      params = {:api_key  => options.delete(:api_key) || api_key}
-      HTTP.get("#{options[:base_url] || base_url}/account/integration", merge_params(options, params))
+      put("/account/integration", nil, options)
     end
 
     def self.live(options={})
-      params = {:api_key  => options.delete(:api_key) || api_key}
-      HTTP.get("#{options[:base_url] || base_url}/account/live", merge_params(options, params))
+      put("/account/live", nil, options)
     end
 
   end

data/lib/zencoder/errors.rb

@@ -15,7 +15,9 @@ module Zencoder
 
     def backtrace
       if @error
-        @error.backtrace
+        error_backtrace = ["--- Backtrace from #{@error.class} ---"] + (@error.backtrace || [])
+        wrapper_backtrace = ["--- Backtrace from #{self.class} ---"] + (super || [])
+        error_backtrace + wrapper_backtrace
       else
         super
       end

data/lib/zencoder/http.rb

@@ -1,23 +1,27 @@
 module Zencoder
-  class HTTP < Base
+  class HTTP
 
-    attr_accessor :body, :url, :options, :method, :format
+    CA_CHAIN_PATH = File.expand_path(File.join(File.dirname(__FILE__), "http", "resources", "zencoder_ca_chain.crt"))
 
-    cattr_accessor :default_options
-    cattr_accessor :http_backend
+    include Zencoder::Serializer
+
+    attr_accessor :url, :options, :method
+
+    class << self
+      attr_accessor :default_options, :http_backend
+    end
 
     self.http_backend = NetHTTP
 
     self.default_options = {:timeout => 10000,
-                            :headers => {'Accept' => 'application/json',
-                                         'Content-Type' => 'application/json'}}.recursive_with_indifferent_access
+                            :headers => {'Accept'       => 'application/json',
+                                         'Content-Type' => 'application/json',
+                                         'User-Agent'   => "Zencoder-rb v#{Zencoder::GEM_VERSION}"}}
 
     def initialize(method, url, options={})
       self.method  = method
       self.url     = url
-      self.format  = options.delete(:format)
       self.options = options
-      self.body    = options.delete(:body)
     end
 
     def self.post(url, body, options={})
@@ -43,29 +47,32 @@ module Zencoder
     end
 
     def options=(value)
-      @options = default_options.recursive_with_indifferent_access.merge(value || {})
-
-      options[:headers] ||= {}
-      options[:headers]['Accept'] = "application/#{format}"
-      options[:headers]['Content-Type'] = "application/#{format}"
+      value ||= {}
+
+      # Hacky, deeper hash merge
+      default_options.keys.each do |key|
+        if value.has_key?(key)
+          if value[key].is_a?(Hash) && default_options[key].is_a?(Hash)
+            value[key] = default_options[key].merge(value[key])
+          end
+        else
+          value[key] = default_options[key]
+        end
+      end
 
-      options
+      @options = value
     end
 
     def options
       @options || self.options = default_options
     end
 
-    def format
-      @format ||= :json
-    end
-
     def http_backend
       self.class.http_backend
     end
 
     def default_options
-      self.class.default_options.recursive_with_indifferent_access
+      self.class.default_options
     end
 
 
@@ -76,7 +83,7 @@ module Zencoder
       response.code = http_response.code
 
       begin
-        response.body = decode(http_response.body.to_s, format)
+        response.body = decode(http_response.body.to_s)
       rescue StandardError # Hack! Returns different exceptions depending on the decoding engine
         response.body = http_response.body
       end

data/lib/zencoder/http/net_http.rb

@@ -1,27 +1,9 @@
-# Ruby's Net/HTTP Sucks
-# Borrowed root cert checking from http://redcorundum.blogspot.com/2008/03/ssl-certificates-and-nethttps.html
-
 module Zencoder
-  class HTTP < Base
+  class HTTP
     class NetHTTP
 
       attr_accessor :method, :url, :uri, :body, :params, :headers, :timeout, :skip_ssl_verify, :options
 
-      cattr_accessor :root_cert_paths
-      cattr_accessor :skip_setting_root_cert_path
-
-      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 initialize(method, url, options)
         @method          = method
         @url             = url
@@ -73,14 +55,13 @@ module Zencoder
 
         if u.scheme == 'https'
           http.use_ssl = true
-          root_cert_path = locate_root_cert_path
 
-          if !skip_ssl_verify && (self.class.skip_setting_root_cert_path || root_cert_path)
-            http.ca_path = root_cert_path unless self.class.skip_setting_root_cert_path
+          if skip_ssl_verify
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          else
+            http.ca_file = Zencoder::HTTP::CA_CHAIN_PATH
             http.verify_mode = OpenSSL::SSL::VERIFY_PEER
             http.verify_depth = 5
-          else
-            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
           end
         end
 
@@ -131,12 +112,6 @@ module Zencoder
         Net::HTTP.const_get(method.to_s.capitalize)
       end
 
-      def locate_root_cert_path
-        self.class.root_cert_paths.detect do |root_cert_path|
-          File.directory?(root_cert_path)
-        end
-      end
-
     end
   end
 end

data/lib/zencoder/http/resources/zencoder_ca_chain.crt

@@ -0,0 +1,62 @@
+-----BEGIN CERTIFICATE-----
+MIIDJzCCApCgAwIBAgIBATANBgkqhkiG9w0BAQQFADCBzjELMAkGA1UEBhMCWkEx
+FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD
+VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv
+biBTZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UEAxMYVGhhd3RlIFByZW1pdW0gU2Vy
+dmVyIENBMSgwJgYJKoZIhvcNAQkBFhlwcmVtaXVtLXNlcnZlckB0aGF3dGUuY29t
+MB4XDTk2MDgwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgc4xCzAJBgNVBAYTAlpB
+MRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEdMBsG
+A1UEChMUVGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNVBAsTH0NlcnRpZmljYXRp
+b24gU2VydmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQcmVtaXVtIFNl
+cnZlciBDQTEoMCYGCSqGSIb3DQEJARYZcHJlbWl1bS1zZXJ2ZXJAdGhhd3RlLmNv
+bTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0jY2aovXwlue2oFBYo847kkE
+VdbQ7xwblRZH7xhINTpS9CtqBo87L+pW46+GjZ4X9560ZXUCTe/LCaIhUdib0GfQ
+ug2SBhRz1JPLlyoAnFxODLz6FVL88kRu2hFKbgifLy3j+ao6hnO2RlNYyIkFvYMR
+uHM/qgeN9EJN50CdHDcCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG
+9w0BAQQFAAOBgQAmSCwWwlj66BZ0DKqqX1Q/8tfJeGBeXm43YyJ3Nn6yF8Q0ufUI
+hfzJATj/Tb7yFkJD57taRvvBxhEf8UqwKEbJw8RCfbz6q1lu1bdRiBHjpIUZa4JM
+pAwSremkrj/xw0llmozFyD4lt5SZu5IycQfwhl7tUCemDaYj+bvLpgcUQg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIE2DCCBEGgAwIBAgIEN0rSQzANBgkqhkiG9w0BAQUFADCBwzELMAkGA1UEBhMC
+VVMxFDASBgNVBAoTC0VudHJ1c3QubmV0MTswOQYDVQQLEzJ3d3cuZW50cnVzdC5u
+ZXQvQ1BTIGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxpYWIuKTElMCMGA1UECxMc
+KGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDE6MDgGA1UEAxMxRW50cnVzdC5u
+ZXQgU2VjdXJlIFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05OTA1
+MjUxNjA5NDBaFw0xOTA1MjUxNjM5NDBaMIHDMQswCQYDVQQGEwJVUzEUMBIGA1UE
+ChMLRW50cnVzdC5uZXQxOzA5BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5j
+b3JwLiBieSByZWYuIChsaW1pdHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBF
+bnRydXN0Lm5ldCBMaW1pdGVkMTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUg
+U2VydmVyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGdMA0GCSqGSIb3DQEBAQUA
+A4GLADCBhwKBgQDNKIM0VBuJ8w+vN5Ex/68xYMmo6LIQaO2f55M28Qpku0f1BBc/
+I0dNxScZgSYMVHINiC3ZH5oSn7yzcdOAGT9HZnuMNSjSuQrfJNqc1lB5gXpa0zf3
+wkrYKZImZNHkmGw6AIr1NJtl+O3jEP/9uElY3KDegjlrgbEWGWG5VLbmQwIBA6OC
+AdcwggHTMBEGCWCGSAGG+EIBAQQEAwIABzCCARkGA1UdHwSCARAwggEMMIHeoIHb
+oIHYpIHVMIHSMQswCQYDVQQGEwJVUzEUMBIGA1UEChMLRW50cnVzdC5uZXQxOzA5
+BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5jb3JwLiBieSByZWYuIChsaW1p
+dHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBFbnRydXN0Lm5ldCBMaW1pdGVk
+MTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUgU2VydmVyIENlcnRpZmljYXRp
+b24gQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMCmgJ6AlhiNodHRwOi8vd3d3LmVu
+dHJ1c3QubmV0L0NSTC9uZXQxLmNybDArBgNVHRAEJDAigA8xOTk5MDUyNTE2MDk0
+MFqBDzIwMTkwNTI1MTYwOTQwWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAU8Bdi
+E1U9s/8KAGv7UISX8+1i0BowHQYDVR0OBBYEFPAXYhNVPbP/CgBr+1CEl/PtYtAa
+MAwGA1UdEwQFMAMBAf8wGQYJKoZIhvZ9B0EABAwwChsEVjQuMAMCBJAwDQYJKoZI
+hvcNAQEFBQADgYEAkNwwAvpkdMKnCqV8IY00F6j7Rw7/JXyNEwr75Ji174z4xRAN
+95K+8cPV1ZVqBLssziY2ZcgxxufuP+NXdYR6Ee9GTxj005i7qIcyunL2POI9n9cd
+2cNgQ4xYDiKWL2KjLB+6rQXvqzJ4h6BUcxm1XAX5Uj5tLUUL9wqT6u0G+bI=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICWjCCAcMCAgGlMA0GCSqGSIb3DQEBBAUAMHUxCzAJBgNVBAYTAlVTMRgwFgYD
+VQQKEw9HVEUgQ29ycG9yYXRpb24xJzAlBgNVBAsTHkdURSBDeWJlclRydXN0IFNv
+bHV0aW9ucywgSW5jLjEjMCEGA1UEAxMaR1RFIEN5YmVyVHJ1c3QgR2xvYmFsIFJv
+b3QwHhcNOTgwODEzMDAyOTAwWhcNMTgwODEzMjM1OTAwWjB1MQswCQYDVQQGEwJV
+UzEYMBYGA1UEChMPR1RFIENvcnBvcmF0aW9uMScwJQYDVQQLEx5HVEUgQ3liZXJU
+cnVzdCBTb2x1dGlvbnMsIEluYy4xIzAhBgNVBAMTGkdURSBDeWJlclRydXN0IEds
+b2JhbCBSb290MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVD6C28FCc6HrH
+iM3dFw4usJTQGz0O9pTAipTHBsiQl8i4ZBp6fmw8U+E3KHNgf7KXUwefU/ltWJTS
+r41tiGeA5u2ylc9yMcqlHHK6XALnZELn+aks1joNrI1CqiQBOeacPwGFVw1Yh0X4
+04Wqk2kmhXBIgD8SFcd5tB8FLztimQIDAQABMA0GCSqGSIb3DQEBBAUAA4GBAG3r
+GwnpXtlR22ciYaQqPEh346B8pt5zohQDhT37qw4wxYMWM4ETCJ57NE7fQMh017l9
+3PR2VX2bY1QY6fDq81yx2YtCHrnAlU66+tXifPVoYb+O7AWXX1uw16OFNMQkpw0P
+lZPvy5TYnh+dXIVtx6quTx8itc2VrbqnzPmrC3p/
+-----END CERTIFICATE-----

data/lib/zencoder/http/typhoeus.rb

@@ -1,5 +1,5 @@
 module Zencoder
-  class HTTP < Base
+  class HTTP
     class Typhoeus
 
       def self.post(url, options={})

data/lib/zencoder/input.rb

@@ -0,0 +1,13 @@
+module Zencoder
+  class Input < Resource
+
+    def self.details(input_id, options={})
+      get("/inputs/#{input_id}", options)
+    end
+
+    def self.progress(input_id, options={})
+      get("/inputs/#{input_id}/progress", options)
+    end
+
+  end
+end

data/lib/zencoder/job.rb

@@ -1,40 +1,33 @@
 module Zencoder
-  class Job < Base
+  class Job < Resource
 
     def self.create(params={}, options={})
-      params = apply_api_key(params, options[:format])
-      HTTP.post("#{options[:base_url] || base_url}/jobs",
-                           encode(params, options[:format]),
-                           options)
+      post("/jobs", params, options)
     end
 
     def self.list(options={})
-      params = {:api_key  => options.delete(:api_key) || api_key,
-                :page     => options.delete(:page) || 1,
-                :per_page => options.delete(:per_page) || 50,
-                :state    => options.delete(:state) }
+      options = options.dup
+      params  = { :page     => options.delete(:page) || 1,
+                  :per_page => options.delete(:per_page) || 50,
+                  :state    => options.delete(:state) }
 
-      HTTP.get("#{options[:base_url] || base_url}/jobs", merge_params(options, params))
+      get("/jobs", merge_params(options, params))
     end
 
     def self.details(job_id, options={})
-      params = {:api_key => options.delete(:api_key) || api_key}
-      HTTP.get("#{options[:base_url] || base_url}/jobs/#{job_id}", merge_params(options, params))
+      get("/jobs/#{job_id}", options)
     end
 
-    def self.resubmit(job_id, options={})
-      params = {:api_key => options.delete(:api_key) || api_key}
-      HTTP.get("#{options[:base_url] || base_url}/jobs/#{job_id}/resubmit", merge_params(options, params))
+    def self.progress(job_id, options={})
+      get("/jobs/#{job_id}/progress", options)
     end
 
-    def self.cancel(job_id, options={})
-      params = {:api_key => options.delete(:api_key) || api_key}
-      HTTP.get("#{options[:base_url] || base_url}/jobs/#{job_id}/cancel", merge_params(options, params))
+    def self.resubmit(job_id, options={})
+      put("/jobs/#{job_id}/resubmit", nil, options)
     end
 
-    def self.delete(job_id, options={})
-      params = {:api_key => options.delete(:api_key) || api_key}
-      HTTP.delete("#{options[:base_url] || base_url}/jobs/#{job_id}", merge_params(options, params))
+    def self.cancel(job_id, options={})
+      put("/jobs/#{job_id}/cancel", nil, options)
     end
 
   end

data/lib/zencoder/notification.rb

@@ -1,12 +1,12 @@
 module Zencoder
-  class Notification < Base
+  class Notification < Resource
 
     def self.list(options={})
-      params = {:api_key  => options.delete(:api_key) || api_key,
-                :page     => options.delete(:page) || 1,
-                :per_page => options.delete(:per_page) || 50 }
+      options = options.dup
+      params  = {:page     => options.delete(:page) || 1,
+                 :per_page => options.delete(:per_page) || 50 }
 
-      HTTP.get("#{options[:base_url] || base_url}/notifications", merge_params(options, params))
+      get("/notifications", merge_params(options, params))
     end
 
   end

data/lib/zencoder/output.rb

@@ -1,9 +1,12 @@
 module Zencoder
-  class Output < Base
+  class Output < Resource
+
+    def self.details(output_id, options={})
+      get("/outputs/#{output_id}", options)
+    end
 
     def self.progress(output_id, options={})
-      params = {:api_key => options.delete(:api_key) || api_key}
-      HTTP.get("#{options[:base_url] || base_url}/outputs/#{output_id}/progress", merge_params(options, params))
+      get("/outputs/#{output_id}/progress", options)
     end
 
   end

data/lib/zencoder/report.rb

@@ -0,0 +1,9 @@
+module Zencoder
+  class Report < Resource
+
+    def self.minutes(options={})
+      get("/reports/minutes", options)
+    end
+
+  end
+end

data/lib/zencoder/resource.rb

@@ -0,0 +1,76 @@
+module Zencoder
+  class Resource
+
+    include Zencoder::Serializer
+
+    def self.api_key
+      Zencoder.api_key
+    end
+
+    def self.base_url
+      Zencoder.base_url
+    end
+
+    def self.post(path, params={}, options={})
+      options = options.dup
+      url     = url_for(path, options)
+      body    = encode(params)
+      options = add_api_key_header(options)
+      HTTP.post(url, body, options)
+    end
+
+    def self.put(path, params={}, options={})
+      options = options.dup
+      url     = url_for(path, options)
+      body    = encode(params)
+      options = add_api_key_header(options)
+      HTTP.put(url, body, options)
+    end
+
+    def self.get(path, options={})
+      options = options.dup
+      url     = url_for(path, options)
+      options = add_api_key_header(options)
+      HTTP.get(url, options)
+    end
+
+    def self.delete(path, options={})
+      options = options.dup
+      url     = url_for(path)
+      options = add_api_key_header(options)
+      HTTP.delete(url, options)
+    end
+
+
+  protected
+
+    def self.url_for(path, options={})
+      File.join((options[:base_url] || base_url).to_s, path.to_s)
+    end
+
+    def self.add_api_key_header(options)
+      effective_api_key = options.delete(:api_key) || api_key
+
+      if effective_api_key
+        if options[:headers]
+          options[:headers] = options[:headers].dup
+        else
+          options[:headers] = {}
+        end
+        options[:headers]["Zencoder-Api-Key"] = effective_api_key
+      end
+
+      options
+    end
+
+    def self.merge_params(options, params)
+      if options[:params]
+        options[:params] = options[:params].merge(params)
+        options
+      else
+        options.merge(:params => params)
+      end
+    end
+
+  end
+end

data/lib/zencoder/response.rb

@@ -1,5 +1,5 @@
 module Zencoder
-  class Response < Base
+  class Response
 
     attr_accessor :code, :body, :raw_body, :raw_response
 

data/lib/zencoder/serializer.rb

@@ -0,0 +1,27 @@
+module Zencoder
+  module Serializer
+
+    extend self
+
+    def self.included(klass)
+      klass.extend(self)
+    end
+
+    def encode(content)
+      if content.is_a?(String) || content.nil?
+        content
+      else
+        MultiJson.encode(content)
+      end
+    end
+
+    def decode(content)
+      if content.is_a?(String)
+        MultiJson.decode(content)
+      else
+        content
+      end
+    end
+
+  end
+end

data/lib/zencoder/version.rb

@@ -1,3 +1,3 @@
 module Zencoder
-  GEM_VERSION = '2.3.3'
+  GEM_VERSION = '2.4.0'
 end

data/lib/zencoder/zencoder.rb

@@ -1,17 +1,18 @@
 module Zencoder
 
-  mattr_writer :api_key
-  mattr_writer :base_url
+  class << self
+    attr_accessor :api_key, :base_url
+  end
 
   self.api_key  = nil
-  self.base_url = 'https://app.zencoder.com/api'
+  self.base_url = 'https://app.zencoder.com/api/v2'
 
   def self.api_key
-    @@api_key || ENV['ZENCODER_API_KEY']
+    @api_key || ENV['ZENCODER_API_KEY']
   end
 
   def self.base_url(env=nil)
-    @@base_url
+    @base_url
   end
 
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zencoder
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 31
   prerelease: 
   segments: 
   - 2
-  - 3
-  - 3
-  version: 2.3.3
+  - 4
+  - 0
+  version: 2.4.0
 platform: ruby
 authors: 
 - Nathan Sutton
@@ -16,10 +16,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-11 00:00:00 Z
+date: 2012-01-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: multi_json
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
@@ -33,7 +33,7 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: i18n
+  name: shoulda
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -44,10 +44,10 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :runtime
+  type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  name: mocha
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -61,7 +61,7 @@ dependencies:
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: mocha
+  name: webmock
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
@@ -74,20 +74,6 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: webmock
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id005
 description: Zencoder <http://zencoder.com> integration library.
 email: info@zencoder.com
 executables: []
@@ -98,16 +84,19 @@ extra_rdoc_files: []
 
 files: 
 - lib/zencoder/account.rb
-- lib/zencoder/base.rb
 - lib/zencoder/errors.rb
-- lib/zencoder/extensions.rb
 - lib/zencoder/http/net_http.rb
+- lib/zencoder/http/resources/zencoder_ca_chain.crt
 - lib/zencoder/http/typhoeus.rb
 - lib/zencoder/http.rb
+- lib/zencoder/input.rb
 - lib/zencoder/job.rb
 - lib/zencoder/notification.rb
 - lib/zencoder/output.rb
+- lib/zencoder/report.rb
+- lib/zencoder/resource.rb
 - lib/zencoder/response.rb
+- lib/zencoder/serializer.rb
 - lib/zencoder/version.rb
 - lib/zencoder/zencoder.rb
 - lib/zencoder.rb

data/lib/zencoder/base.rb

@@ -1,82 +0,0 @@
-module Zencoder
-  class Base
-
-    def self.api_key
-      Zencoder.api_key
-    end
-
-    def self.base_url
-      Zencoder.base_url
-    end
-
-    def self.encode(content, format=nil)
-      if content.is_a?(String)
-        content
-      elsif format.to_s == 'xml'
-        if content.is_a?(Hash) && content.keys.size == 1
-          content[content.keys.first].to_xml(:root => content.keys.first)
-        else
-          content.to_xml
-        end
-      else
-        content.to_json
-      end
-    end
-
-    def encode(content, format=nil)
-      self.class.encode(content, format)
-    end
-
-    def self.decode(content, format=nil)
-      if content.is_a?(String)
-        if format.to_s == 'xml'
-          Hash.from_xml(content)
-        else
-          ActiveSupport::JSON.decode(content)
-        end
-      else
-        content
-      end
-    end
-
-    def decode(content, format=nil)
-      self.class.decode(content, format)
-    end
-
-
-  protected
-
-    def self.apply_api_key(params, format=nil)
-      if api_key
-        decoded_params = decode(params, format).with_indifferent_access
-
-        if decoded_params[:api_request]
-          decoded_params[:api_request] = decoded_params[:api_request].with_indifferent_access
-        end
-
-        if format.to_s == 'xml'
-          if !(decoded_params[:api_request] && decoded_params[:api_request][:api_key])
-            decoded_params[:api_request] ||= {}.with_indifferent_access
-            decoded_params[:api_request][:api_key] = api_key
-          end
-        else
-          decoded_params['api_key'] = api_key unless decoded_params['api_key']
-        end
-
-        decoded_params
-      else
-        params
-      end
-    end
-
-    def self.merge_params(options, params)
-      if options[:params]
-        options[:params] = options[:params].merge(params)
-        options
-      else
-        options.merge(:params => params)
-      end
-    end
-
-  end
-end

data/lib/zencoder/extensions.rb

@@ -1,31 +0,0 @@
-unless Hash.method_defined?(:recursive_with_indifferent_access)
-  class Hash
-    def recursive_with_indifferent_access
-      hash = with_indifferent_access
-
-      hash.each do |key, value|
-        if value.is_a?(Hash) || value.is_a?(Array)
-          hash[key] = value.recursive_with_indifferent_access
-        end
-      end
-
-      hash
-    end
-  end
-end
-
-unless Array.method_defined?(:recursive_with_indifferent_access)
-  class Array
-    def recursive_with_indifferent_access
-      array = dup
-
-      array.each_with_index do |value, index|
-        if value.is_a?(Hash) || value.is_a?(Array)
-          array[index] = value.recursive_with_indifferent_access
-        end
-      end
-
-      array
-    end
-  end
-end