primary_connect_proto 0.9.0 → 0.11.0

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-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.unrescued_exceptions
-        false
-        # All other exceptions will be caught.
-      else
-        true
-      end
-    end
-  end
-
-  # Catches SecurityErrors if $SAFE is set
-  module TooSafeException
-    def self.===(exception)
-      if Pry::HAS_SAFE_LEVEL
-        $SAFE > 0 && exception.is_a?(SecurityError)
-      else
-        exception.is_a?(SecurityError)
-      end
-    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
-
-  # 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
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  module Forwardable
-    require 'forwardable'
-    include ::Forwardable
-
-    #
-    # Since Ruby 2.4, Forwardable will print a warning when
-    # calling a method that is private on a delegate, and
-    # in the future it could be an error: https://bugs.ruby-lang.org/issues/12782#note-3
-    #
-    # That's why we revert to a custom implementation for delegating one
-    # private method to another.
-    #
-    def def_private_delegators(target, *private_delegates)
-      private_delegates.each do |private_delegate|
-        define_method(private_delegate) do |*a, &b|
-          instance_variable_get(target).__send__(private_delegate, *a, &b)
-        end
-      end
-      class_eval do
-        private(*private_delegates) # rubocop:disable Style/AccessModifierDeclarations
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  module Helpers
-    module BaseHelpers
-      extend self
-
-      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)
-        (obj.is_a?(Module) ? Module : Object).instance_method(method)
-          .bind(obj).call(*args, &block)
-      end
-
-      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 use_ansi_codes?
-        Pry::Helpers::Platform.windows_ansi? ||
-          ((term = Pry::Env['TERM']) && term != "dumb")
-      end
-
-      def colorize_code(code)
-        SyntaxHighlighter.highlight(code)
-      end
-
-      def highlight(string, regexp, highlight_color = :bright_yellow)
-        string.gsub(regexp) do |match|
-          "<#{highlight_color}>#{match}</#{highlight_color}>"
-        end
-      end
-
-      # formatting
-      def heading(text)
-        text = "#{text}\n--"
-        "\e[1m#{text}\e[0m"
-      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)
-        if defined?(pry_instance) && pry_instance
-          pry_instance.pager.page text
-        else
-          Pry.new.pager.page text
-        end
-      end
-    end
-  end
-end

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

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require 'tempfile'
-
-class Pry
-  module Helpers
-    module CommandHelpers
-      include OptionsHelpers
-
-      extend self
-
-      # 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)
-      end
-
-      def internal_binding?(context)
-        method_name = context.eval("::Kernel.__method__").to_s
-        # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
-        %w[__binding__ __pry__ class_eval].include?(method_name)
-        # TODO: codehaus is dead, there was no test for this and the
-        # description for the commit doesn't exist. Probably a candidate for
-        # removal so we have a chance to introduce a regression and document it
-        # properly.
-      end
-
-      def get_method_or_raise(method_name, context, opts = {})
-        method = Pry::Method.from_str(method_name, context, opts)
-        if !method && method_name
-          raise Pry::MethodNotFound, "method '#{method_name}' could not be found."
-        end
-
-        (opts[:super] || 0).times do
-          if method.super
-            method = method.super
-          else
-            raise Pry::MethodNotFound,
-                  "'#{method.name_with_owner}' has no super method"
-          end
-        end
-
-        if !method || (!method_name && internal_binding?(context))
-          raise Pry::MethodNotFound,
-                'no method name given, and context is not a method'
-        end
-
-        set_file_and_dir_locals(method.source_file)
-        method
-      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.
-      #
-      # @example
-      #   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
-      #
-      # @param [String] dirty_text The text from which to remove indentation
-      # @return [String] the text with indentation stripped
-      def unindent(dirty_text, left_padding = 0)
-        text = dirty_text.sub(/\A[ \t]+\z/, '') # Empty blank lines.
-
-        # 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.
-        scanned_text = text.scan(/^[ \t]*(?!--\n|\+\+\n)(?=[^ \t\n])/)
-        margin = scanned_text.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, Integer] 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)
-        line_number > 0 ? line_number - 1 : line_number
-      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_instance, ctx = target)
-        return if !ctx || !file_name
-
-        pry.last_file = File.expand_path(file_name)
-        pry.inject_local("_file_", pry.last_file, ctx)
-
-        pry.last_dir = File.dirname(pry.last_file)
-        pry.inject_local("_dir_", pry.last_dir, ctx)
-      end
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  module Helpers
-    # This class contains methods useful for extracting
-    # documentation from methods and classes.
-    module DocumentationHelpers
-      YARD_TAGS = %w[
-        param return option yield attr attr_reader attr_writer deprecate example
-        raise
-      ].freeze
-
-      module_function
-
-      def process_rdoc(comment)
-        comment = comment.dup
-        last_match_ruby = proc do
-          SyntaxHighlighter.highlight(Regexp.last_match(1))
-        end
-        comment.gsub(%r{<code>(?:\s*\n)?(.*?)\s*</code>}m, &last_match_ruby)
-          .gsub(%r{<em>(?:\s*\n)?(.*?)\s*</em>}m) { "\e[1m#{Regexp.last_match(1)}\e[0m" }
-          .gsub(%r{<i>(?:\s*\n)?(.*?)\s*</i>}m) { "\e[1m#{Regexp.last_match(1)}\e[0m" }
-          .gsub(%r{<tt>(?:\s*\n)?(.*?)\s*</tt>}m, &last_match_ruby)
-          .gsub(/\B\+(\w+?)\+\B/) { "\e[32m#{Regexp.last_match(1)}\e[0m" }
-          .gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/, &last_match_ruby)
-          .gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{last_match_ruby.call}`" }
-      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 - %w[example])
-          .inject(comment) { |a, v| process_yardoc_tag(a, v) }
-          .gsub(/^@(#{YARD_TAGS.join("|")})/) { "\e[33m#{Regexp.last_match(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(%r{\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

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  module Helpers
-    module OptionsHelpers
-      module_function
-
-      # Add method options to the Pry::Slop instance
-      def method_options(opt)
-        @method_target = target
-        opt.on :M, "instance-methods", "Operate on instance methods."
-        opt.on :m, :methods, "Operate on methods."
-        opt.on :s, :super, "Select the 'super' method. Can be repeated to " \
-                           "traverse the ancestors.", as: :count
-        opt.on(
-          :c, :context, "Select object context to run under.", argument: true
-        ) do |context|
-          @method_target = Pry.binding_for(target.eval(context))
-        end
-      end
-
-      # Get the method object parsed by the slop instance
-      def method_object
-        @method_object ||= get_method_or_raise(
-          args.empty? ? nil : args.join(" "),
-          @method_target,
-          super: opts[:super],
-          instance: opts.present?(:'instance-methods') && !opts.present?(:methods),
-          methods: opts.present?(:methods) && !opts.present?(:'instance-methods')
-        )
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'rbconfig'
-
-class Pry
-  module Helpers
-    # Contains methods for querying the platform that Pry is running on
-    # @api public
-    # @since v0.12.0
-    module Platform
-      # @return [Boolean]
-      def self.mac_osx?
-        !!(RbConfig::CONFIG['host_os'] =~ /\Adarwin/i)
-      end
-
-      # @return [Boolean]
-      def self.linux?
-        !!(RbConfig::CONFIG['host_os'] =~ /linux/i)
-      end
-
-      # @return [Boolean] true when Pry is running on Windows with ANSI support,
-      #   false otherwise
-      def self.windows?
-        !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/)
-      end
-
-      # @return [Boolean]
-      def self.windows_ansi?
-        return false unless windows?
-
-        !!(defined?(Win32::Console) || Pry::Env['ANSICON'] || mri_2?)
-      end
-
-      # @return [Boolean]
-      def self.jruby?
-        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
-      end
-
-      # @return [Boolean]
-      def self.jruby_19?
-        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
-      end
-
-      # @return [Boolean]
-      def self.mri?
-        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
-      end
-
-      # @return [Boolean]
-      def self.mri_19?
-        mri? && RUBY_VERSION.start_with?('1.9')
-      end
-
-      # @return [Boolean]
-      def self.mri_2?
-        mri? && RUBY_VERSION.start_with?('2')
-      end
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  module Helpers
-    def self.tablify_or_one_line(heading, things, pry_instance = Pry.new)
-      plain_heading = Pry::Helpers::Text.strip_color(heading)
-      attempt = Table.new(things, column_count: things.size)
-      if attempt.fits_on_line?(pry_instance.output.width - plain_heading.size - 2)
-        "#{heading}: #{attempt}\n"
-      else
-        content = tablify_to_screen_width(things, { indent: '  ' }, pry_instance)
-        "#{heading}: \n#{content}\n"
-      end
-    end
-
-    def self.tablify_to_screen_width(things, options, pry_instance = Pry.new)
-      options ||= {}
-      things = things.compact
-      if (indent = options[:indent])
-        usable_width = pry_instance.output.width - indent.size
-        tablify(things, usable_width, pry_instance).to_s.gsub(/^/, indent)
-      else
-        tablify(things, pry_instance.output.width, pry_instance).to_s
-      end
-    end
-
-    def self.tablify(things, line_length, pry_instance = Pry.new)
-      table = Table.new(things, { column_count: things.size }, pry_instance)
-      until (table.column_count == 1) || table.fits_on_line?(line_length)
-        table.column_count -= 1
-      end
-      table
-    end
-
-    class Table
-      attr_reader :items, :column_count
-      def initialize(items, args, pry_instance = Pry.new)
-        @column_count = args[:column_count]
-        @config = pry_instance.config
-        self.items = items
-      end
-
-      def to_s
-        rows_to_s.join("\n")
-      end
-
-      def rows_to_s(style = :color_on)
-        widths = columns.map { |e| _max_width(e) }
-        @rows_without_colors.map do |r|
-          padded = []
-          r.each_with_index do |e, i|
-            next unless e
-
-            item = e.ljust(widths[i])
-            item.sub! e, _recall_color_for(e) if style == :color_on
-            padded << item
-          end
-          padded.join(@config.ls.separator)
-        end
-      end
-
-      def items=(items)
-        @items = items
-        _rebuild_colorless_cache
-        _recolumn
-      end
-
-      def column_count=(count)
-        @column_count = count
-        _recolumn
-      end
-
-      def fits_on_line?(line_length)
-        _max_width(rows_to_s(:no_color)) <= line_length
-      end
-
-      def columns
-        @rows_without_colors.transpose
-      end
-
-      def ==(other)
-        items == other.to_a
-      end
-
-      def to_a
-        items.to_a
-      end
-
-      private
-
-      def _max_width(things)
-        things.compact.map(&:size).max || 0
-      end
-
-      def _rebuild_colorless_cache
-        @colorless_cache = {}
-        @plain_items = []
-        items.map do |e|
-          plain = Pry::Helpers::Text.strip_color(e)
-          @colorless_cache[plain] = e
-          @plain_items << plain
-        end
-      end
-
-      def _recolumn
-        @rows_without_colors = []
-        return if items.size.zero?
-
-        row_count = (items.size.to_f / column_count).ceil
-        row_count.times do |i|
-          row_indices = (0...column_count).map { |e| row_count * e + i }
-          @rows_without_colors << row_indices.map { |e| @plain_items[e] }
-        end
-      end
-
-      def _recall_color_for(thing)
-        @colorless_cache[thing]
-      end
-    end
-  end
-end