cloudhdr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3036def6a619677ffd69024da48637829b1914b
+  data.tar.gz: e77342a103971dbd7d3a0cbfad6c566b4c100923
+SHA512:
+  metadata.gz: 5370100a148b2d47ca5657c61a347f4a2f50a58e269a3b7d4807c451cc9b7e9ced19fd4e6e4e39fe6114b0c953865a3fe85edbd3c601d6013a07b4e9e7ef3c64
+  data.tar.gz: 80351437144c162fbfe9d5a1c8ef0933149243bcdfcaf5cf0e58525f5dfef69f30a9eb12ed9459ff990bea53a31e9089d74a77be3e18c000bf1d93bcd6c56388

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

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

data/Gemfile

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

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,29 @@
+# Cloudhdr
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cloudhdr'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cloudhdr
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/cloudhdr.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cloudhdr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cloudhdr"
+  spec.version       = Cloudhdr::VERSION
+  spec.authors       = ["Jeremy Green"]
+  spec.email         = ["jeremy@octolabs.com"]
+  spec.description   = %q{Ruby wrapper for the CloudHdr Processing API}
+  spec.summary       = %q{Ruby wrapper for the CloudHdr Processing API}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "> 3.0.0"
+  spec.add_dependency "json", "~> 1.8.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec", "~> 2.13.0"
+  spec.add_development_dependency "webmock", "~> 1.11.0"
+  #spec.add_development_dependency "mocha", "~> 0.14.0"
+  spec.add_development_dependency "builder", "~> 3.2.0"
+  spec.add_development_dependency "rake"
+end

data/lib/cloudhdr.rb

@@ -0,0 +1,22 @@
+# 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
+
+
+require "cloudhdr/version"
+require 'cloudhdr/extensions'
+require 'cloudhdr/cloudhdr'
+require 'cloudhdr/base'
+require 'cloudhdr/http/net_http'
+require 'cloudhdr/http/typhoeus'
+require 'cloudhdr/http'
+require 'cloudhdr/errors'
+require 'cloudhdr/job'
+require 'cloudhdr/response'
+
+module Cloudhdr
+  # Your code goes here...
+end

data/lib/cloudhdr/base.rb

@@ -0,0 +1,85 @@
+module Cloudhdr
+  class Base
+    
+    def self.api_key
+      Cloudhdr.api_key
+    end
+    
+    def self.base_url
+      Cloudhdr.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)
+      begin
+        if content.is_a?(String)
+          if format.to_s == 'xml'
+            Hash.from_xml(content)
+          else
+            ActiveSupport::JSON.decode(content)
+          end
+        else
+          content
+        end
+      rescue Exception => e
+        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/cloudhdr/cloudhdr.rb

@@ -0,0 +1,17 @@
+module Cloudhdr
+
+  mattr_writer :api_key
+  mattr_writer :base_url
+
+  self.api_key  = nil
+  self.base_url = 'http://processing.cloudhdr.com/'
+
+  def self.api_key
+    @@api_key || ENV['CLOUDHDR_API_KEY']
+  end
+
+  def self.base_url(env=nil)
+    @@base_url
+  end
+
+end

data/lib/cloudhdr/errors.rb

@@ -0,0 +1,43 @@
+module Cloudhdr
+  class Error < StandardError
+
+    def initialize(error_or_message)
+      if error_or_message.is_a?(Exception)
+        @error = error_or_message
+      else
+        @message = error_or_message
+      end
+    end
+
+    def message
+      @message || "#{@error.class} (wrapped in a #{self.class}) - #{@error.message}"
+    end
+
+    def backtrace
+      if @error
+        @error.backtrace
+      else
+        super
+      end
+    end
+
+    def inspect
+      if @error
+        "#{@error.inspect} (wrapped in a #{self.class})"
+      else
+        super
+      end
+    end
+
+    def to_s
+      if @error
+        "#{@error.class} (wrapped in a #{self.class}) - #{@error}"
+      else
+        super
+      end
+    end
+  end
+
+  class HTTPError < Error; end
+
+end

data/lib/cloudhdr/extensions.rb

@@ -0,0 +1,39 @@
+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
+#
+#unless String.method_defined?(:shell_escape)
+#  class String
+#    def shell_escape
+#      empty? ? "''" : gsub(/([^A-Za-z0-9_\-.,:\/@\n])/n, '\\\\\\1').gsub(/\n/, "'\n'")
+#    end
+#  end
+#end

data/lib/cloudhdr/http.rb

@@ -0,0 +1,90 @@
+module Cloudhdr
+  class HTTP < Base
+
+    attr_accessor :body, :url, :options, :method, :format
+
+    cattr_accessor :default_options
+    cattr_accessor :http_backend
+
+    self.http_backend = NetHTTP
+
+    self.default_options = {:timeout => 10000,
+                            :headers => {'Accept' => 'application/json',
+                                         'Content-Type' => 'application/json'}}.recursive_with_indifferent_access
+
+    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={})
+      new(:post, url, options.merge(:body => body)).perform_method
+    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
+
+    def self.delete(url, options={})
+      new(:delete, url, options).perform_method
+    end
+
+    def perform_method
+      process(http_backend.send(method, url, options))
+    rescue StandardError => e
+      raise HTTPError.new(e)
+    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}"
+
+      options
+    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
+    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/cloudhdr/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 Cloudhdr
+  class HTTP < Base
+    class NetHTTP
+
+      require 'cgi'
+
+      attr_accessor :method, :url, :uri, :body, :params, :headers, :timeout, :skip_ssl_verify, :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)
+        @skip_ssl_verify = options.delete(:skip_ssl_verify)
+        @options         = options
+      end
+
+      def self.post(url, options={})
+        new(:post, url, options).perform
+      end
+
+      def self.put(url, options={})
+        new(:put, url, options).perform
+      end
+
+      def self.get(url, options={})
+        new(:get, url, options).perform
+      end
+
+      def self.delete(url, options={})
+        new(:delete, url, options).perform
+      end
+
+      def perform
+        deliver(http, request)
+      end
+
+
+    protected
+
+      def deliver(http, request)
+        if timeout
+          Timeout.timeout(timeout / 1000.0) do
+            http.request(request)
+          end
+        else
+          http.request(request)
+        end
+      end
+
+      def http
+        u = uri
+
+        http = Net::HTTP.new(u.host, u.port)
+
+        if u.scheme == 'https'
+          http.use_ssl = true
+
+          if !skip_ssl_verify && 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 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 uri
+        u = URI.parse(url)
+
+        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
+
+        u
+      end
+
+      def path
+        u = uri
+
+        if u.path.empty?
+          u.path = '/'
+        end
+
+        if u.query.to_s.empty?
+          u.path
+        else
+          u.path + '?' + u.query.to_s
+        end
+      end
+
+      def request_class
+        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