+++ /dev/null
-module Faraday
- # A Builder that processes requests into responses by passing through an inner
- # middleware stack (heavily inspired by Rack).
- #
- # Faraday::Connection.new(:url => 'http://sushi.com') do |builder|
- # builder.request :url_encoded # Faraday::Request::UrlEncoded
- # builder.adapter :net_http # Faraday::Adapter::NetHttp
- # end
- class RackBuilder
- attr_accessor :handlers
-
- # Error raised when trying to modify the stack after calling `lock!`
- class StackLocked < RuntimeError; end
-
- # borrowed from ActiveSupport::Dependencies::Reference &
- # ActionDispatch::MiddlewareStack::Middleware
- class Handler
- @@constants_mutex = Mutex.new
- @@constants = Hash.new { |h, k|
- value = k.respond_to?(:constantize) ? k.constantize : Object.const_get(k)
- @@constants_mutex.synchronize { h[k] = value }
- }
-
- attr_reader :name
-
- def initialize(klass, *args, &block)
- @name = klass.to_s
- if klass.respond_to?(:name)
- @@constants_mutex.synchronize { @@constants[@name] = klass }
- end
- @args, @block = args, block
- end
-
- def klass() @@constants[@name] end
- def inspect() @name end
-
- def ==(other)
- if other.is_a? Handler
- self.name == other.name
- elsif other.respond_to? :name
- klass == other
- else
- @name == other.to_s
- end
- end
-
- def build(app)
- klass.new(app, *@args, &@block)
- end
- end
-
- def initialize(handlers = [])
- @handlers = handlers
- if block_given?
- build(&Proc.new)
- elsif @handlers.empty?
- # default stack, if nothing else is configured
- self.request :url_encoded
- self.adapter Faraday.default_adapter
- end
- end
-
- def build(options = {})
- raise_if_locked
- @handlers.clear unless options[:keep]
- yield(self) if block_given?
- end
-
- def [](idx)
- @handlers[idx]
- end
-
- # Locks the middleware stack to ensure no further modifications are possible.
- def lock!
- @handlers.freeze
- end
-
- def locked?
- @handlers.frozen?
- end
-
- def use(klass, *args, &block)
- if klass.is_a? Symbol
- use_symbol(Faraday::Middleware, klass, *args, &block)
- else
- raise_if_locked
- @handlers << self.class::Handler.new(klass, *args, &block)
- end
- end
-
- def request(key, *args, &block)
- use_symbol(Faraday::Request, key, *args, &block)
- end
-
- def response(key, *args, &block)
- use_symbol(Faraday::Response, key, *args, &block)
- end
-
- def adapter(key, *args, &block)
- use_symbol(Faraday::Adapter, key, *args, &block)
- end
-
- ## methods to push onto the various positions in the stack:
-
- def insert(index, *args, &block)
- raise_if_locked
- index = assert_index(index)
- handler = self.class::Handler.new(*args, &block)
- @handlers.insert(index, handler)
- end
-
- alias_method :insert_before, :insert
-
- def insert_after(index, *args, &block)
- index = assert_index(index)
- insert(index + 1, *args, &block)
- end
-
- def swap(index, *args, &block)
- raise_if_locked
- index = assert_index(index)
- @handlers.delete_at(index)
- insert(index, *args, &block)
- end
-
- def delete(handler)
- raise_if_locked
- @handlers.delete(handler)
- end
-
- # Processes a Request into a Response by passing it through this Builder's
- # middleware stack.
- #
- # connection - Faraday::Connection
- # request - Faraday::Request
- #
- # Returns a Faraday::Response.
- def build_response(connection, request)
- app.call(build_env(connection, request))
- end
-
- # The "rack app" wrapped in middleware. All requests are sent here.
- #
- # The builder is responsible for creating the app object. After this,
- # the builder gets locked to ensure no further modifications are made
- # to the middleware stack.
- #
- # Returns an object that responds to `call` and returns a Response.
- def app
- @app ||= begin
- lock!
- to_app(lambda { |env|
- response = Response.new
- response.finish(env) unless env.parallel?
- env.response = response
- })
- end
- end
-
- def to_app(inner_app)
- # last added handler is the deepest and thus closest to the inner app
- @handlers.reverse.inject(inner_app) { |app, handler| handler.build(app) }
- end
-
- def ==(other)
- other.is_a?(self.class) && @handlers == other.handlers
- end
-
- def dup
- self.class.new(@handlers.dup)
- end
-
- # ENV Keys
- # :method - a symbolized request method (:get, :post)
- # :body - the request body that will eventually be converted to a string.
- # :url - URI instance for the current request.
- # :status - HTTP response status code
- # :request_headers - hash of HTTP Headers to be sent to the server
- # :response_headers - Hash of HTTP headers from the server
- # :parallel_manager - sent if the connection is in parallel mode
- # :request - Hash of options for configuring the request.
- # :timeout - open/read timeout Integer in seconds
- # :open_timeout - read timeout Integer in seconds
- # :proxy - Hash of proxy options
- # :uri - Proxy Server URI
- # :user - Proxy server username
- # :password - Proxy server password
- # :ssl - Hash of options for configuring SSL requests.
- def build_env(connection, request)
- Env.new(request.method, request.body,
- connection.build_exclusive_url(request.path, request.params),
- request.options, request.headers, connection.ssl,
- connection.parallel_manager)
- end
-
- private
-
- def raise_if_locked
- raise StackLocked, "can't modify middleware stack after making a request" if locked?
- end
-
- def use_symbol(mod, key, *args, &block)
- use(mod.lookup_middleware(key), *args, &block)
- end
-
- def assert_index(index)
- idx = index.is_a?(Integer) ? index : @handlers.index(index)
- raise "No such handler: #{index.inspect}" unless idx
- idx
- end
- end
-end
projects / dsa-puppet.git / blobdiff