saddle 0.0.5 → 0.0.6

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NjNmZmY5MTg1ZjdlOWQ0MGExNTU5ODU1OWE2NmEyZDhlNjEzNjUxNg==
+    NDdlNWQ0MWNlODhhYTQ2NTMwZWQ2MDhkMjRlOGQ1YTQ1MTBhMjNjMA==
   data.tar.gz: !binary |-
-    Yjg5MmI0MGZmYTExYmM2YjNmZTgxNGU3OGYzN2Y1ZTVmN2E0NWIwNw==
+    YmE2MmYxZjQyNjhmYTJhNzhkZjk3MDcwMjdhNjgxNTI5ZWJlZDAyZA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZWYyYmI5Njc3NmYxYmRhMWVjN2QzYWI3YjQ1ZGNkZjUxNjBiNjhhM2JiYTAz
-    YmM0ZjYwMWQwZDA0ZDVlYWU0N2ZlMjNhZWYxMWM1NzQwNmE4ZDdjNjE2M2Uw
-    OTlmODFjZjg0ZGY0NGM4NmJiYjljZmNmZDkyOTA0MDQ3MjNhNGM=
+    MWQ4Y2ZiOThmMGIwNjNiMDQ5M2EwMTNkZjdkMmIyMjFhOGFiNmU3NTNjMjQy
+    NGI4MmQyNWNmOTY5M2Y5MjJmMTg5ZGRjMThjYWUwZTRlZWQ3MDhkZDdiODIw
+    NWQwMWM4YTZmNjVmNmZjZjc3NjIwZDlhMGRlMDYzOWM3M2Y0ZTQ=
   data.tar.gz: !binary |-
-    YWY0OGE2NTdhN2EzZTQ4MmE3ZmRjYjYyZjhmNDJlNTQxZDJhNGMwYWE3OGYz
-    NzM3YjQ2YzJjZTM5ODg1MjJhYTAxY2Q0MWQxZWRiOWVlZTAwZjVkMjI2NzRj
-    MzI4MjQ4MzI0NzE2NzA1ODVkNzQ3NzBiYmYzYWE0Y2U5OWRiZDk=
+    ODM4ZGM4ZTdlYTM3OGY3NzNkYTZlOTQ3ZWY0N2Y2MzViZjgzZWFiZjA2Njg4
+    Mjc4Y2NiNGVkYmZiZDhjYTliMzZmYmE0NjhkNDQ3YmY4MTQ0NjIzMzk0ZTkx
+    ZTczYmRkYTViOWIzODY0NWI0MGY3YWVmNDIzMDYxYTE2MDIwMmU=

data/lib/saddle/middleware/logging/airbrake.rb

@@ -0,0 +1,35 @@
+require 'airbrake'
+require 'faraday'
+
+
+
+module Saddle::Middleware
+  module Logging
+
+    # Public: Reports exceptions to Airbrake
+    #
+    class AirbrakeLogger < Faraday::Middleware
+
+      def initialize(app, airbrake_api_key=nil)
+        super(app)
+        @airbrake_api_key = airbrake_api_key
+      end
+
+      def call(env)
+        begin
+          @app.call(env)
+        rescue => e
+          # If we don't have an api key, use the default config
+          if @airbrake_api_key
+            ::Airbrake.notify(e, {:api_key => @airbrake_api_key} )
+          else
+            ::Airbrake.notify(e)
+          end
+          # Re-raise the error
+          raise
+        end
+      end
+
+    end
+  end
+end

data/lib/saddle/middleware/logging/statsd.rb

@@ -0,0 +1,49 @@
+require 'statsd'
+require 'faraday'
+
+
+
+
+module Saddle::Middleware
+  module Logging
+
+    # Public: Wraps request with statsd logging
+    # Expects statsd_path in request options.  However, if using saddle and no statsd_path is specified
+    # will read call_chain and action and use them to construct a statsd_path
+    class StatsdLogger < Faraday::Middleware
+      attr_accessor :graphite_host, :graphite_port, :namespace
+
+      def initialize(app, graphite_host, graphite_port=nil, namespace=nil)
+        super(app)
+        @graphite_host = graphite_host
+        @graphite_port = graphite_port
+        @namespace = namespace
+      end
+
+      def statsd
+        @statsd ||= begin
+          client = ::Statsd.new(@graphite_host, @graphite_port)
+          client.namespace = @namespace if @namespace
+        end
+      end
+
+      def call(env)
+        statsd_path = nil
+        if env[:request][:statsd_path]
+          statsd_path = env[:request][:statsd_path]
+        elsif env[:request][:saddle] && env[:request][:saddle][:call_chain] && env[:request][:saddle][:action]
+          statsd_path = (env[:request][:saddle][:call_chain] + [env[:request][:saddle][:action]]).join('.')
+        end
+
+        if statsd_path
+          self.statsd.time statsd_path do
+            @app.call(env)
+          end
+        else
+          @app.call(env)
+        end
+      end
+    end
+
+  end
+end

data/lib/saddle/middleware/request/encode_json.rb

@@ -0,0 +1,34 @@
+require 'faraday'
+
+
+
+module Saddle::Middleware
+  module Request
+
+    # Request middleware that encodes the body as JSON.
+    #
+    # Make sure you set request[:request_style] = :json
+    # for it to be activated.
+
+    class JsonEncoded < Faraday::Middleware
+      CONTENT_TYPE = 'Content-Type'.freeze
+      MIME_TYPE    = 'application/json'.freeze
+
+      dependency do
+        require 'json' unless defined?(::JSON)
+      end
+
+      def call(env)
+        if env[:request][:request_style] == :json
+          # Make sure we're working with a valid body that's not a String
+          if env[:body] and !env[:body].respond_to?(:to_str)
+            env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+            env[:body] = ::JSON.dump(env[:body])
+          end
+        end
+        @app.call env
+      end
+    end
+
+  end
+end

data/lib/saddle/middleware/request/retry.rb

@@ -0,0 +1,55 @@
+require 'faraday'
+
+
+
+module Saddle::Middleware
+  module Request
+
+    # Catches exceptions and retries each request a limited number of times.
+    #
+    # By default, it retries 2 times and performs exponential backoff, starting
+    # at 50ms
+    class Retry < Faraday::Middleware
+      def initialize(app, ignored_exceptions=[])
+        super(app)
+        @ignored_exceptions = ignored_exceptions
+      end
+
+      def call(env)
+        retries = env[:request][:num_retries] || 2
+        backoff = env[:request][:retry_backoff] || 0.050 # ms
+        begin
+          @app.call(self.class.deep_copy(env))
+        rescue => e
+          unless @ignored_exceptions.include?(e.class)
+            # Retry a limited number of times
+            if retries > 0
+              retries -= 1
+              sleep(backoff) if backoff > 0.0
+              backoff *= 2
+              retry
+            end
+          end
+          # Re-raise if we're out of retries or it's not handled
+          raise
+        end
+      end
+
+      def self.deep_copy(value)
+        if value.is_a?(Hash)
+          result = value.clone
+          value.each{|k, v| result[k] = deep_copy(v)}
+          result
+        elsif value.is_a?(Array)
+          result = value.clone
+          result.clear
+          value.each{|v| result << deep_copy(v)}
+          result
+        else
+          value
+        end
+      end
+    end
+
+  end
+end

data/lib/saddle/middleware/request/url_encoded.rb

@@ -0,0 +1,86 @@
+require 'faraday'
+
+
+
+module Saddle::Middleware
+  module Request
+
+    # This magically handles converting your body from a hash
+    # into an url-encoded (or multipart if needed) request
+
+    # Make sure you set request[:request_style] = :urlencoded
+    # for it to be activated.
+
+    class UrlEncoded < Faraday::Middleware
+      CONTENT_TYPE = 'Content-Type'.freeze unless defined? CONTENT_TYPE
+
+      URL_ENCODED_MIME_TYPE = 'application/x-www-form-urlencoded'.freeze
+      MULTIPART_MIME_TYPE = 'multipart/form-data'.freeze
+
+      VALID_MIME_TYPES = [URL_ENCODED_MIME_TYPE, MULTIPART_MIME_TYPE]
+
+      DEFAULT_MULTIPART_BOUNDARY = "-^---_---^-".freeze
+
+
+      def call(env)
+        if env[:request][:request_style] == :urlencoded
+          # Make sure we're working with a valid body that's not a String
+          if env[:body] and !env[:body].respond_to?(:to_str)
+            if has_multipart?(env[:body])
+              env[:request][:boundary] ||= DEFAULT_MULTIPART_BOUNDARY
+              env[:request_headers][CONTENT_TYPE] ||= MULTIPART_MIME_TYPE
+              env[:request_headers][CONTENT_TYPE] += ";boundary=#{env[:request][:boundary]}"
+              env[:body] = create_multipart(env, env[:body])
+            else
+              env[:request_headers][CONTENT_TYPE] ||= URL_ENCODED_MIME_TYPE
+              env[:body] = Faraday::Utils::ParamsHash[env[:body]].to_query
+            end
+          end
+        end
+        @app.call env
+      end
+
+
+      private
+
+      def has_multipart?(obj)
+        # string is an enum in 1.8, returning list of itself
+        if obj.respond_to?(:each) && !obj.is_a?(String)
+          (obj.respond_to?(:values) ? obj.values : obj).each do |val|
+            return true if (val.respond_to?(:content_type) || has_multipart?(val))
+          end
+        end
+        false
+      end
+
+      def create_multipart(env, params)
+        boundary = env[:request][:boundary]
+        parts = process_params(params) do |key, value|
+          Faraday::Parts::Part.new(boundary, key, value)
+        end
+        parts << Faraday::Parts::EpiloguePart.new(boundary)
+
+        body = Faraday::CompositeReadIO.new(parts)
+        env[:request_headers][Faraday::Env::ContentLength] = body.length.to_s
+        body
+      end
+
+      def process_params(params, prefix = nil, pieces = nil, &block)
+        params.inject(pieces || []) do |all, (key, value)|
+          key = "#{prefix}[#{key}]" if prefix
+
+          case value
+            when Array
+              values = value.inject([]) { |a,v| a << [nil, v] }
+              process_params(values, key, all, &block)
+            when Hash
+              process_params(value, key, all, &block)
+            else
+              all << block.call(key, value)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/saddle/middleware/response/default_response.rb

@@ -0,0 +1,24 @@
+require 'faraday'
+
+
+module Saddle::Middleware
+  module Response
+
+    # Public: Returns a default response in the case of an exception
+    # Expects default_response to be defined in the request of connection options, otherwise rethrows exception
+    class DefaultResponse < Faraday::Middleware
+      def call(env)
+        begin
+          @app.call(env)
+        rescue Faraday::Error
+          if res = env[:request][:default_response]
+            return ::Faraday::Response.new(:body => res)
+          else
+            raise
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/saddle/middleware/response/parse_json.rb

@@ -0,0 +1,45 @@
+require 'faraday'
+
+
+
+module Saddle::Middleware
+  module Response
+
+  # Public: Parse response bodies as JSON.
+    class ParseJson < Faraday::Middleware
+      CONTENT_TYPE = 'Content-Type'.freeze
+      MIME_TYPE    = 'application/json'.freeze
+
+      dependency do
+        require 'json' unless defined?(::JSON)
+      end
+
+      def call(env)
+        if parse_response?(env)
+          # Make sure we're working with a valid body that's not a String
+          if env.body and !env.body.respond_to?(:to_str)
+            env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+            env.body = ::JSON.dump env.body
+          end
+        end
+        @app.call env
+      end
+
+      def parse_response?(env)
+        has_body?(env) and (response_type(env) == MIME_TYPE)
+      end
+
+      def has_body?(env)
+        body = env[:body] and !(body.respond_to?(:to_str) and body.empty?)
+      end
+
+      def response_type(env)
+        return nil unless env[:response_headers]
+        type = env[:response_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+
+  end
+end

data/lib/saddle/options.rb

@@ -13,11 +13,10 @@ module Saddle::Options
       :host => host,
       :port => port,
       :use_ssl => use_ssl,
-      :post_style => post_style,
-      :response_style => response_style,
+      :request_style => request_style,
       :num_retries => num_retries,
       :timeout => timeout,
-      :additional_middlewares => additional_middlewares,
+      :additional_middlewares => @@additional_middlewares,
       :stubs => stubs,
     }
   end
@@ -39,13 +38,7 @@ module Saddle::Options
 
   # The POST/PUT style for this client
   # options are [:json, :urlencoded]
-  def post_style
-    :json
-  end
-
-  # How to parse results
-  # options are [:json, :urlencoded]
-  def response_style
+  def request_style
     :json
   end
 
@@ -59,17 +52,18 @@ module Saddle::Options
     30
   end
 
-  # Override this to add additional middleware to the request stack
+  # Use this to add additional middleware to the request stack
   # ex:
-  #
-  # require 'my_middleware'
-  # def self.default_middleware
-  #   [MyMiddleware]
+  # add_middleware({
+  #   :klass => MyMiddleware,
+  #   :args => [arg1, arg2],
+  # })
   # end
   #
   ###
-  def additional_middlewares
-    []
+  @@additional_middlewares = []
+  def add_middleware m
+    @@additional_middlewares << m
   end
 
   # If the Typhoeus adapter is being used, pass stubs to it for testing.

data/lib/saddle/requester.rb

@@ -1,8 +1,11 @@
 require 'faraday'
 require 'faraday_middleware'
 
-require 'saddle/middleware/default_response'
-require 'saddle/middleware/parse_json'
+require 'saddle/middleware/request/encode_json'
+require 'saddle/middleware/request/retry'
+require 'saddle/middleware/request/url_encoded'
+require 'saddle/middleware/response/default_response'
+require 'saddle/middleware/response/parse_json'
 require 'saddle/middleware/ruby_timeout'
 
 
@@ -21,8 +24,7 @@ module Saddle
     ## host - host to connect to (default: localhost)
     ## port - port to connect on (default: 80)
     ## use_ssl - true if we should use https (default: false)
-    ## post_style - :json or :urlencoded (default: :json)
-    ## response_style - :json or :urlencoded (default: :json)
+    ## request_style - :json or :urlencoded (default: :json)
     ## num_retries - number of times to retry each request (default: 3)
     ## timeout - timeout in seconds
     ## additional_middleware - an Array of more middlewares to apply to the top of the stack
@@ -35,10 +37,8 @@ module Saddle
       raise ':port must be an integer' unless @port.is_a?(Fixnum)
       @use_ssl = opt[:use_ssl] || false
       raise ':use_ssl must be true or false' unless (@use_ssl.is_a?(TrueClass) || @use_ssl.is_a?(FalseClass))
-      @post_style = opt[:post_style] || :json
-      raise ":post_style must be in: #{VALID_BODY_STYLES.join(',')}" unless VALID_BODY_STYLES.include?(@post_style)
-      @response_style = opt[:response_style] || :json
-      raise ":response_style must be in: #{VALID_BODY_STYLES.join(',')}" unless VALID_BODY_STYLES.include?(@response_style)
+      @request_style = opt[:request_style] || :json
+      raise ":request_style must be in: #{VALID_BODY_STYLES.join(',')}" unless VALID_BODY_STYLES.include?(@request_style)
       @num_retries = opt[:num_retries] || 3
       raise ':num_retries must be an integer' unless @num_retries.is_a?(Fixnum)
       @timeout = opt[:timeout]
@@ -65,33 +65,24 @@ module Saddle
       response.body
     end
 
-    # Handle request logic for PUT or POST
-    def post_or_put(f, url, params={}, options={})
-      response = connection.send(f) do |req|
+    # Make a POST request
+    def post(url, data={}, options={})
+      response = connection.post do |req|
         req.options.merge! options
         req.url url
-        # Handle different supported post styles
-        case @post_style
-          when :json
-            req.headers['Content-Type'] = 'application/json'
-            req.body = params.to_json
-          when :urlencoded
-            req.params = params
-          else
-            raise RuntimeError(":post_style must be one of: #{VALID_POST_STYLES.join(',')}")
-        end
+        req.body = data
       end
       response.body
     end
 
-    # Make a POST request
-    def post(url, params={}, options={})
-      post_or_put(:post, url, params, options)
-    end
-
     # Make a PUT request
-    def put(url, params={}, options={})
-      post_or_put(:put, url, params, options)
+    def put(url, data={}, options={})
+      response = connection.put do |req|
+        req.options.merge! options
+        req.url url
+        req.body = data
+      end
+      response.body
     end
 
     # Make a DELETE request
@@ -118,10 +109,12 @@ module Saddle
         # Config options
         unless @timeout.nil?
           builder.options[:timeout] = @timeout
+          builder.options[:request_style] = @request_style
+          builder.options[:num_retries] = @num_retries
         end
 
         # Support default return values upon exception
-        builder.use Saddle::Middleware::DefaultResponse
+        builder.use Saddle::Middleware::Response::DefaultResponse
 
         # Apply additional implementation-specific middlewares
         @additional_middlewares.each do |m|
@@ -131,12 +124,18 @@ module Saddle
         # Hard timeout on the entire request
         builder.use Saddle::Middleware::RubyTimeout
 
-        # Support multi-part encoding if there is a file attached
-        builder.request :multipart
-        # Handle retries
-        if @num_retries
-          builder.request :retry, @num_retries
-        end
+        # Request encoding
+        builder.use Saddle::Middleware::Request::JsonEncoded
+        builder.use Saddle::Middleware::Request::UrlEncoded
+
+        # Automatic retries
+        builder.use Saddle::Middleware::Request::Retry
+
+        # Handle parsing out the response if it's JSON
+        builder.use Saddle::Middleware::Response::ParseJson
+
+        # Raise exceptions on 4xx and 5xx errors
+        builder.use Faraday::Response::RaiseError
 
         # Set up our adapter
         if @stubs.nil?
@@ -146,11 +145,6 @@ module Saddle
           # Use the test adapter
           builder.adapter :test, @stubs
         end
-
-        # Raise exceptions on 4xx and 5xx errors
-        builder.response :raise_error
-        # Handle parsing out the response if it's JSON
-        builder.use Saddle::Middleware::ParseJson
       end
     end
 

data/lib/saddle/version.rb

@@ -1,3 +1,3 @@
 module Saddle
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/spec/requester/get_spec.rb

@@ -0,0 +1,40 @@
+require 'saddle'
+
+describe Saddle::Client do
+
+  context "GET requests" do
+    context "using the default client" do
+
+      before :each do
+        @stubs = Faraday::Adapter::Test::Stubs.new
+        @default_client = Saddle::Client.create(:stubs => @stubs)
+      end
+
+      it "should request properly with params" do
+        @stubs.get('/test?name=mike&party=true') {
+          [
+            200,
+            {},
+            'Party on!',
+          ]
+        }
+        @default_client.requester.get(
+          '/test',
+          {'name' => 'mike', 'party' => true}
+        ).should == 'Party on!'
+      end
+
+      it "should parse JSON encoded responses" do
+        @stubs.get('/test.json') {
+          [
+            200,
+            {'Content-Type' => 'application/json'},
+            {'success' => true},
+          ]
+        }
+        @default_client.requester.get('/test.json')['success'].should == true
+      end
+
+    end
+  end
+end

data/spec/requester/post_spec.rb

@@ -0,0 +1,56 @@
+require 'saddle'
+
+describe Saddle::Client do
+
+  context "POST requests" do
+    context "using the default client" do
+
+      before :each do
+        @stubs = Faraday::Adapter::Test::Stubs.new
+        @default_client = Saddle::Client.create(:stubs => @stubs)
+      end
+
+      it "should post empty" do
+        @stubs.post('/test') {
+          [
+            200,
+            {},
+            'Party on!',
+          ]
+        }
+        @default_client.requester.post('/test').should == 'Party on!'
+      end
+
+      it "should post url encoded" do
+        @stubs.post('/test', 'a=0&b=true&c=Wingdings') {
+          [
+            200,
+            {},
+            'Party on!',
+          ]
+        }
+        @default_client.requester.post(
+          '/test',
+          {'a' => 0, 'b' => true, 'c' => 'Wingdings'},
+          {:request_style => :urlencoded}
+        ).should == 'Party on!'
+      end
+
+      it "should post JSON encoded" do
+        @stubs.post('/test', '{"a":0,"b":true,"c":"Wingdings"}') {
+          [
+            200,
+            {},
+            'Party on!',
+          ]
+        }
+        @default_client.requester.post(
+          '/test',
+          {'a' => 0, 'b' => true, 'c' => 'Wingdings'},
+          {:request_style => :json}
+        ).should == 'Party on!'
+      end
+
+    end
+  end
+end

data/spec/requester/retry_spec.rb

@@ -0,0 +1,54 @@
+require 'saddle'
+
+describe Saddle::Client do
+
+  context "retry requests" do
+    context "using the default client" do
+
+      before :each do
+        @stubs = Faraday::Adapter::Test::Stubs.new
+        @default_client = Saddle::Client.create(:stubs => @stubs)
+      end
+
+      it "should retry properly with no params" do
+        @stubs.get('/test') {
+          [
+            500,
+            {},
+            'Failure',
+          ]
+        }
+        @stubs.get('/test') {
+          [
+            200,
+            {},
+            'Party!',
+          ]
+        }
+        @default_client.requester.get('/test').should == 'Party!'
+      end
+
+      it "should retry properly when posting params urlencoded" do
+        @stubs.post('/test', '{"a":"b","c":"d"}') {
+          [
+            500,
+            {},
+            'Failure',
+          ]
+        }
+        @stubs.post('/test', '{"a":"b","c":"d"}') {
+          [
+            200,
+            {},
+            'Party!',
+          ]
+        }
+        @default_client.requester.post(
+          '/test',
+          {'a' => 'b', 'c' => 'd'}
+        ).should == 'Party!'
+      end
+
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: saddle
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Mike Lewis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-10 00:00:00.000000000 Z
+date: 2013-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -68,16 +68,21 @@ files:
 - lib/saddle.rb
 - lib/saddle/endpoint.rb
 - lib/saddle/method_tree_builder.rb
-- lib/saddle/middleware/airbrake_logging.rb
-- lib/saddle/middleware/default_response.rb
-- lib/saddle/middleware/parse_json.rb
+- lib/saddle/middleware/logging/airbrake.rb
+- lib/saddle/middleware/logging/statsd.rb
+- lib/saddle/middleware/request/encode_json.rb
+- lib/saddle/middleware/request/retry.rb
+- lib/saddle/middleware/request/url_encoded.rb
+- lib/saddle/middleware/response/default_response.rb
+- lib/saddle/middleware/response/parse_json.rb
 - lib/saddle/middleware/ruby_timeout.rb
-- lib/saddle/middleware/statsd_logging.rb
 - lib/saddle/options.rb
 - lib/saddle/requester.rb
 - lib/saddle/version.rb
 - saddle.gemspec
-- spec/saddle_client_spec.rb
+- spec/requester/get_spec.rb
+- spec/requester/post_spec.rb
+- spec/requester/retry_spec.rb
 homepage: https://github.com/mLewisLogic/saddle
 licenses:
 - MIT
@@ -104,4 +109,6 @@ specification_version: 4
 summary: A generic client wrapper for building service-specific wrappers. Base functionality,
   meant to be extended to concrete implementations.
 test_files:
-- spec/saddle_client_spec.rb
+- spec/requester/get_spec.rb
+- spec/requester/post_spec.rb
+- spec/requester/retry_spec.rb

data/lib/saddle/middleware/airbrake_logging.rb

@@ -1,31 +0,0 @@
-require 'faraday'
-
-
-module Saddle::Middleware
-
-  # Public: Reports exceptions to airbrake
-  #
-  class AirbrakeLogging < Faraday::Middleware
-
-    def initialize(app, airbrake_api_key)
-      @airbrake_api_key = airbrake_api_key
-      super(app)
-    end
-
-    def call(env)
-      begin
-        @app.call(env)
-      rescue => e
-        ::Airbrake.notify(
-          e,
-          {
-            :api_key => @airbrake_api_key,
-          }
-        )
-        raise
-      end
-    end
-
-  end
-
-end

data/lib/saddle/middleware/default_response.rb

@@ -1,24 +0,0 @@
-require 'faraday'
-
-
-module Saddle::Middleware
-
-  # Public: Returns a default response in the case of an exception
-  # Expects default_response to be defined in the request of connection options, otherwise rethrows exception
-  class DefaultResponse < Faraday::Middleware
-
-    def call(env)
-      begin
-        @app.call(env)
-      rescue => e
-        if res = env[:request][:default_response]
-          return ::Faraday::Response.new(:body => res)
-        else
-          raise
-        end
-      end
-    end
-
-  end
-
-end

data/lib/saddle/middleware/parse_json.rb

@@ -1,36 +0,0 @@
-require 'faraday_middleware/response_middleware'
-
-
-module Saddle::Middleware
-
-# Public: Parse response bodies as JSON.
-  class ParseJson < FaradayMiddleware::ResponseMiddleware
-    MIME_TYPE = 'application/json'.freeze
-
-    dependency do
-      require 'json' unless defined?(::JSON)
-    end
-
-    define_parser do |body|
-      ::JSON.parse body unless body.strip.empty?
-    end
-
-
-    def parse_response?(env)
-      type = response_type(env)
-      super and has_body?(env) and (type.empty? or type == MIME_TYPE)
-    end
-
-    def has_body?(env)
-      body = env[:body] and !(body.respond_to?(:to_str) and body.empty?)
-    end
-
-    def response_type(env)
-      type = env[:response_headers][CONTENT_TYPE].to_s
-      type = type.split(';', 2).first if type.index(';')
-      type
-    end
-
-  end
-
-end

data/lib/saddle/middleware/statsd_logging.rb

@@ -1,45 +0,0 @@
-require 'statsd'
-
-module Saddle::Middleware
-
-  # Public: Wraps request with statsd logging
-  # Expects statsd_path in request options.  However, if using saddle and no statsd_path is specified
-  # will read call_chain and action and use them to construct a statsd_path
-  class StatsdLogging < Faraday::Middleware
-    attr_accessor :graphite_host, :graphite_port, :namespace
-
-    def initialize(app, graphite_host, graphite_port=nil, namespace=nil)
-      super(app)
-      @graphite_host = graphite_host
-      @graphite_port = graphite_port
-      @namespace = namespace
-      self.statsd
-    end
-
-    def statsd
-      if(@statsd.nil?)
-        @statsd = Statsd.new(@graphite_host, @graphite_port)
-        @statsd.namespace = @namespace if @namespace
-      end
-      return @statsd
-    end
-
-    def call(env)
-      if env[:request][:statsd_path]
-        statsd_path = env[:request][:statsd_path]
-      elsif env[:request][:saddle] && env[:request][:saddle][:call_chain] && env[:request][:saddle][:action]
-        statsd_path = (env[:request][:saddle][:call_chain] + [env[:request][:saddle][:action]]).join(".")
-      end
-
-      if statsd_path
-        self.statsd.time statsd_path do
-          @app.call(env)
-        end
-      else
-        @app.call(env)
-      end
-    end
-
-  end
-
-end

data/spec/saddle_client_spec.rb

@@ -1,34 +0,0 @@
-require 'saddle'
-
-describe Saddle::Client do
-
-  context "instance" do
-    before :each do
-      stubs = Faraday::Adapter::Test::Stubs.new do |stub|
-        stub.get('/test') {
-          [
-            200,
-            {'Content-Type' => 'application/x-www-form-urlencoded'},
-            'success'
-          ]
-        }
-        stub.get('/test.json') {
-          [
-            200,
-            {'Content-Type' => 'application/json'},
-            {'success' => true}.to_json
-          ]
-        }
-      end
-      @client = Saddle::Client.create(:stubs => stubs)
-    end
-
-    it "should be able to request urlencoded" do
-      @client.requester.get('/test').should == 'success'
-    end
-
-    it "should be able to request JSON encoded" do
-      @client.requester.get('/test.json')['success'].should == true
-    end
-  end
-end