logstash-output-scalyr 0.1.3 → 0.1.8

data/vendor/bundle/jruby/2.5.0/gems/rake-13.0.1/lib/rake/file_task.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-require "rake/task"
-require "rake/early_time"
-
-module Rake
-
-  # A FileTask is a task that includes time based dependencies.  If any of a
-  # FileTask's prerequisites have a timestamp that is later than the file
-  # represented by this task, then the file must be rebuilt (using the
-  # supplied actions).
-  #
-  class FileTask < Task
-
-    # Is this file task needed?  Yes if it doesn't exist, or if its time stamp
-    # is out of date.
-    def needed?
-      !File.exist?(name) || out_of_date?(timestamp) || @application.options.build_all
-    end
-
-    # Time stamp for file task.
-    def timestamp
-      if File.exist?(name)
-        File.mtime(name.to_s)
-      else
-        Rake::LATE
-      end
-    end
-
-    private
-
-    # Are there any prerequisites with a later time than the given time stamp?
-    def out_of_date?(stamp)
-      all_prerequisite_tasks.any? { |prereq|
-        prereq_task = application[prereq, @scope]
-        if prereq_task.instance_of?(Rake::FileTask)
-          prereq_task.timestamp > stamp || @application.options.build_all
-        else
-          prereq_task.timestamp > stamp
-        end
-      }
-    end
-
-    # ----------------------------------------------------------------
-    # Task class methods.
-    #
-    class << self
-      # Apply the scope to the task name according to the rules for this kind
-      # of task.  File based tasks ignore the scope when creating the name.
-      def scope_name(scope, task_name)
-        Rake.from_pathname(task_name)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rake-13.0.1/lib/rake/file_utils.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-require "rbconfig"
-require "fileutils"
-
-#--
-# This a FileUtils extension that defines several additional commands to be
-# added to the FileUtils utility functions.
-module FileUtils
-  # Path to the currently running Ruby program
-  RUBY = ENV["RUBY"] || File.join(
-    RbConfig::CONFIG["bindir"],
-    RbConfig::CONFIG["ruby_install_name"] + RbConfig::CONFIG["EXEEXT"]).
-    sub(/.*\s.*/m, '"\&"')
-
-  # Run the system command +cmd+.  If multiple arguments are given the command
-  # is run directly (without the shell, same semantics as Kernel::exec and
-  # Kernel::system).
-  #
-  # It is recommended you use the multiple argument form over interpolating
-  # user input for both usability and security reasons.  With the multiple
-  # argument form you can easily process files with spaces or other shell
-  # reserved characters in them.  With the multiple argument form your rake
-  # tasks are not vulnerable to users providing an argument like
-  # <code>; rm # -rf /</code>.
-  #
-  # If a block is given, upon command completion the block is called with an
-  # OK flag (true on a zero exit status) and a Process::Status object.
-  # Without a block a RuntimeError is raised when the command exits non-zero.
-  #
-  # Examples:
-  #
-  #   sh 'ls -ltr'
-  #
-  #   sh 'ls', 'file with spaces'
-  #
-  #   # check exit status after command runs
-  #   sh %{grep pattern file} do |ok, res|
-  #     if !ok
-  #       puts "pattern not found (status = #{res.exitstatus})"
-  #     end
-  #   end
-  #
-  def sh(*cmd, &block)
-    options = (Hash === cmd.last) ? cmd.pop : {}
-    shell_runner = block_given? ? block : create_shell_runner(cmd)
-
-    set_verbose_option(options)
-    verbose = options.delete :verbose
-    noop    = options.delete(:noop) || Rake::FileUtilsExt.nowrite_flag
-
-    Rake.rake_output_message sh_show_command cmd if verbose
-
-    unless noop
-      res = (Hash === cmd.last) ? system(*cmd) : system(*cmd, options)
-      status = $?
-      status = Rake::PseudoStatus.new(1) if !res && status.nil?
-      shell_runner.call(res, status)
-    end
-  end
-
-  def create_shell_runner(cmd) # :nodoc:
-    show_command = sh_show_command cmd
-    show_command = show_command[0, 42] + "..." unless $trace
-
-    lambda do |ok, status|
-      ok or
-        fail "Command failed with status (#{status.exitstatus}): " +
-        "[#{show_command}]"
-    end
-  end
-  private :create_shell_runner
-
-  def sh_show_command(cmd) # :nodoc:
-    cmd = cmd.dup
-
-    if Hash === cmd.first
-      env = cmd.first
-      env = env.map { |name, value| "#{name}=#{value}" }.join " "
-      cmd[0] = env
-    end
-
-    cmd.join " "
-  end
-  private :sh_show_command
-
-  def set_verbose_option(options) # :nodoc:
-    unless options.key? :verbose
-      options[:verbose] =
-        (Rake::FileUtilsExt.verbose_flag == Rake::FileUtilsExt::DEFAULT) ||
-        Rake::FileUtilsExt.verbose_flag
-    end
-  end
-  private :set_verbose_option
-
-  # Run a Ruby interpreter with the given arguments.
-  #
-  # Example:
-  #   ruby %{-pe '$_.upcase!' <README}
-  #
-  def ruby(*args, **options, &block)
-    if args.length > 1
-      sh(RUBY, *args, **options, &block)
-    else
-      sh("#{RUBY} #{args.first}", **options, &block)
-    end
-  end
-
-  LN_SUPPORTED = [true]
-
-  #  Attempt to do a normal file link, but fall back to a copy if the link
-  #  fails.
-  def safe_ln(*args, **options)
-    if LN_SUPPORTED[0]
-      begin
-        return options.empty? ? ln(*args) : ln(*args, **options)
-      rescue StandardError, NotImplementedError
-        LN_SUPPORTED[0] = false
-      end
-    end
-    options.empty? ? cp(*args) : cp(*args, **options)
-  end
-
-  # Split a file path into individual directory names.
-  #
-  # Example:
-  #   split_all("a/b/c") =>  ['a', 'b', 'c']
-  #
-  def split_all(path)
-    head, tail = File.split(path)
-    return [tail] if head == "." || tail == "/"
-    return [head, tail] if head == "/"
-    return split_all(head) + [tail]
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rake-13.0.1/lib/rake/file_utils_ext.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-require "rake/file_utils"
-
-module Rake
-  #
-  # FileUtilsExt provides a custom version of the FileUtils methods
-  # that respond to the <tt>verbose</tt> and <tt>nowrite</tt>
-  # commands.
-  #
-  module FileUtilsExt
-    include FileUtils
-
-    class << self
-      attr_accessor :verbose_flag, :nowrite_flag
-    end
-
-    DEFAULT = Object.new
-
-    FileUtilsExt.verbose_flag = DEFAULT
-    FileUtilsExt.nowrite_flag = false
-
-    FileUtils.commands.each do |name|
-      opts = FileUtils.options_of name
-      default_options = []
-      if opts.include?("verbose")
-        default_options << "verbose: FileUtilsExt.verbose_flag"
-      end
-      if opts.include?("noop")
-        default_options << "noop: FileUtilsExt.nowrite_flag"
-      end
-
-      next if default_options.empty?
-      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
-      def #{name}(*args, **options, &block)
-        super(*args,
-            #{default_options.join(', ')},
-            **options, &block)
-      end
-      EOS
-    end
-
-    # Get/set the verbose flag controlling output from the FileUtils
-    # utilities.  If verbose is true, then the utility method is
-    # echoed to standard output.
-    #
-    # Examples:
-    #    verbose              # return the current value of the
-    #                         # verbose flag
-    #    verbose(v)           # set the verbose flag to _v_.
-    #    verbose(v) { code }  # Execute code with the verbose flag set
-    #                         # temporarily to _v_.  Return to the
-    #                         # original value when code is done.
-    def verbose(value=nil)
-      oldvalue = FileUtilsExt.verbose_flag
-      FileUtilsExt.verbose_flag = value unless value.nil?
-      if block_given?
-        begin
-          yield
-        ensure
-          FileUtilsExt.verbose_flag = oldvalue
-        end
-      end
-      FileUtilsExt.verbose_flag
-    end
-
-    # Get/set the nowrite flag controlling output from the FileUtils
-    # utilities.  If verbose is true, then the utility method is
-    # echoed to standard output.
-    #
-    # Examples:
-    #    nowrite              # return the current value of the
-    #                         # nowrite flag
-    #    nowrite(v)           # set the nowrite flag to _v_.
-    #    nowrite(v) { code }  # Execute code with the nowrite flag set
-    #                         # temporarily to _v_. Return to the
-    #                         # original value when code is done.
-    def nowrite(value=nil)
-      oldvalue = FileUtilsExt.nowrite_flag
-      FileUtilsExt.nowrite_flag = value unless value.nil?
-      if block_given?
-        begin
-          yield
-        ensure
-          FileUtilsExt.nowrite_flag = oldvalue
-        end
-      end
-      oldvalue
-    end
-
-    # Use this function to prevent potentially destructive ruby code
-    # from running when the :nowrite flag is set.
-    #
-    # Example:
-    #
-    #   when_writing("Building Project") do
-    #     project.build
-    #   end
-    #
-    # The following code will build the project under normal
-    # conditions. If the nowrite(true) flag is set, then the example
-    # will print:
-    #
-    #      DRYRUN: Building Project
-    #
-    # instead of actually building the project.
-    #
-    def when_writing(msg=nil)
-      if FileUtilsExt.nowrite_flag
-        $stderr.puts "DRYRUN: #{msg}" if msg
-      else
-        yield
-      end
-    end
-
-    # Send the message to the default rake output (which is $stderr).
-    def rake_output_message(message)
-      $stderr.puts(message)
-    end
-
-    # Check that the options do not contain options not listed in
-    # +optdecl+.  An ArgumentError exception is thrown if non-declared
-    # options are found.
-    def rake_check_options(options, *optdecl)
-      h = options.dup
-      optdecl.each do |name|
-        h.delete name
-      end
-      raise ArgumentError, "no such option: #{h.keys.join(' ')}" unless
-        h.empty?
-    end
-
-    extend self
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rake-13.0.1/lib/rake/invocation_chain.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-module Rake
-
-  # InvocationChain tracks the chain of task invocations to detect
-  # circular dependencies.
-  class InvocationChain < LinkedList
-
-    # Is the invocation already in the chain?
-    def member?(invocation)
-      head == invocation || tail.member?(invocation)
-    end
-
-    # Append an invocation to the chain of invocations. It is an error
-    # if the invocation already listed.
-    def append(invocation)
-      if member?(invocation)
-        fail RuntimeError, "Circular dependency detected: #{to_s} => #{invocation}"
-      end
-      conj(invocation)
-    end
-
-    # Convert to string, ie: TOP => invocation => invocation
-    def to_s
-      "#{prefix}#{head}"
-    end
-
-    # Class level append.
-    def self.append(invocation, chain)
-      chain.append(invocation)
-    end
-
-    private
-
-    def prefix
-      "#{tail} => "
-    end
-
-    # Null object for an empty chain.
-    class EmptyInvocationChain < LinkedList::EmptyLinkedList
-      @parent = InvocationChain
-
-      def member?(obj)
-        false
-      end
-
-      def append(invocation)
-        conj(invocation)
-      end
-
-      def to_s
-        "TOP"
-      end
-    end
-
-    EMPTY = EmptyInvocationChain.new
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rake-13.0.1/lib/rake/invocation_exception_mixin.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-module Rake
-  module InvocationExceptionMixin
-    # Return the invocation chain (list of Rake tasks) that were in
-    # effect when this exception was detected by rake.  May be null if
-    # no tasks were active.
-    def chain
-      @rake_invocation_chain ||= nil
-    end
-
-    # Set the invocation chain in effect when this exception was
-    # detected.
-    def chain=(value)
-      @rake_invocation_chain = value
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rake-13.0.1/lib/rake/late_time.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-module Rake
-  # LateTime is a fake timestamp that occurs _after_ any other time value.
-  class LateTime
-    include Comparable
-    include Singleton
-
-    def <=>(other)
-      1
-    end
-
-    def to_s
-      "<LATE TIME>"
-    end
-  end
-
-  LATE = LateTime.instance
-end

data/vendor/bundle/jruby/2.5.0/gems/rake-13.0.1/lib/rake/linked_list.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-module Rake
-
-  # Polylithic linked list structure used to implement several data
-  # structures in Rake.
-  class LinkedList
-    include Enumerable
-    attr_reader :head, :tail
-
-    # Polymorphically add a new element to the head of a list. The
-    # type of head node will be the same list type as the tail.
-    def conj(item)
-      self.class.cons(item, self)
-    end
-
-    # Is the list empty?
-    # .make guards against a list being empty making any instantiated LinkedList
-    # object not empty by default
-    # You should consider overriding this method if you implement your own .make method
-    def empty?
-      false
-    end
-
-    # Lists are structurally equivalent.
-    def ==(other)
-      current = self
-      while !current.empty? && !other.empty?
-        return false if current.head != other.head
-        current = current.tail
-        other = other.tail
-      end
-      current.empty? && other.empty?
-    end
-
-    # Convert to string: LL(item, item...)
-    def to_s
-      items = map(&:to_s).join(", ")
-      "LL(#{items})"
-    end
-
-    # Same as +to_s+, but with inspected items.
-    def inspect
-      items = map(&:inspect).join(", ")
-      "LL(#{items})"
-    end
-
-    # For each item in the list.
-    def each
-      current = self
-      while !current.empty?
-        yield(current.head)
-        current = current.tail
-      end
-      self
-    end
-
-    # Make a list out of the given arguments. This method is
-    # polymorphic
-    def self.make(*args)
-      # return an EmptyLinkedList if there are no arguments
-      return empty if !args || args.empty?
-
-      # build a LinkedList by starting at the tail and iterating
-      # through each argument
-      # inject takes an EmptyLinkedList to start
-      args.reverse.inject(empty) do |list, item|
-        list = cons(item, list)
-        list # return the newly created list for each item in the block
-      end
-    end
-
-    # Cons a new head onto the tail list.
-    def self.cons(head, tail)
-      new(head, tail)
-    end
-
-    # The standard empty list class for the given LinkedList class.
-    def self.empty
-      self::EMPTY
-    end
-
-    protected
-
-    def initialize(head, tail=EMPTY)
-      @head = head
-      @tail = tail
-    end
-
-    # Represent an empty list, using the Null Object Pattern.
-    #
-    # When inheriting from the LinkedList class, you should implement
-    # a type specific Empty class as well. Make sure you set the class
-    # instance variable @parent to the associated list class (this
-    # allows conj, cons and make to work polymorphically).
-    class EmptyLinkedList < LinkedList
-      @parent = LinkedList
-
-      def initialize
-      end
-
-      def empty?
-        true
-      end
-
-      def self.cons(head, tail)
-        @parent.cons(head, tail)
-      end
-    end
-
-    EMPTY = EmptyLinkedList.new
-  end
-end