primary_connect_proto 0.9.0 → 0.11.0

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

@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class REPL
-    extend Pry::Forwardable
-    def_delegators :@pry, :input, :output
-
-    # @return [Pry] The instance of {Pry} that the user is controlling.
-    attr_accessor :pry
-
-    # Instantiate a new {Pry} instance with the given options, then start a
-    # {REPL} instance wrapping it.
-    # @option options See {Pry#initialize}
-    def self.start(options)
-      new(Pry.new(options)).start
-    end
-
-    # Create an instance of {REPL} wrapping the given {Pry}.
-    # @param [Pry] pry The instance of {Pry} that this {REPL} will control.
-    # @param [Hash] options Options for this {REPL} instance.
-    # @option options [Object] :target The initial target of the session.
-    def initialize(pry, options = {})
-      @pry    = pry
-      @indent = Pry::Indent.new(pry)
-
-      @readline_output = nil
-
-      @pry.push_binding options[:target] if options[:target]
-    end
-
-    # Start the read-eval-print loop.
-    # @return [Object?] If the session throws `:breakout`, return the value
-    #   thrown with it.
-    # @raise [Exception] If the session throws `:raise_up`, raise the exception
-    #   thrown with it.
-    def start
-      prologue
-      Pry::InputLock.for(:all).with_ownership { repl }
-    ensure
-      epilogue
-    end
-
-    private
-
-    # Set up the repl session.
-    # @return [void]
-    def prologue
-      pry.exec_hook :before_session, pry.output, pry.current_binding, pry
-
-      return unless pry.config.correct_indent
-
-      # Clear the line before starting Pry. This fixes issue #566.
-      output.print(Helpers::Platform.windows_ansi? ? "\e[0F" : "\e[0G")
-    end
-
-    # The actual read-eval-print loop.
-    #
-    # The {REPL} instance is responsible for reading and looping, whereas the
-    # {Pry} instance is responsible for evaluating user input and printing
-    # return values and command output.
-    #
-    # @return [Object?] If the session throws `:breakout`, return the value
-    #   thrown with it.
-    # @raise [Exception] If the session throws `:raise_up`, raise the exception
-    #   thrown with it.
-    def repl
-      loop do
-        case val = read
-        when :control_c
-          output.puts ""
-          pry.reset_eval_string
-        when :no_more_input
-          output.puts "" if output.tty?
-          break
-        else
-          output.puts "" if val.nil? && output.tty?
-          return pry.exit_value unless pry.eval(val)
-        end
-      end
-    end
-
-    # Clean up after the repl session.
-    # @return [void]
-    def epilogue
-      pry.exec_hook :after_session, pry.output, pry.current_binding, pry
-    end
-
-    # Read a line of input from the user.
-    # @return [String] The line entered by the user.
-    # @return [nil] On `<Ctrl-D>`.
-    # @return [:control_c] On `<Ctrl+C>`.
-    # @return [:no_more_input] On EOF.
-    def read
-      @indent.reset if pry.eval_string.empty?
-      current_prompt = pry.select_prompt
-      indentation = pry.config.auto_indent ? @indent.current_prefix : ''
-
-      val = read_line("#{current_prompt}#{indentation}")
-
-      # Return nil for EOF, :no_more_input for error, or :control_c for <Ctrl-C>
-      return val unless val.is_a?(String)
-
-      if pry.config.auto_indent
-        original_val = "#{indentation}#{val}"
-        indented_val = @indent.indent(val)
-
-        if output.tty? &&
-           pry.config.correct_indent &&
-           Pry::Helpers::BaseHelpers.use_ansi_codes?
-          output.print @indent.correct_indentation(
-            current_prompt,
-            indented_val,
-            calculate_overhang(current_prompt, original_val, indented_val)
-          )
-          output.flush
-        end
-      else
-        indented_val = val
-      end
-
-      indented_val
-    end
-
-    # Manage switching of input objects on encountering `EOFError`s.
-    # @return [Object] Whatever the given block returns.
-    # @return [:no_more_input] Indicates that no more input can be read.
-    def handle_read_errors
-      should_retry = true
-      exception_count = 0
-
-      begin
-        yield
-      rescue EOFError
-        pry.config.input = Pry.config.input
-        unless should_retry
-          output.puts "Error: Pry ran out of things to read from! " \
-            "Attempting to break out of REPL."
-          return :no_more_input
-        end
-        should_retry = false
-        retry
-
-      # Handle <Ctrl+C> like Bash: empty the current input buffer, but don't
-      # quit.  This is only for MRI 1.9; other versions of Ruby don't let you
-      # send Interrupt from within Readline.
-      rescue Interrupt
-        return :control_c
-
-      # If we get a random error when trying to read a line we don't want to
-      # automatically retry, as the user will see a lot of error messages
-      # scroll past and be unable to do anything about it.
-      rescue RescuableException => e
-        puts "Error: #{e.message}"
-        output.puts e.backtrace
-        exception_count += 1
-        retry if exception_count < 5
-        puts "FATAL: Pry failed to get user input using `#{input}`."
-        puts "To fix this you may be able to pass input and output file " \
-          "descriptors to pry directly. e.g."
-        puts "  Pry.config.input = STDIN"
-        puts "  Pry.config.output = STDOUT"
-        puts "  binding.pry"
-        return :no_more_input
-      end
-    end
-
-    # Returns the next line of input to be sent to the {Pry} instance.
-    # @param [String] current_prompt The prompt to use for input.
-    # @return [String?] The next line of input, or `nil` on <Ctrl-D>.
-    def read_line(current_prompt)
-      handle_read_errors do
-        if coolline_available?
-          input.completion_proc = proc do |cool|
-            completions = @pry.complete cool.completed_word
-            completions.compact
-          end
-        elsif input.respond_to? :completion_proc=
-          input.completion_proc = proc do |inp|
-            @pry.complete inp
-          end
-        end
-
-        if readline_available?
-          set_readline_output
-          input_readline(current_prompt, false) # false since we'll add it manually
-        elsif coolline_available?
-          input_readline(current_prompt)
-        elsif input.method(:readline).arity == 1
-          input_readline(current_prompt)
-        else
-          input_readline
-        end
-      end
-    end
-
-    def input_readline(*args)
-      Pry::InputLock.for(:all).interruptible_region do
-        input.readline(*args)
-      end
-    end
-
-    def readline_available?
-      defined?(Readline) && input == Readline
-    end
-
-    def coolline_available?
-      defined?(Coolline) && input.is_a?(Coolline)
-    end
-
-    # If `$stdout` is not a tty, it's probably a pipe.
-    # @example
-    #   # `piping?` returns `false`
-    #   % pry
-    #   [1] pry(main)
-    #
-    #   # `piping?` returns `true`
-    #   % pry | tee log
-    def piping?
-      return false unless $stdout.respond_to?(:tty?)
-
-      !$stdout.tty? && $stdin.tty? && !Helpers::Platform.windows?
-    end
-
-    # @return [void]
-    def set_readline_output
-      return if @readline_output
-
-      @readline_output = (Readline.output = Pry.config.output) if piping?
-    end
-
-    # Calculates correct overhang for current line. Supports vi Readline
-    # mode and its indicators such as "(ins)" or "(cmd)".
-    #
-    # @return [Integer]
-    # @note This doesn't calculate overhang for Readline's emacs mode with an
-    #   indicator because emacs is the default mode and it doesn't use
-    #   indicators in 99% of cases.
-    def calculate_overhang(current_prompt, original_val, indented_val)
-      overhang = original_val.length - indented_val.length
-
-      if readline_available? && Readline.respond_to?(:vi_editing_mode?)
-        begin
-          # rb-readline doesn't support this method:
-          # https://github.com/ConnorAtherton/rb-readline/issues/152
-          if Readline.vi_editing_mode?
-            overhang = output.width - current_prompt.size - indented_val.size
-          end
-        rescue NotImplementedError
-          # VI editing mode is unsupported on JRuby.
-          # https://github.com/pry/pry/issues/1840
-          nil
-        end
-      end
-      [0, overhang].max
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  # A class to manage the loading of files through the REPL loop.
-  # This is an interesting trick as it processes your file as if it
-  # was user input in an interactive session. As a result, all Pry
-  # commands are available, and they are executed non-interactively. Furthermore
-  # the session becomes interactive when the repl loop processes a
-  # 'make-interactive' command in the file. The session also becomes
-  # interactive when an exception is encountered, enabling you to fix
-  # the error before returning to non-interactive processing with the
-  # 'make-non-interactive' command.
-
-  class REPLFileLoader
-    def initialize(file_name)
-      full_name = File.expand_path(file_name)
-      raise "No such file: #{full_name}" unless File.exist?(full_name)
-
-      define_additional_commands
-      @content = File.read(full_name)
-    end
-
-    # Switch to interactive mode, i.e take input from the user
-    # and use the regular print and exception handlers.
-    # @param [Pry] pry_instance the Pry instance to make interactive.
-    def interactive_mode(pry_instance)
-      pry_instance.config.input = Pry.config.input
-      pry_instance.config.print = Pry.config.print
-      pry_instance.config.exception_handler = Pry.config.exception_handler
-      Pry::REPL.new(pry_instance).start
-    end
-
-    # Switch to non-interactive mode. Essentially
-    # this means there is no result output
-    # and that the session becomes interactive when an exception is encountered.
-    # @param [Pry] pry_instance the Pry instance to make non-interactive.
-    def non_interactive_mode(pry_instance, content)
-      pry_instance.print = proc {}
-      pry_instance.exception_handler = proc do |o, _e, p|
-        p.run_command "cat --ex"
-        o.puts "...exception encountered, going interactive!"
-        interactive_mode(pry_instance)
-      end
-
-      content.lines.each do |line|
-        break unless pry_instance.eval line, generated: true
-      end
-
-      return if pry_instance.eval_string.empty?
-
-      pry_instance.output.puts(
-        "#{pry_instance.eval_string}...exception encountered, going interactive!"
-      )
-      interactive_mode(pry_instance)
-    end
-
-    # Define a few extra commands useful for flipping back & forth
-    # between interactive/non-interactive modes
-    def define_additional_commands
-      s = self
-
-      Pry::Commands.command "make-interactive", "Make the session interactive" do
-        s.interactive_mode(pry_instance)
-      end
-
-      Pry::Commands.command(
-        "load-file", "Load another file through the repl"
-      ) do |file_name|
-        s.non_interactive_mode(pry_instance, File.read(File.expand_path(file_name)))
-      end
-    end
-
-    # Actually load the file through the REPL by setting file content
-    # as the REPL input stream.
-    def load
-      non_interactive_mode(Pry.new, @content)
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  # A ring is a thread-safe fixed-capacity array to which you can only add
-  # elements. Older entries are overwritten as you add new elements, so that the
-  # ring can never contain more than `max_size` elemens.
-  #
-  # @example
-  #   ring = Pry::Ring.new(3)
-  #   ring << 1 << 2 << 3
-  #   ring.to_a #=> [1, 2, 3]
-  #   ring << 4
-  #   ring.to_a #=> [2, 3, 4]
-  #
-  #   ring[0] #=> 2
-  #   ring[-1] #=> 4
-  #   ring.clear
-  #   ring[0] #=> nil
-  #
-  # @api public
-  # @since v0.12.0
-  class Ring
-    # @return [Integer] maximum buffer size
-    attr_reader :max_size
-
-    # @return [Integer] how many objects were added during the lifetime of the
-    #   ring
-    attr_reader :count
-    alias size count
-
-    # @param [Integer] max_size Maximum buffer size. The buffer will start
-    #   overwriting elements once its reaches its maximum capacity
-    def initialize(max_size)
-      @max_size = max_size
-      @mutex = Mutex.new
-      clear
-    end
-
-    # Push `value` to the current index.
-    #
-    # @param [Object] value
-    # @return [self]
-    def <<(value)
-      @mutex.synchronize do
-        @buffer[count % max_size] = value
-        @count += 1
-        self
-      end
-    end
-
-    # Read the value stored at `index`.
-    #
-    # @param [Integer, Range] index The element (if Integer) or elements
-    #   (if Range) associated with `index`
-    # @return [Object, Array<Object>, nil] element(s) at `index`, `nil` if none
-    #   exist
-    def [](index)
-      @mutex.synchronize do
-        return @buffer[(count + index) % max_size] if index.is_a?(Integer)
-        return @buffer[index] if count <= max_size
-
-        transpose_buffer_tail[index]
-      end
-    end
-
-    # @return [Array<Object>] the buffer as unwinded array
-    def to_a
-      return @buffer.dup if count <= max_size
-
-      transpose_buffer_tail
-    end
-
-    # Clear the buffer and reset count.
-    # @return [void]
-    def clear
-      @mutex.synchronize do
-        @buffer = []
-        @count = 0
-      end
-    end
-
-    private
-
-    def transpose_buffer_tail
-      tail = @buffer.slice(count % max_size, @buffer.size)
-      tail.concat @buffer.slice(0, count % max_size)
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/slop/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2012 Lee Jarvis
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Slop
-    class Commands
-      include Enumerable
-
-      attr_reader :config, :commands, :arguments
-      attr_writer :banner
-
-      # Create a new instance of Slop::Commands and optionally build
-      # Slop instances via a block. Any configuration options used in
-      # this method will be the default configuration options sent to
-      # each Slop object created.
-      #
-      # config - An optional configuration Hash.
-      # block  - Optional block used to define commands.
-      #
-      # Examples:
-      #
-      #   commands = Slop::Commands.new do
-      #     on :new do
-      #       on '-o', '--outdir=', 'The output directory'
-      #       on '-v', '--verbose', 'Enable verbose mode'
-      #     end
-      #
-      #     on :generate do
-      #       on '--assets', 'Generate assets', :default => true
-      #     end
-      #
-      #     global do
-      #       on '-D', '--debug', 'Enable debug mode', :default => false
-      #     end
-      #   end
-      #
-      #   commands[:new].class #=> Slop
-      #   commands.parse
-      #
-      def initialize(config = {}, &block)
-        @config = config
-        @commands = {}
-        @banner = nil
-        @triggered_command = nil
-
-        warn "[DEPRECATED] Slop::Commands is deprecated and will be removed in "\
-          "Slop version 4. Check out http://injekt.github.com/slop/#commands for "\
-          "a new implementation of commands."
-
-        return unless block_given?
-
-        block.arity == 1 ? yield(self) : instance_eval(&block)
-      end
-
-      # Optionally set the banner for this command help output.
-      #
-      # banner - The String text to set the banner.
-      #
-      # Returns the String banner if one is set.
-      def banner(banner = nil)
-        @banner = banner if banner
-        @banner
-      end
-
-      # Add a Slop instance for a specific command.
-      #
-      # command - A String or Symbol key used to identify this command.
-      # config  - A Hash of configuration options to pass to Slop.
-      # block   - An optional block used to pass options to Slop.
-      #
-      # Returns the newly created Slop instance mapped to command.
-      def on(command, config = {}, &block)
-        commands[command.to_s] = Slop.new(@config.merge(config), &block)
-      end
-
-      # Add a Slop instance used when no other commands exist.
-      #
-      # config - A Hash of configuration options to pass to Slop.
-      # block  - An optional block used to pass options to Slop.
-      #
-      # Returns the newly created Slop instance mapped to default.
-      def default(config = {}, &block)
-        on('default', config, &block)
-      end
-
-      # Add a global Slop instance.
-      #
-      # config - A Hash of configuration options to pass to Slop.
-      # block  - An optional block used to pass options to Slop.
-      #
-      # Returns the newly created Slop instance mapped to global.
-      def global(config = {}, &block)
-        on('global', config, &block)
-      end
-
-      # Fetch the instance of Slop tied to a command.
-      #
-      # key - The String or Symbol key used to locate this command.
-      #
-      # Returns the Slop instance if this key is found, nil otherwise.
-      def [](key)
-        commands[key.to_s]
-      end
-      alias get []
-
-      # Check for a command presence.
-      #
-      # Examples:
-      #
-      #   cmds.parse %w( foo )
-      #   cmds.present?(:foo) #=> true
-      #   cmds.present?(:bar) #=> false
-      #
-      # Returns true if the given key is present in the parsed arguments.
-      def present?(key)
-        key.to_s == @triggered_command
-      end
-
-      # Enumerable interface.
-      def each(&block)
-        @commands.each(&block)
-      end
-
-      # Parse a list of items.
-      #
-      # items - The Array of items to parse.
-      #
-      # Returns the original Array of items.
-      def parse(items = ARGV)
-        parse! items.dup
-        items
-      end
-
-      # Parse a list of items, removing any options or option arguments found.
-      #
-      # items - The Array of items to parse.
-      #
-      # Returns the original Array of items with options removed.
-      def parse!(items = ARGV)
-        if (opts = commands[items[0].to_s])
-          @triggered_command = items.shift
-          execute_arguments! items
-          opts.parse! items
-        elsif (opts = commands['default'])
-          opts.parse! items
-        elsif config[:strict] && items[0]
-          raise InvalidCommandError, "Unknown command `#{items[0]}`"
-        end
-        execute_global_opts! items
-        items
-      end
-
-      # Returns a nested Hash with Slop options and values. See Slop#to_hash.
-      def to_hash
-        Hash[commands.map { |k, v| [k.to_sym, v.to_hash] }]
-      end
-
-      # Returns the help String.
-      def to_s
-        defaults = commands.delete('default')
-        globals = commands.delete('global')
-        helps = commands.reject { |_, v| v.options.none? }
-        helps['Global options'] = globals.to_s if globals && globals.options.any?
-        helps['Other options'] = defaults.to_s if defaults && defaults.options.any?
-        banner = @banner ? "#{@banner}\n" : ""
-        banner + helps.map { |key, opts| "  #{key}\n#{opts}" }.join("\n\n")
-      end
-      alias help to_s
-
-      # Returns the inspection String.
-      def inspect
-        "#<Slop::Commands #{config.inspect} #{commands.values.map(&:inspect)}>"
-      end
-
-      private
-
-      # Returns nothing.
-      def execute_arguments!(items)
-        @arguments = items.take_while { |arg| !arg.start_with?('-') }
-        items.shift @arguments.size
-      end
-
-      # Returns nothing.
-      def execute_global_opts!(items)
-        return unless (global_opts = commands['global'])
-
-        global_opts.parse!(items)
-      end
-    end
-  end
-end