logstash-filter-delta 1.1.0 → 1.1.1

data/vendor/bundle/jruby/2.2.0/gems/pry-0.10.4-java/lib/pry/core_extensions.rb

@@ -1,131 +0,0 @@
-class Pry
-  # @return [Array] Code of the method used when implementing Pry's
-  #   __binding__, along with line indication to be used with instance_eval (and
-  #   friends).
-  #
-  # @see Object#__binding__
-  BINDING_METHOD_IMPL = [<<-METHOD, __FILE__, __LINE__ + 1]
-    # Get a binding with 'self' set to self, and no locals.
-    #
-    # The default definee is determined by the context in which the
-    # definition is eval'd.
-    #
-    # Please don't call this method directly, see {__binding__}.
-    #
-    # @return [Binding]
-    def __pry__
-      binding
-    end
-  METHOD
-end
-
-class Object
-  # Start a Pry REPL on self.
-  #
-  # If `self` is a Binding then that will be used to evaluate expressions;
-  # otherwise a new binding will be created.
-  #
-  # @param [Object] object  the object or binding to pry
-  #                         (__deprecated__, use `object.pry`)
-  # @param [Hash] hash  the options hash
-  # @example With a binding
-  #    binding.pry
-  # @example On any object
-  #   "dummy".pry
-  # @example With options
-  #   def my_method
-  #     binding.pry :quiet => true
-  #   end
-  #   my_method()
-  # @see Pry.start
-  def pry(object=nil, hash={})
-    if object.nil? || Hash === object
-      Pry.start(self, object || {})
-    else
-      Pry.start(object, hash)
-    end
-  end
-
-  # Return a binding object for the receiver.
-  #
-  # The `self` of the binding is set to the current object, and it contains no
-  # local variables.
-  #
-  # The default definee (http://yugui.jp/articles/846) is set such that:
-  #
-  # * If `self` is a class or module, then new methods created in the binding
-  #   will be defined in that class or module (as in `class Foo; end`).
-  # * If `self` is a normal object, then new methods created in the binding will
-  #   be defined on its singleton class (as in `class << self; end`).
-  # * If `self` doesn't have a  real singleton class (i.e. it is a Fixnum, Float,
-  #   Symbol, nil, true, or false), then new methods will be created on the
-  #   object's class (as in `self.class.class_eval{ }`)
-  #
-  # Newly created constants, including classes and modules, will also be added
-  # to the default definee.
-  #
-  # @return [Binding]
-  def __binding__
-    # If you ever feel like changing this method, be careful about variables
-    # that you use. They shouldn't be inserted into the binding that will
-    # eventually be returning.
-
-    # When you're cd'd into a class, methods you define should be added to it.
-    if is_a?(Module)
-      # class_eval sets both self and the default definee to this class.
-      return class_eval "binding"
-    end
-
-    unless respond_to?(:__pry__)
-      # The easiest way to check whether an object has a working singleton class
-      # is to try and define a method on it. (just checking for the presence of
-      # the singleton class gives false positives for `true` and `false`).
-      # __pry__ is just the closest method we have to hand, and using
-      # it has the nice property that we can memoize this check.
-      begin
-        # instance_eval sets the default definee to the object's singleton class
-        instance_eval(*Pry::BINDING_METHOD_IMPL)
-
-      # If we can't define methods on the Object's singleton_class. Then we fall
-      # back to setting the default definee to be the Object's class. That seems
-      # nicer than having a REPL in which you can't define methods.
-      rescue TypeError, Pry::FrozenObjectException
-        # class_eval sets the default definee to self.class
-        self.class.class_eval(*Pry::BINDING_METHOD_IMPL)
-      end
-    end
-
-    __pry__
-  end
-end
-
-class BasicObject
-  # Return a binding object for the receiver.
-  #
-  # The `self` of the binding is set to the current object, and it contains no
-  # local variables.
-  #
-  # The default definee (http://yugui.jp/articles/846) is set such that new
-  # methods defined will be added to the singleton class of the BasicObject.
-  #
-  # @return [Binding]
-  def __binding__
-    # BasicObjects don't have respond_to?, so we just define the method
-    # every time. As they also don't have `.freeze`, this call won't
-    # fail as it can for normal Objects.
-    (class << self; self; end).class_eval <<-EOF, __FILE__, __LINE__ + 1
-      # Get a binding with 'self' set to self, and no locals.
-      #
-      # The default definee is determined by the context in which the
-      # definition is eval'd.
-      #
-      # Please don't call this method directly, see {__binding__}.
-      #
-      # @return [Binding]
-      def __pry__
-        ::Kernel.binding
-      end
-    EOF
-    self.__pry__
-  end
-end

data/vendor/bundle/jruby/2.2.0/gems/pry-0.10.4-java/lib/pry/editor.rb

@@ -1,135 +0,0 @@
-class Pry
-  class Editor
-    include Pry::Helpers::BaseHelpers
-    include Pry::Helpers::CommandHelpers
-
-    attr_reader :_pry_
-
-    def initialize(_pry_)
-      @_pry_ = _pry_
-    end
-
-    def edit_tempfile_with_content(initial_content, line=1)
-      temp_file do |f|
-        f.puts(initial_content)
-        f.flush
-        f.close(false)
-        invoke_editor(f.path, line, true)
-        File.read(f.path)
-      end
-    end
-
-    def invoke_editor(file, line, blocking=true)
-      raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless _pry_.config.editor
-
-      editor_invocation = build_editor_invocation_string(file, line, blocking)
-      return nil unless editor_invocation
-
-      if jruby?
-        open_editor_on_jruby(editor_invocation)
-      else
-        open_editor(editor_invocation)
-      end
-    end
-
-    private
-
-    # Generate the string that's used to start the editor. This includes
-    # all the flags we want as well as the file and line number we
-    # want to open at.
-    def build_editor_invocation_string(file, line, blocking)
-
-      if _pry_.config.editor.respond_to?(:call)
-        args = [file, line, blocking][0...(_pry_.config.editor.arity)]
-        _pry_.config.editor.call(*args)
-      else
-        sanitized_file = if windows?
-                            file.gsub(/\//, '\\')
-                          else
-                            Shellwords.escape(file)
-                          end
-
-        "#{_pry_.config.editor} #{blocking_flag_for_editor(blocking)} #{start_line_syntax_for_editor(sanitized_file, line)}"
-      end
-    end
-
-    # Start the editor running, using the calculated invocation string
-    def open_editor(editor_invocation)
-      # Note we dont want to use Pry.config.system here as that
-      # may be invoked non-interactively (i.e via Open4), whereas we want to
-      # ensure the editor is always interactive
-      system(*Shellwords.split(editor_invocation)) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
-    end
-
-    # We need JRuby specific code here cos just shelling out using
-    # system() appears to be pretty broken :/
-    def open_editor_on_jruby(editor_invocation)
-      begin
-        require 'spoon'
-        pid = Spoon.spawnp(*Shellwords.split(editor_invocation))
-        Process.waitpid(pid)
-      rescue FFI::NotFoundError
-        system(editor_invocation)
-      end
-    end
-
-    # Some editors that run outside the terminal allow you to control whether or
-    # not to block the process from which they were launched (in this case, Pry).
-    # For those editors, return the flag that produces the desired behavior.
-    def blocking_flag_for_editor(blocking)
-      case editor_name
-      when /^emacsclient/
-        '--no-wait' unless blocking
-      when /^[gm]vim/
-        '--nofork' if blocking
-      when /^jedit/
-        '-wait' if blocking
-      when /^mate/, /^subl/, /^redcar/
-        '-w' if blocking
-      end
-    end
-
-    # Return the syntax for a given editor for starting the editor
-    # and moving to a particular line within that file
-    def start_line_syntax_for_editor(file_name, line_number)
-      # special case for 1st line
-      return file_name if line_number <= 1
-
-      case editor_name
-      when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
-        "+#{line_number} #{file_name}"
-      when /^mate/, /^geany/
-        "-l #{line_number} #{file_name}"
-      when /^subl/
-        "#{file_name}:#{line_number}"
-      when /^uedit32/
-        "#{file_name}/#{line_number}"
-      when /^jedit/
-        "#{file_name} +line:#{line_number}"
-      when /^redcar/
-        "-l#{line_number} #{file_name}"
-      else
-        if windows?
-          "#{file_name}"
-        else
-          "+#{line_number} #{file_name}"
-        end
-      end
-    end
-
-    # Get the name of the binary that Pry.config.editor points to.
-    #
-    # This is useful for deciding which flags we pass to the editor as
-    # we can just use the program's name and ignore any absolute paths.
-    #
-    # @example
-    #   Pry.config.editor="/home/conrad/bin/textmate -w"
-    #   editor_name
-    #   # => textmate
-    #
-    def editor_name
-      File.basename(_pry_.config.editor).split(" ").first
-    end
-
-  end
-end

data/vendor/bundle/jruby/2.2.0/gems/pry-0.10.4-java/lib/pry/exceptions.rb

@@ -1,78 +0,0 @@
-class Pry
-
-  # As a REPL, we often want to catch any unexpected exceptions that may have
-  # been raised; however we don't want to go overboard and prevent the user
-  # from exiting Pry when they want to.
-  module RescuableException
-    def self.===(exception)
-      case exception
-        # Catch when the user hits ^C (Interrupt < SignalException), and assume
-        # that they just wanted to stop the in-progress command (just like bash
-        # etc.)
-      when Interrupt
-        true
-        # Don't catch signals (particularly not SIGTERM) as these are unlikely
-        # to be intended for pry itself. We should also make sure that
-        # Kernel#exit works.
-      when *Pry.config.exception_whitelist
-        false
-        # All other exceptions will be caught.
-      else
-        true
-      end
-    end
-  end
-
-  # Catches SecurityErrors if $SAFE is set
-  module Pry::TooSafeException
-    def self.===(exception)
-      $SAFE > 0 && SecurityError === exception
-    end
-  end
-
-  # An Exception Tag (cf. Exceptional Ruby) that instructs Pry to show the error
-  # in a more user-friendly manner. This should be used when the exception
-  # happens within Pry itself as a direct consequence of the user typing
-  # something wrong.
-  #
-  # This allows us to distinguish between the user typing:
-  #
-  # pry(main)> def )
-  # SyntaxError: unexpected )
-  #
-  # pry(main)> method_that_evals("def )")
-  # SyntaxError: (eval):1: syntax error, unexpected ')'
-  # from ./a.rb:2 in `eval'
-  module UserError; end
-
-  # When we try to get a binding for an object, we try to define a method on
-  # that Object's singleton class. This doesn't work for "frozen" Object's, and
-  # the exception is just a vanilla RuntimeError.
-  module FrozenObjectException
-    def self.===(exception)
-      ["can't modify frozen class/module",
-       "can't modify frozen Class",
-       "can't modify frozen object"
-      ].include?(exception.message)
-    end
-  end
-
-  # Don't catch these exceptions
-  DEFAULT_EXCEPTION_WHITELIST = [SystemExit,
-                                 SignalException,
-                                 Pry::TooSafeException]
-
-  # CommandErrors are caught by the REPL loop and displayed to the user. They
-  # indicate an exceptional condition that's fatal to the current command.
-  class CommandError < StandardError; end
-  class MethodNotFound < CommandError; end
-
-  # indicates obsolete API
-  class ObsoleteError < StandardError; end
-
-  # This is to keep from breaking under Rails 3.2 for people who are doing that
-  # IRB = Pry thing.
-  module ExtendCommandBundle
-  end
-
-end

data/vendor/bundle/jruby/2.2.0/gems/pry-0.10.4-java/lib/pry/helpers/base_helpers.rb

@@ -1,113 +0,0 @@
-class Pry
-  module Helpers
-
-    module BaseHelpers
-
-      module_function
-
-      def silence_warnings
-        old_verbose = $VERBOSE
-        $VERBOSE = nil
-        begin
-          yield
-        ensure
-          $VERBOSE = old_verbose
-        end
-      end
-
-      # Acts like send but ignores any methods defined below Object or Class in the
-      # inheritance hierarchy.
-      # This is required to introspect methods on objects like Net::HTTP::Get that
-      # have overridden the `method` method.
-      def safe_send(obj, method, *args, &block)
-        (Module === obj ? Module : Object).instance_method(method).bind(obj).call(*args, &block)
-      end
-      public :safe_send
-
-      def find_command(name, set = Pry::Commands)
-        command_match = set.find do |_, command|
-          (listing = command.options[:listing]) == name && listing != nil
-        end
-        command_match.last if command_match
-      end
-
-      def not_a_real_file?(file)
-        file =~ /(\(.*\))|<.*>/ || file =~ /__unknown__/ || file == "" || file == "-e"
-      end
-
-      def command_dependencies_met?(options)
-        return true if !options[:requires_gem]
-        Array(options[:requires_gem]).all? do |g|
-          Rubygem.installed?(g)
-        end
-      end
-
-      def use_ansi_codes?
-        windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
-      end
-
-      def colorize_code(code)
-        CodeRay.scan(code, :ruby).term
-      end
-
-      def highlight(string, regexp, highlight_color=:bright_yellow)
-        string.gsub(regexp) { |match| "<#{highlight_color}>#{match}</#{highlight_color}>" }
-      end
-
-      # formatting
-      def heading(text)
-        text = "#{text}\n--"
-        "\e[1m#{text}\e[0m"
-      end
-
-      # have fun on the Windows platform.
-      def windows?
-        RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-      end
-
-      # are we able to use ansi on windows?
-      def windows_ansi?
-        defined?(Win32::Console) || ENV['ANSICON'] || (windows? && mri_2?)
-      end
-
-      def jruby?
-        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
-      end
-
-      def jruby_19?
-        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
-      end
-
-      def rbx?
-        RbConfig::CONFIG['ruby_install_name'] == 'rbx'
-      end
-
-      def mri?
-        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
-      end
-
-      def mri_19?
-        mri? && RUBY_VERSION =~ /^1\.9/
-      end
-
-      def mri_2?
-        mri? && RUBY_VERSION =~ /^2/
-      end
-
-      def mri_20?
-        mri? && RUBY_VERSION =~ /^2\.0/
-      end
-
-      def mri_21?
-        mri? && RUBY_VERSION =~ /^2\.1/
-      end
-
-      # Send the given text through the best available pager (if Pry.config.pager is
-      # enabled). Infers where to send the output if used as a mixin.
-      # DEPRECATED.
-      def stagger_output(text, out = nil)
-        Pry.new.pager.page text
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.2.0/gems/pry-0.10.4-java/lib/pry/helpers/command_helpers.rb

@@ -1,156 +0,0 @@
-class Pry
-  module Helpers
-
-    module CommandHelpers
-      include OptionsHelpers
-
-      module_function
-
-      # Open a temp file and yield it to the block, closing it after
-      # @return [String] The path of the temp file
-      def temp_file(ext='.rb')
-        file = Tempfile.new(['pry', ext])
-        yield file
-      ensure
-        file.close(true) if file
-      end
-
-      def internal_binding?(target)
-        m = target.eval("::Kernel.__method__").to_s
-        # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
-        ["__binding__", "__pry__", "class_eval"].include?(m)
-      end
-
-      def get_method_or_raise(name, target, opts={}, omit_help=false)
-        meth = Pry::Method.from_str(name, target, opts)
-
-        if name && !meth
-          command_error("The method '#{name}' could not be found.", omit_help, MethodNotFound)
-        end
-
-        (opts[:super] || 0).times do
-          if meth.super
-            meth = meth.super
-          else
-            command_error("'#{meth.name_with_owner}' has no super method.", omit_help, MethodNotFound)
-          end
-        end
-
-        if !meth || (!name && internal_binding?(target))
-          command_error("No method name given, and context is not a method.", omit_help, MethodNotFound)
-        end
-
-        set_file_and_dir_locals(meth.source_file)
-        meth
-      end
-
-      def command_error(message, omit_help, klass=CommandError)
-        message += " Type `#{command_name} --help` for help." unless omit_help
-        raise klass, message
-      end
-
-      # Remove any common leading whitespace from every line in `text`.
-      #
-      # This can be used to make a HEREDOC line up with the left margin, without
-      # sacrificing the indentation level of the source code.
-      #
-      # e.g.
-      #   opt.banner unindent <<-USAGE
-      #     Lorem ipsum dolor sit amet, consectetur adipisicing elit,
-      #     sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
-      #       "Ut enim ad minim veniam."
-      #   USAGE
-      #
-      # Heavily based on textwrap.dedent from Python, which is:
-      #   Copyright (C) 1999-2001 Gregory P. Ward.
-      #   Copyright (C) 2002, 2003 Python Software Foundation.
-      #   Written by Greg Ward <gward@python.net>
-      #
-      #   Licensed under <http://docs.python.org/license.html>
-      #   From <http://hg.python.org/cpython/file/6b9f0a6efaeb/Lib/textwrap.py>
-      #
-      # @param [String] text The text from which to remove indentation
-      # @return [String] The text with indentation stripped.
-      def unindent(text, left_padding = 0)
-        # Empty blank lines
-        text = text.sub(/^[ \t]+$/, '')
-
-        # Find the longest common whitespace to all indented lines
-        # Ignore lines containing just -- or ++ as these seem to be used by
-        # comment authors as delimeters.
-        margin = text.scan(/^[ \t]*(?!--\n|\+\+\n)(?=[^ \t\n])/).inject do |current_margin, next_indent|
-          if next_indent.start_with?(current_margin)
-            current_margin
-          elsif current_margin.start_with?(next_indent)
-            next_indent
-          else
-            ""
-          end
-        end
-
-        text.gsub(/^#{margin}/, ' ' * left_padding)
-      end
-
-      # Restrict a string to the given range of lines (1-indexed)
-      # @param [String] content The string.
-      # @param [Range, Fixnum] lines The line(s) to restrict it to.
-      # @return [String] The resulting string.
-      def restrict_to_lines(content, lines)
-        line_range = one_index_range_or_number(lines)
-        Array(content.lines.to_a[line_range]).join
-      end
-
-      def one_index_number(line_number)
-        if line_number > 0
-          line_number - 1
-        else
-          line_number
-        end
-      end
-
-      # convert a 1-index range to a 0-indexed one
-      def one_index_range(range)
-        Range.new(one_index_number(range.begin), one_index_number(range.end))
-      end
-
-      def one_index_range_or_number(range_or_number)
-        case range_or_number
-        when Range
-          one_index_range(range_or_number)
-        else
-          one_index_number(range_or_number)
-        end
-      end
-
-      def absolute_index_number(line_number, array_length)
-        if line_number >= 0
-          line_number
-        else
-          [array_length + line_number, 0].max
-        end
-      end
-
-      def absolute_index_range(range_or_number, array_length)
-        case range_or_number
-        when Range
-          a = absolute_index_number(range_or_number.begin, array_length)
-          b = absolute_index_number(range_or_number.end, array_length)
-        else
-          a = b = absolute_index_number(range_or_number, array_length)
-        end
-
-        Range.new(a, b)
-      end
-
-      def set_file_and_dir_locals(file_name, _pry_=_pry_(), target=target())
-        return if !target or !file_name
-        _pry_.last_file = File.expand_path(file_name)
-        _pry_.inject_local("_file_", _pry_.last_file, target)
-
-        _pry_.last_dir = File.dirname(_pry_.last_file)
-        _pry_.inject_local("_dir_", _pry_.last_dir, target)
-      end
-    end
-
-  end
-end

data/vendor/bundle/jruby/2.2.0/gems/pry-0.10.4-java/lib/pry/helpers/documentation_helpers.rb

@@ -1,75 +0,0 @@
-class Pry
-  module Helpers
-
-    # This class contains methods useful for extracting
-    # documentation from methods and classes.
-    module DocumentationHelpers
-
-      module_function
-
-      def process_rdoc(comment)
-        comment = comment.dup
-        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { CodeRay.scan($1, :ruby).term }.
-          gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { "\e[1m#{$1}\e[0m" }.
-          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { "\e[1m#{$1}\e[0m" }.
-          gsub(/\B\+(\w+?)\+\B/)  { "\e[32m#{$1}\e[0m" }.
-          gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { CodeRay.scan($1, :ruby).term }.
-          gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{CodeRay.scan($1, :ruby).term}`" }
-      end
-
-      def process_yardoc_tag(comment, tag)
-        in_tag_block = nil
-        comment.lines.map do |v|
-          if in_tag_block && v !~ /^\S/
-            Pry::Helpers::Text.strip_color Pry::Helpers::Text.strip_color(v)
-          elsif in_tag_block
-            in_tag_block = false
-            v
-          else
-            in_tag_block = true if v =~ /^@#{tag}/
-            v
-          end
-        end.join
-      end
-
-      def process_yardoc(comment)
-        yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
-                     "deprecate", "example", "raise"]
-        (yard_tags - ["example"]).inject(comment) { |a, v| process_yardoc_tag(a, v) }.
-          gsub(/^@(#{yard_tags.join("|")})/) { "\e[33m#{$1}\e[0m" }
-      end
-
-      def process_comment_markup(comment)
-        process_yardoc process_rdoc(comment)
-      end
-
-      # @param [String] code
-      # @return [String]
-      def strip_comments_from_c_code(code)
-        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
-      end
-
-      # Given a string that makes up a comment in a source-code file parse out the content
-      # that the user is intended to read. (i.e. without leading indentation, #-characters
-      # or shebangs)
-      #
-      # @param [String] comment
-      # @return [String]
-      def get_comment_content(comment)
-        comment = comment.dup
-        # Remove #!/usr/bin/ruby
-        comment.gsub!(/\A\#!.*$/, '')
-        # Remove leading empty comment lines
-        comment.gsub!(/\A\#+?$/, '')
-        comment.gsub!(/^\s*#/, '')
-        strip_leading_whitespace(comment)
-      end
-
-      # @param [String] text
-      # @return [String]
-      def strip_leading_whitespace(text)
-        Pry::Helpers::CommandHelpers.unindent(text)
-      end
-    end
-  end
-end