logstash-filter-delta 1.1.0 → 1.1.1

data/vendor/bundle/jruby/2.2.0/gems/concurrent-ruby-1.0.0-java/lib/concurrent/utility/at_exit.rb

@@ -1,97 +0,0 @@
-require 'logger'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  # Provides ability to add and remove handlers to be run at `Kernel#at_exit`, order is undefined.
-  # Each handler is executed at most once.
-  #
-  # @!visibility private
-  class AtExitImplementation < Synchronization::LockableObject
-    include Logger::Severity
-
-    def initialize(*args)
-      super()
-      synchronize { ns_initialize(*args) }
-    end
-
-    # Add a handler to be run at `Kernel#at_exit`
-    # @param [Object] handler_id optionally provide an id, if allready present, handler is replaced
-    # @yield the handler
-    # @return id of the handler
-    def add(handler_id = nil, &handler)
-      id = handler_id || handler.object_id
-      synchronize { @handlers[id] = handler }
-      id
-    end
-
-    # Delete a handler by handler_id
-    # @return [true, false]
-    def delete(handler_id)
-      !!synchronize { @handlers.delete handler_id }
-    end
-
-    # Is handler with handler_id rpesent?
-    # @return [true, false]
-    def handler?(handler_id)
-      synchronize { @handlers.key? handler_id }
-    end
-
-    # @return copy of the handlers
-    def handlers
-      synchronize { @handlers }.clone
-    end
-
-    # install `Kernel#at_exit` callback to execute added handlers
-    def install
-      synchronize do
-        @installed ||= begin
-                         at_exit { runner }
-                         true
-                       end
-        self
-      end
-    end
-
-    # Will it run during `Kernel#at_exit`
-    def enabled?
-      synchronize { @enabled }
-    end
-
-    # Configure if it runs during `Kernel#at_exit`
-    def enabled=(value)
-      synchronize { @enabled = value }
-    end
-
-    # run the handlers manually
-    # @return ids of the handlers
-    def run
-      handlers, _ = synchronize { handlers, @handlers = @handlers, {} }
-      handlers.each do |_, handler|
-        begin
-          handler.call
-        rescue => error
-          Concurrent.global_logger.call(ERROR, error)
-        end
-      end
-      handlers.keys
-    end
-
-    private
-
-    def ns_initialize(enabled = true)
-      @handlers = {}
-      @enabled  = enabled
-    end
-
-    def runner
-      run if synchronize { @enabled }
-    end
-  end
-
-  private_constant :AtExitImplementation
-
-  # @see AtExitImplementation
-  # @!visibility private
-  AtExit = AtExitImplementation.new.install
-end

data/vendor/bundle/jruby/2.2.0/gems/concurrent-ruby-1.0.0-java/lib/concurrent/utility/engine.rb

@@ -1,48 +0,0 @@
-module Concurrent
-  module Utility
-
-    # @!visibility private
-    module EngineDetector
-      def on_jruby?
-        ruby_engine == 'jruby'
-      end
-
-      def on_jruby_9000?
-        on_jruby? && 0 == (JRUBY_VERSION =~ /^9\.0\.0\.0/)
-      end
-
-      def on_cruby?
-        ruby_engine == 'ruby'
-      end
-
-      def on_rbx?
-        ruby_engine == 'rbx'
-      end
-
-      def on_truffle?
-        ruby_engine == 'jruby+truffle'
-      end
-
-      def on_windows?
-        !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/).nil?
-      end
-
-      def ruby_engine
-        defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
-      end
-
-      def ruby_version(comparison, major, minor = 0, patch = 0)
-        result      = (RUBY_VERSION.split('.').map(&:to_i) <=> [major, minor, patch])
-        comparisons = { :== => [0],
-                        :>= => [1, 0],
-                        :<= => [-1, 0],
-                        :>  => [1],
-                        :<  => [-1] }
-        comparisons.fetch(comparison).include? result
-      end
-    end
-  end
-
-  # @!visibility private
-  extend Utility::EngineDetector
-end

data/vendor/bundle/jruby/2.2.0/gems/concurrent-ruby-1.0.0-java/lib/concurrent/utility/monotonic_time.rb

@@ -1,58 +0,0 @@
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  class_definition = Class.new(Synchronization::LockableObject) do
-    def initialize
-      @last_time = Time.now.to_f
-      super()
-    end
-
-    if defined?(Process::CLOCK_MONOTONIC)
-      # @!visibility private
-      def get_time
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-    elsif Concurrent.on_jruby?
-      # @!visibility private
-      def get_time
-        java.lang.System.nanoTime() / 1_000_000_000.0
-      end
-    else
-
-      # @!visibility private
-      def get_time
-        synchronize do
-          now = Time.now.to_f
-          if @last_time < now
-            @last_time = now
-          else # clock has moved back in time
-            @last_time += 0.000_001
-          end
-        end
-      end
-
-    end
-  end
-
-  # Clock that cannot be set and represents monotonic time since
-  # some unspecified starting point.
-  #
-  # @!visibility private
-  GLOBAL_MONOTONIC_CLOCK = class_definition.new
-  private_constant :GLOBAL_MONOTONIC_CLOCK
-
-  # @!macro [attach] monotonic_get_time
-  #
-  #   Returns the current time a tracked by the application monotonic clock.
-  #
-  #   @return [Float] The current monotonic time when `since` not given else
-  #     the elapsed monotonic time between `since` and the current time
-  #
-  #   @!macro monotonic_clock_warning
-  def monotonic_time
-    GLOBAL_MONOTONIC_CLOCK.get_time
-  end
-
-  module_function :monotonic_time
-end

data/vendor/bundle/jruby/2.2.0/gems/concurrent-ruby-1.0.0-java/lib/concurrent/utility/native_extension_loader.rb

@@ -1,73 +0,0 @@
-require 'concurrent/utility/engine'
-
-module Concurrent
-
-  module Utility
-
-    # @!visibility private
-    module NativeExtensionLoader
-
-      def allow_c_extensions?
-        Concurrent.on_cruby?
-      end
-
-      def c_extensions_loaded?
-        @c_extensions_loaded ||= false
-      end
-
-      def java_extensions_loaded?
-        @java_extensions_loaded ||= false
-      end
-
-      def set_c_extensions_loaded
-        @c_extensions_loaded = true
-      end
-
-      def set_java_extensions_loaded
-        @java_extensions_loaded = true
-      end
-
-      def load_native_extensions
-        unless defined? Synchronization::AbstractObject
-          raise 'native_extension_loader loaded before Synchronization::AbstractObject'
-        end
-
-        if Concurrent.on_cruby? && !c_extensions_loaded?
-          tries = [
-            lambda do
-              require 'concurrent/extension'
-              set_c_extensions_loaded
-            end,
-            lambda do
-              # may be a Windows cross-compiled native gem
-              require "concurrent/#{RUBY_VERSION[0..2]}/extension"
-              set_c_extensions_loaded
-            end]
-
-          tries.each do |try|
-            begin
-              try.call
-              break
-            rescue LoadError
-              next
-            end
-          end
-        end
-
-        if Concurrent.on_jruby? && !java_extensions_loaded?
-          begin
-            require 'concurrent_ruby_ext'
-            set_java_extensions_loaded
-          rescue LoadError
-            # move on with pure-Ruby implementations
-            raise 'On JRuby but Java extensions failed to load.'
-          end
-        end
-      end
-    end
-  end
-
-  # @!visibility private
-  extend Utility::NativeExtensionLoader
-end
-

data/vendor/bundle/jruby/2.2.0/gems/concurrent-ruby-1.0.0-java/lib/concurrent/utility/processor_counter.rb

@@ -1,156 +0,0 @@
-require 'rbconfig'
-require 'concurrent/delay'
-
-module Concurrent
-  module Utility
-
-    # @!visibility private
-    class ProcessorCounter
-      def initialize
-        @processor_count          = Delay.new { compute_processor_count }
-        @physical_processor_count = Delay.new { compute_physical_processor_count }
-      end
-
-      # Number of processors seen by the OS and used for process scheduling. For
-      # performance reasons the calculated value will be memoized on the first
-      # call.
-      #
-      # When running under JRuby the Java runtime call
-      # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
-      # to the Java documentation this "value may change during a particular
-      # invocation of the virtual machine... [applications] should therefore
-      # occasionally poll this property." Subsequently the result will NOT be
-      # memoized under JRuby.
-      #
-      # On Windows the Win32 API will be queried for the
-      # `NumberOfLogicalProcessors from Win32_Processor`. This will return the
-      # total number "logical processors for the current instance of the
-      # processor", which taked into account hyperthreading.
-      #
-      # * AIX: /usr/sbin/pmcycles (AIX 5+), /usr/sbin/lsdev
-      # * BSD: /sbin/sysctl
-      # * Cygwin: /proc/cpuinfo
-      # * Darwin: /usr/bin/hwprefs, /usr/sbin/sysctl
-      # * HP-UX: /usr/sbin/ioscan
-      # * IRIX: /usr/sbin/sysconf
-      # * Linux: /proc/cpuinfo
-      # * Minix 3+: /proc/cpuinfo
-      # * Solaris: /usr/sbin/psrinfo
-      # * Tru64 UNIX: /usr/sbin/psrinfo
-      # * UnixWare: /usr/sbin/psrinfo
-      #
-      # @return [Integer] number of processors seen by the OS or Java runtime
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
-      def processor_count
-        @processor_count.value
-      end
-
-      # Number of physical processor cores on the current system. For performance
-      # reasons the calculated value will be memoized on the first call.
-      #
-      # On Windows the Win32 API will be queried for the `NumberOfCores from
-      # Win32_Processor`. This will return the total number "of cores for the
-      # current instance of the processor." On Unix-like operating systems either
-      # the `hwprefs` or `sysctl` utility will be called in a subshell and the
-      # returned value will be used. In the rare case where none of these methods
-      # work or an exception is raised the function will simply return 1.
-      #
-      # @return [Integer] number physical processor cores on the current system
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
-      # @see http://www.unix.com/man-page/osx/1/HWPREFS/
-      # @see http://linux.die.net/man/8/sysctl
-      def physical_processor_count
-        @physical_processor_count.value
-      end
-
-      private
-
-      def compute_processor_count
-        if Concurrent.on_jruby?
-          java.lang.Runtime.getRuntime.availableProcessors
-        else
-          os_name = RbConfig::CONFIG["target_os"]
-          if os_name =~ /mingw|mswin/
-            require 'win32ole'
-            result = WIN32OLE.connect("winmgmts://").ExecQuery(
-              "select NumberOfLogicalProcessors from Win32_Processor")
-            result.to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
-          elsif File.readable?("/proc/cpuinfo")
-            IO.read("/proc/cpuinfo").scan(/^processor/).size
-          elsif File.executable?("/usr/bin/hwprefs")
-            IO.popen("/usr/bin/hwprefs thread_count").read.to_i
-          elsif File.executable?("/usr/sbin/psrinfo")
-            IO.popen("/usr/sbin/psrinfo").read.scan(/^.*on-*line/).size
-          elsif File.executable?("/usr/sbin/ioscan")
-            IO.popen("/usr/sbin/ioscan -kC processor") do |out|
-              out.read.scan(/^.*processor/).size
-            end
-          elsif File.executable?("/usr/sbin/pmcycles")
-            IO.popen("/usr/sbin/pmcycles -m").read.count("\n")
-          elsif File.executable?("/usr/sbin/lsdev")
-            IO.popen("/usr/sbin/lsdev -Cc processor -S 1").read.count("\n")
-          elsif File.executable?("/usr/sbin/sysconf") and os_name =~ /irix/i
-            IO.popen("/usr/sbin/sysconf NPROC_ONLN").read.to_i
-          elsif File.executable?("/usr/sbin/sysctl")
-            IO.popen("/usr/sbin/sysctl -n hw.ncpu").read.to_i
-          elsif File.executable?("/sbin/sysctl")
-            IO.popen("/sbin/sysctl -n hw.ncpu").read.to_i
-          else
-            1
-          end
-        end
-      rescue
-        return 1
-      end
-
-      def compute_physical_processor_count
-        ppc = case RbConfig::CONFIG["target_os"]
-              when /darwin1/
-                IO.popen("/usr/sbin/sysctl -n hw.physicalcpu").read.to_i
-              when /linux/
-                cores = {} # unique physical ID / core ID combinations
-                phy   = 0
-                IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
-                  if ln.start_with?("physical")
-                    phy = ln[/\d+/]
-                  elsif ln.start_with?("core")
-                    cid        = phy + ":" + ln[/\d+/]
-                    cores[cid] = true if not cores[cid]
-                  end
-                end
-                cores.count
-              when /mswin|mingw/
-                require 'win32ole'
-                result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
-                  "select NumberOfCores from Win32_Processor")
-                result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
-              else
-                processor_count
-              end
-        # fall back to logical count if physical info is invalid
-        ppc > 0 ? ppc : processor_count
-      rescue
-        return 1
-      end
-    end
-  end
-
-  # create the default ProcessorCounter on load
-  @processor_counter = Utility::ProcessorCounter.new
-  singleton_class.send :attr_reader, :processor_counter
-
-  def self.processor_count
-    processor_counter.processor_count
-  end
-
-  def self.physical_processor_count
-    processor_counter.physical_processor_count
-  end
-end

data/vendor/bundle/jruby/2.2.0/gems/concurrent-ruby-1.0.0-java/lib/concurrent/version.rb

@@ -1,4 +0,0 @@
-module Concurrent
-  VERSION      = '1.0.0'
-  EDGE_VERSION = '0.2.0'
-end

data/vendor/bundle/jruby/2.2.0/gems/concurrent-ruby-1.0.0-java/lib/concurrent.rb

@@ -1,130 +0,0 @@
-require 'concurrent/version'
-require 'concurrent/constants'
-require 'concurrent/errors'
-require 'concurrent/configuration'
-
-require 'concurrent/atomics'
-require 'concurrent/executors'
-require 'concurrent/synchronization'
-
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/agent'
-require 'concurrent/atom'
-require 'concurrent/array'
-require 'concurrent/hash'
-require 'concurrent/map'
-require 'concurrent/tuple'
-require 'concurrent/async'
-require 'concurrent/dataflow'
-require 'concurrent/delay'
-require 'concurrent/exchanger'
-require 'concurrent/future'
-require 'concurrent/immutable_struct'
-require 'concurrent/ivar'
-require 'concurrent/maybe'
-require 'concurrent/mutable_struct'
-require 'concurrent/mvar'
-require 'concurrent/promise'
-require 'concurrent/scheduled_task'
-require 'concurrent/settable_struct'
-require 'concurrent/timer_task'
-require 'concurrent/tvar'
-
-require 'concurrent/thread_safe/synchronized_delegator'
-require 'concurrent/thread_safe/util'
-
-require 'concurrent/options'
-
-# @!macro [new] internal_implementation_note
-#
-#   @note **Private Implementation:** This abstraction is a private, internal
-#     implementation detail. It should never be used directly.
-
-# @!macro [new] monotonic_clock_warning
-#
-#   @note Time calculations one all platforms and languages are sensitive to
-#     changes to the system clock. To alleviate the potential problems
-#     associated with changing the system clock while an application is running,
-#     most modern operating systems provide a monotonic clock that operates
-#     independently of the system clock. A monotonic clock cannot be used to
-#     determine human-friendly clock times. A monotonic clock is used exclusively
-#     for calculating time intervals. Not all Ruby platforms provide access to an
-#     operating system monotonic clock. On these platforms a pure-Ruby monotonic
-#     clock will be used as a fallback. An operating system monotonic clock is both
-#     faster and more reliable than the pure-Ruby implementation. The pure-Ruby
-#     implementation should be fast and reliable enough for most non-realtime
-#     operations. At this time the common Ruby platforms that provide access to an
-#     operating system monotonic clock are MRI 2.1 and above and JRuby (all versions).
-#
-#   @see http://linux.die.net/man/3/clock_gettime Linux clock_gettime(3)
-
-# @!macro [new] copy_options
-#
-#   ## Copy Options
-#
-#   Object references in Ruby are mutable. This can lead to serious
-#   problems when the {#value} of an object is a mutable reference. Which
-#   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
-#   "primative" data type. Each instance can be configured with a few
-#   options that can help protect the program from potentially dangerous
-#   operations. Each of these options can be optionally set when the oject
-#   instance is created:
-#
-#   * `:dup_on_deref` When true the object will call the `#dup` method on
-#     the `value` object every time the `#value` methid is called
-#     (default: false)
-#   * `:freeze_on_deref` When true the object will call the `#freeze`
-#     method on the `value` object every time the `#value` method is called
-#     (default: false)
-#   * `:copy_on_deref` When given a `Proc` object the `Proc` will be run
-#     every time   the `#value` method is called. The `Proc` will be given
-#     the current `value` as its only argument and the result returned by
-#     the block will be the return   value of the `#value` call. When `nil`
-#     this option will be ignored (default: nil)
-#
-#   When multiple deref options are set the order of operations is strictly defined.
-#   The order of deref operations is:
-#   * `:copy_on_deref`
-#   * `:dup_on_deref`
-#   * `:freeze_on_deref`
-#
-#   Because of this ordering there is no need to `#freeze` an object created by a
-#   provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`.
-#   Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is
-#   as close to the behavior of a "pure" functional language (like Erlang, Clojure,
-#   or Haskell) as we are likely to get in Ruby.
-
-# @!macro [attach] deref_options
-#
-#   @option opts [Boolean] :dup_on_deref (false) Call `#dup` before
-#     returning the data from {#value}
-#   @option opts [Boolean] :freeze_on_deref (false) Call `#freeze` before
-#     returning the data from {#value}
-#   @option opts [Proc] :copy_on_deref (nil) When calling the {#value}
-#     method, call the given proc passing the internal value as the sole
-#     argument then return the new value returned from the proc.
-
-# @!macro [attach] executor_and_deref_options
-#
-#   @param [Hash] opts the options used to define the behavior at update and deref
-#     and to specify the executor on which to perform actions
-#   @option opts [Executor] :executor when set use the given `Executor` instance.
-#     Three special values are also supported: `:task` returns the global task pool,
-#     `:operation` returns the global operation pool, and `:immediate` returns a new
-#     `ImmediateExecutor` object.
-#   @!macro deref_options
-
-# Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
-# F#, C#, Java, and classic concurrency patterns.
-#
-# The design goals of this gem are:
-#
-# * Stay true to the spirit of the languages providing inspiration
-# * But implement in a way that makes sense for Ruby
-# * Keep the semantics as idiomatic Ruby as possible
-# * Support features that make sense in Ruby
-# * Exclude features that don't make sense in Ruby
-# * Be small, lean, and loosely coupled
-module Concurrent
-
-end

data/vendor/bundle/jruby/2.2.0/gems/diff-lcs-1.2.5/Contributing.rdoc

@@ -1,64 +0,0 @@
-== Contributing
-
-I value any contribution to Diff::LCS you can provide: a bug report, a feature
-request, or code contributions.
-
-Code contributions to Diff::LCS are especially <del>welcome</del>encouraged.
-Because Diff::LCS is a complex codebase, there are a few guidelines:
-
-* Changes <strong>will not</strong> be accepted without tests.
-* The test suite is written with RSpec.‡
-* Match my coding style.
-* Use a thoughtfully-named topic branch that contains your change. Rebase your
-  commits into logical chunks as necessary.
-* Use {quality commit messages}[http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html].
-* Do not change the version number; when your patch is accepted and a release
-  is made, the version will be updated at that point.
-* Submit a GitHub pull request with your changes.
-* New features require new documentation.
-
-=== Test Dependencies
-
-To run the test suite, you will need to install the development dependencies
-for Diff::LCS. If you have Bundler, you can accomplish this easily:
-
-    $ bundle install
-
-Diff::LCS uses Ryan Davis’s excellent {Hoe}[https://github.com/seattlerb/hoe]
-to manage the release process, and it adds a number of rake tasks. You will
-mostly be interested in:
-
-    $ rake
-
-which runs the tests the same way that:
-
-    $ rake spec
-    $ rake test
-    $ rake travis
-
-will do.
-
-=== Workflow
-
-Here's the most direct way to get your work merged into the project:
-
-* Fork the project.
-* Clone down your fork (+git clone git://github.com/<username>/diff-lcs.git+).
-* Create a topic branch to contain your change (+git checkout -b my\_awesome\_feature+).
-* Hack away, add tests. Not necessarily in that order.
-* Make sure everything still passes by running `rake`.
-* If necessary, rebase your commits into logical chunks, without errors.
-* Push the branch up (+git push origin my\_awesome\_feature+).
-* Create a pull request against halostatue/diff-lcs and describe what your
-  change does and the why you think it should be merged.
-
-=== Contributors
-
-* Austin Ziegler created Diff::LCS.
-
-Thanks to everyone else who has contributed to Diff::LCS:
-
-* Kenichi Kamiya
-* Michael Granger
-* Vít Ondruch
-* Jon Rowe

data/vendor/bundle/jruby/2.2.0/gems/diff-lcs-1.2.5/Gemfile

@@ -1,20 +0,0 @@
-# -*- ruby -*-
-
-# DO NOT EDIT THIS FILE. Instead, edit Rakefile, and run `rake bundler:gemfile`.
-
-source "https://rubygems.org/"
-
-
-gem "rubyforge", ">=2.0.4", :group => [:development, :test]
-gem "rdoc", "~>4.0", :group => [:development, :test]
-gem "hoe-bundler", "~>1.2", :group => [:development, :test]
-gem "hoe-doofus", "~>1.0", :group => [:development, :test]
-gem "hoe-gemspec2", "~>1.1", :group => [:development, :test]
-gem "hoe-git", "~>1.5", :group => [:development, :test]
-gem "hoe-rubygems", "~>1.0", :group => [:development, :test]
-gem "hoe-travis", "~>1.2", :group => [:development, :test]
-gem "rake", "~>10.0", :group => [:development, :test]
-gem "rspec", "~>2.0", :group => [:development, :test]
-gem "hoe", "~>3.7", :group => [:development, :test]
-
-# vim: syntax=ruby