normalize URI() behavior across Ruby versions
# File lib/faraday/connection.rb, line 165 def self.URI(url) if url.respond_to?(:host) url elsif url.respond_to?(:to_str) Kernel.URI(url) else raise ArgumentError, "bad argument (expected URI object or URI string)" end end
:url :params :headers :request :ssl
# File lib/faraday/connection.rb, line 21 def initialize(url = nil, options = {}) if url.is_a?(Hash) options = url url = options[:url] end @headers = Utils::Headers.new @params = Utils::ParamsHash.new @options = options[:request] || {} @ssl = options[:ssl] || {} @parallel_manager = nil @default_parallel_manager = options[:parallel_manager] @builder = options[:builder] || begin # pass an empty block to Builder so it doesn't assume default middleware block = block_given?? Proc.new {|b| } : nil Builder.new(&block) end self.url_prefix = url || 'http:/' @params.update options[:params] if options[:params] @headers.update options[:headers] if options[:headers] @proxy = nil proxy(options.fetch(:proxy) { ENV['http_proxy'] }) yield self if block_given? 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.
# File lib/faraday/connection.rb, line 71 def app @app ||= begin builder.lock! builder.to_app(lambda { |env| # the inner app that creates and returns the Response object response = Response.new response.finish(env) unless env[:parallel_manager] env[:response] = response }) end end
# File lib/faraday/connection.rb, line 104 def basic_auth(login, pass) headers[Faraday::Request::Authorization::KEY] = Faraday::Request::BasicAuthentication.header(login, pass) end
Internal: Build an absolute URL based on url_prefix.
url - A String or URI-like object params - A Faraday::Utils::ParamsHash to replace the query values
of the resulting url (default: nil).
Returns the resulting URI instance.
# File lib/faraday/connection.rb, line 269 def build_exclusive_url(url, params = nil) url = nil if url.respond_to?(:empty?) and url.empty? base = url_prefix if url and base.path and base.path !~ /\/$/ base = base.dup base.path = base.path + '/' # ensure trailing slash end uri = url ? base + url : base uri.query = params.to_query if params uri.query = nil if uri.query and uri.query.empty? uri end
Internal: Creates and configures the request object.
Returns the new Request.
# File lib/faraday/connection.rb, line 232 def build_request(method) Request.create(method) do |req| req.params = self.params.dup req.headers = self.headers.dup req.options = self.options.merge(:proxy => self.proxy) yield req if block_given? end end
Takes a relative url for a request and combines it with the defaults set on the connection instance.
conn = Faraday::Connection.new { ... } conn.url_prefix = "https://sushi.com/api?token=abc" conn.scheme # => https conn.path_prefix # => "/api" conn.build_url("nigiri?page=2") # => https://sushi.com/api/nigiri?token=abc&page=2 conn.build_url("nigiri", :page => 2) # => https://sushi.com/api/nigiri?token=abc&page=2
# File lib/faraday/connection.rb, line 252 def build_url(url, extra_params = nil) uri = build_exclusive_url(url) query_values = self.params.dup.merge_query(uri.query) query_values.update extra_params if extra_params uri.query = query_values.empty? ? nil : query_values.to_query uri end
Internal: Traverse the middleware stack in search of a parallel-capable adapter.
Yields in case of not found.
Returns a parallel manager or nil if not found.
# File lib/faraday/connection.rb, line 125 def default_parallel_manager @default_parallel_manager ||= begin handler = @builder.handlers.detect do |h| h.klass.respond_to?(:supports_parallel?) and h.klass.supports_parallel? end if handler then handler.klass.setup_parallel_manager elsif block_given? then yield end end end
# File lib/faraday/connection.rb, line 282 def dup self.class.new(build_url(''), :headers => headers.dup, :params => params.dup, :builder => builder.dup, :ssl => ssl.dup) end
Public: Replace default request headers.
# File lib/faraday/connection.rb, line 57 def headers=(hash) @headers.replace hash end
# File lib/faraday/connection.rb, line 141 def in_parallel(manager = nil) @parallel_manager = manager || default_parallel_manager { warn "Warning: `in_parallel` called but no parallel-capable adapter on Faraday stack" warn caller[2,10].join("\n") nil } yield @parallel_manager && @parallel_manager.run ensure @parallel_manager = nil end
# File lib/faraday/connection.rb, line 137 def in_parallel? !!@parallel_manager end
Public: Replace default query parameters.
# File lib/faraday/connection.rb, line 52 def params=(hash) @params.replace hash end
Ensures that the path prefix always has a leading but no trailing slash
# File lib/faraday/connection.rb, line 205 def path_prefix=(value) url_prefix.path = if value value = value.chomp '/' value = '/' + value unless value[0,1] == '/' value end end
# File lib/faraday/connection.rb, line 153 def proxy(arg = nil) return @proxy if arg.nil? @proxy = if arg.is_a? Hash uri = arg.fetch(:uri) { raise ArgumentError, "no :uri option" } arg.merge :uri => self.class.URI(uri) else {:uri => self.class.URI(arg)} end end
# File lib/faraday/connection.rb, line 213 def run_request(method, url, body, headers) if !METHODS.include?(method) raise ArgumentError, "unknown http method: #{method}" end request = build_request(method) do |req| req.url(url) if url req.headers.update(headers) if headers req.body = body if body yield req if block_given? end env = request.to_env(self) self.app.call(env) end
# File lib/faraday/connection.rb, line 109 def token_auth(token, options = nil) headers[Faraday::Request::Authorization::KEY] = Faraday::Request::TokenAuthentication.header(token, options) end
Parses the giving url with URI and stores the individual components in this connection. These components serve as defaults for requests made by this connection.
conn = Faraday::Connection.new { ... } conn.url_prefix = "https://sushi.com/api" conn.scheme # => https conn.path_prefix # => "/api" conn.get("nigiri?page=2") # accesses https://sushi.com/api/nigiri
# File lib/faraday/connection.rb, line 189 def url_prefix=(url) uri = @url_prefix = self.class.URI(url) self.path_prefix = uri.path params.merge_query(uri.query) uri.query = nil if uri.user && uri.password basic_auth(CGI.unescape(uri.user), CGI.unescape(uri.password)) uri.user = uri.password = nil end uri end
Generated with the Darkfish Rdoc Generator 2.