logstash-filter-cache-redis 0.1.0

data/vendor/bundle/jruby/1.9/gems/tins-1.6.0/lib/tins/extract_last_argument_options.rb

@@ -0,0 +1,14 @@
+module Tins
+  module ExtractLastArgumentOptions
+    def extract_last_argument_options
+      last_argument = last
+      if last_argument.respond_to?(:to_hash) and
+        options = last_argument.to_hash.dup
+      then
+        return self[0..-2], options
+      else
+        return dup, {}
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/tins-1.6.0/lib/tins/file_binary.rb

@@ -0,0 +1,83 @@
+module Tins
+  module FileBinary
+    module Constants
+      SEEK_SET = ::File::SEEK_SET
+
+      ZERO   = "\x00"
+      BINARY = "\x01-\x1f\x7f-\xff"
+
+      if defined?(::Encoding)
+        ZERO.force_encoding(Encoding::ASCII_8BIT)
+        BINARY.force_encoding(Encoding::ASCII_8BIT)
+      end
+    end
+
+    class << self
+      # Default options can be queried/set via this hash.
+      attr_accessor :default_options
+    end
+    self.default_options = {
+      :offset            => 0,
+      :buffer_size       => 2 ** 13,
+      :percentage_binary => 30.0,
+      :percentage_zeros  => 0.0,
+    }
+
+    # Returns true if this file is considered to be binary, false if it is not
+    # considered to be binary, and nil if it was empty.
+    #
+    # A file is considered to be binary if the percentage of zeros exceeds
+    # <tt>options[:percentage_zeros]</tt> or the percentage of binary bytes
+    # (8-th bit is 1) exceeds <tt>options[:percentage_binary]</tt> in the
+    # buffer of size <tt>options[:buffer_size]</tt> that is checked (beginning
+    # from offset <tt>options[:offset]</tt>). If an option isn't given the one
+    # from FileBinary.default_options is used instead.
+    def binary?(options = {})
+      options = FileBinary.default_options.merge(options)
+      old_pos = tell
+      seek options[:offset], Constants::SEEK_SET
+      data = read options[:buffer_size]
+      !data or data.empty? and return nil
+      data_size = data.size
+      data.count(Constants::ZERO).to_f / data_size >
+        options[:percentage_zeros] / 100.0 and return true
+      data.count(Constants::BINARY).to_f / data_size >
+        options[:percentage_binary] / 100.0
+    ensure
+      old_pos and seek old_pos, Constants::SEEK_SET
+    end
+
+    # Returns true if FileBinary#binary? returns false, false if
+    # FileBinary#binary? returns true, and nil otherwise. For an explanation of
+    # +options+, see FileBinary#binary?.
+    def ascii?(options = {})
+      case binary?(options)
+      when true   then false
+      when false  then true
+      end
+    end
+
+    def self.included(modul)
+      modul.instance_eval do
+        extend ClassMethods
+      end
+      super
+    end
+
+    module ClassMethods
+      # Returns true if the file with name +name+ is considered to be binary
+      # using the FileBinary#binary? method.
+      def binary?(name, options = {})
+        open(name, 'rb') { |f| f.binary?(options) }
+      end
+
+      # Returns true if the file with name +name+ is considered to be ascii
+      # using the FileBinary#ascii? method.
+      def ascii?(name, options = {})
+        open(name, 'rb') { |f| f.ascii?(options) }
+      end
+    end
+  end
+end
+
+require 'tins/alias'

data/vendor/bundle/jruby/1.9/gems/tins-1.6.0/lib/tins/find.rb

@@ -0,0 +1,138 @@
+require 'enumerator'
+require 'pathname'
+require 'tins/module_group'
+
+module Tins
+  module Find
+    EXPECTED_STANDARD_ERRORS = ModuleGroup[
+      Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP,
+      Errno::ENAMETOOLONG
+    ]
+
+    class Finder
+      module PathExtension
+        attr_accessor :finder
+
+        def finder_stat
+          finder.protect_from_errors do
+            finder.follow_symlinks ? File.stat(self) : File.lstat(self)
+          end
+        end
+
+        def file
+          finder.protect_from_errors do
+            File.new(self) if file?
+          end
+        end
+
+        def file?
+          finder.protect_from_errors { s = finder_stat and s.file? }
+        end
+
+        def directory?
+          finder.protect_from_errors { s = finder_stat and s.directory? }
+        end
+
+        def exist?
+          finder.protect_from_errors { File.exist?(self) }
+        end
+
+        def stat
+          finder.protect_from_errors { File.stat(self) }
+        end
+
+        def lstat
+          finder.protect_from_errors { File.lstat(self) }
+        end
+
+        def pathname
+          Pathname.new(self)
+        end
+
+        def suffix
+          pathname.extname[1..-1] || ''
+        end
+      end
+
+      def initialize(opts = {})
+        @show_hidden     = opts.fetch(:show_hidden)     { true }
+        @raise_errors    = opts.fetch(:raise_errors)    { false }
+        @follow_symlinks = opts.fetch(:follow_symlinks) { true }
+        opts[:suffix].full? { |s| @suffix = [*s] }
+      end
+
+      attr_accessor :show_hidden
+
+      attr_accessor :raise_errors
+
+      attr_accessor :follow_symlinks
+
+      attr_accessor :suffix
+
+      def visit_path?(path)
+        @suffix.nil? || @suffix.include?(path.suffix)
+      end
+
+      def find(*paths)
+        block_given? or return enum_for(__method__, *paths)
+        paths.collect! { |d| d.dup }
+        while path = paths.shift
+          path = prepare_path(path)
+          catch(:prune) do
+            stat = path.finder_stat or next
+            visit_path?(path) and yield path
+            if stat.directory?
+              ps = protect_from_errors { Dir.entries(path) } or next
+              ps.sort!
+              ps.reverse_each do |p|
+                next if p == "." or p == ".."
+                next if !@show_hidden && p.start_with?('.')
+                p = File.join(path, p)
+                paths.unshift p.untaint
+              end
+            end
+          end
+        end
+      end
+
+      def prepare_path(path)
+        path = path.dup.taint
+        path.extend PathExtension
+        path.finder = self
+        path
+      end
+
+      def protect_from_errors(errors = Find::EXPECTED_STANDARD_ERRORS)
+        yield
+      rescue errors
+        raise_errors and raise
+        return
+      end
+    end
+
+    #
+    # Calls the associated block with the name of every path and directory
+    # listed as arguments, then recursively on their subdirectories, and so on.
+    #
+    # See the +Find+ module documentation for an example.
+    #
+    def find(*paths, &block) # :yield: path
+      opts = Hash === paths.last ? paths.pop : {}
+      Finder.new(opts).find(*paths, &block)
+    end
+
+    #
+    # Skips the current path or directory, restarting the loop with the next
+    # entry. If the current path is a directory, that directory will not be
+    # recursively entered. Meaningful only within the block associated with
+    # Find::find.
+    #
+    # See the +Find+ module documentation for an example.
+    #
+    def prune
+      throw :prune
+    end
+
+    module_function :find, :prune
+  end
+end

data/vendor/bundle/jruby/1.9/gems/tins-1.6.0/lib/tins/generator.rb

@@ -0,0 +1,68 @@
+module Tins
+  # This class can create generator objects, that can produce all tuples, that
+  # would be created by as many for-loops as dimensions were given.
+  #
+  # The generator
+  #  g = Tins::Generator[1..2, %w[a b c]]
+  # produces
+  #  g.to_a # => [[1, "a"], [1, "b"], [1, "c"], [2, "a"], [2, "b"], [2, "c"]]
+  #
+  # The 'each' method can be used to iterate over the tuples
+  #  g.each { |a, b| puts "#{a} #{b}" }
+  # and Tins::Generator includes the Enumerable module, so
+  # Enumerable.instance_methods can be used as well:
+  #  g.select { |a, b| %w[a c].include? b  } # => [[1, "a"], [1, "c"], [2, "a"], [2, "c"]]
+  #
+  class Generator
+    include Enumerable
+
+    # Create a new Generator object from the enumberables _enums_.
+    def self.[](*enums)
+      new(enums)
+    end
+
+    # Create a new Generator instance. Use the objects in the Array _enums_
+    # as dimensions. The should all respond to the :each method (see module
+    # Enumerable in the core ruby library).
+    def initialize(enums)
+      @enums, @iterators, @n = [], [], 0
+      enums.each { |e| add_dimension(e) }
+    end
+
+    # Iterate over all tuples produced by this generator and yield to them.
+    def each(&block) # :yield: tuple
+      recurse(&block)
+      self
+    end
+
+    def recurse(tuple = [ nil ] * @n, i = 0, &block)
+      if i < @n - 1 then
+        @enums[i].__send__(@iterators[i]) do |x|
+          tuple[i] = x
+          recurse(tuple, i + 1, &block)
+        end
+      else
+        @enums[i].__send__(@iterators[i]) do |x|
+          tuple[i] = x
+          yield tuple.dup
+        end
+      end
+    end
+    private :recurse
+
+    # Add another dimension to this generator. _enum_ is an object, that ought
+    # to respond to the _iterator_ method (defaults to :each).
+    def add_dimension(enum, iterator = :each)
+      @enums << enum
+      @iterators << iterator
+      @n += 1
+    end
+
+    # Return the size of this generator, that is the number of its dimensions.
+    def size
+      @enums.size
+    end
+  end
+end
+
+require 'tins/alias'

data/vendor/bundle/jruby/1.9/gems/tins-1.6.0/lib/tins/go.rb

@@ -0,0 +1,69 @@
+module Tins
+  module GO
+    module EnumerableExtension
+      def push(argument)
+        @arguments ||= []
+        @arguments.push argument
+        self
+      end
+
+      def each(&block)
+        @arguments.each(&block)
+        self
+      end
+      include Enumerable
+    end
+
+    module_function
+
+    # Parses the argument array _args_, according to the pattern _s_, to
+    # retrieve the single character command line options from it. If _s_ is
+    # 'xy:' an option '-x' without an option argument is searched, and an
+    # option '-y foo' with an option argument ('foo').
+    #
+    # An option hash is returned with all found options set to true or the
+    # found option argument.
+    def go(s, args = ARGV)
+      b, v = s.scan(/(.)(:?)/).inject([ {}, {} ]) { |t, (o, a)|
+        a = a == ':'
+        t[a ? 1 : 0][o] = a ? nil : false
+        t
+      }
+      while a = args.shift
+        a !~ /\A-(.+)/ and args.unshift a and break
+        p = $1
+        until p == ''
+          o = p.slice!(0, 1)
+          if v.key?(o)
+            if p == '' then
+              a = args.shift or break 1
+            else
+              a = p
+            end
+            if v[o].nil?
+              a = a.dup
+              a.extend EnumerableExtension
+              a.push a
+              v[o] = a
+            else
+              v[o].push a
+            end
+            break
+          elsif b.key?(o)
+            if b[o] == false
+              b[o]= 1
+            else
+              b[o] += 1
+            end
+          else
+            args.unshift a
+            break 1
+          end
+        end and break
+      end
+      b.merge(v)
+    end
+  end
+end
+
+require 'tins/alias'

data/vendor/bundle/jruby/1.9/gems/tins-1.6.0/lib/tins/hash_symbolize_keys_recursive.rb

@@ -0,0 +1,28 @@
+module Tins
+  module HashSymbolizeKeysRecursive
+    def symbolize_keys_recursive
+      inject(self.class.new) do |h,(k, v)|
+        k = k.to_s
+        k.empty? and next
+        case v
+        when Hash
+          h[k.to_sym] = v.symbolize_keys_recursive
+        when Array
+          h[k.to_sym] = a = v.dup
+          v.each_with_index do |x, i|
+            Hash === x and a[i] = x.symbolize_keys_recursive
+          end
+        else
+          h[k.to_sym] = v
+        end
+        h
+      end
+    end
+
+    def symbolize_keys_recursive!
+      replace symbolize_keys_recursive
+    end
+  end
+end
+
+require 'tins/alias'

data/vendor/bundle/jruby/1.9/gems/tins-1.6.0/lib/tins/hash_union.rb

@@ -0,0 +1,15 @@
+module Tins
+  module HashUnion
+    def |(other)
+      case
+      when other.respond_to?(:to_hash)
+        other = other.to_hash
+      when other.respond_to?(:to_h)
+        other = other.to_h
+      end
+      other.merge(self)
+    end
+  end
+end
+
+require 'tins/alias'

data/vendor/bundle/jruby/1.9/gems/tins-1.6.0/lib/tins/if_predicate.rb

@@ -0,0 +1,7 @@
+module Tins
+  module IfPredicate
+    def if?
+      self ? self : nil
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/tins-1.6.0/lib/tins/implement.rb

@@ -0,0 +1,40 @@
+module Tins
+  module Implement
+    MESSAGES = {
+      default:   'method %{method_name} not implemented in module %{module}',
+      subclass:  'method %{method_name} has to be implemented in '\
+        'subclasses of %{module}',
+      submodule: 'method %{method_name} has to be implemented in '\
+        'submodules of %{module}',
+    }
+
+    def implement(method_name, msg = :default)
+      method_name.nil? and return
+      case msg
+      when ::Symbol
+        msg = MESSAGES.fetch(msg)
+      when ::Hash
+        return implement method_name, msg.fetch(:in)
+      end
+      display_method_name = method_name
+      if m = instance_method(method_name) rescue nil
+        m.extend Tins::MethodDescription
+        display_method_name = m.description(style: :name)
+      end
+      begin
+        msg = msg % { method_name: display_method_name, module: self }
+      rescue KeyError
+      end
+      define_method(method_name) do |*|
+        raise ::NotImplementedError, msg
+      end
+    end
+
+    def implement_in_submodule(method_name)
+      implement method_name,
+        'method %{method_name} has to be implemented in submodules of'\
+        ' %{module}'
+    end
+  end
+end
+