docspring 3.0.0 → 3.1.0

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/notifier.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+#
+#   notifier.rb - output methods used by irb
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+
+require_relative "output-method"
+
+module IRB
+  # An output formatter used internally by the lexer.
+  module Notifier
+    class ErrUndefinedNotifier < StandardError
+      def initialize(val)
+        super("undefined notifier level: #{val} is specified")
+      end
+    end
+    class ErrUnrecognizedLevel < StandardError
+      def initialize(val)
+        super("unrecognized notifier level: #{val} is specified")
+      end
+    end
+
+    # Define a new Notifier output source, returning a new CompositeNotifier
+    # with the given +prefix+ and +output_method+.
+    #
+    # The optional +prefix+ will be appended to all objects being inspected
+    # during output, using the given +output_method+ as the output source. If
+    # no +output_method+ is given, StdioOutputMethod will be used, and all
+    # expressions will be sent directly to STDOUT without any additional
+    # formatting.
+    def def_notifier(prefix = "", output_method = StdioOutputMethod.new)
+      CompositeNotifier.new(prefix, output_method)
+    end
+    module_function :def_notifier
+
+    # An abstract class, or superclass, for CompositeNotifier and
+    # LeveledNotifier to inherit. It provides several wrapper methods for the
+    # OutputMethod object used by the Notifier.
+    class AbstractNotifier
+      # Creates a new Notifier object
+      def initialize(prefix, base_notifier)
+        @prefix = prefix
+        @base_notifier = base_notifier
+      end
+
+      # The +prefix+ for this Notifier, which is appended to all objects being
+      # inspected during output.
+      attr_reader :prefix
+
+      # A wrapper method used to determine whether notifications are enabled.
+      #
+      # Defaults to +true+.
+      def notify?
+        true
+      end
+
+      # See OutputMethod#print for more detail.
+      def print(*opts)
+        @base_notifier.print prefix, *opts if notify?
+      end
+
+      # See OutputMethod#printn for more detail.
+      def printn(*opts)
+        @base_notifier.printn prefix, *opts if notify?
+      end
+
+      # See OutputMethod#printf for more detail.
+      def printf(format, *opts)
+        @base_notifier.printf(prefix + format, *opts) if notify?
+      end
+
+      # See OutputMethod#puts for more detail.
+      def puts(*objs)
+        if notify?
+          @base_notifier.puts(*objs.collect{|obj| prefix + obj.to_s})
+        end
+      end
+
+      # Same as #ppx, except it uses the #prefix given during object
+      # initialization.
+      # See OutputMethod#ppx for more detail.
+      def pp(*objs)
+        if notify?
+          @base_notifier.ppx @prefix, *objs
+        end
+      end
+
+      # Same as #pp, except it concatenates the given +prefix+ with the #prefix
+      # given during object initialization.
+      #
+      # See OutputMethod#ppx for more detail.
+      def ppx(prefix, *objs)
+        if notify?
+          @base_notifier.ppx @prefix+prefix, *objs
+        end
+      end
+
+      # Execute the given block if notifications are enabled.
+      def exec_if
+        yield(@base_notifier) if notify?
+      end
+    end
+
+    # A class that can be used to create a group of notifier objects with the
+    # intent of representing a leveled notification system for irb.
+    #
+    # This class will allow you to generate other notifiers, and assign them
+    # the appropriate level for output.
+    #
+    # The Notifier class provides a class-method Notifier.def_notifier to
+    # create a new composite notifier. Using the first composite notifier
+    # object you create, sibling notifiers can be initialized with
+    # #def_notifier.
+    class CompositeNotifier < AbstractNotifier
+      # Create a new composite notifier object with the given +prefix+, and
+      # +base_notifier+ to use for output.
+      def initialize(prefix, base_notifier)
+        super
+
+        @notifiers = [D_NOMSG]
+        @level_notifier = D_NOMSG
+      end
+
+      # List of notifiers in the group
+      attr_reader :notifiers
+
+      # Creates a new LeveledNotifier in the composite #notifiers group.
+      #
+      # The given +prefix+ will be assigned to the notifier, and +level+ will
+      # be used as the index of the #notifiers Array.
+      #
+      # This method returns the newly created instance.
+      def def_notifier(level, prefix = "")
+        notifier = LeveledNotifier.new(self, level, prefix)
+        @notifiers[level] = notifier
+        notifier
+      end
+
+      # Returns the leveled notifier for this object
+      attr_reader :level_notifier
+      alias level level_notifier
+
+      # Sets the leveled notifier for this object.
+      #
+      # When the given +value+ is an instance of AbstractNotifier,
+      # #level_notifier is set to the given object.
+      #
+      # When an Integer is given, #level_notifier is set to the notifier at the
+      # index +value+ in the #notifiers Array.
+      #
+      # If no notifier exists at the index +value+ in the #notifiers Array, an
+      # ErrUndefinedNotifier exception is raised.
+      #
+      # An ErrUnrecognizedLevel exception is raised if the given +value+ is not
+      # found in the existing #notifiers Array, or an instance of
+      # AbstractNotifier
+      def level_notifier=(value)
+        case value
+        when AbstractNotifier
+          @level_notifier = value
+        when Integer
+          l = @notifiers[value]
+          raise ErrUndefinedNotifier, value unless l
+          @level_notifier = l
+        else
+          raise ErrUnrecognizedLevel, value unless l
+        end
+      end
+
+      alias level= level_notifier=
+    end
+
+    # A leveled notifier is comparable to the composite group from
+    # CompositeNotifier#notifiers.
+    class LeveledNotifier < AbstractNotifier
+      include Comparable
+
+      # Create a new leveled notifier with the given +base+, and +prefix+ to
+      # send to AbstractNotifier.new
+      #
+      # The given +level+ is used to compare other leveled notifiers in the
+      # CompositeNotifier group to determine whether or not to output
+      # notifications.
+      def initialize(base, level, prefix)
+        super(prefix, base)
+
+        @level = level
+      end
+
+      # The current level of this notifier object
+      attr_reader :level
+
+      # Compares the level of this notifier object with the given +other+
+      # notifier.
+      #
+      # See the Comparable module for more information.
+      def <=>(other)
+        @level <=> other.level
+      end
+
+      # Whether to output messages to the output method, depending on the level
+      # of this notifier object.
+      def notify?
+        @base_notifier.level >= self
+      end
+    end
+
+    # NoMsgNotifier is a LeveledNotifier that's used as the default notifier
+    # when creating a new CompositeNotifier.
+    #
+    # This notifier is used as the +zero+ index, or level +0+, for
+    # CompositeNotifier#notifiers, and will not output messages of any sort.
+    class NoMsgNotifier < LeveledNotifier
+      # Creates a new notifier that should not be used to output messages.
+      def initialize
+        @base_notifier = nil
+        @level = 0
+        @prefix = ""
+      end
+
+      # Ensures notifications are ignored, see AbstractNotifier#notify? for
+      # more information.
+      def notify?
+        false
+      end
+    end
+
+    D_NOMSG = NoMsgNotifier.new # :nodoc:
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/output-method.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+#
+#   output-method.rb - output methods used by irb
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+
+module IRB
+  # An abstract output class for IO in irb. This is mainly used internally by
+  # IRB::Notifier. You can define your own output method to use with Irb.new,
+  # or Context.new
+  class OutputMethod
+    # Open this method to implement your own output method, raises a
+    # NotImplementedError if you don't define #print in your own class.
+    def print(*opts)
+      raise NotImplementedError
+    end
+
+    # Prints the given +opts+, with a newline delimiter.
+    def printn(*opts)
+      print opts.join(" "), "\n"
+    end
+
+    # Extends IO#printf to format the given +opts+ for Kernel#sprintf using
+    # #parse_printf_format
+    def printf(format, *opts)
+      if /(%*)%I/ =~ format
+        format, opts = parse_printf_format(format, opts)
+      end
+      print sprintf(format, *opts)
+    end
+
+    # Returns an array of the given +format+ and +opts+ to be used by
+    # Kernel#sprintf, if there was a successful Regexp match in the given
+    # +format+ from #printf
+    #
+    #     %
+    #     <flag>  [#0- +]
+    #     <minimum field width> (\*|\*[1-9][0-9]*\$|[1-9][0-9]*)
+    #     <precision>.(\*|\*[1-9][0-9]*\$|[1-9][0-9]*|)?
+    #     #<length modifier>(hh|h|l|ll|L|q|j|z|t)
+    #     <conversion specifier>[diouxXeEfgGcsb%]
+    def parse_printf_format(format, opts)
+      return format, opts if $1.size % 2 == 1
+    end
+
+    # Calls #print on each element in the given +objs+, followed by a newline
+    # character.
+    def puts(*objs)
+      for obj in objs
+        print(*obj)
+        print "\n"
+      end
+    end
+
+    # Prints the given +objs+ calling Object#inspect on each.
+    #
+    # See #puts for more detail.
+    def pp(*objs)
+      puts(*objs.collect{|obj| obj.inspect})
+    end
+
+    # Prints the given +objs+ calling Object#inspect on each and appending the
+    # given +prefix+.
+    #
+    # See #puts for more detail.
+    def ppx(prefix, *objs)
+      puts(*objs.collect{|obj| prefix+obj.inspect})
+    end
+
+  end
+
+  # A standard output printer
+  class StdioOutputMethod < OutputMethod
+    # Prints the given +opts+ to standard output, see IO#print for more
+    # information.
+    def print(*opts)
+      STDOUT.print(*opts)
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/pager.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'reline'
+
+module IRB
+  # The implementation of this class is borrowed from RDoc's lib/rdoc/ri/driver.rb.
+  # Please do NOT use this class directly outside of IRB.
+  class Pager
+    PAGE_COMMANDS = [ENV['RI_PAGER'], ENV['PAGER'], 'less', 'more'].compact.uniq
+
+    class << self
+      def page_content(content, **options)
+        if content_exceeds_screen_height?(content)
+          page(**options) do |io|
+            io.puts content
+          end
+        else
+          $stdout.puts content
+        end
+      end
+
+      def page(retain_content: false)
+        if should_page? && pager = setup_pager(retain_content: retain_content)
+          begin
+            pid = pager.pid
+            yield pager
+          ensure
+            pager.close
+          end
+        else
+          yield $stdout
+        end
+      # When user presses Ctrl-C, IRB would raise `IRB::Abort`
+      # But since Pager is implemented by running paging commands like `less` in another process with `IO.popen`,
+      # the `IRB::Abort` exception only interrupts IRB's execution but doesn't affect the pager
+      # So to properly terminate the pager with Ctrl-C, we need to catch `IRB::Abort` and kill the pager process
+      rescue IRB::Abort
+        begin
+          begin
+            Process.kill("TERM", pid) if pid
+          rescue Errno::EINVAL
+            # SIGTERM not supported (windows)
+            Process.kill("KILL", pid)
+          end
+        rescue Errno::ESRCH
+          # Pager process already terminated
+        end
+        nil
+      rescue Errno::EPIPE
+      end
+
+      def should_page?
+        IRB.conf[:USE_PAGER] && STDIN.tty? && (ENV.key?("TERM") && ENV["TERM"] != "dumb")
+      end
+
+      def page_with_preview(width, height, formatter_proc)
+        overflow_callback = ->(lines) do
+          modified_output = formatter_proc.call(lines.join, true)
+          content, = take_first_page(width, [height - 2, 0].max) {|o| o.write modified_output }
+          content = content.chomp
+          content = "#{content}\e[0m" if Color.colorable?
+          $stdout.puts content
+          $stdout.puts 'Preparing full inspection value...'
+        end
+        out = PageOverflowIO.new(width, height, overflow_callback, delay: 0.1)
+        yield out
+        content = formatter_proc.call(out.string, out.multipage?)
+        if out.multipage?
+          page(retain_content: true) do |io|
+            io.puts content
+          end
+        else
+          $stdout.puts content
+        end
+      end
+
+      def take_first_page(width, height)
+        overflow_callback = proc do |lines|
+          return lines.join, true
+        end
+        out = Pager::PageOverflowIO.new(width, height, overflow_callback)
+        yield out
+        [out.string, false]
+      end
+
+      private
+
+      def content_exceeds_screen_height?(content)
+        screen_height, screen_width = begin
+          Reline.get_screen_size
+        rescue Errno::EINVAL
+          [24, 80]
+        end
+
+        pageable_height = screen_height - 3 # leave some space for previous and the current prompt
+
+        return true if content.lines.size > pageable_height
+
+        _, overflow = take_first_page(screen_width, pageable_height) {|out| out.write content }
+        overflow
+      end
+
+      def setup_pager(retain_content:)
+        require 'shellwords'
+
+        PAGE_COMMANDS.each do |pager_cmd|
+          cmd = Shellwords.split(pager_cmd)
+          next if cmd.empty?
+
+          if cmd.first == 'less'
+            cmd << '-R' unless cmd.include?('-R')
+            cmd << '-X' if retain_content && !cmd.include?('-X')
+          end
+
+          begin
+            io = IO.popen(cmd, 'w')
+          rescue
+            next
+          end
+
+          if $? && $?.pid == io.pid && $?.exited? # pager didn't work
+            next
+          end
+
+          return io
+        end
+
+        nil
+      end
+    end
+
+    # Writable IO that has page overflow callback
+    class PageOverflowIO
+      attr_reader :string, :first_page_lines
+
+      # Maximum size of a single cell in terminal
+      # Assumed worst case: "\e[1;3;4;9;38;2;255;128;128;48;2;128;128;255mA\e[0m"
+      # bold, italic, underline, crossed_out, RGB forgound, RGB background
+      MAX_CHAR_PER_CELL = 50
+
+      def initialize(width, height, overflow_callback, delay: nil)
+        @lines = []
+        @first_page_lines = nil
+        @width = width
+        @height = height
+        @buffer = +''
+        @overflow_callback = overflow_callback
+        @col = 0
+        @string = +''
+        @multipage = false
+        @delay_until = (Time.now + delay if delay)
+      end
+
+      def puts(text = '')
+        text = text.to_s unless text.is_a?(String)
+        write(text)
+        write("\n") unless text.end_with?("\n")
+      end
+
+      def write(text)
+        text = text.to_s unless text.is_a?(String)
+        @string << text
+        if @multipage
+          if @delay_until && Time.now > @delay_until
+            @overflow_callback.call(@first_page_lines)
+            @delay_until = nil
+          end
+          return
+        end
+
+        overflow_size = (@width * (@height - @lines.size) + @width - @col) * MAX_CHAR_PER_CELL
+        if text.size >= overflow_size
+          text = text[0, overflow_size]
+          overflow = true
+        end
+        @buffer << text
+        @col += Reline::Unicode.calculate_width(text, true)
+        if text.include?("\n") || @col >= @width
+          @buffer.lines.each do |line|
+            wrapped_lines = Reline::Unicode.split_by_width(line.chomp, @width).first.compact
+            wrapped_lines.pop if wrapped_lines.last == ''
+            @lines.concat(wrapped_lines)
+            if line.end_with?("\n")
+              if @lines.empty? || @lines.last.end_with?("\n")
+                @lines << "\n"
+              else
+                @lines[-1] += "\n"
+              end
+            end
+          end
+          @buffer.clear
+          @buffer << @lines.pop unless @lines.last.end_with?("\n")
+          @col = Reline::Unicode.calculate_width(@buffer, true)
+        end
+        if overflow || @lines.size > @height || (@lines.size == @height && @col > 0)
+          @first_page_lines = @lines.take(@height)
+          if !@delay_until || Time.now > @delay_until
+            @overflow_callback.call(@first_page_lines)
+            @delay_until = nil
+          end
+          @multipage = true
+        end
+      end
+
+      def multipage?
+        @multipage
+      end
+
+      alias print write
+      alias << write
+    end
+  end
+end