primary_connect_proto 0.20.0 → 0.22.0

data/vendor/bundle/ruby/3.0.0/gems/pry-0.13.1/lib/pry/output.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Output
-    # @return [Array<Integer>] default terminal screen size [rows, cols]
-    DEFAULT_SIZE = [27, 80].freeze
-
-    attr_reader :pry_instance
-
-    def initialize(pry_instance)
-      @output = pry_instance.config.output
-      @color = pry_instance.config.color
-    end
-
-    def puts(*objs)
-      return print "\n" if objs.empty?
-
-      objs.each do |obj|
-        if (ary = Array.try_convert(obj))
-          puts(*ary)
-        else
-          print "#{obj.to_s.chomp}\n"
-        end
-      end
-      nil
-    end
-
-    def print(*objs)
-      objs.each do |obj|
-        @output.print decolorize_maybe(obj.to_s)
-      end
-      nil
-    end
-    alias << print
-    alias write print
-
-    def tty?
-      @output.respond_to?(:tty?) && @output.tty?
-    end
-
-    def method_missing(method_name, *args, &block)
-      if @output.respond_to?(method_name)
-        @output.__send__(method_name, *args, &block)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      @output.respond_to?(method_name, include_private)
-    end
-
-    def decolorize_maybe(str)
-      return str if @color
-
-      Pry::Helpers::Text.strip_color(str)
-    end
-
-    # @return [Array<Integer>] a pair of [rows, columns] which gives the size of
-    #   the window. If the window size cannot be determined, the default value.
-    def size
-      rows, cols = actual_screen_size
-      return [rows.to_i, cols.to_i] if rows.to_i != 0 && cols.to_i != 0
-
-      DEFAULT_SIZE
-    end
-
-    # Return a screen width or the default if that fails.
-    def width
-      size.last
-    end
-
-    # Return a screen height or the default if that fails.
-    def height
-      size.first
-    end
-
-    private
-
-    def actual_screen_size
-      # The best way, if possible (requires non-jruby >=1.9 or io-console gem).
-      io_console_size ||
-        # Fall back to the old standby, though it might be stale.
-        env_size ||
-        # Fall further back, though this one is also out of date without
-        # something calling Readline.set_screen_size.
-        readline_size ||
-        # Windows users can otherwise run ansicon and get a decent answer.
-        ansicon_env_size
-    end
-
-    def io_console_size
-      return if Pry::Helpers::Platform.jruby?
-
-      begin
-        require 'io/console'
-
-        begin
-          @output.winsize if tty? && @output.respond_to?(:winsize)
-        rescue Errno::EOPNOTSUPP # rubocop:disable Lint/HandleExceptions
-          # Output is probably a socket, which doesn't support #winsize.
-        end
-      rescue LoadError # rubocop:disable Lint/HandleExceptions
-        # They probably don't have the io/console stdlib or the io-console gem.
-        # We'll keep trying.
-      end
-    end
-
-    def env_size
-      size = [Pry::Env['LINES'] || Pry::Env['ROWS'], Pry::Env['COLUMNS']]
-      size if nonzero_column?(size)
-    end
-
-    def readline_size
-      return unless defined?(Readline) && Readline.respond_to?(:get_screen_size)
-
-      size = Readline.get_screen_size
-      size if nonzero_column?(size)
-    rescue Java::JavaLang::NullPointerException
-      # This rescue won't happen on jrubies later than:
-      #     https://github.com/jruby/jruby/pull/436
-      nil
-    end
-
-    def ansicon_env_size
-      return unless Pry::Env['ANSICON'] =~ /\((.*)x(.*)\)/
-
-      size = [Regexp.last_match(2), Regexp.last_match(1)]
-      size if nonzero_column?(size)
-    end
-
-    def nonzero_column?(size)
-      size[1].to_i > 0
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/pry-0.13.1/lib/pry/pager.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-# A pager is an `IO`-like object that accepts text and either prints it
-# immediately, prints it one page at a time, or streams it to an external
-# program to print one page at a time.
-class Pry
-  class Pager
-    class StopPaging < StandardError
-    end
-
-    attr_reader :pry_instance
-
-    def initialize(pry_instance)
-      @pry_instance = pry_instance
-    end
-
-    # Send the given text through the best available pager (if
-    # `Pry.config.pager` is enabled). If you want to send text through in
-    # chunks as you generate it, use `open` to get a writable object
-    # instead.
-    #
-    # @param [String] text
-    #   Text to run through a pager.
-    #
-    def page(text)
-      open do |pager|
-        pager << text
-      end
-    end
-
-    # Yields a pager object (`NullPager`, `SimplePager`, or `SystemPager`).
-    # All pagers accept output with `#puts`, `#print`, `#write`, and `#<<`.
-    def open
-      pager = best_available
-      yield pager
-    rescue StopPaging # rubocop:disable Lint/HandleExceptions
-    ensure
-      pager.close if pager
-    end
-
-    private
-
-    def enabled?
-      !!@enabled
-    end
-
-    attr_reader :output
-
-    # Return an instance of the "best" available pager class --
-    # `SystemPager` if possible, `SimplePager` if `SystemPager` isn't
-    # available, and `NullPager` if the user has disabled paging. All
-    # pagers accept output with `#puts`, `#print`, `#write`, and `#<<`. You
-    # must call `#close` when you're done writing output to a pager, and
-    # you must rescue `Pry::Pager::StopPaging`. These requirements can be
-    # avoided by using `.open` instead.
-    def best_available
-      if !pry_instance.config.pager
-        NullPager.new(pry_instance.output)
-      elsif !SystemPager.available? || Helpers::Platform.jruby?
-        SimplePager.new(pry_instance.output)
-      else
-        SystemPager.new(pry_instance.output)
-      end
-    end
-
-    # `NullPager` is a "pager" that actually just prints all output as it
-    # comes in. Used when `Pry.config.pager` is false.
-    class NullPager
-      def initialize(out)
-        @out = out
-      end
-
-      def puts(str)
-        print "#{str.chomp}\n"
-      end
-
-      def print(str)
-        write str
-      end
-      alias << print
-
-      def write(str)
-        @out.write str
-      end
-
-      def close; end
-
-      private
-
-      def height
-        @height ||= @out.height
-      end
-
-      def width
-        @width ||= @out.width
-      end
-    end
-
-    # `SimplePager` is a straightforward pure-Ruby pager. We use it on
-    # JRuby and when we can't find a usable external pager.
-    class SimplePager < NullPager
-      def initialize(*)
-        super
-        @tracker = PageTracker.new(height - 3, width)
-      end
-
-      def write(str)
-        str.lines.each do |line|
-          @out.print line
-          @tracker.record line
-
-          next unless @tracker.page?
-
-          @out.print "\n"
-          @out.print "\e[0m"
-          @out.print "<page break> --- Press enter to continue " \
-                     "( q<enter> to break ) --- <page break>\n"
-          raise StopPaging if Readline.readline("").chomp == "q"
-
-          @tracker.reset
-        end
-      end
-    end
-
-    # `SystemPager` buffers output until we're pretty sure it's at least a
-    # page long, then invokes an external pager and starts streaming output
-    # to it. If `#close` is called before then, it just prints out the
-    # buffered content.
-    class SystemPager < NullPager
-      def self.default_pager
-        pager = Pry::Env['PAGER'] || ''
-
-        # Default to less, and make sure less is being passed the correct
-        # options
-        pager = "less -R -F -X" if pager.strip.empty? || pager =~ /^less\b/
-
-        pager
-      end
-
-      @system_pager = nil
-
-      def self.available?
-        if @system_pager.nil?
-          @system_pager =
-            begin
-              pager_executable = default_pager.split(' ').first
-              if Helpers::Platform.windows? || Helpers::Platform.windows_ansi?
-                `where /Q #{pager_executable}`
-              else
-                `which #{pager_executable}`
-              end
-              $CHILD_STATUS.success?
-            rescue StandardError
-              false
-            end
-        else
-          @system_pager
-        end
-      end
-
-      def initialize(*)
-        super
-        @tracker = PageTracker.new(height, width)
-        @buffer  = ""
-        @pager   = nil
-      end
-
-      def write(str)
-        if invoked_pager?
-          write_to_pager str
-        else
-          @tracker.record str
-          @buffer += str
-
-          write_to_pager @buffer if @tracker.page?
-        end
-      rescue Errno::EPIPE
-        raise StopPaging
-      end
-
-      def close
-        if invoked_pager?
-          pager.close
-        else
-          @out.puts @buffer
-        end
-      end
-
-      private
-
-      def write_to_pager(text)
-        pager.write @out.decolorize_maybe(text)
-      end
-
-      def invoked_pager?
-        @pager
-      end
-
-      def pager
-        @pager ||= IO.popen(self.class.default_pager, 'w')
-      end
-    end
-
-    # `PageTracker` tracks output to determine whether it's likely to take
-    # up a whole page. This doesn't need to be super precise, but we can
-    # use it for `SimplePager` and to avoid invoking the system pager
-    # unnecessarily.
-    #
-    # One simplifying assumption is that we don't need `#page?` to return
-    # `true` on the basis of an incomplete line. Long lines should be
-    # counted as multiple lines, but we don't have to transition from
-    # `false` to `true` until we see a newline.
-    class PageTracker
-      def initialize(rows, cols)
-        @rows = rows
-        @cols = cols
-        reset
-      end
-
-      def record(str)
-        str.lines.each do |line|
-          if line.end_with? "\n"
-            @row += ((@col + line_length(line) - 1) / @cols) + 1
-            @col  = 0
-          else
-            @col += line_length(line)
-          end
-        end
-      end
-
-      def page?
-        @row >= @rows
-      end
-
-      def reset
-        @row = 0
-        @col = 0
-      end
-
-      private
-
-      # Approximation of the printable length of a given line, without the
-      # newline and without ANSI color codes.
-      def line_length(line)
-        line.chomp.gsub(/\e\[[\d;]*m/, '').length
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/pry-0.13.1/lib/pry/plugins.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require 'ostruct'
-
-class Pry
-  class PluginManager
-    PRY_PLUGIN_PREFIX = /^pry-/.freeze
-
-    # Placeholder when no associated gem found, displays warning
-    class NoPlugin
-      def initialize(name)
-        @name = name
-      end
-
-      def method_missing(*)
-        warn "Warning: The plugin '#{@name}' was not found! (no gem found)"
-        super
-      end
-
-      def respond_to_missing?(*)
-        false
-      end
-    end
-
-    class Plugin
-      attr_accessor :name, :gem_name, :enabled, :spec, :active
-
-      def initialize(name, gem_name, spec, enabled)
-        @name = name
-        @gem_name = gem_name
-        @enabled = enabled
-        @spec = spec
-      end
-
-      # Disable a plugin. (prevents plugin from being loaded, cannot
-      # disable an already activated plugin)
-      def disable!
-        self.enabled = false
-      end
-
-      # Enable a plugin. (does not load it immediately but puts on
-      # 'white list' to be loaded)
-      def enable!
-        self.enabled = true
-      end
-
-      # Load the Command line options defined by this plugin (if they exist)
-      def load_cli_options
-        cli_options_file = File.join(spec.full_gem_path, "lib/#{spec.name}/cli.rb")
-        return unless File.exist?(cli_options_file)
-
-        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.4.4")
-          cli_options_file = File.realpath(cli_options_file)
-        end
-        require cli_options_file
-      end
-
-      # Activate the plugin (require the gem - enables/loads the
-      # plugin immediately at point of call, even if plugin is
-      # disabled)
-      # Does not reload plugin if it's already active.
-      def activate!
-        # Create the configuration object for the plugin.
-        Pry.config.send("#{gem_name.tr('-', '_')}=", OpenStruct.new)
-
-        begin
-          require gem_name unless active?
-        rescue LoadError => e
-          warn "Found plugin #{gem_name}, but could not require '#{gem_name}'"
-          warn e
-        rescue StandardError => e
-          warn "require '#{gem_name}' # Failed, saying: #{e}"
-        end
-
-        self.active = true
-        self.enabled = true
-      end
-
-      alias active? active
-      alias enabled? enabled
-
-      def supported?
-        pry_version = Gem::Version.new(VERSION)
-        spec.dependencies.each do |dependency|
-          if dependency.name == "pry"
-            return dependency.requirement.satisfied_by?(pry_version)
-          end
-        end
-        true
-      end
-    end
-
-    def initialize
-      @plugins = []
-    end
-
-    # Find all installed Pry plugins and store them in an internal array.
-    def locate_plugins
-      gem_list.each do |gem|
-        next if gem.name !~ PRY_PLUGIN_PREFIX
-
-        plugin_name = gem.name.split('-', 2).last
-        plugin = Plugin.new(plugin_name, gem.name, gem, false)
-        @plugins << plugin.tap(&:enable!) if plugin.supported? && !plugin_located?(plugin)
-      end
-      @plugins
-    end
-
-    # @return [Hash] A hash with all plugin names (minus the 'pry-') as
-    #   keys and Plugin objects as values.
-    def plugins
-      h = Hash.new { |_, key| NoPlugin.new(key) }
-      @plugins.each do |plugin|
-        h[plugin.name] = plugin
-      end
-      h
-    end
-
-    # Require all enabled plugins, disabled plugins are skipped.
-    def load_plugins
-      @plugins.each do |plugin|
-        plugin.activate! if plugin.enabled?
-      end
-    end
-
-    private
-
-    def plugin_located?(plugin)
-      @plugins.any? { |existing| existing.gem_name == plugin.gem_name }
-    end
-
-    def gem_list
-      Gem.refresh
-      return Gem::Specification if Gem::Specification.respond_to?(:each)
-
-      Gem.source_index.find_name('')
-    end
-  end
-end