class Saddle::Requester

Constants

VALID_BODY_STYLES

Public Class Methods

new(parent_client, opt={}) click to toggle source

Available options

host - host to connect to (default: localhost)
port - port to connect on
use_ssl - true if we should use https (default: false)
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
                      - each middleware consists of hash of klass, and optionally args (an array)
stubs - test stubs for specs
# File lib/saddle/requester.rb, line 42
def initialize(parent_client, opt={})
  # We may want properties about the parent client in middlewares
  @parent_client = parent_client
  # Store the options for later use
  @options = opt
  @host = opt[:host] || 'localhost'
  raise ':host must be a string' unless @host.is_a?(String)
  @port = opt[:port]
  raise ':port must be nil or an integer' unless (@port.nil? || @port.is_a?(Integer))
  @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))
  @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?(Integer)
  @timeout = opt[:timeout]
  raise ':timeout must be nil or an integer' unless (@timeout.nil? || @timeout.is_a?(Numeric))
  @extra_env = opt[:extra_env] || {}
  raise 'extra_env must be a Hash' unless @extra_env.is_a?(Hash)
  @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) }

  @http_adapter = opt[:http_adapter] || :net_http
  raise ':http_adapter must be a symbol or a hash' unless @http_adapter.is_a?(Symbol) || @http_adapter.is_a?(Hash)
  @http_adapter = { :key => @http_adapter } if @http_adapter.is_a?(Symbol)
  raise 'adapter key must be a symbol' unless @http_adapter[:key].is_a?(Symbol)
  raise 'adapter arguments must be an array' unless @http_adapter[:args].nil? || @http_adapter[: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
  @return_full_response = opt[:return_full_response] || false
end

Public Instance Methods

delete(url, params={}, options={}) click to toggle source

Make a DELETE request

# File lib/saddle/requester.rb, line 111
def delete(url, params={}, options={})
  response = connection.delete do |req|
    req.saddle_options = options
    req.url(url, params)
  end
  handle_response(response)
end
get(url, params={}, options={}) click to toggle source

Make a GET request

# File lib/saddle/requester.rb, line 81
def get(url, params={}, options={})
  response = connection.get do |req|
    req.saddle_options = options
    req.body = options[:body] if options.has_key?(:body)
    req.url(url, params)
  end
  handle_response(response)
end
post(url, data={}, options={}) click to toggle source

Make a POST request

# File lib/saddle/requester.rb, line 91
def post(url, data={}, options={})
  response = connection.post do |req|
    req.saddle_options = options
    req.url(url)
    req.body = data
  end
  handle_response(response)
end
put(url, data={}, options={}) click to toggle source

Make a PUT request

# File lib/saddle/requester.rb, line 101
def put(url, data={}, options={})
  response = connection.put do |req|
    req.saddle_options = options
    req.url(url)
    req.body = data
  end
  handle_response(response)
end

Private Instance Methods

base_url() click to toggle source

Construct a base url using this requester’s settings

# File lib/saddle/requester.rb, line 129
def base_url
  "http#{'s' if @use_ssl}://#{@host}#{":#{@port}" if @port}"
end
connection() click to toggle source

Build a connection instance, wrapped in the middleware that we want

# File lib/saddle/requester.rb, line 134
def connection
  @connection ||= Faraday.new(base_url, :builder_class => Saddle::RackBuilder) do |connection|
    # Include the requester level options
    connection.builder.saddle_options[:client_options] = @options

    # Config options
    connection.options[:timeout] = @timeout
    connection.builder.saddle_options[:request_style] = @request_style
    connection.builder.saddle_options[:num_retries] = @num_retries
    connection.builder.saddle_options[:client] = @parent_client

    # Support default return values upon exception
    connection.use(Saddle::Middleware::Response::DefaultResponse)

    # Hard timeout on the entire request
    connection.use(Saddle::Middleware::RubyTimeout)

    # Set up a user agent
    connection.use(Saddle::Middleware::Request::UserAgent)

    # Set up the path prefix if needed
    connection.use(Saddle::Middleware::Request::PathPrefix)

    # Apply additional implementation-specific middlewares
    @additional_middlewares.each do |m|
      m[:args] ? connection.use(m[:klass], *m[:args]) : connection.use(m[:klass])
    end

    # Request encoding
    connection.use(Saddle::Middleware::Request::JsonEncoded)
    connection.use(Saddle::Middleware::Request::UrlEncoded)

    # Automatic retries
    connection.use(Saddle::Middleware::Request::Retry)

    # Raise exceptions on 4xx and 5xx errors
    connection.use(Saddle::Middleware::Response::RaiseError)

    # Handle parsing out the response if it's JSON
    connection.use(Saddle::Middleware::Response::ParseJson)

    # Set up instrumentation around the adapter for extensibility
    connection.request :instrumentation

    # Add in extra env data if needed
    connection.use(Saddle::Middleware::ExtraEnv)

    # Set up our adapter
    if @stubs.nil?
      # Use the default adapter
      connection.adapter(@http_adapter[:key], *@http_adapter[:args])
    else
      # Use the test adapter
      connection.adapter(:test, @stubs)
    end
  end
end
handle_response(response) click to toggle source

Return the appropriate response format based on options

# File lib/saddle/requester.rb, line 124
def handle_response response
  @return_full_response ? response : response.body
end