saddle 0.0.3 → 0.0.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZGNhYTRlODExY2JjZDgyN2NiZTQzZjQ3MThmODJiMjRjOGFmOWMwZQ==
+    ZTEzYTVkN2VkMjExYWQ4ZDg1OWY1NDFjMTI1M2E1NzliNTYwYTE3ZA==
   data.tar.gz: !binary |-
-    MDE2M2U2ZWNkNzJlOWU4OTkwYTkxMTFmMjI4MmRlZTg0Yzk3YTRmMQ==
+    MzUyNzE1NDk1MDcxMmEzNzc2NzYyYjI0NjI5MGU0YmI0OWEwYzc4OQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZTI4ZTYzZGZhZGViMTBlYzMzNzM4ZjE5MDM2ODVhOTI1NjA2ZGUxYzRjZjA1
-    ZWZiZWJiMDgyMzUyNTE3OWM3ZTMxNjBlMzcyNTI4NjJjNGRiYjNhYmIwYjU5
-    NWYzZjE2OTYwMGQ0M2Q3Njk3ZjQ3MjUxNGNlNmQ5OGMwODk4ODc=
+    MDliMzRkYjYyY2VhMjlmNTgzNzM2ZTgxNjhiZGI2M2EzMzc5YmMwM2JmN2Ux
+    ZjgyOGU4NjZlZGNjN2Q4NzNiOGIyYzgzY2U2NmExY2E2OTRlZThjM2JmMDMy
+    MTgxMDE2ZjZmMmE3OTA2OTE4YTE3YmE5NDQ4ODVmZGVjMmFmNDY=
   data.tar.gz: !binary |-
-    ODM2NzNmZTRkNTcxNDVlMGU1ZWI4NTVjMTMzMjdlNWQzYjI5ZWY5MTBhNDcy
-    MDIyZWMwZGIyN2Q2Y2M2YTdhNGM1YmYwMDcxODVhODRhN2ViODQzZWY4MmZl
-    MmJhMWNhMmQ5MDJhYjUwMDlhZjE2ZDU1ZmRmYWE3OTIyY2RlYTA=
+    ZDM5MWY5NDRiYzBiMmM1NjM1ZTQzNzc1YmE1N2VjZDI1MjM0ZmU0ZGE3MWU4
+    NDI2ZTNiODI2MmYxYjZjMjA0MGUzYzUwZjNhOGRmMGEzNmY3OTBkODVkYTFl
+    MDJiMDZiYzA5YmY5OTJiNjg2MGY0YmJlZTExYTNiYTBkMjNlNTU=

data/.gitignore

@@ -0,0 +1,13 @@
+# Ignore tempfiles
+*.sw[op]
+.DS_Store
+
+# RVM
+.rvmrc
+
+# Gems
+*.gem
+
+# IDEs
+.idea
+.project

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require rspec/instafail
+--format RSpec::Instafail

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+
+gem 'activesupport', '>= 3.0', :require => 'active_support'
+gem 'faraday', '~> 0.8.6'
+gem 'faraday_middleware', '~> 0.9.0'
+
+group :test do
+  gem 'rspec', '~> 2.13.0'
+  gem 'rspec-instafail', '~> 0.2'
+end

data/Gemfile.lock

@@ -0,0 +1,33 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
+    diff-lcs (1.2.1)
+    faraday (0.8.6)
+      multipart-post (~> 1.1)
+    faraday_middleware (0.9.0)
+      faraday (>= 0.7.4, < 0.9)
+    i18n (0.6.1)
+    multi_json (1.7.2)
+    multipart-post (1.2.0)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-instafail (0.2.4)
+    rspec-mocks (2.13.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (>= 3.0)
+  faraday (~> 0.8.6)
+  faraday_middleware (~> 0.9.0)
+  rspec (~> 2.13.0)
+  rspec-instafail (~> 0.2)

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013, Mike Lewis
+
+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,39 @@
+# saddle
+
+Hey nerd! Wrangle your SOA!
+
+
+Saddle makes writing service clients as easy as giving high fives.©™®℗☃✓
+
+It's a full-featured generic consumer layer for you to build API client implementations on top of.
+
+
+## about
+
+Ok, I love high fives, but what does Saddle do for me?
+
+I'm glad you asked fellow nerd! Do you like automatic retries? Automatic multi-part file posting? I know I sure do!
+
+Do you like sending your POSTs url-encoded? That's okay, I still love you anyways and Saddle has your back. Does your rampant OCD refuse to let you post in anything less structured than JSON? High five nerd, Saddle bleeds OCD. Just set your :post_style flag and fuhgedaboutit!
+
+For an example of a concrete implementation, see [saddle-example](https://github.com/mLewisLogic/saddle-example)
+
+
+## features
+* set default connection settings for your implementation
+* post urlencoded or JSON
+* auto-parse JSON responses
+* automatic retries and exception throwing
+
+
+## guide
+1. Inherit your endpoint from BaseEndpoint and call .get or .post within its action methods
+2. Place those endpoints in the *endpoints* directory at the root of your client. Nest them if you like.
+3. Inherit your client from Saddle
+4. Call client.endpoint.action()
+
+
+## todo
+* xml posting
+* xml parsing
+* clean up custom middleware loading interface

data/lib/saddle.rb

@@ -0,0 +1,32 @@
+require 'saddle/method_tree_builder'
+require 'saddle/options'
+require 'saddle/requester'
+
+
+
+# Ghost ride the whip.
+# Inherit your client implementation from Saddle::Client
+# then call YourCrayClient.create to get a client instance.
+
+
+module Saddle
+
+  class Client
+
+    extend MethodTreeBuilder
+    extend Options
+
+
+    # Once your implementation is written, this is the magic you need to
+    # create a client instance.
+    def self.create(opt={})
+      self.build_tree(
+        Saddle::Requester.new(
+          default_options.merge(opt)
+        )
+      )
+    end
+
+  end
+
+end

data/lib/saddle/endpoint.rb

@@ -0,0 +1,108 @@
+
+
+
+
+module Saddle
+
+  # This base endpoint is what all implementation endpoints should inherit
+  # from. It automatically provides tree construction and traversal
+  # functionality. It also abstracts away url construction and requests to
+  # the underlying requester instance.
+
+  class BaseEndpoint
+
+    attr_reader :requester, :relative_path, :parent
+
+    # Each endpoint needs to have a requester in order to ... make ... uh ... requests.
+    def initialize(requester, relative_path=nil, parent=nil)
+      @requester = requester
+      @relative_path = relative_path
+      @parent = parent.is_a?(BaseEndpoint) ? parent : nil
+    end
+
+
+    # Provide GET functionality for the implementer class
+    def get(action, params={}, options={})
+      request(:get, action, params, options)
+    end
+
+    # Provide POST functionality for the implementer class
+    def post(action, params={}, options={})
+      request(:post, action, params, options)
+    end
+
+    # Provide PUT functionality for the implementer class
+    def put(action, params={}, options={})
+      request(:put, action, params, options)
+    end
+
+    # Provide DELETE functionality for the implementer class
+    def delete(action, params={}, options={})
+      request(:delete, action, params, options)
+    end
+
+    def request(method, action, params={}, options={})
+      # Augment in interesting options
+      options[:saddle] = {
+        :call_chain => path_array,
+        :action => action,
+      }
+      @requester.send(method, path(action), params, options)
+    end
+
+
+    # Get the url path for this endpoint/action combo
+    def path(action=nil)
+      paths = path_array
+      paths << action unless action.nil?
+      '/' + paths.join('/')
+    end
+
+    def path_array
+      endpoint_chain.map(&:relative_path).reject{|p| p.nil?}
+    end
+
+    # Get the parent chain that led to this endpoint
+    def endpoint_chain
+      chain = []
+      node = self
+      until node.nil?
+        chain << node
+        node = node.parent
+      end
+      chain.reverse
+    end
+
+
+    # Create an endpoint instance and foist it upon this node
+    def build_and_attach_node(endpoint_class, method_name)
+      endpoint_instance = endpoint_class.new(@requester, method_name, self)
+      self.instance_variable_set("@#{method_name}", endpoint_instance)
+      self.class.class_eval { define_method(method_name) { endpoint_instance } }
+      endpoint_instance
+    end
+
+    # This will create a resource endpoint, based upon the parameters
+    # of this current node endpoint
+    def create_resource_endpoint(endpoint_class, resource_id)
+      endpoint_class.new(
+        @requester,
+        (path_array + [resource_id]).join('/')
+        # no parent so that it can free up memory
+      )
+    end
+  end
+
+
+
+
+  # This endpoint will be automatically constructed into the node
+  # traversal tree.
+  class TraversalEndpoint < BaseEndpoint; end
+
+
+  # This endpoint is used for constructing resource-style endpoints. This
+  # means it will NOT be automatically added into the traversal tree.
+  class ResourceEndpoint < BaseEndpoint; end
+
+end

data/lib/saddle/method_tree_builder.rb

@@ -0,0 +1,113 @@
+require 'active_support'
+
+require 'saddle/endpoint'
+
+
+
+# This mixin provides functionality for the construction of the endpoint
+# tree. It will start at the root directory and namespace of the client
+# implementation. It will then load the 'endpoints' directory and
+# 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)
+    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(
+        @@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
+      # 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)
+        )
+      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 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(@@implementation_root, 'endpoints')
+  end
+
+
+
+  # When Saddle is inherited, we store the root of the implementation class
+  # This is so that we know where to look for relative files, like
+  # the endpoints directory
+  def inherited(obj)
+    path, = caller[0].partition(":")
+    @@implementation_root = File.dirname(path)
+  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?(@@implementation_root)
+  end
+end

data/lib/saddle/middleware/airbrake.rb

@@ -0,0 +1,30 @@
+require 'faraday'
+
+
+module Saddle::Middleware
+
+  # Public: Reports exceptions to airbrake
+  #
+  class Airbrake < Faraday::Middleware
+
+    def initialize(app, airbrake_api_key)
+      super(app)
+        ::Airbrake.configure do |config|
+          config.api_key = airbrake_api_key
+          # TODO: filter sensitive info
+          # config.params_filters.concat(Security::SENSITIVE_PARAMS_STR)
+        end
+    end
+
+    def call(env)
+      begin
+        @app.call(env)
+      rescue => e
+        ::Airbrake.notify(e)
+        raise
+      end
+    end
+
+  end
+
+end

data/lib/saddle/middleware/default_response.rb

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,36 @@
+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/ruby_timeout.rb

@@ -0,0 +1,19 @@
+require 'faraday'
+
+
+module Saddle::Middleware
+
+  # Public: Enforces a ruby timeout on the request
+  # :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) do
+        @app.call(env)
+      end
+    end
+
+  end
+
+end

data/lib/saddle/middleware/statsd_logging.rb

@@ -0,0 +1,45 @@
+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/lib/saddle/options.rb

@@ -0,0 +1,80 @@
+
+
+
+# Default options for a client. Override whatever you need to for
+# your specific implementation
+
+
+module Saddle::Options
+
+  # Construct our default options, based upon the class methods
+  def default_options
+    {
+      :host => host,
+      :port => port,
+      :use_ssl => use_ssl,
+      :post_style => post_style,
+      :response_style => response_style,
+      :num_retries => num_retries,
+      :timeout => timeout,
+      :additional_middlewares => additional_middlewares,
+      :stubs => stubs,
+    }
+  end
+
+  # The default host for this client
+  def host
+    'localhost'
+  end
+
+  # The default port for this client
+  def port
+    80
+  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 post_style
+    :json
+  end
+
+  # How to parse results
+  # options are [:json, :urlencoded]
+  def response_style
+    :json
+  end
+
+  # Default number of retries per request
+  def num_retries
+    3
+  end
+
+  # Default timeout per request (in seconds)
+  def timeout
+    30
+  end
+
+  # Override this to add additional middleware to the request stack
+  # ex:
+  #
+  # require 'my_middleware'
+  # def self.default_middleware
+  #   [MyMiddleware]
+  # end
+  #
+  ###
+  def additional_middlewares
+    []
+  end
+
+  # If the Typhoeus adapter is being used, pass stubs to it for testing.
+  def stubs
+    nil
+  end
+
+end

data/lib/saddle/requester.rb

@@ -0,0 +1,159 @@
+require 'faraday'
+require 'faraday_middleware'
+
+require 'saddle/middleware/default_response'
+require 'saddle/middleware/parse_json'
+require 'saddle/middleware/ruby_timeout'
+
+
+
+# The requester handles setting up the network connecting and brokering
+# requests.
+
+
+module Saddle
+
+  class Requester
+
+    VALID_BODY_STYLES = [:json, :urlencoded]
+
+    # Available options
+    ## 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)
+    ## 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
+    ##                       - each middleware consists of hash of klass, and optionally args (an array)
+    ## stubs - test stubs for specs
+    def initialize(opt={})
+      @host = opt[:host] || 'localhost'
+      raise ':host must be a string' unless @host.is_a?(String)
+      @port = opt[:port] || 80
+      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)
+      @num_retries = opt[:num_retries] || 3
+      raise ':num_retries must be an integer' unless @num_retries.is_a?(Fixnum)
+      @timeout = opt[:timeout]
+      unless @timeout.nil?
+        raise ':timeout must be a number or nil' unless @timeout.is_a?(Numeric)
+      end
+      @additional_middlewares = opt[:additional_middlewares] || []
+      raise ':additional_middleware must be an Array' unless @additional_middlewares.is_a?(Array)
+      raise 'invalid middleware found' unless @additional_middlewares.all? { |m| m[:klass] < Faraday::Middleware }
+      raise 'middleware arguments must be an array' unless @additional_middlewares.all? { |m| m[:args].nil? || m[:args].is_a?(Array) }
+      @stubs = opt[:stubs] || nil
+      unless @stubs.nil?
+        raise ':stubs must be a Faraday::Adapter::Test::Stubs' unless @stubs.is_a?(Faraday::Adapter::Test::Stubs)
+      end
+    end
+
+
+    # Make a GET request
+    def get(url, params={}, options={})
+      response = connection.get do |req|
+        req.options.merge! options
+        req.url url, params
+      end
+      response.body
+    end
+
+    # Handle request logic for PUT or POST
+    def post_or_put(f, url, params={}, options={})
+      response = connection.send(f) 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
+      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)
+    end
+
+    # Make a DELETE request
+    def delete(url, params={}, options={})
+      response = connection.delete do |req|
+        req.options.merge! options
+        req.url url, params
+      end
+      response.body
+    end
+
+
+
+    private
+
+    # Construct a base url using this requester's settings
+    def base_url
+      "http#{'s' if @use_ssl}://#{@host}:#{@port}"
+    end
+
+    # Build a connection instance, wrapped in the middleware that we want
+    def connection
+      @connection ||= Faraday.new(base_url) do |builder|
+        # Config options
+        unless @timeout.nil?
+          builder.options[:timeout] = @timeout
+        end
+
+        # Support default return values upon exception
+        builder.use Saddle::Middleware::DefaultResponse
+
+        # Apply additional implementation-specific middlewares
+        @additional_middlewares.each do |m|
+          builder.use m[:klass], *m[:args]
+        end
+
+        # 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
+
+        # Set up our adapter
+        if @stubs.nil?
+          # Use the default adapter
+          builder.adapter :net_http
+        else
+          # 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
+
+  end
+
+end

data/lib/saddle/version.rb

@@ -0,0 +1,3 @@
+module Saddle
+  VERSION = '0.0.4'
+end

data/saddle.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/saddle/version', __FILE__)
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name          = 'saddle'
+  s.version       = Saddle::VERSION
+
+  s.authors       = ['Mike Lewis', 'Naseem Hakim']
+  s.email         = 'mike@cleverkoala.com'
+  s.description   = %q{Makes writing API clients as easy as giving high fives}
+  s.summary       = %q{
+    A generic client wrapper for building service-specific wrappers. Base functionality, meant to be extended to concrete implementations.
+  }
+  s.homepage      = 'https://github.com/mLewisLogic/saddle'
+  s.license       = 'MIT'
+
+  s.require_path  = 'lib'
+  s.files         = `git ls-files`.split($\)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+
+  s.add_dependency 'activesupport', '>= 3.0'
+  s.add_dependency 'faraday', '~> 0.8.6'
+  s.add_dependency 'faraday_middleware', '~> 0.9.0'
+end

data/spec/saddle_client_spec.rb

@@ -0,0 +1,34 @@
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: saddle
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Mike Lewis
@@ -58,7 +58,26 @@ email: mike@cleverkoala.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/saddle.rb
+- lib/saddle/endpoint.rb
+- lib/saddle/method_tree_builder.rb
+- lib/saddle/middleware/airbrake.rb
+- lib/saddle/middleware/default_response.rb
+- lib/saddle/middleware/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
 homepage: https://github.com/mLewisLogic/saddle
 licenses:
 - MIT
@@ -84,4 +103,5 @@ signing_key:
 specification_version: 4
 summary: A generic client wrapper for building service-specific wrappers. Base functionality,
   meant to be extended to concrete implementations.
-test_files: []
+test_files:
+- spec/saddle_client_spec.rb