saddle 0.0.12 → 0.0.14

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MGJkMTFhMzc3ZGU3YWQwZWFlOGQ3ZjdiYmM2OTk3NzRkMjg4OTRiMg==
+    MDE2NjI0YTFjNzExNzNhNTVjZGIxNDc0MjBmNjQ4ZWUzNzA1ODFkMA==
   data.tar.gz: !binary |-
-    MTQxMzRjZDdmODhmMGI1ZTA5NzAyYzFhYTVjMzg2MGViMzMwYTY1Yw==
+    ZDkyZTUxZjgwNjMyNmFjYmEwMDc5ZWNkOTZiYTU3ZjZlYzI2NzVkZA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZGJmMTZhZTAzOWFmMzg0ODE1Zjc5N2E0Yjk4N2M5N2U4NWNiYjc0MzA1MjJm
-    ZmRhODc3MGYxMjZhNDlmYmNjYTA4ZTQ3ZTVmOTU0MDA5NmQ0MjAxYmEzMzAx
-    YWIxN2NjODdlYmYzYzVlMjY3MmViY2UwM2JiOTcwMDlmMmE3M2I=
+    N2Y2ZDFiMmNhZjNmNmM5NzYxNzIzZWQ1YThmMGUzMTdkNTM3ZDM5YzJkNWJm
+    Y2Q5MGFkYzM0MGQ1NzdlNGY1ZmExMjFhN2JiZGNlZjRkMTIxZjQ0ZTUxMzNk
+    YWIxNWMxNTQ1YWQ4NjdkM2EzNDVjNTFkYjk3NjRiMmMxYmU5NWU=
   data.tar.gz: !binary |-
-    MzZmOWM1M2RkM2IwNjRmNGM0OGM2NGQ3NmI5ZDAxMjBmY2U3OTEwNjE5YzEz
-    MDA2YzQ2YWQxODY4NmZhMTM1MzQ4NzY3MDQ0YTcwNjUwMDViNGRkOTkyZjQy
-    MzhlYWIwMzAyNWIwMTYxZjVmZTI0NWJkM2Y4MDUyODJjZjNmZGE=
+    Yzc0MzU4M2E5ZmQzYTQ5NTNlNjFlYzdjODJiYzgwZWNkOGRmZjg0OTYzMTU3
+    ZWZkZmUwZjMyMTBhZmI3OWY1YzdiNWQyYWY4NzkwNjk5Nzc3MzQ1ZDI2MTNm
+    NDdhYmRmZWI1YWQ0OTE3OWY5NTk1Yzg5NjRkYWQ2ZGE0MmE2YjU=

data/lib/saddle/client_attributes.rb

@@ -1,24 +1,18 @@
-module Saddle::ClientAttributes
+module Saddle
+  module ClientAttributes
 
-  def self.included(obj)
-    obj.extend ClassMethods
+    def self.included(obj)
+      obj.extend ClassMethods
 
-    # Clone the parent's additional_middlewares
-    obj.additional_middlewares = if defined?(obj.superclass.additional_middlewares)
-      obj.superclass.additional_middlewares.clone
-    else
-      []
+      # We know that this module is included when saddle client is inherited,
+      # so we're actually interested in the path of the caller two levels deep.
+      path, = caller[2].partition(":")
+      obj.implementation_root = File.dirname(path)
     end
 
-    # We know that this module is included when saddle client is inherited,
-    # so we're actually interested in the path of the caller two levels deep.
-    path, = caller[2].partition(":")
-    obj.implementation_root = File.dirname(path)
-  end
+    module ClassMethods
+      attr_accessor :implementation_root
+    end
 
-  module ClassMethods
-    attr_accessor :implementation_root
-    attr_accessor :additional_middlewares
   end
-
-end
+end

data/lib/saddle/endpoint.rb

@@ -1,7 +1,3 @@
-
-
-
-
 module Saddle
 
   # This base endpoint is what all implementation endpoints should inherit

data/lib/saddle/errors.rb

@@ -1,7 +1,9 @@
 module Saddle
+
   # The parent class of all exceptions thrown by Saddle
   class Error < StandardError; end
 
   # Thrown when a request timeout is exceeded
   class TimeoutError < Error; end
-end
+
+end

data/lib/saddle/method_tree_builder.rb

@@ -10,94 +10,97 @@ require 'saddle/endpoint'
 # build the endpoint tree based upon module/class namespaces
 
 
-module Saddle::MethodTreeBuilder
-
-  # Build out the endpoint structure from the root of the implementation
-  def build_tree(requester)
-    root_node = build_root_node(requester)
-    # If we have an 'endpoints' directory, build it out
-    if knows_root? && Dir.exists?(endpoints_directory)
-      Dir["#{endpoints_directory}/**/*.rb"].each { |f| load(f) }
-      build_node_children(self.endpoints_module, root_node, requester)
+module Saddle
+  module MethodTreeBuilder
+
+    # Build out the endpoint structure from the root of the implementation
+    def build_tree(requester)
+      root_node = build_root_node(requester)
+      # If we have an 'endpoints' directory, build it out
+      if knows_root? && Dir.exists?(endpoints_directory)
+        Dir["#{endpoints_directory}/**/*.rb"].each { |f| load(f) }
+        build_node_children(self.endpoints_module, root_node, requester)
+      end
+      root_node
     end
-    root_node
-  end
 
 
-  # Build our root node here. The root node is special in that it lives below
-  # the 'endpoints' directory, and so we need to manually check if it exists.
-  def build_root_node(requester)
-    if knows_root?
-      root_endpoint_file = File.join(
-        self.implementation_root,
-        'root_endpoint.rb'
-      )
-      if File.file?(root_endpoint_file)
-        # Load it and create our base endpoint
-        load(root_endpoint_file)
-        self.implementation_module::RootEndpoint.new(requester)
+    # Build our root node here. The root node is special in that it lives below
+    # the 'endpoints' directory, and so we need to manually check if it exists.
+    def build_root_node(requester)
+      if knows_root?
+        root_endpoint_file = File.join(
+          self.implementation_root,
+          'root_endpoint.rb'
+        )
+        if File.file?(root_endpoint_file)
+          # Load it and create our base endpoint
+          load(root_endpoint_file)
+          self.implementation_module::RootEndpoint.new(requester)
+        else
+          # 'root_endpoint.rb' doesn't exist, so create a dummy endpoint
+          Saddle::BaseEndpoint.new(requester)
+        end
       else
-        # 'root_endpoint.rb' doesn't exist, so create a dummy endpoint
+        # we don't even have an implementation root, so create a dummy endpoint
         Saddle::BaseEndpoint.new(requester)
       end
-    else
-      # we don't even have an implementation root, so create a dummy endpoint
-      Saddle::BaseEndpoint.new(requester)
     end
-  end
 
 
-  # Build out the traversal tree by module namespace
-  def build_node_children(current_module, current_node, requester)
-    current_module.constants.each do |const_symbol|
-      const = current_module.const_get(const_symbol)
-
-      if const.class == Module
-        # A module means that it's a branch
-        # Build the branch out with a base endpoint
-        branch_node = current_node.build_and_attach_node(
-          Saddle::BaseEndpoint,
-          ActiveSupport::Inflector.underscore(const_symbol)
-        )
-        # Build out the branch's endpoints on the new branch node
-        self.build_node_children(const, branch_node, requester)
-      end
-
-      if const < Saddle::TraversalEndpoint
-        # A class means that it's a node
-        # Build out this endpoint on the current node
-        current_node.build_and_attach_node(
-          const,
-          ActiveSupport::Inflector.underscore(const_symbol)
-        )
+    # Build out the traversal tree by module namespace
+    def build_node_children(current_module, current_node, requester)
+      current_module.constants.each do |const_symbol|
+        const = current_module.const_get(const_symbol)
+
+        if const.class == Module
+          # A module means that it's a branch
+          # Build the branch out with a base endpoint
+          branch_node = current_node.build_and_attach_node(
+            Saddle::BaseEndpoint,
+            ActiveSupport::Inflector.underscore(const_symbol)
+          )
+          # Build out the branch's endpoints on the new branch node
+          self.build_node_children(const, branch_node, requester)
+        end
+
+        if const < Saddle::TraversalEndpoint
+          # A class means that it's a node
+          # Build out this endpoint on the current node
+          current_node.build_and_attach_node(
+            const,
+            ActiveSupport::Inflector.underscore(const_symbol)
+          )
+        end
       end
     end
-  end
 
 
-  # Get the module that the client implementation belongs to. This will act
-  # as the root namespace for endpoint traversal and construction
-  def implementation_module
-    ::ActiveSupport::Inflector.constantize(
-      self.name.split('::')[0..-2].join('::')
-    )
-  end
+    # Get the module that the client implementation belongs to. This will act
+    # as the root namespace for endpoint traversal and construction
+    def implementation_module
+      ::ActiveSupport::Inflector.constantize(
+        self.name.split('::')[0..-2].join('::')
+      )
+    end
 
-  # Get the Endpoints module that lives within this implementation's
-  # namespace
-  def endpoints_module
-    implementation_module.const_get('Endpoints')
-  end
+    # Get the Endpoints module that lives within this implementation's
+    # namespace
+    def endpoints_module
+      implementation_module.const_get('Endpoints')
+    end
 
-  # Get the path to the 'endpoints' directory, based upon the client
-  # class that inherited Saddle
-  def endpoints_directory
-    File.join(self.implementation_root, 'endpoints')
-  end
+    # Get the path to the 'endpoints' directory, based upon the client
+    # class that inherited Saddle
+    def endpoints_directory
+      File.join(self.implementation_root, 'endpoints')
+    end
+
+    # If this client was not fully constructed, it may not even have an
+    # implementation root. Allow that behavior and avoid firesystem searching.
+    def knows_root?
+      defined?(self.implementation_root)
+    end
 
-  # If this client was not fully constructed, it may not even have an
-  # implementation root. Allow that behavior and avoid firesystem searching.
-  def knows_root?
-    defined?(self.implementation_root)
   end
 end

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

@@ -3,33 +3,35 @@ require 'faraday'
 
 
 
-module Saddle::Middleware
-  module Logging
+module Saddle
+  module Middleware
+    module Logging
 
-    # Public: Reports exceptions to Airbrake
-    #
-    class AirbrakeLogger < Faraday::Middleware
+      # 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 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)
+        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
-          # Re-raise the error
-          raise
         end
-      end
 
+      end
     end
   end
 end

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

@@ -4,48 +4,50 @@ 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
+module Saddle
+  module 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
-      end
 
-      def call(env)
-        # Try to build up a path for the STATSD logging
-        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 = (['saddle'] + env[:request][:saddle][:call_chain] + [env[:request][:saddle][:action]]).join('.')
+        def statsd
+          @statsd ||= begin
+            client = ::Statsd.new(@graphite_host, @graphite_port)
+            client.namespace = @namespace if @namespace
+          end
         end
 
-        # If we have a path, wrap the ensuing app call in STATSD timing
-        if statsd_path
-          self.statsd.time(statsd_path) do
+        def call(env)
+          # Try to build up a path for the STATSD logging
+          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 = (['saddle'] + env[:request][:saddle][:call_chain] + [env[:request][:saddle][:action]]).join('.')
+          end
+
+          # If we have a path, wrap the ensuing app call in STATSD timing
+          if statsd_path
+            self.statsd.time(statsd_path) do
+              @app.call(env)
+            end
+          else
             @app.call(env)
           end
-        else
-          @app.call(env)
         end
       end
-    end
 
+    end
   end
 end

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

@@ -2,33 +2,35 @@ require 'faraday'
 
 
 
-module Saddle::Middleware
-  module Request
+module Saddle
+  module Middleware
+    module Request
 
-    # Request middleware that encodes the body as JSON.
-    #
-    # Make sure you set request[:request_style] = :json
-    # for it to be activated.
+      # 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
+      class JsonEncoded < Faraday::Middleware
+        CONTENT_TYPE = 'Content-Type'.freeze
+        MIME_TYPE    = 'application/json'.freeze
 
-      dependency do
-        require 'json' unless defined?(::JSON)
-      end
+        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])
+        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
-        @app.call env
       end
-    end
 
+    end
   end
-end
+end

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

@@ -2,54 +2,56 @@ require 'faraday'
 
 
 
-module Saddle::Middleware
-  module Request
+module Saddle
+  module 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
+      # 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
+        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
-          # 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
+        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
   end
 end

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

@@ -2,85 +2,87 @@ require 'faraday'
 
 
 
-module Saddle::Middleware
-  module Request
+module Saddle
+  module Middleware
+    module Request
 
-    # This magically handles converting your body from a hash
-    # into an url-encoded (or multipart if needed) 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.
+      # 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
+      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
+        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]
+        VALID_MIME_TYPES = [URL_ENCODED_MIME_TYPE, MULTIPART_MIME_TYPE]
 
-      DEFAULT_MULTIPART_BOUNDARY = "-^---_---^-".freeze
+        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
+        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
-        @app.call env
-      end
 
 
-      private
+        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))
+        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
-        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)
+        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
+          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)
+        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
   end
 end

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

@@ -1,24 +1,27 @@
 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
+module Saddle
+  module 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
   end
 end

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

@@ -2,45 +2,47 @@ require 'faraday'
 
 
 
-module Saddle::Middleware
-  module Response
+module Saddle
+  module Middleware
+    module Response
 
-  # Public: Parse response bodies as JSON.
-    class ParseJson < Faraday::Middleware
-      CONTENT_TYPE = 'Content-Type'.freeze
-      MIME_TYPE    = 'application/json'.freeze
+    # 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
+        dependency do
+          require 'json' unless defined?(::JSON)
+        end
 
-      def call(env)
-        result = @app.call env
-        if parse_response?(env)
-          # Make sure we're working with a valid body that's not a String
-          if env[:body] && env[:body].respond_to?(:to_str)
-            env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
-            env[:body] = ::JSON.parse env[:body]
+        def call(env)
+          result = @app.call env
+          if parse_response?(env)
+            # Make sure we're working with a valid body that's not a String
+            if env[:body] && env[:body].respond_to?(:to_str)
+              env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+              env[:body] = ::JSON.parse env[:body]
+            end
           end
+          result
         end
-        result
-      end
 
-      def parse_response?(env)
-        has_body?(env) and (response_type(env) == MIME_TYPE)
-      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 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
+        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
   end
 end

data/lib/saddle/middleware/ruby_timeout.rb

@@ -1,24 +1,29 @@
 require 'faraday'
 
+require 'saddle/errors'
 
-module Saddle::Middleware
 
-  # Public: Enforces a ruby timeout on the request and throws one consistent
-  # exception for all classes of timeout, internal or from faraday.
-  # :timeout must be present in the request or client options
-  class RubyTimeout < Faraday::Middleware
 
-    def call(env)
-      timeout = env[:request][:timeout] # nil or 0 means no timeout
-      Timeout.timeout(timeout, Saddle::TimeoutError) do
-        @app.call(env)
+module Saddle
+  module Middleware
+
+    # Public: Enforces a ruby timeout on the request and throws one consistent
+    # exception for all classes of timeout, internal or from faraday.
+    # :timeout must be present in the request or client options
+    class RubyTimeout < Faraday::Middleware
+
+      def call(env)
+        timeout = env[:request][:timeout] # nil or 0 means no timeout
+        Timeout.timeout(timeout, Saddle::TimeoutError) do
+          @app.call(env)
+        end
+      # It is possible that faraday will catch the timeout first and throw
+      # this exception, rethrow as a class derived from standard error.
+      rescue Faraday::Error::TimeoutError
+        raise Saddle::TimeoutError
       end
-    # It is possible that faraday will catch the timeout first and throw
-    # this exception, rethrow as a class derived from standard error.
-    rescue Faraday::Error::TimeoutError
-      raise Saddle::TimeoutError
+
     end
 
   end
-
 end

data/lib/saddle/options.rb

@@ -1,73 +1,71 @@
-
-
-
 # Default options for a client. Override whatever you need to for
 # your specific implementation
 
+module Saddle
+  module Options
 
-module Saddle::Options
+    # Construct our default options, based upon the class methods
+    def default_options
+      {
+        :host => host,
+        :port => port,
+        :use_ssl => use_ssl,
+        :request_style => request_style,
+        :num_retries => num_retries,
+        :timeout => timeout,
+        :additional_middlewares => self.additional_middlewares,
+        :stubs => stubs,
+      }
+    end
 
-  # Construct our default options, based upon the class methods
-  def default_options
-    {
-      :host => host,
-      :port => port,
-      :use_ssl => use_ssl,
-      :request_style => request_style,
-      :num_retries => num_retries,
-      :timeout => timeout,
-      :additional_middlewares => self.additional_middlewares,
-      :stubs => stubs,
-    }
-  end
+    # The default host for this client
+    def host
+      'localhost'
+    end
 
-  # The default host for this client
-  def host
-    'localhost'
-  end
+    # The default port for this client
+    def port
+      80
+    end
 
-  # The default port for this client
-  def port
-    80
-  end
+    # Should this client use SSL by default?
+    def use_ssl
+      false
+    end
 
-  # Should this client use SSL by default?
-  def use_ssl
-    false
-  end
+    # The POST/PUT style for this client
+    # options are [:json, :urlencoded]
+    def request_style
+      :json
+    end
 
-  # The POST/PUT style for this client
-  # options are [:json, :urlencoded]
-  def request_style
-    :json
-  end
+    # Default number of retries per request
+    def num_retries
+      3
+    end
 
-  # Default number of retries per request
-  def num_retries
-    3
-  end
+    # Default timeout per request (in seconds)
+    def timeout
+      30
+    end
 
-  # Default timeout per request (in seconds)
-  def timeout
-    30
-  end
+    # Use this to add additional middleware to the request stack
+    # ex:
+    # add_middleware({
+    #   :klass => MyMiddleware,
+    #   :args => [arg1, arg2],
+    # })
+    # end
+    #
+    ###
+    def add_middleware m
+      self.additional_middlewares << m
+    end
 
-  # Use this to add additional middleware to the request stack
-  # ex:
-  # add_middleware({
-  #   :klass => MyMiddleware,
-  #   :args => [arg1, arg2],
-  # })
-  # end
-  #
-  ###  
-  def add_middleware m
-    self.additional_middlewares << m
-  end
+    # If the Typhoeus adapter is being used, pass stubs to it for testing.
+    def stubs
+      nil
+    end
 
-  # If the Typhoeus adapter is being used, pass stubs to it for testing.
-  def stubs
-    nil
   end
-
 end

data/lib/saddle/requester.rb

@@ -15,7 +15,6 @@ require 'saddle/middleware/ruby_timeout'
 
 
 module Saddle
-
   class Requester
 
     VALID_BODY_STYLES = [:json, :urlencoded]
@@ -149,5 +148,4 @@ module Saddle
     end
 
   end
-
 end

data/lib/saddle/version.rb

@@ -1,3 +1,3 @@
 module Saddle
-  VERSION = '0.0.12'
+  VERSION = '0.0.14'
 end

data/lib/saddle.rb

@@ -15,6 +15,10 @@ module Saddle
     extend MethodTreeBuilder
     extend Options
 
+    class << self
+      attr_accessor :additional_middlewares
+    end
+
     # Once your implementation is written, this is the magic you need to
     # create a client instance.
     def self.create(opt={})
@@ -26,6 +30,13 @@ module Saddle
     end
 
     def self.inherited(obj)
+      # Clone the parent's additional_middlewares
+      obj.additional_middlewares = if defined?(obj.superclass.additional_middlewares)
+        (obj.superclass.additional_middlewares || []).clone
+      else
+        []
+      end
+      # Add additional client attributes
       obj.send(:include, Saddle::ClientAttributes)
     end    
 

data/spec/requester/multiple_spec.rb

@@ -0,0 +1,73 @@
+require 'faraday'
+require 'saddle'
+
+
+
+### Make sure that multiple implementations of Saddle clients don't conflict with each other's middlewar.
+
+describe Saddle::Client do
+
+  context "multiple implementations" do
+    context "using different middleware" do
+
+      before :each do
+        # Middlewares
+        class Middleware1 < Faraday::Middleware
+          # Hook for catching calls
+          def subcall
+          end
+
+          def call(env)
+            self.subcall
+            @app.call(env)
+          end
+        end
+
+        class Middleware2 < Faraday::Middleware
+          # Hook for catching calls
+          def subcall
+          end
+
+          def call(env)
+            self.subcall
+            @app.call(env)
+          end
+        end
+
+
+        # Clients
+        class Client1 < Saddle::Client
+          add_middleware({:klass => Middleware1})
+        end
+        class Client2 < Saddle::Client
+          add_middleware({:klass => Middleware2})
+        end
+      end
+
+      it "should not overlap" do
+        # Set up our stubs
+        stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+          stub.get('/') {
+            [
+              200,
+              {},
+              'Party on!',
+            ]
+          }
+        end
+
+        # Set up our clients
+        client1 = Client1.create(:stubs => stubs)
+        client2 = Client2.create(:stubs => stubs)
+
+        # Make sure client2's middleware isn't called
+        Middleware1.any_instance.should_receive(:subcall)
+        Middleware2.any_instance.should_not_receive(:subcall)
+
+        # Make the call
+        client1.requester.get('/')
+      end
+
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: saddle
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.14
 platform: ruby
 authors:
 - Mike Lewis
@@ -82,6 +82,7 @@ files:
 - lib/saddle/version.rb
 - saddle.gemspec
 - spec/requester/get_spec.rb
+- spec/requester/multiple_spec.rb
 - spec/requester/post_spec.rb
 - spec/requester/retry_spec.rb
 homepage: https://github.com/mLewisLogic/saddle
@@ -111,5 +112,6 @@ summary: A full-featured, generic consumer layer for you to build API client imp
   with.
 test_files:
 - spec/requester/get_spec.rb
+- spec/requester/multiple_spec.rb
 - spec/requester/post_spec.rb
 - spec/requester/retry_spec.rb