logstash-codec-json 2.0.3 → 2.0.4

data/vendor/gems/stud-0.0.22/lib/stud/secret.rb

@@ -1,35 +0,0 @@
-
-# A class for holding a secret. The main goal is to prevent the common mistake
-# of accidentally logging or printing passwords or other secrets.
-#
-# See
-# <https://github.com/jordansissel/software-patterns/blob/master/dont-log-secrets/ruby/>
-# for a discussion of why this implementation is useful.
-module Stud
-  class Secret
-    # Initialize a new secret with a given value.
-    #
-    # value - anything you want to keep secret from loggers, etc.
-    def initialize(secret_value)
-      # Redefine the 'value' method on this instance. This exposes no instance
-      # variables to be accidentally leaked by things like awesome_print, etc.
-      # This makes any #value call return the secret value.
-      (class << self; self; end).class_eval do
-        define_method(:value) { secret_value }
-      end
-    end # def initialize
-
-    # Emit simply "<secret>" when printed or logged.
-    def to_s
-      return "<secret>"
-    end # def to_s
-
-    alias_method :inspect, :to_s
-
-    # Get the secret value.
-    def value
-      # Nothing, this will be filled in by Secret.new
-      # But we'll still document this so rdoc/yard know the method exists.
-    end # def value
-  end # class Secret
-end # class Stud

data/vendor/gems/stud-0.0.22/lib/stud/task.rb

@@ -1,64 +0,0 @@
-require "thread"
-require "stud/interval"
-
-module Stud
-
-  # A Task spawns a thread to execute the given block. execution completion and result retrieval is
-  # done using the Task#wait method. A Task is run once and the thread exists upon block completion.
-  # A task and its underlying thread are not reusable.
-  #
-  # Task does not provide a mean to force-interrupt a running task, it only provides the #stop!
-  # method to signal the task for a stop request. The task or code block can use the #stop? method
-  # to check for a stop request. Note that the #stop! and #stop? methods are thread safe.
-  class Task
-    # provide access to the underlying thread if ever needed.
-    attr_reader :thread
-
-    def initialize(*args, &block)
-      # A queue to receive the result of the block
-      # TODO(sissel): Don't use a queue, just store it in an instance variable.
-      @queue = Queue.new
-
-      @thread = Thread.new(@queue, *args) do |queue, *args|
-        begin
-          result = block.call(*args)
-          queue << [:return, result]
-        rescue => e
-          queue << [:exception, e]
-        end
-      end # thread
-    end # def initialize
-
-    # wait waits for the task thread to complete and return the block return value
-    # if the block raises an exception, this exception is propagated in this
-    # wait method.
-    # @return [Object, Exception] block return value
-    def wait
-      @thread.join
-      reason, result = @queue.pop
-
-      if reason == :exception
-        #raise StandardError.new(result)
-        raise result
-      else
-        return result
-      end
-    end # def wait
-
-    # stop! requests the task to stop. the Thread#wakeup method is also
-    # called so that a sleeping task is waked up and has a chance to verify
-    # the stop request using the #stop? method. also see Stud.stop!
-    def stop!
-      Stud.stop!(@thread)
-    end
-
-    # stop? returns true if this task stop! has been called
-    # See Stud.stop?
-    # @return [Boolean] true if the stop! has been called
-    def stop?
-      Stud.stop?(@thread)
-    end
-    alias_method :interrupted?, :stop?
-
-  end # class Task
-end # module Stud

data/vendor/gems/stud-0.0.22/lib/stud/temporary.rb

@@ -1,63 +0,0 @@
-require "securerandom" # for uuid generation
-require "fileutils"
-
-module Stud
-  module Temporary
-    DEFAULT_PREFIX = "studtmp"
-
-    # Returns a string for a randomly-generated temporary path.
-    #
-    # This does not create any files.
-    def pathname(prefix=DEFAULT_PREFIX)
-
-      root = ENV["TMP"] || ENV["TMPDIR"] || ENV["TEMP"] || "/tmp"
-      return File.join(root, "#{prefix}-#{SecureRandom.hex(30)}")
-    end
-
-    # Return a File handle to a randomly-generated path.
-    #
-    # Any arguments beyond the first (prefix) argument will be
-    # given to File.new.
-    #
-    # If no file args are given, the default file mode is "w+"
-    def file(prefix=DEFAULT_PREFIX, *args, &block)
-      args << "w+" if args.empty?
-      file = File.new(pathname(prefix), *args)
-      if block_given?
-        begin
-          block.call(file)
-        ensure
-          file.close unless file.closed?
-          File.unlink(file.path)
-        end
-      else
-        return file
-      end
-    end
-
-    # Make a temporary directory.
-    #
-    # If given a block, the directory path is given to the block.  WHen the
-    # block finishes, the directory and all its contents will be deleted.
-    #
-    # If no block given, it will return the path to a newly created directory.
-    # You are responsible for then cleaning up.
-    def directory(prefix=DEFAULT_PREFIX, &block)
-      path = pathname(prefix)
-      Dir.mkdir(path)
-
-      if block_given?
-        begin
-          block.call(path)
-        ensure
-          FileUtils.rm_r(path)
-        end
-      else
-        return path
-      end
-    end
-    extend self
-  end # module Temporary
-
-end # module Stud
-

data/vendor/gems/stud-0.0.22/lib/stud/trap.rb

@@ -1,80 +0,0 @@
-module Stud
-  # Bind a block to be called when a certain signal is received.
-  #
-  # Same arguments to Signal::trap.
-  #
-  # The behavior of this method is different than Signal::trap because
-  # multiple handlers can request notification for the same signal.
-  #
-  # For example, this is valid:
-  #
-  #     Stud.trap("INT") { puts "Hello" }
-  #     Stud.trap("INT") { puts "World" }
-  #
-  # When SIGINT is received, both callbacks will be invoked, in order.
-  #
-  # This helps avoid the situation where a library traps a signal outside of
-  # your control.
-  #
-  # If something has already used Signal::trap, that callback will be saved
-  # and scheduled the same way as any other Stud::trap.
-  def self.trap(signal, &block)
-    @traps ||= Hash.new { |h,k| h[k] = [] }
-
-    if !@traps.include?(signal)
-      # First trap call for this signal, tell ruby to invoke us.
-      previous_trap = Signal::trap(signal) { simulate_signal(signal) }
-      # If there was a previous trap (via Kernel#trap) set, make sure we remember it.
-      if previous_trap.is_a?(Proc)
-        # MRI's default traps are "DEFAULT" string
-        # JRuby's default traps are Procs with a source_location of "(internal")
-        if RUBY_ENGINE != "jruby" || previous_trap.source_location.first != "(internal)"
-          @traps[signal] << previous_trap
-        end
-      end
-    end
-
-    @traps[signal] << block
-
-    return block.object_id
-  end # def self.trap
-
-  # Simulate a signal. This lets you force an interrupt without
-  # sending a signal to yourself.
-  def self.simulate_signal(signal)
-    #puts "Simulate: #{signal} w/ #{@traps[signal].count} callbacks"
-    @traps[signal].each(&:call)
-  end # def self.simulate_signal
-
-  # Remove a previously set signal trap.
-  #
-  # 'signal' is the name of the signal ("INT", etc)
-  # 'id' is the value returned by a previous Stud.trap() call
-  def self.untrap(signal, id)
-    @traps[signal].delete_if { |block| block.object_id == id }
-
-    # Restore the default handler if there are no custom traps anymore.
-    if @traps[signal].empty?
-      @traps.delete(signal)
-      Signal::trap(signal, "DEFAULT")
-    end
-  end # def self.untrap
-end # module Stud
-
-# Monkey-patch the main 'trap' stuff? This could be useful.
-#module Signal
-  #def trap(signal, value=nil, &block)
-    #if value.nil?
-      #Stud.trap(signal, &block)
-    #else
-      ## do nothing?
-    #end
-  #end # def trap
-#end
-#
-#module Kernel
-  #def trap(signal, value=nil, &block)
-    #Signal.trap(signal, value, &block)
-  #end
-#end
-

data/vendor/gems/stud-0.0.22/lib/stud/try.rb

@@ -1,127 +0,0 @@
-module Stud
-
-  # A class implementing 'retry-on-failure'
-  #
-  # Example:
-  #
-  #     Try.new.try(5.times) { your_code }
-  #
-  # A failure is indicated by any exception being raised.
-  # On success, the return value of the block is the return value of the try
-  # call.
-  #
-  # On final failure (ran out of things to try), the last exception is raised.
-  class Try
-    # An infinite enumerator
-    class Forever
-      include Enumerable
-      def each(&block)
-        a = 0
-        yield a += 1 while true
-      end
-    end # class Forever
-
-    FOREVER = Forever.new
-
-    BACKOFF_SCHEDULE = [0.01, 0.02, 0.04, 0.08, 0.16, 0.32, 0.64, 1.28, 2.0]
-
-    DEFAULT_CATCHABLE_EXCEPTIONS = [StandardError]
-
-    # Log a failure.
-    #
-    # You should override this method if you want a better logger.
-    def log_failure(exception, fail_count, message)
-      puts "Failed (#{exception}). #{message}"
-    end # def log_failure
-
-    # This method is called when a try attempt fails.
-    #
-    # The default implementation will sleep with exponential backoff up to a
-    # maximum of 2 seconds (see BACKOFF_SCHEDULE)
-    #
-    # exception - the exception causing the failure
-    # fail_count - how many times we have failed.
-    def failure(exception, fail_count)
-      backoff = BACKOFF_SCHEDULE[fail_count] || BACKOFF_SCHEDULE.last
-      log_failure(exception, fail_count, "Sleeping for #{backoff}")
-      sleep(backoff)
-    end # def failure
-
-    # Public: try a block of code until either it succeeds or we give up.
-    #
-    # enumerable - an Enumerable or omitted/nil, #each is invoked and is tried
-    #   that number of times. If this value is omitted or nil, we will try until
-    #   success with no limit on the number of tries.
-    #
-    # exceptions - the type of exceptions to retry, we use `StandardError` by default.
-    #
-    # Returns the return value of the block once the block succeeds.
-    # Raises the last seen exception if we run out of tries.
-    #
-    # Examples
-    #
-    #   # Try 10 times to fetch http://google.com/
-    #   response = try(10.times) { Net::HTTP.get_response("google.com", "/") }
-    #
-    #   # Try many times, yielding the value of the enumeration to the block.
-    #   # This allows you to try different inputs.
-    #   response = try([0, 2, 4, 6]) { |val| 50 / val }
-    #   
-    #   Output: 
-    #   Failed (divided by 0). Retrying in 0.01 seconds...
-    #   => 25
-    #
-    #   # Try forever
-    #   return_value = try { ... }
-    def try(enumerable=FOREVER, exceptions=DEFAULT_CATCHABLE_EXCEPTIONS, &block)
-      if block.arity == 0
-        # If the block takes no arguments, give none
-        procedure = lambda { |val| return block.call }
-      else
-        # Otherwise, pass the current 'enumerable' value to the block.
-        procedure = lambda { |val| return block.call(val) }
-      end
-
-      # Track the last exception so we can reraise it on failure.
-      last_exception = nil
-
-      # When 'enumerable' runs out of things, if we still haven't succeeded,
-      # we'll reraise
-      fail_count = 0
-      enumerable.each do |val|
-        begin
-          # If the 'procedure' (the block, really) succeeds, we'll break 
-          # and return the return value of the block. Win!
-          return procedure.call(val)
-        rescue NoMethodError, NameError
-          # Abort immediately on exceptions that are unlikely to recover.
-          raise
-        rescue *exceptions => exception
-          last_exception = exception
-          fail_count += 1
-
-          # Note: Since we can't reliably detect the 'end' of an enumeration, we
-          # will call 'failure' for the final iteration (if it failed) and sleep
-          # even though there's no strong reason to backoff on the last error.
-          failure(exception, fail_count)
-        end
-      end # enumerable.each
-
-      # generally make the exception appear from the 'try' method itself, not from
-      # any deeply nested enumeration/begin/etc
-      # It is my hope that this makes the backtraces easier to read, not more
-      # difficult. If you find this is not the case, please please please let me
-      # know.
-      last_exception.set_backtrace(StandardError.new.backtrace)
-      raise last_exception
-    end # def try
-  end # class Stud::Try
-
-  TRY = Try.new
-  # A simple try method for the common case.
-  def try(enumerable=Stud::Try::FOREVER, exceptions=Try::DEFAULT_CATCHABLE_EXCEPTIONS, &block)
-    return TRY.try(enumerable, exceptions, &block)
-  end # def try
-
-  extend self
-end # module Stud

data/vendor/gems/stud-0.0.22/lib/stud/with.rb

@@ -1,22 +0,0 @@
-module Stud
-  module With
-    # Run a block with arguments. This is sometimes useful in lieu of
-    # explicitly assigning variables.
-    # 
-    # I find mainly that using 'with' is a clue that I can factor out
-    # a given segment of code into a method or function.
-    #
-    # Example usage:
-    #
-    #   with(TCPSocket.new("google.com", 80)) do |s|
-    #     s.write("GET / HTTP/1.0\r\nHost: google.com\r\n\r\n")
-    #     puts s.read
-    #     s.close
-    #   end
-    def with(*args, &block)
-      block.call(*args)
-    end
-
-    extend self
-  end
-end

data/vendor/gems/thread_safe-0.3.5-java/Gemfile

@@ -1,17 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-group :development, :test do
-  gem 'minitest', '~> 5.5.1'
-  gem 'minitest-reporters', '~> 1.0.11'
-  gem 'simplecov', '~> 0.9.2', :require => false
-  gem 'coveralls', '~> 0.7.11', :require => false
-end
-
-group :documentation do
-  gem 'countloc', '~> 0.4.0', :platforms => :mri, :require => false
-  gem 'yard', '~> 0.8.7.6', :require => false
-  gem 'inch', '~> 0.5.10', :platforms => :mri, :require => false
-  gem 'redcarpet', '~> 3.2.2', platforms: :mri # understands github markdown
-end

data/vendor/gems/thread_safe-0.3.5-java/LICENSE

@@ -1,144 +0,0 @@
-Apache License
-
-Version 2.0, January 2004
-
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-"License" shall mean the terms and conditions for use, reproduction, and distribution as 
-defined by Sections 1 through 9 of this document.
-
-"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that 
-is granting the License.
-
-"Legal Entity" shall mean the union of the acting entity and all other entities that 
-control, are controlled by, or are under common control with that entity. For the purposes 
-of this definition, "control" means (i) the power, direct or indirect, to cause the 
-direction or management of such entity, whether by contract or otherwise, or (ii) ownership 
-of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of 
-such entity.
-
-"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by 
-this License.
-
-"Source" form shall mean the preferred form for making modifications, including but not 
-limited to software source code, documentation source, and configuration files.
-
-"Object" form shall mean any form resulting from mechanical transformation or translation of 
-a Source form, including but not limited to compiled object code, generated documentation, 
-and conversions to other media types.
-
-"Work" shall mean the work of authorship, whether in Source or Object form, made available 
-under the License, as indicated by a copyright notice that is included in or attached to the 
-work (an example is provided in the Appendix below).
-
-"Derivative Works" shall mean any work, whether in Source or Object form, that is based on 
-(or derived from) the Work and for which the editorial revisions, annotations, elaborations, 
-or other modifications represent, as a whole, an original work of authorship. For the 
-purposes of this License, Derivative Works shall not include works that remain separable 
-from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works 
-thereof.
-
-"Contribution" shall mean any work of authorship, including the original version of the Work 
-and any modifications or additions to that Work or Derivative Works thereof, that is 
-intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by 
-an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the 
-purposes of this definition, "submitted" means any form of electronic, verbal, or written 
-communication sent to the Licensor or its representatives, including but not limited to 
-communication on electronic mailing lists, source code control systems, and issue tracking 
-systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and 
-improving the Work, but excluding communication that is conspicuously marked or otherwise 
-designated in writing by the copyright owner as "Not a Contribution."
-
-"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a 
-Contribution has been received by Licensor and subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of this License, each 
-Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, 
-royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, 
-publicly display, publicly perform, sublicense, and distribute the Work and such Derivative 
-Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of this License, each 
-Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, 
-royalty-free, irrevocable (except as stated in this section) patent license to make, have 
-made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license 
-applies only to those patent claims licensable by such Contributor that are necessarily 
-infringed by their Contribution(s) alone or by combination of their Contribution(s) with the 
-Work to which such Contribution(s) was submitted. If You institute patent litigation against 
-any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or 
-a Contribution incorporated within the Work constitutes direct or contributory patent 
-infringement, then any patent licenses granted to You under this License for that Work shall 
-terminate as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works 
-thereof in any medium, with or without modifications, and in Source or Object form, provided 
-that You meet the following conditions:
-
-You must give any other recipients of the Work or Derivative Works a copy of this License; 
-and
-
-You must cause any modified files to carry prominent notices stating that You changed the 
-files; and
-
-You must retain, in the Source form of any Derivative Works that You distribute, all 
-copyright, patent, trademark, and attribution notices from the Source form of the Work, 
-excluding those notices that do not pertain to any part of the Derivative Works; and
-
-If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative 
-Works that You distribute must include a readable copy of the attribution notices contained 
-within such NOTICE file, excluding those notices that do not pertain to any part of the 
-Derivative Works, in at least one of the following places: within a NOTICE text file 
-distributed as part of the Derivative Works; within the Source form or documentation, if 
-provided along with the Derivative Works; or, within a display generated by the Derivative 
-Works, if and wherever such third-party notices normally appear. The contents of the NOTICE 
-file are for informational purposes only and do not modify the License. You may add Your own 
-attribution notices within Derivative Works that You distribute, alongside or as an addendum 
-to the NOTICE text from the Work, provided that such additional attribution notices cannot 
-be construed as modifying the License. You may add Your own copyright statement to Your 
-modifications and may provide additional or different license terms and conditions for use, 
-reproduction, or distribution of Your modifications, or for any such Derivative Works as a 
-whole, provided Your use, reproduction, and distribution of the Work otherwise complies with 
-the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution 
-intentionally submitted for inclusion in the Work by You to the Licensor shall be under the 
-terms and conditions of this License, without any additional terms or conditions. 
-Notwithstanding the above, nothing herein shall supersede or modify the terms of any 
-separate license agreement you may have executed with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade names, trademarks, 
-service marks, or product names of the Licensor, except as required for reasonable and 
-customary use in describing the origin of the Work and reproducing the content of the NOTICE 
-file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, 
-Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" 
-BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, 
-without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, 
-MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for 
-determining the appropriateness of using or redistributing the Work and assume any risks 
-associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory, whether in tort 
-(including negligence), contract, or otherwise, unless required by applicable law (such as 
-deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be 
-liable to You for damages, including any direct, indirect, special, incidental, or 
-consequential damages of any character arising as a result of this License or out of the use 
-or inability to use the Work (including but not limited to damages for loss of goodwill, 
-work stoppage, computer failure or malfunction, or any and all other commercial damages or 
-losses), even if such Contributor has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative 
-Works thereof, You may choose to offer, and charge a fee for, acceptance of support, 
-warranty, indemnity, or other liability obligations and/or rights consistent with this 
-License. However, in accepting such obligations, You may act only on Your own behalf and on 
-Your sole responsibility, not on behalf of any other Contributor, and only if You agree to 
-indemnify, defend, and hold each Contributor harmless for any liability incurred by, or 
-claims asserted against, such Contributor by reason of your accepting any such warranty or 
-additional liability.
-
-END OF TERMS AND CONDITIONS