primary_connect_proto 0.9.0 → 0.11.0

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/code.rb

@@ -1,365 +0,0 @@
-# frozen_string_literal: true
-
-require 'method_source'
-
-class Pry
-  class << self
-    # Convert the given object into an instance of `Pry::Code`, if it isn't
-    # already one.
-    #
-    # @param [Code, Method, UnboundMethod, Proc, Pry::Method, String, Array,
-    #   IO] obj
-    def Code(obj)
-      case obj
-      when Code
-        obj
-      when ::Method, UnboundMethod, Proc, Pry::Method
-        Code.from_method(obj)
-      else
-        Code.new(obj)
-      end
-    end
-  end
-
-  # `Pry::Code` is a class that encapsulates lines of source code and their
-  # line numbers and formats them for terminal output. It can read from a file
-  # or method definition or be instantiated with a `String` or an `Array`.
-  #
-  # In general, the formatting methods in `Code` return a new `Code` object
-  # which will format the text as specified when `#to_s` is called. This allows
-  # arbitrary chaining of formatting methods without mutating the original
-  # object.
-  class Code
-    class << self
-      include MethodSource::CodeHelpers
-
-      # Instantiate a `Code` object containing code loaded from a file or
-      # Pry's line buffer.
-      #
-      # @param [String] filename The name of a file, or "(pry)".
-      # @param [Symbol] code_type The type of code the file contains.
-      # @return [Code]
-      def from_file(filename, code_type = nil)
-        code_file = CodeFile.new(filename, code_type)
-        new(code_file.code, 1, code_file.code_type)
-      end
-
-      # Instantiate a `Code` object containing code extracted from a
-      # `::Method`, `UnboundMethod`, `Proc`, or `Pry::Method` object.
-      #
-      # @param [::Method, UnboundMethod, Proc, Pry::Method] meth The method
-      #   object.
-      # @param [Integer, nil] start_line The line number to start on, or nil to
-      #   use the method's original line numbers.
-      # @return [Code]
-      def from_method(meth, start_line = nil)
-        meth = Pry::Method(meth)
-        start_line ||= meth.source_line || 1
-        new(meth.source, start_line, meth.source_type)
-      end
-
-      # Attempt to extract the source code for module (or class) `mod`.
-      #
-      # @param [Module, Class] mod The module (or class) of interest.
-      # @param [Integer] candidate_rank The module candidate (by rank)
-      #   to use (see `Pry::WrappedModule::Candidate` for more information).
-      # @param [Integer, nil] start_line The line number to start on, or nil to
-      #   use the method's original line numbers.
-      # @return [Code]
-      def from_module(mod, candidate_rank = 0, start_line = nil)
-        candidate = Pry::WrappedModule(mod).candidate(candidate_rank)
-        start_line ||= candidate.line
-        new(candidate.source, start_line, :ruby)
-      end
-    end
-
-    # @return [Symbol] The type of code stored in this wrapper.
-    attr_accessor :code_type
-
-    # Instantiate a `Code` object containing code from the given `Array`,
-    # `String`, or `IO`. The first line will be line 1 unless specified
-    # otherwise. If you need non-contiguous line numbers, you can create an
-    # empty `Code` object and then use `#push` to insert the lines.
-    #
-    # @param [Array<String>, String, IO] lines
-    # @param [Integer?] start_line
-    # @param [Symbol?] code_type
-    def initialize(lines = [], start_line = 1, code_type = :ruby)
-      lines = lines.lines if lines.is_a? String
-      @lines = lines.each_with_index.map do |line, lineno|
-        LOC.new(line, lineno + start_line.to_i)
-      end
-      @code_type = code_type
-
-      @with_marker = @with_indentation = @with_line_numbers = nil
-    end
-
-    # Append the given line. +lineno+ is one more than the last existing
-    # line, unless specified otherwise.
-    #
-    # @param [String] line
-    # @return [void]
-    def push(line)
-      line_number = @lines.any? ? @lines.last.lineno + 1 : 1
-      @lines.push(LOC.new(line, line_number))
-    end
-    alias << push
-
-    # Filter the lines using the given block.
-    #
-    # @yield [LOC]
-    # @return [Code]
-    def select(&block)
-      alter do
-        @lines = @lines.select(&block)
-      end
-    end
-
-    # Filter the lines using the given block.
-    #
-    # @yield [LOC]
-    # @return [Code]
-    def reject(&block)
-      alter do
-        @lines = @lines.reject(&block)
-      end
-    end
-
-    # Remove all lines that aren't in the given range, expressed either as a
-    # `Range` object or a first and last line number (inclusive). Negative
-    # indices count from the end of the array of lines.
-    #
-    # @param [Range, Integer] start_line
-    # @param [Integer?] end_line
-    # @return [Code]
-    def between(start_line, end_line = nil)
-      return self unless start_line
-
-      code_range = CodeRange.new(start_line, end_line)
-
-      alter do
-        @lines = @lines[code_range.indices_range(@lines)] || []
-      end
-    end
-
-    # Take `num_lines` from `start_line`, forward or backwards.
-    #
-    # @param [Integer] start_line
-    # @param [Integer] num_lines
-    # @return [Code]
-    def take_lines(start_line, num_lines)
-      start_idx =
-        if start_line >= 0
-          @lines.index { |loc| loc.lineno >= start_line } || @lines.length
-        else
-          [@lines.length + start_line, 0].max
-        end
-
-      alter do
-        @lines = @lines.slice(start_idx, num_lines)
-      end
-    end
-
-    # Remove all lines except for the +lines+ up to and excluding +lineno+.
-    #
-    # @param [Integer] lineno
-    # @param [Integer] lines
-    # @return [Code]
-    def before(lineno, lines = 1)
-      return self unless lineno
-
-      select do |loc|
-        loc.lineno >= lineno - lines && loc.lineno < lineno
-      end
-    end
-
-    # Remove all lines except for the +lines+ on either side of and including
-    # +lineno+.
-    #
-    # @param [Integer] lineno
-    # @param [Integer] lines
-    # @return [Code]
-    def around(lineno, lines = 1)
-      return self unless lineno
-
-      select do |loc|
-        loc.lineno >= lineno - lines && loc.lineno <= lineno + lines
-      end
-    end
-
-    # Remove all lines except for the +lines+ after and excluding +lineno+.
-    #
-    # @param [Integer] lineno
-    # @param [Integer] lines
-    # @return [Code]
-    def after(lineno, lines = 1)
-      return self unless lineno
-
-      select do |loc|
-        loc.lineno > lineno && loc.lineno <= lineno + lines
-      end
-    end
-
-    # Remove all lines that don't match the given `pattern`.
-    #
-    # @param [Regexp] pattern
-    # @return [Code]
-    def grep(pattern)
-      return self unless pattern
-
-      pattern = Regexp.new(pattern)
-
-      select do |loc|
-        loc.line =~ pattern
-      end
-    end
-
-    # Format output with line numbers next to it, unless `y_n` is falsy.
-    #
-    # @param [Boolean?] y_n
-    # @return [Code]
-    def with_line_numbers(y_n = true)
-      alter do
-        @with_line_numbers = y_n
-      end
-    end
-
-    # Format output with a marker next to the given +lineno+, unless +lineno+ is
-    # falsy.
-    #
-    # @param [Integer?] lineno
-    # @return [Code]
-    def with_marker(lineno = 1)
-      alter do
-        @with_marker   = !!lineno
-        @marker_lineno = lineno
-      end
-    end
-
-    # Format output with the specified number of spaces in front of every line,
-    # unless `spaces` is falsy.
-    #
-    # @param [Integer?] spaces
-    # @return [Code]
-    def with_indentation(spaces = 0)
-      alter do
-        @with_indentation = !!spaces
-        @indentation_num  = spaces
-      end
-    end
-
-    # @return [Integer] the number of digits in the last line.
-    def max_lineno_width
-      !@lines.empty? ? @lines.last.lineno.to_s.length : 0
-    end
-
-    # @return [String] a formatted representation (based on the configuration of
-    #   the object).
-    def to_s
-      print_to_output(''.dup, false)
-    end
-
-    # @return [String] a (possibly highlighted) copy of the source code.
-    def highlighted
-      print_to_output(''.dup, true)
-    end
-
-    # Writes a formatted representation (based on the configuration of the
-    # object) to the given output, which must respond to `#<<`.
-    def print_to_output(output, color = false)
-      @lines.each do |loc|
-        loc = loc.dup
-        loc.colorize(@code_type)              if color
-        loc.add_line_number(max_lineno_width, color) if @with_line_numbers
-        loc.add_marker(@marker_lineno)        if @with_marker
-        loc.indent(@indentation_num)          if @with_indentation
-        output << loc.line
-        output << "\n"
-      end
-      output
-    end
-
-    # Get the comment that describes the expression on the given line number.
-    #
-    # @param [Integer] line_number (1-based)
-    # @return [String] the code.
-    def comment_describing(line_number)
-      self.class.comment_describing(raw, line_number)
-    end
-
-    # Get the multiline expression that starts on the given line number.
-    #
-    # @param [Integer] line_number (1-based)
-    # @return [String] the code.
-    def expression_at(line_number, consume = 0)
-      self.class.expression_at(raw, line_number, consume: consume)
-    end
-
-    # Get the (approximate) Module.nesting at the give line number.
-    #
-    # @param [Integer] line_number line number starting from 1
-    # @return [Array<Module>] a list of open modules.
-    def nesting_at(line_number)
-      Pry::Indent.nesting_at(raw, line_number)
-    end
-
-    # Return an unformatted String of the code.
-    #
-    # @return [String]
-    def raw
-      @lines.map(&:line).join("\n") << "\n"
-    end
-
-    # Return the number of lines stored.
-    #
-    # @return [Integer]
-    def length
-      @lines ? @lines.length : 0
-    end
-
-    # Two `Code` objects are equal if they contain the same lines with the same
-    # numbers. Otherwise, call `to_s` and `chomp` and compare as Strings.
-    #
-    # @param [Code, Object] other
-    # @return [Boolean]
-    def ==(other)
-      if other.is_a?(Code)
-        other_lines = other.instance_variable_get(:@lines)
-        @lines.each_with_index.all? { |loc, i| loc == other_lines[i] }
-      else
-        to_s.chomp == other.to_s.chomp
-      end
-    end
-
-    # Forward any missing methods to the output of `#to_s`.
-    def method_missing(method_name, *args, &block)
-      if (string = to_s).respond_to?(method_name)
-        string.__send__(method_name, *args, &block)
-      else
-        super
-      end
-    end
-    undef =~
-
-    # Check whether String responds to missing methods.
-    def respond_to_missing?(method_name, include_private = false)
-      ''.respond_to?(method_name, include_private) || super
-    end
-
-    if RUBY_VERSION.start_with?('1.9')
-      # @todo This is needed for Ruby 1.9 support where `lines` return an
-      #   Enumerator. Newer Rubies return an Array
-      def lines
-        super.to_a
-      end
-    end
-
-    protected
-
-    # An abstraction of the `dup.instance_eval` pattern used throughout this
-    # class.
-    def alter(&block)
-      dup.tap { |o| o.instance_eval(&block) }
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/code_object.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  # This class is responsible for taking a string (identifying a
-  # command/class/method/etc) and returning the relevant type of object.
-  # For example, if the user looks up "show-source" then  a
-  # `Pry::Command` will be returned. Alternatively, if the user passes in "Pry#repl" then
-  # a `Pry::Method` object will be returned.
-  #
-  # The `CodeObject.lookup` method is responsible for 1. figuring out what kind of
-  # object the user wants (applying precedence rules in doing so -- i.e methods
-  # get precedence over commands with the same name) and 2. Returning
-  # the appropriate object. If the user fails to provide a string
-  # identifer for the object (i.e they pass in `nil` or "") then the
-  # object looked up will be the 'current method' or 'current class'
-  # associated with the Binding.
-  #
-  # TODO: This class is a clusterfuck. We need a much more robust
-  # concept of what a "Code Object" really is. Currently
-  # commands/classes/candidates/methods and so on just share a very
-  # ill-defined interface.
-  class CodeObject
-    module Helpers
-      # we need this helper as some Pry::Method objects can wrap Procs
-      # @return [Boolean]
-      def real_method_object?
-        is_a?(::Method) || is_a?(::UnboundMethod)
-      end
-
-      def c_method?
-        real_method_object? && source_type == :c
-      end
-
-      def module_with_yard_docs?
-        is_a?(WrappedModule) && yard_docs?
-      end
-
-      def command?
-        is_a?(Module) && self <= Pry::Command
-      end
-
-      # @return [Boolean] `true` if this module was defined by means of the C API,
-      #   `false` if it's a Ruby module.
-      # @note If a module defined by C was extended with a lot of methods written
-      #   in Ruby, this method would fail.
-      def c_module?
-        return unless is_a?(WrappedModule)
-
-        method_locations = wrapped.methods(false).map do |m|
-          wrapped.method(m).source_location
-        end
-
-        method_locations.concat(
-          wrapped.instance_methods(false).map do |m|
-            wrapped.instance_method(m).source_location
-          end
-        )
-
-        c_methods = method_locations.grep(nil).count
-        ruby_methods = method_locations.count - c_methods
-
-        c_methods > ruby_methods
-      end
-    end
-
-    include Pry::Helpers::CommandHelpers
-
-    class << self
-      def lookup(str, pry_instance, options = {})
-        co = new(str, pry_instance, options)
-
-        co.default_lookup || co.method_or_class_lookup ||
-          co.command_lookup || co.empty_lookup
-      end
-    end
-
-    attr_accessor :str
-    attr_accessor :target
-    attr_accessor :pry_instance
-    attr_accessor :super_level
-
-    def initialize(str, pry_instance, options = {})
-      options = {
-        super: 0
-      }.merge!(options)
-
-      @str = str
-      @pry_instance = pry_instance
-      @target = pry_instance.current_context
-      @super_level = options[:super]
-    end
-
-    # TODO: just make it so find_command_by_match_or_listing doesn't raise?
-    def command_lookup
-      pry_instance.commands.find_command_by_match_or_listing(str)
-    rescue StandardError
-      nil
-    end
-
-    # when no paramter is given (i.e CodeObject.lookup(nil)), then we
-    # lookup the 'current object' from the binding.
-    def empty_lookup
-      return nil if str && !str.empty?
-
-      obj = if internal_binding?(target)
-              mod = target_self.is_a?(Module) ? target_self : target_self.class
-              Pry::WrappedModule(mod)
-            else
-              Pry::Method.from_binding(target)
-            end
-
-      # respect the super level (i.e user might have specified a
-      # --super flag to show-source)
-      lookup_super(obj, super_level)
-    end
-
-    # lookup variables and constants and `self` that are not modules
-    def default_lookup
-      # we skip instance methods as we want those to fall through to
-      # method_or_class_lookup()
-      if safe_to_evaluate?(str) && !looks_like_an_instance_method?(str)
-        obj = target.eval(str)
-
-        # restrict to only objects we KNOW for sure support the full API
-        # Do NOT support just any object that responds to source_location
-        if sourcable_object?(obj)
-          Pry::Method(obj)
-        elsif !obj.is_a?(Module)
-          Pry::WrappedModule(obj.class)
-        end
-      end
-    rescue Pry::RescuableException
-      nil
-    end
-
-    def method_or_class_lookup
-      obj =
-        case str
-        when /\S+\(\)\z/
-          Pry::Method.from_str(str.sub(/\(\)\z/, ''), target) ||
-          Pry::WrappedModule.from_str(str, target)
-        else
-          Pry::WrappedModule.from_str(str, target) ||
-          Pry::Method.from_str(str, target)
-        end
-
-      lookup_super(obj, super_level)
-    end
-
-    private
-
-    def sourcable_object?(obj)
-      [::Proc, ::Method, ::UnboundMethod].any? { |o| obj.is_a?(o) }
-    end
-
-    # Returns true if `str` looks like a method, i.e Klass#method
-    # We need to consider this case because method lookups should fall
-    # through to the `method_or_class_lookup()` method but a
-    # defined?() on a "Klass#method` string will see the `#` as a
-    # comment and only evaluate the `Klass` part.
-    # @param [String] str
-    # @return [Boolean] Whether the string looks like an instance method.
-    def looks_like_an_instance_method?(str)
-      str =~ /\S#\S/
-    end
-
-    # We use this method to decide whether code is safe to eval. Method's are
-    # generally not, but everything else is.
-    # TODO: is just checking != "method" enough??
-    # TODO: see duplication of this method in Pry::WrappedModule
-    # @param [String] str The string to lookup
-    # @return [Boolean]
-    def safe_to_evaluate?(str)
-      return true if str.strip == "self"
-      return false if str =~ /%/
-
-      kind = target.eval("defined?(#{str})")
-      kind =~ /variable|constant/
-    end
-
-    def target_self
-      target.eval('self')
-    end
-
-    # grab the nth (`super_level`) super of `obj
-    # @param [Object] obj
-    # @param [Fixnum] super_level How far up the super chain to ascend.
-    def lookup_super(obj, super_level)
-      return unless obj
-
-      sup = obj.super(super_level)
-      raise Pry::CommandError, "No superclass found for #{obj.wrapped}" unless sup
-
-      sup
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/color_printer.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'pp'
-require 'English'
-
-class Pry
-  # PP subclass for streaming inspect output in color.
-  class ColorPrinter < ::PP
-    Pry::SyntaxHighlighter.overwrite_coderay_comment_token!
-
-    def self.default(_output, value, pry_instance)
-      pry_instance.pager.open do |pager|
-        pager.print pry_instance.config.output_prefix
-        pp(value, pager, pry_instance.output.width - 1)
-      end
-    end
-
-    def self.pp(obj, output = $DEFAULT_OUTPUT, max_width = 79)
-      queue = ColorPrinter.new(output, max_width, "\n")
-      queue.guard_inspect_key { queue.pp(obj) }
-      queue.flush
-      output << "\n"
-    end
-
-    def pp(object)
-      return super unless object.is_a?(String)
-
-      # Avoid calling Ruby 2.4+ String#pretty_print that prints multiline
-      # Strings prettier
-      text(object.inspect)
-    rescue StandardError => exception
-      raise if exception.is_a?(Pry::Pager::StopPaging)
-
-      text(highlight_object_literal(inspect_object(object)))
-    end
-
-    def text(str, max_width = str.length)
-      if str.include?("\e[")
-        super("#{str}\e[0m", max_width)
-      elsif str.start_with?('#<') || %w[= >].include?(str)
-        super(highlight_object_literal(str), max_width)
-      else
-        super(SyntaxHighlighter.highlight(str), max_width)
-      end
-    end
-
-    private
-
-    def highlight_object_literal(object_literal)
-      code = Pry::SyntaxHighlighter.keyword_token_color
-      obj_color = code.start_with?("\e") ? code : "\e[0m\e[0;#{code}m"
-      "#{obj_color}#{object_literal}\e[0m"
-    end
-
-    def inspect_object(object)
-      object.inspect
-    rescue StandardError
-      # Read the class name off of the singleton class to provide a default
-      # inspect.
-      singleton = class << object; self; end
-      ancestors = Pry::Method.safe_send(singleton, :ancestors)
-      klass = ancestors.find { |k| k != singleton }
-      "#<#{klass}:0x#{object.__id__.to_s(16)}>"
-    end
-  end
-end