primary_connect_proto 0.12.1 → 0.14.0

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/commands/find_method.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class FindMethod < Pry::ClassCommand
-      extend Pry::Helpers::BaseHelpers
-
-      match 'find-method'
-      group 'Context'
-      description 'Recursively search for a method within a Class/Module or ' \
-                  'the current namespace.'
-      command_options shellwords: false
-
-      banner <<-'BANNER'
-        Usage: find-method  [-n|-c] METHOD [NAMESPACE]
-
-        Recursively search for a method within a Class/Module or the current namespace.
-        Use the `-n` switch (the default) to search for methods whose name matches the
-        given regex. Use the `-c` switch to search for methods that contain the given
-        code.
-
-        # Find all methods whose name match /re/ inside
-        # the Pry namespace. Matches Pry#repl, etc.
-        find-method re Pry
-
-        # Find all methods that contain the code:
-        # output.puts inside the Pry namespace.
-        find-method -c 'output.puts' Pry
-      BANNER
-
-      def options(opt)
-        opt.on :n, :name,    "Search for a method by name"
-        opt.on :c, :content, "Search for a method based on content in Regex form"
-      end
-
-      def process
-        return if args.empty?
-
-        klass = search_class
-
-        matches = opts.content? ? content_search(klass) : name_search(klass)
-        show_search_results(matches)
-      end
-
-      private
-
-      # @return [Regexp] The pattern to search for.
-      def pattern
-        @pattern ||= ::Regexp.new args[0]
-      end
-
-      # Output the result of the search.
-      #
-      # @param [Array] matches
-      def show_search_results(matches)
-        if matches.empty?
-          output.puts bold("No Methods Matched")
-        else
-          print_matches(matches)
-        end
-      end
-
-      # The class to search for methods.
-      # We only search classes, so if the search object is an
-      # instance, return its class. If no search object is given
-      # search `target_self`.
-      def search_class
-        klass = if args[1]
-                  target.eval(args[1])
-                else
-                  target_self
-                end
-
-        klass.is_a?(Module) ? klass : klass.class
-      end
-
-      # pretty-print a list of matching methods.
-      #
-      # @param [Array<Method>] matches
-      def print_matches(matches)
-        grouped = matches.group_by(&:owner)
-        order = grouped.keys.sort_by { |x| x.name || x.to_s }
-
-        order.each do |klass|
-          print_matches_for_class(klass, grouped)
-        end
-      end
-
-      # Print matched methods for a class
-      def print_matches_for_class(klass, grouped)
-        output.puts bold(klass.name)
-        grouped[klass].each do |method|
-          header = method.name_with_owner
-          output.puts header + additional_info(header, method)
-        end
-      end
-
-      # Return the matched lines of method source if `-c` is given or ""
-      # if `-c` was not given
-      def additional_info(header, method)
-        if opts.content?
-          ': ' + colorize_code(matched_method_lines(header, method))
-        else
-          ""
-        end
-      end
-
-      def matched_method_lines(header, method)
-        method.source.split(/\n/).select { |x| x =~ pattern }.join(
-          "\n#{' ' * header.length}"
-        )
-      end
-
-      # Run the given block against every constant in the provided namespace.
-      #
-      # @param [Module] klass The namespace in which to start the search.
-      # @param [Hash<Module,Boolean>] done The namespaces we've already visited (private)
-      # @yieldparam klass Each class/module in the namespace.
-      #
-      def recurse_namespace(klass, done = {}, &block)
-        return if !klass.is_a?(Module) || done[klass]
-
-        done[klass] = true
-
-        yield klass
-
-        klass.constants.each do |name|
-          next if klass.autoload?(name)
-
-          begin
-            const = klass.const_get(name)
-          rescue RescuableException # rubocop:disable Lint/HandleExceptions
-            # constant loading is an inexact science at the best of times,
-            # this often happens when a constant was .autoload? but someone
-            # tried to load it. It's now not .autoload? but will still raise
-            # a NameError when you access it.
-          else
-            recurse_namespace(const, done, &block)
-          end
-        end
-      end
-
-      # Gather all the methods in a namespace that pass the given block.
-      #
-      # @param [Module] namespace The namespace in which to search.
-      # @yieldparam [Method] method The method to test
-      # @yieldreturn [Boolean]
-      # @return [Array<Method>]
-      #
-      def search_all_methods(namespace)
-        done = Hash.new { |h, k| h[k] = {} }
-        matches = []
-
-        recurse_namespace(namespace) do |klass|
-          methods = Pry::Method.all_from_class(klass) + Pry::Method.all_from_obj(klass)
-          methods.each do |method|
-            next if done[method.owner][method.name]
-
-            done[method.owner][method.name] = true
-
-            matches << method if yield method
-          end
-        end
-
-        matches
-      end
-
-      # Search for all methods with a name that matches the given regex
-      # within a namespace.
-      #
-      # @param [Module] namespace The namespace to search
-      # @return [Array<Method>]
-      #
-      def name_search(namespace)
-        search_all_methods(namespace) do |meth|
-          meth.name =~ pattern
-        end
-      end
-
-      # Search for all methods who's implementation matches the given regex
-      # within a namespace.
-      #
-      # @param [Module] namespace The namespace to search
-      # @return [Array<Method>]
-      #
-      def content_search(namespace)
-        search_all_methods(namespace) do |meth|
-          begin
-            meth.source =~ pattern
-          rescue RescuableException
-            false
-          end
-        end
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::FindMethod)
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/commands/fix_indent.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class FixIndent < Pry::ClassCommand
-      match 'fix-indent'
-      group 'Input and Output'
-
-      description "Correct the indentation for contents of the input buffer"
-
-      banner <<-USAGE
-        Usage: fix-indent
-      USAGE
-
-      def process
-        indented_str = Pry::Indent.indent(eval_string)
-        pry_instance.eval_string = indented_str
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::FixIndent)
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/commands/help.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class Help < Pry::ClassCommand
-      match 'help'
-      group 'Help'
-      description 'Show a list of commands or information about a specific command.'
-
-      banner <<-'BANNER'
-        Usage: help [COMMAND]
-
-        With no arguments, help lists all the available commands along with their
-        descriptions. When given a command name as an argument, shows the help
-        for that command.
-      BANNER
-
-      # We only want to show commands that have descriptions, so that the
-      # easter eggs don't show up.
-      def visible_commands
-        visible = {}
-        commands.each do |key, command|
-          visible[key] = command if command.description && !command.description.empty?
-        end
-        visible
-      end
-
-      # Get a hash of available commands grouped by the "group" name.
-      def command_groups
-        visible_commands.values.group_by(&:group)
-      end
-
-      def process
-        if args.empty?
-          display_index(command_groups)
-        else
-          display_search(args.first)
-        end
-      end
-
-      # Display the index view, with headings and short descriptions per command.
-      #
-      # @param [Hash<String, Array<Commands>>] groups
-      def display_index(groups)
-        help_text = []
-
-        sorted_group_names(groups).each do |group_name|
-          commands = sorted_commands(groups[group_name])
-
-          help_text << help_text_for_commands(group_name, commands) if commands.any?
-        end
-
-        pry_instance.pager.page help_text.join("\n\n")
-      end
-
-      # Given a group name and an array of commands,
-      # return the help string for those commands.
-      #
-      # @param [String] name The group name.
-      # @param [Array<Pry::Command>] commands
-      # @return [String] The generated help string.
-      def help_text_for_commands(name, commands)
-        "#{bold(name.capitalize)}\n" + commands.map do |command|
-          "  #{command.options[:listing].to_s.ljust(18)} " \
-          "#{command.description.capitalize}"
-        end.join("\n")
-      end
-
-      # @param [Hash] groups
-      # @return [Array<String>] An array of sorted group names.
-      def sorted_group_names(groups)
-        groups.keys.sort_by(&method(:group_sort_key))
-      end
-
-      # Sort an array of commands by their `listing` name.
-      #
-      # @param [Array<Pry::Command>] commands The commands to sort
-      # @return [Array<Pry::Command>] commands sorted by listing name.
-      def sorted_commands(commands)
-        commands.sort_by { |command| command.options[:listing].to_s }
-      end
-
-      # Display help for an individual command or group.
-      #
-      # @param [String] search  The string to search for.
-      def display_search(search)
-        if (command = command_set.find_command_for_help(search))
-          display_command(command)
-        else
-          display_filtered_search_results(search)
-        end
-      end
-
-      # Display help for a searched item, filtered first by group
-      # and if that fails, filtered by command name.
-      #
-      # @param [String] search The string to search for.
-      def display_filtered_search_results(search)
-        groups = search_hash(search, command_groups)
-
-        if !groups.empty?
-          display_index(groups)
-        else
-          display_filtered_commands(search)
-        end
-      end
-
-      # Display help for a searched item, filtered by group
-      #
-      # @param [String] search The string to search for.
-      def display_filtered_commands(search)
-        filtered = search_hash(search, visible_commands)
-        raise CommandError, "No help found for '#{args.first}'" if filtered.empty?
-
-        if filtered.size == 1
-          display_command(filtered.values.first)
-        else
-          display_index("'#{search}' commands" => filtered.values)
-        end
-      end
-
-      # Display help for an individual command.
-      #
-      # @param [Pry::Command] command
-      def display_command(command)
-        pry_instance.pager.page command.new.help
-      end
-
-      # Find a subset of a hash that matches the user's search term.
-      #
-      # If there's an exact match a Hash of one element will be returned,
-      # otherwise a sub-Hash with every key that matches the search will
-      # be returned.
-      #
-      # @param [String] search the search term
-      # @param [Hash] hash the hash to search
-      def search_hash(search, hash)
-        matching = {}
-
-        hash.each_pair do |key, value|
-          next unless key.is_a?(String)
-          return { key => value } if normalize(key) == normalize(search)
-          next unless normalize(key).start_with?(normalize(search))
-
-          matching[key] = value
-        end
-
-        matching
-      end
-
-      # Clean search terms to make it easier to search group names
-      #
-      # @param [String] key
-      # @return [String]
-      def normalize(key)
-        key.downcase.gsub(/pry\W+/, '')
-      end
-
-      def group_sort_key(group_name)
-        [
-          %w[
-            Help Context Editing Introspection Input_and_output Navigating_pry
-            Gems Basic Commands
-          ].index(group_name.tr(' ', '_')) || 99, group_name
-        ]
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::Help)
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/commands/hist.rb

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class Hist < Pry::ClassCommand
-      match 'hist'
-      group 'Editing'
-      description 'Show and replay Readline history.'
-
-      banner <<-'BANNER'
-        Usage:   hist [--head|--tail]
-                 hist --all
-                 hist --head N
-                 hist --tail N
-                 hist --show START..END
-                 hist --grep PATTERN
-                 hist --clear
-                 hist --replay START..END
-                 hist --save [START..END] FILE
-        Aliases: history
-
-        Show and replay Readline history.
-      BANNER
-
-      def options(opt)
-        opt.on :a, :all, "Display all history"
-        opt.on :H, :head, "Display the first N items",
-               optional_argument: true, as: Integer
-        opt.on :T, :tail, "Display the last N items",
-               optional_argument: true, as: Integer
-        opt.on :s, :show, "Show the given range of lines",
-               optional_argument: true, as: Range
-        opt.on :G, :grep, "Show lines matching the given pattern",
-               argument: true, as: String
-        opt.on :c, :clear, "Clear the current session's history"
-        opt.on :r, :replay, "Replay a line or range of lines",
-               argument: true, as: Range
-        opt.on :save, "Save history to a file", argument: true, as: Range
-        opt.on :e, :'exclude-pry', "Exclude Pry commands from the history"
-        opt.on :n, :'no-numbers',  "Omit line numbers"
-      end
-
-      def process
-        @history = find_history
-
-        @history = @history.between(opts[:show]) if opts.present?(:show)
-
-        @history = @history.grep(opts[:grep]) if opts.present?(:grep)
-
-        @history =
-          if opts.present?(:head)
-            @history.take_lines(1, opts[:head] || 10)
-          elsif opts.present?(:tail)
-            @history.take_lines(-(opts[:tail] || 10), opts[:tail] || 10)
-          else
-            @history
-          end
-
-        if opts.present?(:'exclude-pry')
-          @history = @history.reject do |loc|
-            command_set.valid_command?(loc.line)
-          end
-        end
-
-        if opts.present?(:save)
-          process_save
-        elsif opts.present?(:clear)
-          process_clear
-        elsif opts.present?(:replay)
-          process_replay
-        else
-          process_display
-        end
-      end
-
-      private
-
-      def process_display
-        @history = @history.with_line_numbers unless opts.present?(:'no-numbers')
-
-        pry_instance.pager.open do |pager|
-          @history.print_to_output(pager, true)
-        end
-      end
-
-      def process_save
-        case opts[:save]
-        when Range
-          @history = @history.between(opts[:save])
-
-          raise CommandError, "Must provide a file name." unless args.first
-
-          file_name = File.expand_path(args.first)
-        when String
-          file_name = File.expand_path(opts[:save])
-        end
-
-        output.puts "Saving history in #{file_name}..."
-
-        File.open(file_name, 'w') { |f| f.write(@history.raw) }
-
-        output.puts "History saved."
-      end
-
-      def process_clear
-        Pry.history.clear
-        output.puts "History cleared."
-      end
-
-      def process_replay
-        @history = @history.between(opts[:r])
-        replay_sequence = @history.raw
-
-        # If we met follow-up "hist" call, check for the "--replay" option
-        # presence. If "hist" command is called with other options, proceed
-        # further.
-        check_for_juxtaposed_replay(replay_sequence)
-
-        replay_sequence.lines.each do |line|
-          pry_instance.eval line, generated: true
-        end
-      end
-
-      # Checks +replay_sequence+ for the presence of neighboring replay calls.
-      # @example
-      #   [1] pry(main)> hist --show 46894
-      #   46894: hist --replay 46675..46677
-      #   [2] pry(main)> hist --show 46675..46677
-      #   46675: 1+1
-      #   46676: a = 100
-      #   46677: hist --tail
-      #   [3] pry(main)> hist --replay 46894
-      #   Error: Replay index 46894 points out to another replay call:
-      #   `hist -r 46675..46677`
-      #   [4] pry(main)>
-      #
-      # @raise [Pry::CommandError] If +replay_sequence+ contains another
-      #   "hist --replay" call
-      # @param [String] replay_sequence The sequence of commands to be replayed
-      #   (per saltum)
-      # @return [Boolean] `false` if +replay_sequence+ does not contain another
-      #   "hist --replay" call
-      def check_for_juxtaposed_replay(replay_sequence)
-        if replay_sequence =~ /\Ahist(?:ory)?\b/
-          # Create *fresh* instance of Options for parsing of "hist" command.
-          slop_instance = slop
-          slop_instance.parse(replay_sequence.split(' ')[1..-1])
-
-          if slop_instance.present?(:r)
-            replay_sequence = replay_sequence.split("\n").join('; ')
-            index = opts[:r]
-            index = index.min if index.min == index.max || index.max.nil?
-
-            raise CommandError,
-                  "Replay index #{index} points out to another replay call: " \
-                  "`#{replay_sequence}`"
-          end
-        else
-          false
-        end
-      end
-
-      # Finds history depending on the given switch.
-      #
-      # @return [Pry::Code] if it finds `--all` (or `-a`) switch, returns all
-      #   entries in history. Without the switch returns only the entries from the
-      #   current Pry session.
-      def find_history
-        h = if opts.present?(:all)
-              Pry.history.to_a
-            else
-              Pry.history.to_a.last(Pry.history.session_line_count)
-            end
-
-        Pry::Code(Pry.history.filter(h[0..-2]))
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::Hist)
-    Pry::Commands.alias_command 'history', 'hist'
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/commands/import_set.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class ImportSet < Pry::ClassCommand
-      match 'import-set'
-      group 'Commands'
-      # TODO: Provide a better description with examples and a general conception
-      # of this command.
-      description 'Import a Pry command set.'
-
-      banner <<-'BANNER'
-        Import a Pry command set.
-      BANNER
-
-      # TODO: resolve unused parameter.
-      def process(_command_set_name)
-        raise CommandError, "Provide a command set name" if command_set.nil?
-
-        set = target.eval(arg_string)
-        pry_instance.commands.import set
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::ImportSet)
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/commands/jump_to.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class JumpTo < Pry::ClassCommand
-      match 'jump-to'
-      group 'Navigating Pry'
-      description 'Jump to a binding further up the stack.'
-
-      banner <<-'BANNER'
-        Jump to a binding further up the stack, popping all bindings below.
-      BANNER
-
-      def process(break_level)
-        break_level    = break_level.to_i
-        nesting_level  = pry_instance.binding_stack.size - 1
-        max_nest_level = nesting_level - 1
-
-        case break_level
-        when nesting_level
-          output.puts "Already at nesting level #{nesting_level}"
-        when 0..max_nest_level
-          pry_instance.binding_stack = pry_instance.binding_stack[0..break_level]
-        else
-          output.puts "Invalid nest level. Must be between 0 and " \
-            "#{max_nest_level}. Got #{break_level}."
-        end
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::JumpTo)
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/commands/list_inspectors.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class ListInspectors < Pry::ClassCommand
-      match 'list-inspectors'
-      group 'Input and Output'
-      description 'List the inspector procs available for use.'
-      banner <<-BANNER
-        Usage: list-inspectors
-
-        List the inspector procs available to print return values. You can use
-        change-inspector to switch between them.
-      BANNER
-
-      def process
-        output.puts heading("Available inspectors") + "\n"
-        inspector_map.each do |name, inspector|
-          output.write "Name: #{bold(name)}"
-          output.puts selected_inspector?(inspector) ? selected_text : ""
-          output.puts inspector[:description]
-          output.puts
-        end
-      end
-
-      private
-
-      def inspector_map
-        Pry::Inspector::MAP
-      end
-
-      def selected_text
-        red " (selected) "
-      end
-
-      def selected_inspector?(inspector)
-        pry_instance.print == inspector[:value]
-      end
-      Pry::Commands.add_command(self)
-    end
-  end
-end