logstash-filter-cache-redis 0.1.0 → 0.2.0

data/vendor/bundle/jruby/1.9/gems/multi_json-1.12.1/CONTRIBUTING.md

@@ -0,0 +1,46 @@
+## Contributing
+In the spirit of [free software][free-sw], **everyone** is encouraged to help
+improve this project.
+
+[free-sw]: http://www.fsf.org/licensing/essays/free-sw.html
+
+Here are some ways *you* can contribute:
+
+* by using alpha, beta, and prerelease versions
+* by reporting bugs
+* by suggesting new features
+* by writing or editing documentation
+* by writing specifications
+* by writing code (**no patch is too small**: fix typos, add comments, clean up
+  inconsistent whitespace)
+* by refactoring code
+* by closing [issues][]
+* by reviewing patches
+
+[issues]: https://github.com/intridea/multi_json/issues
+
+## Submitting an Issue
+We use the [GitHub issue tracker][issues] to track bugs and features. Before
+submitting a bug report or feature request, check to make sure it hasn't
+already been submitted. When submitting a bug report, please include a [Gist][]
+that includes a stack trace and any details that may be necessary to reproduce
+the bug, including your gem version, Ruby version, and operating system.
+Ideally, a bug report should include a pull request with failing specs.
+
+[gist]: https://gist.github.com/
+
+## Submitting a Pull Request
+1. [Fork the repository.][fork]
+2. [Create a topic branch.][branch]
+3. Add specs for your unimplemented feature or bug fix.
+4. Run `bundle exec rake spec`. If your specs pass, return to step 3.
+5. Implement your feature or bug fix.
+6. Run `bundle exec rake spec`. If your specs fail, return to step 5.
+7. Run `open coverage/index.html`. If your changes are not completely covered
+   by your tests, return to step 3.
+8. Add, commit, and push your changes.
+9. [Submit a pull request.][pr]
+
+[fork]: http://help.github.com/fork-a-repo/
+[branch]: http://learn.github.com/p/branching.html
+[pr]: http://help.github.com/send-pull-requests/

data/vendor/bundle/jruby/1.9/gems/multi_json-1.12.1/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2013 Michael Bleigh, Josh Kalderimis, Erik Michaels-Ober, Pavel Pravosud
+
+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/vendor/bundle/jruby/1.9/gems/multi_json-1.12.1/README.md

@@ -0,0 +1,121 @@
+# MultiJSON
+
+[![Gem Version](http://img.shields.io/gem/v/multi_json.svg)][gem]
+[![Build Status](http://travis-ci.org/intridea/multi_json.svg)][travis]
+[![Dependency Status](http://img.shields.io/gemnasium/intridea/multi_json.svg)][gemnasium]
+[![Code Climate](http://img.shields.io/codeclimate/github/intridea/multi_json.svg)][codeclimate]
+
+[gem]: https://rubygems.org/gems/multi_json
+[travis]: http://travis-ci.org/intridea/multi_json
+[gemnasium]: https://gemnasium.com/intridea/multi_json
+[codeclimate]: https://codeclimate.com/github/intridea/multi_json
+
+Lots of Ruby libraries parse JSON and everyone has their favorite JSON coder.
+Instead of choosing a single JSON coder and forcing users of your library to be
+stuck with it, you can use MultiJSON instead, which will simply choose the
+fastest available JSON coder. Here's how to use it:
+
+```ruby
+require 'multi_json'
+
+MultiJson.load('{"abc":"def"}') #=> {"abc" => "def"}
+MultiJson.load('{"abc":"def"}', :symbolize_keys => true) #=> {:abc => "def"}
+MultiJson.dump({:abc => 'def'}) # convert Ruby back to JSON
+MultiJson.dump({:abc => 'def'}, :pretty => true) # encoded in a pretty form (if supported by the coder)
+```
+
+When loading invalid JSON, MultiJson will throw a `MultiJson::ParseError`. `MultiJson::DecodeError` and `MultiJson::LoadError` are aliases for backwards compatibility.
+
+```ruby
+begin
+  MultiJson.load('{invalid json}')
+rescue MultiJson::ParseError => exception
+  exception.data # => "{invalid json}"
+  exception.cause # => JSON::ParserError: 795: unexpected token at '{invalid json}'
+end
+```
+
+`ParseError` instance has `cause` reader which contains the original exception.
+It also has `data` reader with the input that caused the problem.
+
+The `use` method, which sets the MultiJson adapter, takes either a symbol or a
+class (to allow for custom JSON parsers) that responds to both `.load` and `.dump`
+at the class level.
+
+When MultiJson fails to load the specified adapter, it'll throw `MultiJson::AdapterError`
+which inherits from `ArgumentError`.
+
+MultiJSON tries to have intelligent defaulting. That is, if you have any of the
+supported engines already loaded, it will utilize them before attempting to
+load any. When loading, libraries are ordered by speed. First Oj, then Yajl,
+then the JSON gem, then JSON pure. If no other JSON library is available,
+MultiJSON falls back to [OkJson][], a simple, vendorable JSON parser.
+
+[okjson]: https://github.com/kr/okjson
+
+## Supported JSON Engines
+
+* [Oj](https://github.com/ohler55/oj) Optimized JSON by Peter Ohler
+* [Yajl](https://github.com/brianmario/yajl-ruby) Yet Another JSON Library by Brian Lopez
+* [JSON](https://github.com/flori/json) The default JSON gem with C-extensions (ships with Ruby 1.9)
+* [JSON Pure](https://github.com/flori/json) A Ruby variant of the JSON gem
+* [NSJSONSerialization](https://developer.apple.com/library/ios/#documentation/Foundation/Reference/NSJSONSerialization_Class/Reference/Reference.html) Wrapper for Apple's NSJSONSerialization in the Cocoa Framework (MacRuby only)
+* [gson.rb](https://github.com/avsej/gson.rb) A Ruby wrapper for google-gson library (JRuby only)
+* [JrJackson](https://github.com/guyboertje/jrjackson) JRuby wrapper for Jackson (JRuby only)
+* [OkJson][okjson] A simple, vendorable JSON parser
+
+## Supported Ruby Versions
+This library aims to support and is [tested against][travis] the following Ruby
+implementations:
+
+* Ruby 1.8.7
+* Ruby 1.9.2
+* Ruby 1.9.3
+* Ruby 2.0.0
+* Ruby 2.1
+* Ruby 2.2.4
+* Ruby 2.3.1
+* [JRuby][]
+* [Rubinius][]
+* [MacRuby][] (not tested on Travis CI)
+
+[jruby]: http://www.jruby.org/
+[rubinius]: http://rubini.us/
+[macruby]: http://www.macruby.org/
+
+If something doesn't work on one of these interpreters, 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.
+
+## Versioning
+
+This library aims to adhere to [Semantic Versioning 2.0.0][semver]. Violations
+of this scheme should be reported as bugs. Specifically, if a minor or patch
+version is released that breaks backward compatibility, that version should be
+immediately yanked and/or a new version should be immediately released that
+restores compatibility. Breaking changes to the public API will only be
+introduced with new major versions. As a result of this policy, you can (and
+should) specify a dependency on this gem using the [Pessimistic Version
+Constraint][pvc] with two digits of precision. For example:
+
+```ruby
+spec.add_dependency 'multi_json', '~> 1.0'
+```
+
+[semver]: http://semver.org/
+[pvc]: http://docs.rubygems.org/read/chapter/16#page74
+
+## Copyright
+Copyright (c) 2010-2013 Michael Bleigh, Josh Kalderimis, Erik Michaels-Ober,
+and Pavel Pravosud. See [LICENSE][] for details.
+
+[license]: LICENSE.md

data/vendor/bundle/jruby/1.9/gems/multi_json-1.12.1/lib/multi_json.rb

@@ -0,0 +1,161 @@
+require 'multi_json/options'
+require 'multi_json/version'
+require 'multi_json/adapter_error'
+require 'multi_json/parse_error'
+require 'multi_json/options_cache'
+
+module MultiJson
+  include Options
+  extend self
+
+  def default_options=(value)
+    Kernel.warn "MultiJson.default_options setter is deprecated\n" \
+      'Use MultiJson.load_options and MultiJson.dump_options instead'
+
+    self.load_options = self.dump_options = value
+  end
+
+  def default_options
+    Kernel.warn "MultiJson.default_options is deprecated\n" \
+      'Use MultiJson.load_options or MultiJson.dump_options instead'
+
+    load_options
+  end
+
+  %w(cached_options reset_cached_options!).each do |method_name|
+    define_method method_name do |*|
+      Kernel.warn "MultiJson.#{method_name} method is deprecated and no longer used."
+    end
+  end
+
+  ALIASES = {'jrjackson' => 'jr_jackson'}
+
+  REQUIREMENT_MAP = [
+    [:oj,         'oj'],
+    [:yajl,       'yajl'],
+    [:jr_jackson, 'jrjackson'],
+    [:json_gem,   'json/ext'],
+    [:gson,       'gson'],
+    [:json_pure,  'json/pure'],
+  ]
+
+  # The default adapter based on what you currently
+  # have loaded and installed. First checks to see
+  # if any adapters are already loaded, then checks
+  # to see which are installed if none are loaded.
+  def default_adapter
+    return :oj if defined?(::Oj)
+    return :yajl if defined?(::Yajl)
+    return :jr_jackson if defined?(::JrJackson)
+    return :json_gem if defined?(::JSON::JSON_LOADED)
+    return :gson if defined?(::Gson)
+
+    REQUIREMENT_MAP.each do |adapter, library|
+      begin
+        require library
+        return adapter
+      rescue ::LoadError
+        next
+      end
+    end
+
+    Kernel.warn '[WARNING] MultiJson is using the default adapter (ok_json). ' \
+      'We recommend loading a different JSON library to improve performance.'
+
+    :ok_json
+  end
+  alias_method :default_engine, :default_adapter
+
+  # Get the current adapter class.
+  def adapter
+    return @adapter if defined?(@adapter) && @adapter
+
+    use nil # load default adapter
+
+    @adapter
+  end
+  alias_method :engine, :adapter
+
+  # Set the JSON parser utilizing a symbol, string, or class.
+  # Supported by default are:
+  #
+  # * <tt>:oj</tt>
+  # * <tt>:json_gem</tt>
+  # * <tt>:json_pure</tt>
+  # * <tt>:ok_json</tt>
+  # * <tt>:yajl</tt>
+  # * <tt>:nsjsonserialization</tt> (MacRuby only)
+  # * <tt>:gson</tt> (JRuby only)
+  # * <tt>:jr_jackson</tt> (JRuby only)
+  def use(new_adapter)
+    @adapter = load_adapter(new_adapter)
+  ensure
+    OptionsCache.reset
+  end
+  alias_method :adapter=, :use
+  alias_method :engine=, :use
+
+  def load_adapter(new_adapter)
+    case new_adapter
+    when String, Symbol
+      load_adapter_from_string_name new_adapter.to_s
+    when NilClass, FalseClass
+      load_adapter default_adapter
+    when Class, Module
+      new_adapter
+    else
+      fail ::LoadError, new_adapter
+    end
+  rescue ::LoadError => exception
+    raise AdapterError.build(exception)
+  end
+
+  # Decode a JSON string into Ruby.
+  #
+  # <b>Options</b>
+  #
+  # <tt>:symbolize_keys</tt> :: If true, will use symbols instead of strings for the keys.
+  # <tt>:adapter</tt> :: If set, the selected adapter will be used for this call.
+  def load(string, options = {})
+    adapter = current_adapter(options)
+    begin
+      adapter.load(string, options)
+    rescue adapter::ParseError => exception
+      raise ParseError.build(exception, string)
+    end
+  end
+  alias_method :decode, :load
+
+  def current_adapter(options = {})
+    if (new_adapter = options[:adapter])
+      load_adapter(new_adapter)
+    else
+      adapter
+    end
+  end
+
+  # Encodes a Ruby object as JSON.
+  def dump(object, options = {})
+    current_adapter(options).dump(object, options)
+  end
+  alias_method :encode, :dump
+
+  #  Executes passed block using specified adapter.
+  def with_adapter(new_adapter)
+    old_adapter = adapter
+    self.adapter = new_adapter
+    yield
+  ensure
+    self.adapter = old_adapter
+  end
+  alias_method :with_engine, :with_adapter
+
+private
+
+  def load_adapter_from_string_name(name)
+    name = ALIASES.fetch(name, name)
+    require "multi_json/adapters/#{name.downcase}"
+    klass_name = name.to_s.split('_').map(&:capitalize) * ''
+    MultiJson::Adapters.const_get(klass_name)
+  end
+end

data/vendor/bundle/jruby/1.9/gems/multi_json-1.12.1/lib/multi_json/adapter.rb

@@ -0,0 +1,49 @@
+require 'singleton'
+require 'multi_json/options'
+
+module MultiJson
+  class Adapter
+    extend Options
+    include Singleton
+
+    class << self
+      def defaults(action, value)
+        metaclass = class << self; self; end
+
+        metaclass.instance_eval do
+          define_method("default_#{action}_options") { value }
+        end
+      end
+
+      def load(string, options = {})
+        fail self::ParseError if blank?(string)
+        string = string.read if string.respond_to?(:read)
+        instance.load(string, cached_load_options(options))
+      end
+
+      def dump(object, options = {})
+        instance.dump(object, cached_dump_options(options))
+      end
+
+    private
+
+      def blank?(input)
+        input.nil? || /\A\s*\z/ === input
+      rescue ArgumentError # invalid byte sequence in UTF-8
+        false
+      end
+
+      def cached_dump_options(options)
+        OptionsCache.fetch(:dump, options) do
+          dump_options(options).merge(MultiJson.dump_options(options)).merge!(options)
+        end
+      end
+
+      def cached_load_options(options)
+        OptionsCache.fetch(:load, options) do
+          load_options(options).merge(MultiJson.load_options(options)).merge!(options)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/multi_json-1.12.1/lib/multi_json/adapter_error.rb

@@ -0,0 +1,15 @@
+module MultiJson
+  class AdapterError < ArgumentError
+    attr_reader :cause
+
+    def self.build(original_exception)
+      message = "Did not recognize your adapter specification (#{original_exception.message})."
+      new(message).tap do |exception|
+        exception.instance_eval do
+          @cause = original_exception
+          set_backtrace original_exception.backtrace
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/multi_json-1.12.1/lib/multi_json/adapters/gson.rb

@@ -0,0 +1,20 @@
+require 'gson'
+require 'stringio'
+require 'multi_json/adapter'
+
+module MultiJson
+  module Adapters
+    # Use the gson.rb library to dump/load.
+    class Gson < Adapter
+      ParseError = ::Gson::DecodeError
+
+      def load(string, options = {})
+        ::Gson::Decoder.new(options).decode(string)
+      end
+
+      def dump(object, options = {})
+        ::Gson::Encoder.new(options).encode(object)
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/multi_json-1.12.1/lib/multi_json/adapters/jr_jackson.rb

@@ -0,0 +1,25 @@
+require 'jrjackson' unless defined?(::JrJackson)
+require 'multi_json/adapter'
+
+module MultiJson
+  module Adapters
+    # Use the jrjackson.rb library to dump/load.
+    class JrJackson < Adapter
+      ParseError = ::JrJackson::ParseError
+
+      def load(string, options = {}) #:nodoc:
+        ::JrJackson::Json.load(string, options)
+      end
+
+      if ::JrJackson::Json.method(:dump).arity == 1
+        def dump(object, _)
+          ::JrJackson::Json.dump(object)
+        end
+      else
+        def dump(object, options = {})
+          ::JrJackson::Json.dump(object, options)
+        end
+      end
+    end
+  end
+end