primary_connect_proto 0.12.1 → 0.14.0

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

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  # A super-class of Commands with structure.
-  #
-  # This class implements the bare-minimum functionality that a command should
-  # have, namely a --help switch, and then delegates actual processing to its
-  # subclasses.
-  #
-  # Create subclasses using {Pry::CommandSet#create_command}, and override the
-  # `options(opt)` method to set up an instance of Pry::Slop, and the `process`
-  # method to actually run the command. If necessary, you can also override
-  # `setup` which will be called before `options`, for example to require any
-  # gems your command needs to run, or to set up state.
-  class ClassCommand < Command
-    class << self
-      # Ensure that subclasses inherit the options, description and
-      # match from a ClassCommand super class.
-      def inherited(klass)
-        klass.match match
-        klass.description description
-        klass.command_options options
-      end
-
-      def source
-        source_object.source
-      end
-
-      def doc
-        new.help
-      end
-
-      def source_location
-        source_object.source_location
-      end
-
-      def source_file
-        source_object.source_file
-      end
-      alias file source_file
-
-      def source_line
-        source_object.source_line
-      end
-      alias line source_line
-
-      private
-
-      # The object used to extract the source for the command.
-      #
-      # This should be a `Pry::Method(block)` for a command made with `create_command`
-      # and a `Pry::WrappedModule(self)` for a command that's a standard class.
-      # @return [Pry::WrappedModule, Pry::Method]
-      def source_object
-        @source_object ||= if name =~ /^[A-Z]/
-                             Pry::WrappedModule(self)
-                           else
-                             Pry::Method(block)
-                           end
-      end
-    end
-
-    attr_accessor :opts
-    attr_accessor :args
-
-    # Set up `opts` and `args`, and then call `process`.
-    #
-    # This method will display help if necessary.
-    #
-    # @param [Array<String>] args The arguments passed
-    # @return [Object] The return value of `process` or VOID_VALUE
-    def call(*args)
-      setup
-
-      self.opts = slop
-      self.args = opts.parse!(args)
-
-      if opts.present?(:help)
-        output.puts slop.help
-        void
-      else
-        process(*normalize_method_args(method(:process), args))
-      end
-    end
-
-    # Return the help generated by Pry::Slop for this command.
-    def help
-      slop.help
-    end
-
-    # Return an instance of Pry::Slop that can parse either subcommands or the
-    # options that this command accepts.
-    def slop
-      Pry::Slop.new do |opt|
-        opt.banner(unindent(self.class.banner))
-        subcommands(opt)
-        options(opt)
-        opt.on :h, :help, 'Show this message.'
-      end
-    end
-
-    # Generate shell completions
-    # @param [String] search  The line typed so far
-    # @return [Array<String>]  the words to complete
-    def complete(search)
-      slop.flat_map do |opt|
-        [opt.long && "--#{opt.long} " || opt.short && "-#{opt.short}"]
-      end.compact + super
-    end
-
-    # A method called just before `options(opt)` as part of `call`.
-    #
-    # This method can be used to set up any context your command needs to run,
-    # for example requiring gems, or setting default values for options.
-    #
-    # @example
-    #   def setup
-    #     require 'gist'
-    #     @action = :method
-    #   end
-    def setup; end
-
-    # A method to setup Pry::Slop commands so it can parse the subcommands your
-    # command expects. If you need to set up default values, use `setup`
-    # instead.
-    #
-    # @example A minimal example
-    #   def subcommands(cmd)
-    #     cmd.command :download do |opt|
-    #       description 'Downloads a content from a server'
-    #
-    #       opt.on :verbose, 'Use verbose output'
-    #
-    #       run do |options, arguments|
-    #         ContentDownloader.download(options, arguments)
-    #       end
-    #     end
-    #   end
-    #
-    # @example Define the invokation block anywhere you want
-    #   def subcommands(cmd)
-    #     cmd.command :download do |opt|
-    #       description 'Downloads a content from a server'
-    #
-    #       opt.on :verbose, 'Use verbose output'
-    #     end
-    #   end
-    #
-    #   def process
-    #     # Perform calculations...
-    #     opts.fetch_command(:download).run do |options, arguments|
-    #       ContentDownloader.download(options, arguments)
-    #     end
-    #     # More calculations...
-    #   end
-    def subcommands(cmd); end
-
-    # A method to setup Pry::Slop so it can parse the options your command expects.
-    #
-    # @note Please don't do anything side-effecty in the main part of this
-    # method, as it may be called by Pry at any time for introspection reasons.
-    # If you need to set up default values, use `setup` instead.
-    #
-    # @example
-    #  def options(opt)
-    #    opt.banner "Gists methods or classes"
-    #    opt.on(:c, :class, "gist a class") do
-    #      @action = :class
-    #    end
-    #  end
-    def options(opt); end
-
-    # The actual body of your command should go here.
-    #
-    # The `opts` mehod can be called to get the options that Pry::Slop has passed,
-    # and `args` gives the remaining, unparsed arguments.
-    #
-    # The return value of this method is discarded unless the command was
-    # created with `:keep_retval => true`, in which case it is returned to the
-    # repl.
-    #
-    # @example
-    #   def process
-    #     if opts.present?(:class)
-    #       gist_class
-    #     else
-    #       gist_method
-    #     end
-    #   end
-    def process
-      raise CommandError, "command '#{command_name}' not implemented"
-    end
-  end
-end

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

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-
-class Pry
-  # Manage the processing of command line options
-  class CLI
-    NoOptionsError = Class.new(StandardError)
-
-    class << self
-      # @return [Proc] The Proc defining the valid command line options.
-      attr_accessor :options
-
-      # @return [Array] The Procs that process the parsed options. Plugins can
-      #   utilize this facility in order to add and process their own Pry
-      #   options.
-      attr_accessor :option_processors
-
-      # @return [Array<String>] The input array of strings to process
-      #   as CLI options.
-      attr_accessor :input_args
-
-      # Add another set of CLI options (a Pry::Slop block)
-      def add_options(&block)
-        if options
-          old_options = options
-          self.options = proc do
-            instance_exec(&old_options)
-            instance_exec(&block)
-          end
-        else
-          self.options = block
-        end
-
-        self
-      end
-
-      # Bring in options defined in plugins
-      def add_plugin_options
-        Pry.plugins.values.each(&:load_cli_options)
-
-        self
-      end
-
-      # Add a block responsible for processing parsed options.
-      def add_option_processor(&block)
-        self.option_processors ||= []
-        option_processors << block
-
-        self
-      end
-
-      # Clear `options` and `option_processors`
-      def reset
-        self.options           = nil
-        self.option_processors = nil
-      end
-
-      def parse_options(args = ARGV)
-        unless options
-          raise NoOptionsError,
-                "No command line options defined! Use Pry::CLI.add_options to " \
-                "add command line options."
-        end
-
-        @pass_argv = args.index { |cli_arg| %w[- --].include?(cli_arg) }
-        if @pass_argv
-          slop_args = args[0...@pass_argv]
-          self.input_args = args.replace(args[@pass_argv + 1..-1])
-        else
-          self.input_args = slop_args = args
-        end
-
-        begin
-          opts = Pry::Slop.parse!(
-            slop_args,
-            help: true,
-            multiple_switches: false,
-            strict: true,
-            &options
-          )
-        rescue Pry::Slop::InvalidOptionError
-          # Display help message on unknown switches and exit.
-          puts Pry::Slop.new(&options)
-          Kernel.exit
-        end
-
-        Pry.initial_session_setup
-        Pry.final_session_setup
-
-        # Option processors are optional.
-        option_processors.each { |processor| processor.call(opts) } if option_processors
-
-        opts
-      end
-
-      def start(opts)
-        Kernel.exit if opts.help?
-
-        # invoked via cli
-        Pry.cli = true
-
-        # create the actual context
-        if opts[:context]
-          Pry.initial_session_setup
-          context = Pry.binding_for(eval(opts[:context])) # rubocop:disable Security/Eval
-          Pry.final_session_setup
-        else
-          context = Pry.toplevel_binding
-        end
-
-        if !@pass_argv && Pry::CLI.input_args.any? && Pry::CLI.input_args != ["pry"]
-          full_name = File.expand_path(Pry::CLI.input_args.first)
-          Pry.load_file_through_repl(full_name)
-          Kernel.exit
-        end
-
-        # Start the session (running any code passed with -e, if there is any)
-        Pry.start(context, input: StringIO.new(Pry.config.exec_string))
-      end
-    end
-
-    reset
-  end
-end
-
-# Bring in options defined by plugins
-Pry::Slop.new do
-  on "no-plugins" do
-    Pry.config.should_load_plugins = false
-  end
-end.parse(ARGV.dup)
-
-Pry::CLI.add_plugin_options if Pry.config.should_load_plugins
-
-# The default Pry command line options (before plugin options are included)
-Pry::CLI.add_options do
-  banner(
-    "Usage: pry [OPTIONS]\n" \
-    "Start a Pry session.\n" \
-    "See http://pryrepl.org/ for more information.\n" \
-    "Copyright (c) 2016 John Mair (banisterfiend)" \
-  )
-
-  on(
-    :e, :exec=, "A line of code to execute in context before the session starts"
-  ) do |input|
-    Pry.config.exec_string += "\n" unless Pry.config.exec_string.empty?
-    Pry.config.exec_string += input
-  end
-
-  on "no-pager", "Disable pager for long output" do
-    Pry.config.pager = false
-  end
-
-  on "no-history", "Disable history loading" do
-    Pry.config.history.should_load = false
-  end
-
-  on "no-color", "Disable syntax highlighting for session" do
-    Pry.config.color = false
-  end
-
-  on :f, "Suppress loading of pryrc" do
-    Pry.config.should_load_rc = false
-    Pry.config.should_load_local_rc = false
-  end
-
-  on :s, "select-plugin=", "Only load specified plugin (and no others)." do |plugin_name|
-    Pry.config.should_load_plugins = false
-    Pry.plugins[plugin_name].activate!
-  end
-
-  on :d, "disable-plugin=", "Disable a specific plugin." do |plugin_name|
-    Pry.plugins[plugin_name].disable!
-  end
-
-  on "no-plugins", "Suppress loading of plugins." do
-    Pry.config.should_load_plugins = false
-  end
-
-  on "plugins", "List installed plugins." do
-    puts "Installed Plugins:"
-    puts "--"
-    Pry.locate_plugins.each do |plugin|
-      puts plugin.name.to_s.ljust(18) << plugin.spec.summary
-    end
-    Kernel.exit
-  end
-
-  on "simple-prompt", "Enable simple prompt mode" do
-    Pry.config.prompt = Pry::Prompt[:simple]
-  end
-
-  on "noprompt", "No prompt mode" do
-    Pry.config.prompt = Pry::Prompt[:none]
-  end
-
-  on :r, :require=, "`require` a Ruby script at startup" do |file|
-    Pry.config.requires << file
-  end
-
-  on(:I=, "Add a path to the $LOAD_PATH", as: Array, delimiter: ":") do |load_path|
-    load_path.map! do |path|
-      %r{\A\./} =~ path ? path : File.expand_path(path)
-    end
-
-    $LOAD_PATH.unshift(*load_path)
-  end
-
-  on "gem", "Shorthand for -I./lib -rgemname" do |_load_path|
-    $LOAD_PATH.unshift("./lib")
-    Dir["./lib/*.rb"].each do |file|
-      Pry.config.requires << file
-    end
-  end
-
-  on :v, :version, "Display the Pry version" do
-    puts "Pry version #{Pry::VERSION} on Ruby #{RUBY_VERSION}"
-    Kernel.exit
-  end
-
-  on :c, :context=,
-     "Start the session in the specified context. Equivalent to " \
-     "`context.pry` in a session.",
-     default: "Pry.toplevel_binding"
-end

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

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-require 'method_source'
-
-class Pry
-  class CodeFile
-    DEFAULT_EXT = '.rb'.freeze
-
-    # List of all supported languages.
-    # @return [Hash]
-    EXTENSIONS = {
-      %w[.py] => :python,
-      %w[.js] => :javascript,
-      %w[.css] => :css,
-      %w[.xml] => :xml,
-      %w[.php] => :php,
-      %w[.html] => :html,
-      %w[.diff] => :diff,
-      %w[.java] => :java,
-      %w[.json] => :json,
-      %w[.c .h] => :c,
-      %w[.rhtml] => :rhtml,
-      %w[.yaml .yml] => :yaml,
-      %w[.cpp .hpp .cc .h .cxx] => :cpp,
-      %w[.rb .ru .irbrc .gemspec .pryrc .rake] => :ruby
-    }.freeze
-
-    FILES = {
-      %w[Gemfile Rakefile Guardfile Capfile] => :ruby
-    }.freeze
-
-    # Store the current working directory. This allows show-source etc. to work if
-    # your process has changed directory since boot. [Issue #675]
-    INITIAL_PWD = Dir.pwd
-
-    # @return [Symbol] The type of code stored in this wrapper.
-    attr_reader :code_type
-
-    # @param [String] filename The name of a file with code to be detected
-    # @param [Symbol] code_type The type of code the `filename` contains
-    def initialize(filename, code_type = type_from_filename(filename))
-      @filename = filename
-      @code_type = code_type
-    end
-
-    # @return [String] The code contained in the current `@filename`.
-    def code
-      if @filename == Pry.eval_path
-        Pry.line_buffer.drop(1)
-      elsif Pry::Method::Patcher.code_for(@filename)
-        Pry::Method::Patcher.code_for(@filename)
-      else
-        path = abs_path
-        @code_type = type_from_filename(path)
-        File.read(path)
-      end
-    end
-
-    private
-
-    # @raise [MethodSource::SourceNotFoundError] if the `filename` is not
-    #   readable for some reason.
-    # @return [String] absolute path for the given `filename`.
-    def abs_path
-      code_path.detect { |path| readable?(path) } ||
-        raise(MethodSource::SourceNotFoundError,
-              "Cannot open #{@filename.inspect} for reading.")
-    end
-
-    # @param [String] path
-    # @return [Boolean] if the path, with or without the default ext,
-    #   is a readable file then `true`, otherwise `false`.
-    def readable?(path)
-      File.readable?(path) && !File.directory?(path) ||
-        File.readable?(path << DEFAULT_EXT)
-    end
-
-    # @return [Array] All the paths that contain code that Pry can use for its
-    #   API's. Skips directories.
-    def code_path
-      [from_pwd, from_pry_init_pwd, *from_load_path]
-    end
-
-    # @param [String] filename
-    # @param [Symbol] default (:unknown) the file type to assume if none could be
-    #   detected.
-    # @return [Symbol, nil] The SyntaxHighlighter type of a file from its
-    #   extension, or `nil` if `:unknown`.
-    def type_from_filename(filename, default = :unknown)
-      _, @code_type = EXTENSIONS.find do |k, _|
-        k.any? { |ext| ext == File.extname(filename) }
-      end || FILES.find do |k, _|
-        k.any? { |file_name| file_name == File.basename(filename) }
-      end
-
-      code_type || default
-    end
-
-    # @return [String]
-    def from_pwd
-      File.expand_path(@filename, Dir.pwd)
-    end
-
-    # @return [String]
-    def from_pry_init_pwd
-      File.expand_path(@filename, INITIAL_PWD)
-    end
-
-    # @return [String]
-    def from_load_path
-      $LOAD_PATH.map { |path| File.expand_path(@filename, path) }
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Code
-    # Represents a range of lines in a code listing.
-    #
-    # @api private
-    class CodeRange
-      # @param [Integer] start_line
-      # @param [Integer?] end_line
-      def initialize(start_line, end_line = nil)
-        @start_line = start_line
-        @end_line   = end_line
-        force_set_end_line
-      end
-
-      # @param [Array<LOC>] lines
-      # @return [Range]
-      def indices_range(lines)
-        Range.new(*indices(lines))
-      end
-
-      private
-
-      attr_reader :start_line
-
-      attr_reader :end_line
-
-      # If `end_line` is equal to `nil`, then calculate it from the first
-      # parameter, `start_line`. Otherwise, leave it as it is.
-      # @return [void]
-      def force_set_end_line
-        if start_line.is_a?(Range)
-          set_end_line_from_range
-        else
-          @end_line ||= start_line
-        end
-      end
-
-      # Finds indices of `start_line` and `end_line` in the given Array of
-      # +lines+.
-      #
-      # @param [Array<LOC>] lines
-      # @return [Array<Integer>]
-      def indices(lines)
-        [find_start_index(lines), find_end_index(lines)]
-      end
-
-      # @return [Integer]
-      def find_start_index(lines)
-        return start_line if start_line < 0
-
-        lines.index { |loc| loc.lineno >= start_line } || lines.length
-      end
-
-      # @return [Integer]
-      def find_end_index(lines)
-        return end_line if end_line < 0
-
-        (lines.index { |loc| loc.lineno > end_line } || 0) - 1
-      end
-
-      # For example, if the range is 4..10, then `start_line` would be equal to
-      # 4 and `end_line` to 10.
-      # @return [void]
-      def set_end_line_from_range
-        @end_line = start_line.last
-        @end_line -= 1 if start_line.exclude_end?
-        @start_line = start_line.first
-      end
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Code
-    # Represents a line of code (which may, in fact, contain multiple lines if
-    # the entirety was eval'd as a single unit following the `edit` command).
-    #
-    # A line of code is a tuple, which consists of a line and a line number. A
-    # `LOC` object's state (namely, the line parameter) can be changed via
-    # instance methods.  `Pry::Code` heavily uses this class.
-    #
-    # @api private
-    # @example
-    #   loc = LOC.new("def example\n  :example\nend", 1)
-    #   puts loc.line
-    #   def example
-    #     :example
-    #   end
-    #   #=> nil
-    #
-    #   loc.indent(3)
-    #   loc.line #=> "   def example\n  :example\nend"
-    class LOC
-      # @return [Array<String, Integer>]
-      attr_reader :tuple
-
-      # @param [String] line The line of code.
-      # @param [Integer] lineno The position of the +line+.
-      def initialize(line, lineno)
-        @tuple = [line.chomp, lineno.to_i]
-      end
-
-      # @return [Boolean]
-      def ==(other)
-        other.tuple == tuple
-      end
-
-      def dup
-        self.class.new(line, lineno)
-      end
-
-      # @return [String]
-      def line
-        tuple.first
-      end
-
-      # @return [Integer]
-      def lineno
-        tuple.last
-      end
-
-      # Paints the `line` of code.
-      #
-      # @param [Symbol] code_type
-      # @return [void]
-      def colorize(code_type)
-        tuple[0] = SyntaxHighlighter.highlight(line, code_type)
-      end
-
-      # Prepends the line number `lineno` to the `line`.
-      #
-      # @param [Integer] max_width
-      # @return [void]
-      def add_line_number(max_width = 0, color = false)
-        padded = lineno.to_s.rjust(max_width)
-        colorized_lineno =
-          if color
-            Pry::Helpers::BaseHelpers.colorize_code(padded)
-          else
-            padded
-          end
-        properly_padded_line = handle_multiline_entries_from_edit_command(line, max_width)
-        tuple[0] = "#{colorized_lineno}: #{properly_padded_line}"
-      end
-
-      # Prepends a marker "=>" or an empty marker to the +line+.
-      #
-      # @param [Integer] marker_lineno If it is equal to the `lineno`, then
-      #   prepend a hashrocket. Otherwise, an empty marker.
-      # @return [void]
-      def add_marker(marker_lineno)
-        tuple[0] =
-          if lineno == marker_lineno
-            " => #{line}"
-          else
-            "    #{line}"
-          end
-      end
-
-      # Indents the `line` with +distance+ spaces.
-      #
-      # @param [Integer] distance
-      # @return [void]
-      def indent(distance)
-        tuple[0] = "#{' ' * distance}#{line}"
-      end
-
-      def handle_multiline_entries_from_edit_command(line, max_width)
-        line.split("\n").map.with_index do |inner_line, i|
-          i.zero? ? inner_line : "#{' ' * (max_width + 2)}#{inner_line}"
-        end.join("\n")
-      end
-    end
-  end
-end