logstash-filter-cache-redis 0.1.0 → 0.2.0

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/README.md

@@ -0,0 +1,354 @@
+# Faraday
+
+[![Gem Version](https://badge.fury.io/rb/faraday.svg)](https://rubygems.org/gems/faraday)
+[![Build Status](https://travis-ci.org/lostisland/faraday.svg)](https://travis-ci.org/lostisland/faraday)
+[![Gitter](https://badges.gitter.im/lostisland/faraday.svg)](https://gitter.im/lostisland/faraday?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+
+Faraday is an HTTP client lib that provides a common interface over many
+adapters (such as Net::HTTP) and embraces the concept of Rack middleware when
+processing the request/response cycle.
+
+Faraday supports these adapters:
+
+* [Net::HTTP][net_http] _(default)_
+* [Net::HTTP::Persistent][persistent]
+* [Excon][]
+* [Patron][]
+* [EventMachine][]
+* [HTTPClient][]
+
+It also includes a Rack adapter for hitting loaded Rack applications through
+Rack::Test, and a Test adapter for stubbing requests by hand.
+
+## API documentation
+
+Available at [rubydoc.info](http://www.rubydoc.info/gems/faraday).
+
+## Usage
+
+### Basic Use
+
+```ruby
+response = Faraday.get 'http://sushi.com/nigiri/sake.json'
+```
+A simple `get` request can be performed by using the syntax described above. This works if you don't need to set up anything; you can roll with just the default middleware
+stack and default adapter (see [Faraday::RackBuilder#initialize](https://github.com/lostisland/faraday/blob/master/lib/faraday/rack_builder.rb)).
+
+A more flexible way to use Faraday is to start with a Connection object. If you want to keep the same defaults, you can use this syntax:
+
+```ruby
+conn = Faraday.new(:url => 'http://www.example.com') 
+response = conn.get '/users'                 # GET http://www.example.com/users' 
+```
+
+Connections can also take an options hash as a parameter or be configured by using a block. Checkout the section called [Advanced middleware usage](#advanced-middleware-usage) for more details about how to use this block for configurations. 
+
+```ruby
+conn = Faraday.new(:url => 'http://sushi.com') do |faraday|
+  faraday.request  :url_encoded             # form-encode POST params
+  faraday.response :logger                  # log requests to STDOUT
+  faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+end
+
+# Filter sensitive information from logs with a regex matcher
+
+conn = Faraday.new(:url => 'http://sushi.com/api_key=s3cr3t') do |faraday|
+  faraday.response :logger do | logger |
+    logger.filter(/(api_key=)(\w+)/,'\1[REMOVED]')
+  end
+  faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+end
+```
+
+Once you have the connection object, use it to make HTTP requests. You can pass paramters to it in a few different ways:
+
+```ruby
+## GET ##
+
+response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
+response.body
+
+conn.get '/nigiri', { :name => 'Maguro' }   # GET http://sushi.com/nigiri?name=Maguro
+
+conn.get do |req|                           # GET http://sushi.com/search?page=2&limit=100  
+  req.url '/search', :page => 2
+  req.params['limit'] = 100
+end
+
+## POST ##
+
+conn.post '/nigiri', { :name => 'Maguro' }  # POST "name=maguro" to http://sushi.com/nigiri
+```
+
+Some configuration options can be adjusted per request:
+
+```ruby
+# post payload as JSON instead of "www-form-urlencoded" encoding:
+conn.post do |req|
+  req.url '/nigiri'
+  req.headers['Content-Type'] = 'application/json'
+  req.body = '{ "name": "Unagi" }'
+end
+
+## Per-request options ##
+
+conn.get do |req|
+  req.url '/search'
+  req.options.timeout = 5           # open/read timeout in seconds
+  req.options.open_timeout = 2      # connection open timeout in seconds
+end
+```
+
+And you can inject arbitrary data into the request using the `context` option:
+
+```ruby
+# Anything you inject using context option will be available in the env on all middlewares
+
+conn.get do |req|
+  req.url '/search'
+  req.options.context = {
+      foo: 'foo',
+      bar: 'bar'
+  }          
+end
+```
+
+### Changing how parameters are serialized
+
+Sometimes you need to send the same URL parameter multiple times with different
+values. This requires manually setting the parameter encoder and can be done on
+either per-connection or per-request basis.
+
+```ruby
+# per-connection setting
+conn = Faraday.new :request => { :params_encoder => Faraday::FlatParamsEncoder }
+
+conn.get do |req|
+  # per-request setting:
+  # req.options.params_encoder = my_encoder
+  req.params['roll'] = ['california', 'philadelphia']
+end
+# GET 'http://sushi.com?roll=california&roll=philadelphia'
+```
+
+The value of Faraday `params_encoder` can be any object that responds to:
+
+* `encode(hash) #=> String`
+* `decode(string) #=> Hash`
+
+The encoder will affect both how query strings are processed and how POST bodies
+get serialized. The default encoder is Faraday::NestedParamsEncoder.
+
+## Authentication
+  
+Basic and Token authentication are handled by Faraday::Request::BasicAuthentication and Faraday::Request::TokenAuthentication respectively. These can be added as middleware manually or through the helper methods.
+
+```ruby
+Faraday.new(...) do |conn|
+  conn.basic_auth('username', 'password')
+end
+
+Faraday.new(...) do |conn|
+  conn.token_auth('authentication-token') 
+end
+```
+
+## Advanced middleware usage
+
+The order in which middleware is stacked is important. Like with Rack, the
+first middleware on the list wraps all others, while the last middleware is the
+innermost one, so that must be the adapter.
+
+```ruby
+Faraday.new(...) do |conn|
+  # POST/PUT params encoders:
+  conn.request :multipart
+  conn.request :url_encoded
+
+  conn.adapter :net_http
+end
+```
+
+This request middleware setup affects POST/PUT requests in the following way:
+
+1. `Request::Multipart` checks for files in the payload, otherwise leaves
+  everything untouched;
+2. `Request::UrlEncoded` encodes as "application/x-www-form-urlencoded" if not
+  already encoded or of another type
+
+Swapping middleware means giving the other priority. Specifying the
+"Content-Type" for the request is explicitly stating which middleware should
+process it.
+
+Examples:
+
+```ruby
+# uploading a file:
+payload[:profile_pic] = Faraday::UploadIO.new('/path/to/avatar.jpg', 'image/jpeg')
+
+# "Multipart" middleware detects files and encodes with "multipart/form-data":
+conn.put '/profile', payload
+```
+
+## Writing middleware
+
+Middleware are classes that implement a `call` instance method. They hook into
+the request/response cycle.
+
+```ruby
+def call(request_env)
+  # do something with the request
+  # request_env[:request_headers].merge!(...)
+
+  @app.call(request_env).on_complete do |response_env|
+    # do something with the response
+    # response_env[:response_headers].merge!(...)
+  end
+end
+```
+
+It's important to do all processing of the response only in the `on_complete`
+block. This enables middleware to work in parallel mode where requests are
+asynchronous.
+
+The `env` is a hash with symbol keys that contains info about the request and,
+later, response. Some keys are:
+
+```
+# request phase
+:method - :get, :post, ...
+:url    - URI for the current request; also contains GET parameters
+:body   - POST parameters for :post/:put requests
+:request_headers
+
+# response phase
+:status - HTTP response status code, such as 200
+:body   - the response body
+:response_headers
+```
+
+## Ad-hoc adapters customization
+
+Faraday is intended to be a generic interface between your code and the adapter. However, sometimes you need to access a feature specific to one of the adapters that is not covered in Faraday's interface. 
+
+When that happens, you can pass a block when specifying the adapter to customize it. The block parameter will change based on the adapter you're using. See below for some examples.
+
+### NetHttp
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :net_http do |http| # yields Net::HTTP
+    http.idle_timeout = 100
+    http.verify_callback = lambda do | preverify_ok, cert_store |
+      # do something here...
+    end
+  end
+end
+```
+
+### NetHttpPersistent
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :net_http_persistent do |http| # yields Net::HTTP::Persistent
+    http.idle_timeout = 100
+    http.retry_change_requests = true
+  end
+end
+```
+
+### Patron
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :patron do |session| # yields Patron::Session
+    session.max_redirects = 10
+  end
+end
+```
+
+### HTTPClient
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :httpclient do |client| # yields HTTPClient
+    client.keep_alive_timeout = 20
+    client.ssl_config.timeout = 25
+  end
+end
+```
+
+## Using Faraday for testing
+
+```ruby
+# It's possible to define stubbed request outside a test adapter block.
+stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+  stub.get('/tamago') { |env| [200, {}, 'egg'] }
+end
+
+# You can pass stubbed request to the test adapter or define them in a block
+# or a combination of the two.
+test = Faraday.new do |builder|
+  builder.adapter :test, stubs do |stub|
+    stub.get('/ebi') { |env| [ 200, {}, 'shrimp' ]}
+  end
+end
+
+# It's also possible to stub additional requests after the connection has
+# been initialized. This is useful for testing.
+stubs.get('/uni') { |env| [ 200, {}, 'urchin' ]}
+
+resp = test.get '/tamago'
+resp.body # => 'egg'
+resp = test.get '/ebi'
+resp.body # => 'shrimp'
+resp = test.get '/uni'
+resp.body # => 'urchin'
+resp = test.get '/else' #=> raises "no such stub" error
+
+# If you like, you can treat your stubs as mocks by verifying that all of
+# the stubbed calls were made. NOTE that this feature is still fairly
+# experimental: It will not verify the order or count of any stub, only that
+# it was called once during the course of the test.
+stubs.verify_stubbed_calls
+```
+
+## TODO
+
+* support streaming requests/responses
+* better stubbing API
+
+## Supported Ruby versions
+
+This library aims to support and is [tested against][travis] the following Ruby
+implementations:
+
+* Ruby 1.9.3+
+* [JRuby][] 1.7+
+* [Rubinius][] 2+
+
+If something doesn't work on one of these Ruby versions, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby
+implementations, however support will only be provided for the versions listed
+above.
+
+If you would like this library to support another Ruby version, you may
+volunteer to be a maintainer. Being a maintainer entails making sure all tests
+run and pass on that implementation. When something breaks on your
+implementation, you will be responsible for providing patches in a timely
+fashion. If critical issues for a particular implementation exist at the time
+of a major release, support for that Ruby version may be dropped.
+
+## Copyright
+
+Copyright (c) 2009-2017 [Rick Olson](mailto:technoweenie@gmail.com), Zack Hobson.
+See [LICENSE][] for details.
+
+[net_http]:     http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/Net/HTTP.html
+[persistent]:   https://github.com/drbrain/net-http-persistent
+[travis]:       https://travis-ci.org/lostisland/faraday
+[excon]:        https://github.com/excon/excon#readme
+[patron]:       http://toland.github.io/patron/
+[eventmachine]: https://github.com/igrigorik/em-http-request#readme
+[httpclient]:   https://github.com/nahi/httpclient
+[jruby]:        http://jruby.org/
+[rubinius]:     http://rubini.us/
+[license]:      LICENSE.md

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/lib/faraday.rb

@@ -0,0 +1,243 @@
+require 'thread'
+require 'cgi'
+require 'set'
+require 'forwardable'
+
+# Public: This is the main namespace for Faraday.  You can either use it to
+# create Faraday::Connection objects, or access it directly.
+#
+# Examples
+#
+#   Faraday.get "http://faraday.com"
+#
+#   conn = Faraday.new "http://faraday.com"
+#   conn.get '/'
+#
+module Faraday
+  VERSION = "0.12.1"
+
+  class << self
+    # Public: Gets or sets the root path that Faraday is being loaded from.
+    # This is the root from where the libraries are auto-loaded from.
+    attr_accessor :root_path
+
+    # Public: Gets or sets the path that the Faraday libs are loaded from.
+    attr_accessor :lib_path
+
+    # Public: Gets or sets the Symbol key identifying a default Adapter to use
+    # for the default Faraday::Connection.
+    attr_reader :default_adapter
+
+    # Public: Sets the default Faraday::Connection for simple scripts that
+    # access the Faraday constant directly.
+    #
+    #     Faraday.get "https://faraday.com"
+    attr_writer :default_connection
+
+    # Public: Initializes a new Faraday::Connection.
+    #
+    # url     - The optional String base URL to use as a prefix for all
+    #           requests.  Can also be the options Hash.
+    # options - The optional Hash used to configure this Faraday::Connection.
+    #           Any of these values will be set on every request made, unless
+    #           overridden for a specific request.
+    #           :url     - String base URL.
+    #           :params  - Hash of URI query unencoded key/value pairs.
+    #           :headers - Hash of unencoded HTTP header key/value pairs.
+    #           :request - Hash of request options.
+    #           :ssl     - Hash of SSL options.
+    #           :proxy   - Hash of Proxy options.
+    #
+    # Examples
+    #
+    #   Faraday.new 'http://faraday.com'
+    #
+    #   # http://faraday.com?page=1
+    #   Faraday.new 'http://faraday.com', :params => {:page => 1}
+    #
+    #   # same
+    #
+    #   Faraday.new :url => 'http://faraday.com',
+    #     :params => {:page => 1}
+    #
+    # Returns a Faraday::Connection.
+    def new(url = nil, options = nil)
+      block = block_given? ? Proc.new : nil
+      options = options ? default_connection_options.merge(options) : default_connection_options
+      Faraday::Connection.new(url, options, &block)
+    end
+
+    # Internal: Requires internal Faraday libraries.
+    #
+    # *libs - One or more relative String names to Faraday classes.
+    #
+    # Returns nothing.
+    def require_libs(*libs)
+      libs.each do |lib|
+        require "#{lib_path}/#{lib}"
+      end
+    end
+
+    # Public: Updates default adapter while resetting
+    # #default_connection.
+    #
+    # Returns the new default_adapter.
+    def default_adapter=(adapter)
+      @default_connection = nil
+      @default_adapter = adapter
+    end
+
+    alias require_lib require_libs
+
+    def respond_to?(symbol, include_private = false)
+      default_connection.respond_to?(symbol, include_private) || super
+    end
+
+  private
+    # Internal: Proxies method calls on the Faraday constant to
+    # #default_connection.
+    def method_missing(name, *args, &block)
+      default_connection.send(name, *args, &block)
+    end
+  end
+
+  self.root_path = File.expand_path "..", __FILE__
+  self.lib_path = File.expand_path "../faraday", __FILE__
+  self.default_adapter = :net_http
+
+  # Gets the default connection used for simple scripts.
+  #
+  # Returns a Faraday::Connection, configured with the #default_adapter.
+  def self.default_connection
+    @default_connection ||= Connection.new
+  end
+
+  # Gets the default connection options used when calling Faraday#new.
+  #
+  # Returns a Faraday::ConnectionOptions.
+  def self.default_connection_options
+    @default_connection_options ||= ConnectionOptions.new
+  end
+
+  # Public: Sets the default options used when calling Faraday#new.
+  def self.default_connection_options=(options)
+    @default_connection_options = ConnectionOptions.from(options)
+  end
+
+  unless const_defined? :Timer
+    require 'timeout'
+    Timer = Timeout
+  end
+
+  # Public: Adds the ability for other modules to register and lookup
+  # middleware classes.
+  module MiddlewareRegistry
+    # Public: Register middleware class(es) on the current module.
+    #
+    # mapping - A Hash mapping Symbol keys to classes. Classes can be expressed
+    #           as fully qualified constant, or a Proc that will be lazily
+    #           called to return the former.
+    #
+    # Examples
+    #
+    #   module Faraday
+    #     class Whatever
+    #       # Middleware looked up by :foo returns Faraday::Whatever::Foo.
+    #       register_middleware :foo => Foo
+    #
+    #       # Middleware looked up by :bar returns Faraday::Whatever.const_get(:Bar)
+    #       register_middleware :bar => :Bar
+    #
+    #       # Middleware looked up by :baz requires 'baz' and returns Faraday::Whatever.const_get(:Baz)
+    #       register_middleware :baz => [:Baz, 'baz']
+    #     end
+    #   end
+    #
+    # Returns nothing.
+    def register_middleware(autoload_path = nil, mapping = nil)
+      if mapping.nil?
+        mapping = autoload_path
+        autoload_path = nil
+      end
+      middleware_mutex do
+        @middleware_autoload_path = autoload_path if autoload_path
+        (@registered_middleware ||= {}).update(mapping)
+      end
+    end
+
+    # Public: Lookup middleware class with a registered Symbol shortcut.
+    #
+    # key - The Symbol key for the registered middleware.
+    #
+    # Examples
+    #
+    #   module Faraday
+    #     class Whatever
+    #       register_middleware :foo => Foo
+    #     end
+    #   end
+    #
+    #   Faraday::Whatever.lookup_middleware(:foo)
+    #   # => Faraday::Whatever::Foo
+    #
+    # Returns a middleware Class.
+    def lookup_middleware(key)
+      load_middleware(key) ||
+        raise(Faraday::Error.new("#{key.inspect} is not registered on #{self}"))
+    end
+
+    def middleware_mutex(&block)
+      @middleware_mutex ||= begin
+        require 'monitor'
+        Monitor.new
+      end
+      @middleware_mutex.synchronize(&block)
+    end
+
+    def fetch_middleware(key)
+      defined?(@registered_middleware) && @registered_middleware[key]
+    end
+
+    def load_middleware(key)
+      value = fetch_middleware(key)
+      case value
+      when Module
+        value
+      when Symbol, String
+        middleware_mutex do
+          @registered_middleware[key] = const_get(value)
+        end
+      when Proc
+        middleware_mutex do
+          @registered_middleware[key] = value.call
+        end
+      when Array
+        middleware_mutex do
+          const, path = value
+          if root = @middleware_autoload_path
+            path = "#{root}/#{path}"
+          end
+          require(path)
+          @registered_middleware[key] = const
+        end
+        load_middleware(key)
+      end
+    end
+  end
+
+  def self.const_missing(name)
+    if name.to_sym == :Builder
+      warn "Faraday::Builder is now Faraday::RackBuilder."
+      const_set name, RackBuilder
+    else
+      super
+    end
+  end
+
+  require_libs "utils", "options", "connection", "rack_builder", "parameters",
+    "middleware", "adapter", "request", "response", "upload_io", "error"
+
+  if !ENV["FARADAY_NO_AUTOLOAD"]
+    require_lib 'autoload'
+  end
+end