docspring 3.0.0 → 3.1.0

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

@@ -0,0 +1,101 @@
+require 'io/console/size'
+require 'debug/console'
+
+module IRB
+  module Debug
+    class UI < DEBUGGER__::UI_Base
+      def initialize(irb)
+        @irb = irb
+      end
+
+      def remote?
+        false
+      end
+
+      def activate session, on_fork: false
+      end
+
+      def deactivate
+      end
+
+      def width
+        if (w = IO.console_size[1]) == 0 # for tests PTY
+          80
+        else
+          w
+        end
+      end
+
+      def quit n
+        yield
+        exit n
+      end
+
+      def ask prompt
+        setup_interrupt do
+          print prompt
+          ($stdin.gets || '').strip
+        end
+      end
+
+      def puts str = nil
+        case str
+        when Array
+          str.each{|line|
+            $stdout.puts line.chomp
+          }
+        when String
+          Pager.page_content(str, retain_content: true)
+        when nil
+          $stdout.puts
+        end
+      end
+
+      def readline _
+        setup_interrupt do
+          tc = DEBUGGER__::SESSION.instance_variable_get(:@tc)
+          cmd = @irb.debug_readline(tc.current_frame.eval_binding || TOPLEVEL_BINDING)
+
+          case cmd
+          when nil # when user types C-d
+            "continue"
+          else
+            cmd
+          end
+        end
+      end
+
+      def setup_interrupt
+        DEBUGGER__::SESSION.intercept_trap_sigint false do
+          current_thread = Thread.current # should be session_server thread
+
+          prev_handler = trap(:INT){
+            current_thread.raise Interrupt
+          }
+
+          yield
+        ensure
+          trap(:INT, prev_handler)
+        end
+      end
+
+      def after_fork_parent
+        parent_pid = Process.pid
+
+        at_exit{
+          DEBUGGER__::SESSION.intercept_trap_sigint_end
+          trap(:SIGINT, :IGNORE)
+
+          if Process.pid == parent_pid
+            # only check child process from its parent
+            begin
+              # wait for all child processes to keep terminal
+              Process.waitpid
+            rescue Errno::ESRCH, Errno::ECHILD
+            end
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module IRB
+  module Debug
+    IRB_DIR = File.expand_path('..', __dir__)
+
+    class << self
+      def insert_debug_break(pre_cmds: nil, do_cmds: nil)
+        options = { oneshot: true, hook_call: false }
+
+        if pre_cmds || do_cmds
+          options[:command] = ['irb', pre_cmds, do_cmds]
+        end
+        if DEBUGGER__::LineBreakpoint.instance_method(:initialize).parameters.include?([:key, :skip_src])
+          options[:skip_src] = true
+        end
+
+        # To make debugger commands like `next` or `continue` work without asking
+        # the user to quit IRB after that, we need to exit IRB first and then hit
+        # a TracePoint on #debug_break.
+        file, lineno = IRB::Irb.instance_method(:debug_break).source_location
+        DEBUGGER__::SESSION.add_line_breakpoint(file, lineno + 1, **options)
+      end
+
+      def setup(irb)
+        # When debug session is not started at all
+        unless defined?(DEBUGGER__::SESSION)
+          begin
+            require "debug/session"
+          rescue LoadError # debug.gem is not written in Gemfile
+            return false unless load_bundled_debug_gem
+          end
+          DEBUGGER__::CONFIG.set_config
+          configure_irb_for_debugger(irb)
+
+          DEBUGGER__.initialize_session{ IRB::Debug::UI.new(irb) }
+        end
+
+        # When debug session was previously started but not by IRB
+        if defined?(DEBUGGER__::SESSION) && !irb.context.with_debugger
+          configure_irb_for_debugger(irb)
+          DEBUGGER__::SESSION.reset_ui(IRB::Debug::UI.new(irb))
+        end
+
+        # Apply patches to debug gem so it skips IRB frames
+        unless DEBUGGER__.respond_to?(:capture_frames_without_irb)
+          DEBUGGER__.singleton_class.send(:alias_method, :capture_frames_without_irb, :capture_frames)
+
+          def DEBUGGER__.capture_frames(*args)
+            frames = capture_frames_without_irb(*args)
+            frames.reject! do |frame|
+              frame.realpath&.start_with?(IRB_DIR) || frame.path == "<internal:prelude>"
+            end
+            frames
+          end
+
+          DEBUGGER__::ThreadClient.prepend(SkipPathHelperForIRB)
+        end
+
+        if !DEBUGGER__::CONFIG[:no_hint] && irb.context.io.is_a?(RelineInputMethod)
+          Reline.output_modifier_proc = proc do |input, complete:|
+            unless input.strip.empty?
+              cmd = input.split(/\s/, 2).first
+
+              if !complete && DEBUGGER__.commands.key?(cmd)
+                input = input.sub(/\n$/, " # debug command\n")
+              end
+            end
+
+            irb.context.colorize_input(input, complete: complete)
+          end
+        end
+
+        true
+      end
+
+      private
+
+      def configure_irb_for_debugger(irb)
+        require 'irb/debug/ui'
+        IRB.instance_variable_set(:@debugger_irb, irb)
+        irb.context.with_debugger = true
+        irb.context.irb_name += ":rdbg"
+        irb.context.io.load_history if irb.context.io.class < HistorySavingAbility
+      end
+
+      module SkipPathHelperForIRB
+        def skip_internal_path?(path)
+          # The latter can be removed once https://github.com/ruby/debug/issues/866 is resolved
+          super || path.match?(IRB_DIR) || path.match?('<internal:prelude>')
+        end
+      end
+
+      # This is used when debug.gem is not written in Gemfile. Even if it's not
+      # installed by `bundle install`, debug.gem is installed by default because
+      # it's a bundled gem. This method tries to activate and load that.
+      def load_bundled_debug_gem
+        # Discover latest debug.gem under GEM_PATH
+        debug_gem = Gem.paths.path.flat_map { |path| Dir.glob("#{path}/gems/debug-*") }.select do |path|
+          File.basename(path).match?(/\Adebug-\d+\.\d+\.\d+(\w+)?\z/)
+        end.sort_by do |path|
+          Gem::Version.new(File.basename(path).delete_prefix('debug-'))
+        end.last
+        return false unless debug_gem
+
+        # Discover debug/debug.so under extensions for Ruby 3.2+
+        ext_name = "/debug/debug.#{RbConfig::CONFIG['DLEXT']}"
+        ext_path = Gem.paths.path.flat_map do |path|
+          Dir.glob("#{path}/extensions/**/#{File.basename(debug_gem)}#{ext_name}")
+        end.first
+
+        # Attempt to forcibly load the bundled gem
+        if ext_path
+          $LOAD_PATH << ext_path.delete_suffix(ext_name)
+        end
+        $LOAD_PATH << "#{debug_gem}/lib"
+        begin
+          require "debug/session"
+          puts "Loaded #{File.basename(debug_gem)}"
+          true
+        rescue LoadError
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require_relative "command"
+require_relative "command/internal_helpers"
+require_relative "command/backtrace"
+require_relative "command/break"
+require_relative "command/catch"
+require_relative "command/cd"
+require_relative "command/chws"
+require_relative "command/context"
+require_relative "command/continue"
+require_relative "command/copy"
+require_relative "command/debug"
+require_relative "command/delete"
+require_relative "command/disable_irb"
+require_relative "command/edit"
+require_relative "command/exit"
+require_relative "command/finish"
+require_relative "command/force_exit"
+require_relative "command/help"
+require_relative "command/history"
+require_relative "command/info"
+require_relative "command/irb_info"
+require_relative "command/load"
+require_relative "command/ls"
+require_relative "command/measure"
+require_relative "command/next"
+require_relative "command/pushws"
+require_relative "command/show_doc"
+require_relative "command/show_source"
+require_relative "command/step"
+require_relative "command/subirb"
+require_relative "command/whereami"
+
+module IRB
+  module Command
+    NO_OVERRIDE = 0
+    OVERRIDE_PRIVATE_ONLY = 0x01
+    OVERRIDE_ALL = 0x02
+
+    class << self
+      # This API is for IRB's internal use only and may change at any time.
+      # Please do NOT use it.
+      def _register_with_aliases(name, command_class, *aliases)
+        @commands[name.to_sym] = [command_class, aliases]
+      end
+
+      def all_commands_info
+        user_aliases = IRB.CurrentContext.command_aliases.each_with_object({}) do |(alias_name, target), result|
+          result[target] ||= []
+          result[target] << alias_name
+        end
+
+        commands.map do |command_name, (command_class, aliases)|
+          aliases = aliases.map { |a| a.first }
+
+          if additional_aliases = user_aliases[command_name]
+            aliases += additional_aliases
+          end
+
+          display_name = aliases.shift || command_name
+          {
+            display_name: display_name,
+            description: command_class.description,
+            category: command_class.category
+          }
+        end
+      end
+
+      def command_override_policies
+        @@command_override_policies ||= commands.flat_map do |cmd_name, (cmd_class, aliases)|
+          [[cmd_name, OVERRIDE_ALL]] + aliases
+        end.to_h
+      end
+
+      def execute_as_command?(name, public_method:, private_method:)
+        case command_override_policies[name]
+        when OVERRIDE_ALL
+          true
+        when OVERRIDE_PRIVATE_ONLY
+          !public_method
+        when NO_OVERRIDE
+          !public_method && !private_method
+        end
+      end
+
+      def command_names
+        command_override_policies.keys.map(&:to_s)
+      end
+
+      # Convert a command name to its implementation class if such command exists
+      def load_command(command)
+        command = command.to_sym
+        commands.each do |command_name, (command_class, aliases)|
+          if command_name == command || aliases.any? { |alias_name, _| alias_name == command }
+            return command_class
+          end
+        end
+        nil
+      end
+    end
+
+    _register_with_aliases(:irb_context, Command::Context,
+      [:context, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_exit, Command::Exit,
+      [:exit, OVERRIDE_PRIVATE_ONLY],
+      [:quit, OVERRIDE_PRIVATE_ONLY],
+      [:irb_quit, OVERRIDE_PRIVATE_ONLY]
+    )
+
+    _register_with_aliases(:irb_exit!, Command::ForceExit,
+      [:exit!, OVERRIDE_PRIVATE_ONLY]
+    )
+
+    _register_with_aliases(:irb_current_working_workspace, Command::CurrentWorkingWorkspace,
+      [:cwws, NO_OVERRIDE],
+      [:pwws, NO_OVERRIDE],
+      [:irb_print_working_workspace, OVERRIDE_ALL],
+      [:irb_cwws, OVERRIDE_ALL],
+      [:irb_pwws, OVERRIDE_ALL],
+      [:irb_current_working_binding, OVERRIDE_ALL],
+      [:irb_print_working_binding, OVERRIDE_ALL],
+      [:irb_cwb, OVERRIDE_ALL],
+      [:irb_pwb, OVERRIDE_ALL],
+    )
+
+    _register_with_aliases(:irb_change_workspace, Command::ChangeWorkspace,
+      [:chws, NO_OVERRIDE],
+      [:cws, NO_OVERRIDE],
+      [:irb_chws, OVERRIDE_ALL],
+      [:irb_cws, OVERRIDE_ALL],
+      [:irb_change_binding, OVERRIDE_ALL],
+      [:irb_cb, OVERRIDE_ALL],
+      [:cb, NO_OVERRIDE],
+    )
+
+    _register_with_aliases(:irb_workspaces, Command::Workspaces,
+      [:workspaces, NO_OVERRIDE],
+      [:irb_bindings, OVERRIDE_ALL],
+      [:bindings, NO_OVERRIDE],
+    )
+
+    _register_with_aliases(:irb_push_workspace, Command::PushWorkspace,
+      [:pushws, NO_OVERRIDE],
+      [:irb_pushws, OVERRIDE_ALL],
+      [:irb_push_binding, OVERRIDE_ALL],
+      [:irb_pushb, OVERRIDE_ALL],
+      [:pushb, NO_OVERRIDE],
+    )
+
+    _register_with_aliases(:irb_pop_workspace, Command::PopWorkspace,
+      [:popws, NO_OVERRIDE],
+      [:irb_popws, OVERRIDE_ALL],
+      [:irb_pop_binding, OVERRIDE_ALL],
+      [:irb_popb, OVERRIDE_ALL],
+      [:popb, NO_OVERRIDE],
+    )
+
+    _register_with_aliases(:irb_load, Command::Load)
+    _register_with_aliases(:irb_require, Command::Require)
+    _register_with_aliases(:irb_source, Command::Source,
+      [:source, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb, Command::IrbCommand)
+    _register_with_aliases(:irb_jobs, Command::Jobs,
+      [:jobs, NO_OVERRIDE]
+    )
+    _register_with_aliases(:irb_fg, Command::Foreground,
+      [:fg, NO_OVERRIDE]
+    )
+    _register_with_aliases(:irb_kill, Command::Kill,
+      [:kill, OVERRIDE_PRIVATE_ONLY]
+    )
+
+    _register_with_aliases(:irb_debug, Command::Debug,
+      [:debug, NO_OVERRIDE]
+    )
+    _register_with_aliases(:irb_edit, Command::Edit,
+      [:edit, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_break, Command::Break,
+      [:break, OVERRIDE_ALL]
+    )
+    _register_with_aliases(:irb_catch, Command::Catch,
+      [:catch, OVERRIDE_PRIVATE_ONLY]
+    )
+    _register_with_aliases(:irb_next, Command::Next,
+      [:next, OVERRIDE_ALL]
+    )
+    _register_with_aliases(:irb_delete, Command::Delete,
+      [:delete, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_step, Command::Step,
+      [:step, NO_OVERRIDE]
+    )
+    _register_with_aliases(:irb_continue, Command::Continue,
+      [:continue, NO_OVERRIDE]
+    )
+    _register_with_aliases(:irb_finish, Command::Finish,
+      [:finish, NO_OVERRIDE]
+    )
+    _register_with_aliases(:irb_backtrace, Command::Backtrace,
+      [:backtrace, NO_OVERRIDE],
+      [:bt, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_debug_info, Command::Info,
+      [:info, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_help, Command::Help,
+      [:help, NO_OVERRIDE],
+      [:show_cmds, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_show_doc, Command::ShowDoc,
+      [:show_doc, NO_OVERRIDE],
+      [:ri, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_info, Command::IrbInfo)
+
+    _register_with_aliases(:irb_ls, Command::Ls,
+      [:ls, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_measure, Command::Measure,
+      [:measure, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_show_source, Command::ShowSource,
+      [:show_source, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_whereami, Command::Whereami,
+      [:whereami, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_history, Command::History,
+      [:history, NO_OVERRIDE],
+      [:hist, NO_OVERRIDE]
+    )
+
+    _register_with_aliases(:irb_disable_irb, Command::DisableIrb,
+      [:disable_irb, NO_OVERRIDE]
+    )
+
+    register(:cd, Command::CD)
+    register(:copy, Command::Copy)
+  end
+
+  ExtendCommand = Command
+
+  # For backward compatibility, we need to keep this module:
+  # - As a container of helper methods
+  # - As a place to register commands with the deprecated def_extend_command method
+  module ExtendCommandBundle
+    # For backward compatibility
+    NO_OVERRIDE = Command::NO_OVERRIDE
+    OVERRIDE_PRIVATE_ONLY = Command::OVERRIDE_PRIVATE_ONLY
+    OVERRIDE_ALL = Command::OVERRIDE_ALL
+
+    # Deprecated. Doesn't have any effect.
+    @EXTEND_COMMANDS = []
+
+    class << self
+      # Drepcated. Use Command.regiser instead.
+      def def_extend_command(cmd_name, cmd_class, _, *aliases)
+        Command._register_with_aliases(cmd_name, cmd_class, *aliases)
+        Command.class_variable_set(:@@command_override_policies, nil)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+require "reline"
+
+module IRB
+  class << self
+    class Vec
+      def initialize(x, y, z)
+        @x, @y, @z = x, y, z
+      end
+
+      attr_reader :x, :y, :z
+
+      def sub(other)
+        Vec.new(@x - other.x, @y - other.y, @z - other.z)
+      end
+
+      def dot(other)
+        @x*other.x + @y*other.y + @z*other.z
+      end
+
+      def cross(other)
+        ox, oy, oz = other.x, other.y, other.z
+        Vec.new(@y*oz-@z*oy, @z*ox-@x*oz, @x*oy-@y*ox)
+      end
+
+      def normalize
+        r = Math.sqrt(self.dot(self))
+        Vec.new(@x / r, @y / r, @z / r)
+      end
+    end
+
+    class Canvas
+      def initialize((h, w))
+        @data = (0..h-2).map { [0] * w }
+        @scale = [w / 2.0, h-2].min
+        @center = Complex(w / 2, h-2)
+      end
+
+      def line((x1, y1), (x2, y2))
+        p1 = Complex(x1, y1) / 2 * @scale + @center
+        p2 = Complex(x2, y2) / 2 * @scale + @center
+        line0(p1, p2)
+      end
+
+      private def line0(p1, p2)
+        mid = (p1 + p2) / 2
+        if (p1 - p2).abs < 1
+          x, y = mid.rect
+          @data[y / 2][x] |= (y % 2 > 1 ? 2 : 1)
+        else
+          line0(p1, mid)
+          line0(p2, mid)
+        end
+      end
+
+      def draw
+        @data.each {|row| row.fill(0) }
+        yield
+        @data.map {|row| row.map {|n| " ',;"[n] }.join }.join("\n")
+      end
+    end
+
+    class RubyModel
+      def initialize
+        @faces = init_ruby_model
+      end
+
+      def init_ruby_model
+        cap_vertices    = (0..5).map {|i| Vec.new(*Complex.polar(1,  i        * Math::PI / 3).rect, 1) }
+        middle_vertices = (0..5).map {|i| Vec.new(*Complex.polar(2, (i + 0.5) * Math::PI / 3).rect, 0) }
+        bottom_vertex   = Vec.new(0, 0, -2)
+
+        faces = [cap_vertices]
+        6.times do |j|
+          i = j-1
+          faces << [cap_vertices[i], middle_vertices[i], cap_vertices[j]]
+          faces << [cap_vertices[j], middle_vertices[i], middle_vertices[j]]
+          faces << [middle_vertices[i], bottom_vertex, middle_vertices[j]]
+        end
+
+        faces
+      end
+
+      def render_frame(i)
+        angle = i / 10.0
+        dir = Vec.new(*Complex.polar(1, angle).rect, Math.sin(angle)).normalize
+        dir2 = Vec.new(*Complex.polar(1, angle - Math::PI/2).rect, 0)
+        up = dir.cross(dir2)
+        nm = dir.cross(up)
+        @faces.each do |vertices|
+          v0, v1, v2, = vertices
+          if v1.sub(v0).cross(v2.sub(v0)).dot(dir) > 0
+            points = vertices.map {|p| [nm.dot(p), up.dot(p)] }
+            (points + [points[0]]).each_cons(2) do |p1, p2|
+              yield p1, p2
+            end
+          end
+        end
+      end
+    end
+
+    private def easter_egg_logo(type)
+      @easter_egg_logos ||= File.read(File.join(__dir__, 'ruby_logo.aa'), encoding: 'UTF-8:UTF-8')
+        .split(/TYPE: ([A-Z_]+)\n/)[1..]
+        .each_slice(2)
+        .to_h
+      @easter_egg_logos[type.to_s.upcase]
+    end
+
+    private def easter_egg(type = nil)
+      print "\e[?1049h"
+      type ||= [:logo, :dancing].sample
+      case type
+      when :logo
+        Pager.page do |io|
+          logo_type = STDOUT.external_encoding == Encoding::UTF_8 ? :unicode_large : :ascii_large
+          io.write easter_egg_logo(logo_type)
+          STDIN.raw { STDIN.getc } if io == STDOUT
+        end
+      when :dancing
+        STDOUT.cooked do
+          interrupted = false
+          prev_trap = trap("SIGINT") { interrupted = true }
+          canvas = Canvas.new(Reline.get_screen_size)
+          Reline::IOGate.set_winch_handler do
+            canvas = Canvas.new(Reline.get_screen_size)
+          end
+          ruby_model = RubyModel.new
+          print "\e[?25l" # hide cursor
+          0.step do |i| # TODO (0..).each needs Ruby 2.6 or later
+            buff = canvas.draw do
+              ruby_model.render_frame(i) do |p1, p2|
+                canvas.line(p1, p2)
+              end
+            end
+            buff[0, 20] = "\e[0mPress Ctrl+C to stop\e[31m\e[1m"
+            print "\e[H" + buff
+            sleep 0.05
+            break if interrupted
+          end
+        rescue Interrupt
+        ensure
+          print "\e[?25h" # show cursor
+          trap("SIGINT", prev_trap)
+        end
+      end
+    ensure
+      print "\e[0m\e[?1049l"
+    end
+  end
+end
+
+IRB.__send__(:easter_egg, ARGV[0]&.to_sym) if $0 == __FILE__

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/ext/change-ws.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+#
+#   irb/ext/cb.rb -
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+
+module IRB # :nodoc:
+  class Context
+
+    # Inherited from +TOPLEVEL_BINDING+.
+    def home_workspace
+      if defined? @home_workspace
+        @home_workspace
+      else
+        @home_workspace = workspace
+      end
+    end
+
+    # Changes the current workspace to given object or binding.
+    #
+    # If the optional argument is omitted, the workspace will be
+    # #home_workspace which is inherited from +TOPLEVEL_BINDING+ or the main
+    # object, <code>IRB.conf[:MAIN_CONTEXT]</code> when irb was initialized.
+    #
+    # See IRB::WorkSpace.new for more information.
+    def change_workspace(*_main)
+      if _main.empty?
+        replace_workspace(home_workspace)
+        return main
+      end
+
+      workspace = WorkSpace.new(_main[0])
+      replace_workspace(workspace)
+      workspace.load_helper_methods_to_main
+    end
+  end
+end