zencoder 2.0.0 → 2.1.0

data/lib/zencoder.rb

@@ -4,19 +4,13 @@ require 'net/https'
 require 'timeout'
 
 # Gems
-require 'multi_json'
-
-begin
-  MultiJson.engine
-rescue LoadError
-  require 'json'
-end
+require 'active_support' # JSON and XML parsing/encoding
 
 # Zencoder
 require 'zencoder/zencoder'
-require 'zencoder/http'
 require 'zencoder/http/net_http'
 require 'zencoder/http/typhoeus'
+require 'zencoder/http'
 require 'zencoder/errors'
 require 'zencoder/job'
 require 'zencoder/output'

data/lib/zencoder/account.rb

@@ -1,24 +1,24 @@
-module Zencoder::Account
+class Zencoder
+  class Account < Zencoder
 
-  extend Zencoder
+    def self.create(params={}, options={})
+      HTTP.post("#{base_url}/account", encode(params, options[:format]), options)
+    end
 
-  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) || api_key}
+      HTTP.get("#{base_url}/account", merge_params(options, params))
+    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) || api_key}
+      HTTP.get("#{base_url}/account/integration", 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) || api_key}
+      HTTP.get("#{base_url}/account/live", 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

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

data/lib/zencoder/http.rb

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

data/lib/zencoder/http/net_http.rb

@@ -1,142 +1,139 @@
 # 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
+class Zencoder
+  class HTTP < Zencoder
+    class NetHTTP
+
+      attr_accessor :method, :url, :uri, :body, :params, :headers, :timeout, :options
+
+      cattr_accessor :root_cert_paths
+
+      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
+        @body    = options.delete(:body)
+        @params  = options.delete(:params)
+        @headers = options.delete(:headers)
+        @timeout = options.delete(:timeout)
+        @options = options
+      end
 
-  def self.put(url, options={})
-    uri = URI.parse(url)
-    add_params_to_query_string(uri, options[:params])
+      def self.post(url, options={})
+        new(:post, url, options).perform
+      end
 
-    request = Net::HTTP::Put.new(path_with_query_string(uri))
+      def self.put(url, options={})
+        new(:get, url, options).perform
+      end
 
-    add_headers(request, options[:headers])
-    add_body(request, options[:body])
+      def self.get(url, options={})
+        new(:get, url, options).perform
+      end
 
-    request_with_timeout(http_with_ssl(uri), request, options[:timeout])
-  end
+      def self.delete(url, options={})
+        new(:delete, url, options).perform
+      end
 
-  def self.get(url, options={})
-    uri = URI.parse(url)
-    add_params_to_query_string(uri, options[:params])
+      def perform
+        deliver(http, request)
+      end
 
-    request = Net::HTTP::Get.new(path_with_query_string(uri))
 
-    add_headers(request, options[:headers])
+    protected
 
-    request_with_timeout(http_with_ssl(uri), request, options[:timeout])
-  end
+      def deliver(http, request)
+        if timeout
+          Timeout.timeout(timeout / 1000.0) do
+            http.request(request)
+          end
+        else
+          http.request(request)
+        end
+      end
 
-  def self.delete(url, options={})
-    uri = URI.parse(url)
-    add_params_to_query_string(uri, options[:params])
+      def http
+        u = uri
 
-    request = Net::HTTP::Delete.new(path_with_query_string(uri))
+        http = Net::HTTP.new(u.host, u.port)
 
-    add_headers(request, options[:headers])
+        if u.scheme == 'https'
+          http.use_ssl = true
 
-    request_with_timeout(http_with_ssl(uri), request, options[:timeout])
-  end
+          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
 
-protected
+      def request
+        r = request_class.new(path)
+        r.body = body if body
+        if headers
+          headers.each do |header, value|
+            r.add_field(header.to_s, value.to_s)
+          end
+        end
+        r
+      end
 
-  def self.http_with_ssl(uri)
-    http = Net::HTTP.new(uri.host, uri.port)
+      def uri
+        u = URI.parse(url)
 
-    if uri.scheme == 'https'
-      http.use_ssl = true
+        if params
+          params_as_query = params.map{|k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"}.join('&')
+          if u.query.to_s.empty?
+            u.query = params_as_query
+          else
+            u.query = [u.query.to_s, params_as_query].join('&')
+          end
+        end
 
-      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
+        u
       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 path
+        u = uri
 
-  def self.locate_root_cert_path
-    root_cert_paths.detect do |root_cert_path|
-      File.directory?(root_cert_path)
-    end
-  end
+        if u.path.empty?
+          u.path = '/'
+        end
 
-  def self.add_headers(request, headers)
-    if headers
-      headers.each do |header, value|
-        request.add_field(header.to_s, value.to_s)
+        if u.query.to_s.empty?
+          u.path
+        else
+          u.path + '?' + u.query.to_s
+        end
       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('&')
+      def request_class
+        Net::HTTP.const_get(method.to_s.capitalize)
       end
-    end
-  end
 
-  def self.request_with_timeout(http, request, timeout)
-    if timeout
-      Timeout.timeout(timeout / 1000.0) do
-        http.request(request)
+      def locate_root_cert_path
+        self.class.root_cert_paths.detect do |root_cert_path|
+          File.directory?(root_cert_path)
+        end
       end
-    else
-      http.request(request)
+
     end
   end
-
 end

data/lib/zencoder/http/typhoeus.rb

@@ -1,19 +1,23 @@
-module Zencoder::HTTP::Typhoeus
+class Zencoder
+  class HTTP < Zencoder
+    class Typhoeus
 
-  def self.post(url, options={})
-    Typhoeus::Request.post(url, options)
-  end
+      def self.post(url, options={})
+        ::Typhoeus::Request.post(url, options)
+      end
 
-  def self.put(url, options={})
-    Typhoeus::Request.put(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.get(url, options={})
+        ::Typhoeus::Request.get(url, options)
+      end
 
-  def self.delete(url, options={})
-    Typhoeus::Request.delete(url, options)
-  end
+      def self.delete(url, options={})
+        ::Typhoeus::Request.delete(url, options)
+      end
 
+    end
+  end
 end

data/lib/zencoder/job.rb

@@ -1,40 +1,40 @@
-module Zencoder::Job
+class Zencoder
+  class Job < Zencoder
+
+    def self.create(params={}, options={})
+      params_with_api_key = {:api_key => api_key}.merge(params)
+      HTTP.post("#{base_url}/jobs",
+                           encode(params_with_api_key, options[:format]),
+                           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 }
+
+      HTTP.get("#{base_url}/jobs", merge_params(options, params))
+    end
+
+    def self.details(job_id, options={})
+      params = {:api_key => options.delete(:api_key) || api_key}
+      HTTP.get("#{base_url}/jobs/#{job_id}", merge_params(options, params))
+    end
+
+    def self.resubmit(job_id, options={})
+      params = {:api_key => options.delete(:api_key) || api_key}
+      HTTP.get("#{base_url}/jobs/#{job_id}/resubmit", merge_params(options, params))
+    end
+
+    def self.cancel(job_id, options={})
+      params = {:api_key => options.delete(:api_key) || api_key}
+      HTTP.get("#{base_url}/jobs/#{job_id}/cancel", merge_params(options, params))
+    end
+
+    def self.delete(job_id, options={})
+      params = {:api_key => options.delete(:api_key) || api_key}
+      HTTP.delete("#{base_url}/jobs/#{job_id}", merge_params(options, params))
+    end
 
-  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

@@ -1,13 +1,13 @@
-module Zencoder::Notification
+class Zencoder
+  class Notification < Zencoder
 
-  extend Zencoder
+    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 }
 
-  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 }
+      HTTP.get("#{base_url}/notifications", merge_params(options, params))
+    end
 
-    Zencoder::HTTP.get("#{Zencoder.base_url}/notifications", merge_params(options, params))
   end
-
 end

data/lib/zencoder/output.rb

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

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

data/lib/zencoder/version.rb

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

data/lib/zencoder/zencoder.rb

@@ -1,16 +1,44 @@
-module Zencoder
+class Zencoder
 
-  class << self
-    attr_accessor :base_url
-    attr_accessor :api_key
-  end
+  cattr_accessor :base_url
+  cattr_accessor :api_key
 
   self.base_url = 'https://app.zencoder.com/api'
 
+  def self.encode(content, format)
+    if content.is_a?(String)
+      content
+    elsif format.to_s == 'xml'
+      content.to_xml
+    elsif
+      content.to_json
+    end
+  end
+
+  def encode(content, format)
+    self.class.encode(content, format)
+  end
+
+  def self.decode(content, format)
+    if content.is_a?(String)
+      if format.to_s == 'xml'
+        ActiveSupport::XmlMini.parse(content)
+      else
+        ActiveSupport::JSON.decode(content)
+      end
+    else
+      content
+    end
+  end
+
+  def decode(content, format)
+    self.class.decode(content, format)
+  end
+
 
 protected
 
-  def merge_params(options, params)
+  def self.merge_params(options, params)
     if options[:params]
       options[:params] = options[:params].merge(params)
       options

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 2
+  - 1
   - 0
-  - 0
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors: 
 - Nathan Sutton
@@ -14,11 +14,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-21 00:00:00 -05:00
+date: 2010-06-30 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: multi_json
+  name: active_support
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
@@ -30,7 +30,7 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: json_pure
+  name: shoulda
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
@@ -39,10 +39,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 
     requirements: 
@@ -54,7 +54,7 @@ dependencies:
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: mocha
+  name: webmock
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
@@ -65,18 +65,6 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: webmock
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id005
 description: Zencoder <http://zencoder.com> integration library.
 email: nate@zencoder.com
 executables: []