irb 1.13.2 → 1.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 243737997cdd6abe7e129eb7e7945dca379f1af38ed4254dfe094f2a611918cc
-  data.tar.gz: 5a1cbbdf5ab88a61278afe32a5497f38efa1342e123734ae3ede6135aae9b91f
+  metadata.gz: 0777b40af32d70077c30a5c818b82f9b7d6b1962a59648667016fe3b2a5bdc92
+  data.tar.gz: 3487682618e9aa452daaabd727117182dc95d85885a0b18b0b348f67e8a75f6e
 SHA512:
-  metadata.gz: 0b4e5d658e1eba4a0503ffd3776c3baffabb0782eb43a993aac593b6dc4383e9e209ca3c1f077c78225f612a1ac7607f951bc11a2ff8fd78a93e12029fbf1954
-  data.tar.gz: c9e978f318f22d322934b77b8c431830e67a9cb7cf365923041f77123ee5e7d39ffa814a4e7bdd9af759f4671d0b24bd2ae68a9d20beb54b4a0e4248e32ee85f
+  metadata.gz: 528a9784ba5b854519684bbe4cd03a7e6467b3619035d90ca7b7b864300b1dc22a4d755b1824ed5d653bd46e26631d88b577bfdecd6aeed24df16302471df47c
+  data.tar.gz: 9b401a6e0c08bdc361232be10797e307ac94567414300f7b385ae65392340aeb3ccd88ad53e447d8fb3543211ca55e2f61beb1d9543dd593a41fa736ed42c86f

data/Gemfile

@@ -22,6 +22,8 @@ gem "rubocop"
 gem "tracer" if !is_truffleruby
 gem "debug", github: "ruby/debug", platforms: [:mri, :mswin]
 
+gem "rdoc", ">= 6.11.0"
+
 if RUBY_VERSION >= "3.0.0" && !is_truffleruby
   gem "repl_type_completor"
 end

data/README.md

@@ -1,33 +1,14 @@
 # IRB
 
 [![Gem Version](https://badge.fury.io/rb/irb.svg)](https://badge.fury.io/rb/irb)
+[![Static Badge](https://img.shields.io/badge/RDoc-flat?style=flat&label=documentation&link=https%3A%2F%2Fruby.github.io%2Firb%2F)](https://ruby.github.io/irb/)
 [![build](https://github.com/ruby/irb/actions/workflows/test.yml/badge.svg)](https://github.com/ruby/irb/actions/workflows/test.yml)
 
+
 IRB stands for "interactive Ruby" and is a tool to interactively execute Ruby expressions read from the standard input.
 
 The `irb` command from your shell will start the interpreter.
 
-- [Installation](#installation)
-- [Usage](#usage)
-  - [The `irb` Executable](#the-irb-executable)
-  - [The `binding.irb` Breakpoint](#the-bindingirb-breakpoint)
-- [Commands](#commands)
-- [Debugging with IRB](#debugging-with-irb)
-  - [More about `debug.gem`](#more-about-debuggem)
-  - [Advantages Over `debug.gem`'s Console](#advantages-over-debuggems-console)
-- [Type Based Completion](#type-based-completion)
-  - [How to Enable IRB::TypeCompletor](#how-to-enable-irbtypecompletor)
-  - [Advantage over Default IRB::RegexpCompletor](#advantage-over-default-irbregexpcompletor)
-  - [Difference between Steep's Completion](#difference-between-steeps-completion)
-- [Configuration](#configuration)
-  - [Environment Variables](#environment-variables)
-- [Documentation](#documentation)
-- [Extending IRB](#extending-irb)
-- [Development](#development)
-- [Contributing](#contributing)
-- [Releasing](#releasing)
-- [License](#license)
-
 ## Installation
 
 > [!Note]
@@ -58,7 +39,7 @@ $ gem install irb
 
 > [!Note]
 >
-> We're working hard to match Pry's variety of powerful features in IRB, and you can track our progress or find contribution ideas in [this document](https://github.com/ruby/irb/blob/master/COMPARED_WITH_PRY.md).
+> We're working hard to match Pry's variety of powerful features in IRB, and you can track our progress or find contribution ideas in [this document](https://ruby.github.io/irb/COMPARED_WITH_PRY_md.html).
 
 ### The `irb` Executable
 
@@ -105,293 +86,32 @@ irb(main):002:0> exit
 Hello World
 ```
 
-## Commands
-
-The following commands are available on IRB. You can get the same output from the `help` command.
-
-```txt
-Help
-  help           List all available commands. Use `help <command>` to get information about a specific command.
-
-IRB
-  exit           Exit the current irb session.
-  exit!          Exit the current process.
-  irb_load       Load a Ruby file.
-  irb_require    Require a Ruby file.
-  source         Loads a given file in the current session.
-  irb_info       Show information about IRB.
-  history        Shows the input history. `-g [query]` or `-G [query]` allows you to filter the output.
-
-Workspace
-  cwws           Show the current workspace.
-  chws           Change the current workspace to an object.
-  workspaces     Show workspaces.
-  pushws         Push an object to the workspace stack.
-  popws          Pop a workspace from the workspace stack.
-
-Multi-irb (DEPRECATED)
-  irb            Start a child IRB.
-  jobs           List of current sessions.
-  fg             Switches to the session of the given number.
-  kill           Kills the session with the given number.
-
-Debugging
-  debug          Start the debugger of debug.gem.
-  break          Start the debugger of debug.gem and run its `break` command.
-  catch          Start the debugger of debug.gem and run its `catch` command.
-  next           Start the debugger of debug.gem and run its `next` command.
-  delete         Start the debugger of debug.gem and run its `delete` command.
-  step           Start the debugger of debug.gem and run its `step` command.
-  continue       Start the debugger of debug.gem and run its `continue` command.
-  finish         Start the debugger of debug.gem and run its `finish` command.
-  backtrace      Start the debugger of debug.gem and run its `backtrace` command.
-  info           Start the debugger of debug.gem and run its `info` command.
-
-Misc
-  edit           Open a file or source location.
-  measure        `measure` enables the mode to measure processing time. `measure :off` disables it.
-
-Context
-  show_doc       Enter the mode to look up RI documents.
-  ls             Show methods, constants, and variables.
-  show_source    Show the source code of a given method or constant.
-  whereami       Show the source code around binding.irb again.
-
-Aliases
-  $              Alias for `show_source`
-  @              Alias for `whereami`
-```
-
-## Debugging with IRB
-
-Starting from version 1.8.0, IRB boasts a powerful integration with `debug.gem`, providing a debugging experience akin to `pry-byebug`.
-
-After hitting a `binding.irb` breakpoint, you can activate the debugger with the `debug` command. Alternatively, if the `debug` method happens to already be defined in the current scope, you can call `irb_debug`.
-
-```shell
-From: test.rb @ line 3 :
-
-    1:
-    2: def greet(word)
- => 3:   binding.irb
-    4:   puts "Hello #{word}"
-    5: end
-    6:
-    7: greet("World")
-
-irb(main):001> debug
-irb:rdbg(main):002>
-```
-
-Once activated, the prompt's header changes from `irb` to `irb:rdbg`, enabling you to use any of `debug.gem`'s [commands](https://github.com/ruby/debug#debug-command-on-the-debug-console):
-
-```shell
-irb:rdbg(main):002> info # use info command to see available variables
-%self = main
-_ = nil
-word = "World"
-irb:rdbg(main):003> next # use next command to move to the next line
-[1, 7] in test.rb
-     1|
-     2| def greet(word)
-     3|   binding.irb
-=>   4|   puts "Hello #{word}"
-     5| end
-     6|
-     7| greet("World")
-=>#0    Object#greet(word="World") at test.rb:4
-  #1    <main> at test.rb:7
-irb:rdbg(main):004>
-```
-
-Simultaneously, you maintain access to IRB's commands, such as `show_source`:
-
-```shell
-irb:rdbg(main):004> show_source greet
-
-From: test.rb:2
-
-def greet(word)
-  binding.irb
-  puts "Hello #{word}"
-end
-```
-
-### More about `debug.gem`
-
-`debug.gem` offers many advanced debugging features that simple REPLs can't provide, including:
-
-- Step-debugging
-- Frame navigation
-- Setting breakpoints with commands
-- Thread control
-- ...and many more
-
-To learn about these features, please refer to `debug.gem`'s [commands list](https://github.com/ruby/debug#debug-command-on-the-debug-console).
-
-In the `irb:rdbg` session, the `help` command will also display all commands from `debug.gem`.
-
-### Advantages Over `debug.gem`'s Console
-
-This integration offers several benefits over `debug.gem`'s native console:
-
-1. Access to handy IRB commands like `show_source` or `show_doc`.
-2. Support for multi-line input.
-3. Symbol shortcuts such as `@` (`whereami`) and `$` (`show_source`).
-4. Autocompletion.
-5. Customizable prompt.
-
-However, there are also some limitations to be aware of:
-
-1. `binding.irb` doesn't support `pre` and `do` arguments like [`binding.break`](https://github.com/ruby/debug#bindingbreak-method).
-2. As IRB [doesn't currently support remote-connection](https://github.com/ruby/irb/issues/672), it can't be used with `debug.gem`'s remote debugging feature.
-3. Access to the previous return value via the underscore `_` is not supported.
-
-## Type Based Completion
-
-IRB's default completion `IRB::RegexpCompletor` uses Regexp. IRB has another experimental completion `IRB::TypeCompletor` that uses type analysis.
-
-### How to Enable IRB::TypeCompletor
-
-Install [ruby/repl_type_completor](https://github.com/ruby/repl_type_completor/) with:
-```
-$ gem install repl_type_completor
-```
-Or add these lines to your project's Gemfile.
-```ruby
-gem 'irb'
-gem 'repl_type_completor', group: [:development, :test]
-```
-
-Now you can use type based completion by:
-
-Running IRB with the `--type-completor` option
-```
-$ irb --type-completor
-```
-
-Or writing this line to IRB's rc-file (e.g. `~/.irbrc`)
-```ruby
-IRB.conf[:COMPLETOR] = :type # default is :regexp
-```
-
-Or setting the environment variable `IRB_COMPLETOR`
-```ruby
-ENV['IRB_COMPLETOR'] = 'type'
-IRB.start
-```
-
-To check if it's enabled, type `irb_info` into IRB and see the `Completion` section.
-```
-irb(main):001> irb_info
-...
-# Enabled
-Completion: Autocomplete, ReplTypeCompletor: 0.1.0, Prism: 0.18.0, RBS: 3.3.0
-# Not enabled
-Completion: Autocomplete, RegexpCompletor
-...
-```
-If you have `sig/` directory or `rbs_collection.lock.yaml` in current directory, IRB will load it.
-
-### Advantage over Default IRB::RegexpCompletor
-
-IRB::TypeCompletor can autocomplete chained methods, block parameters and more if type information is available.
-These are some examples IRB::RegexpCompletor cannot complete.
-
-```ruby
-irb(main):001> 'Ruby'.upcase.chars.s # Array methods (sample, select, shift, size)
-```
+### Debugging
 
-```ruby
-irb(main):001> 10.times.map(&:to_s).each do |s|
-irb(main):002>   s.up # String methods (upcase, upcase!, upto)
-```
+You can use IRB as a debugging console with `debug.gem` with these options:
 
-```ruby
-irb(main):001> class User < ApplicationRecord
-irb(main):002>   def foo
-irb(main):003>     sa # save, save!
-```
+- In `binding.irb`, use the `debug` command to start an `irb:rdbg` session with access to all `debug.gem` commands.
+- Use the `RUBY_DEBUG_IRB_CONSOLE=1` environment variable to make `debug.gem` use IRB as the debugging console.
 
-As a trade-off, completion calculation takes more time than IRB::RegexpCompletor.
+To learn more about debugging with IRB, see [Debugging with IRB](https://ruby.github.io/irb/#label-Debugging+with+IRB).
 
-### Difference between Steep's Completion
-
-Compared with Steep, IRB::TypeCompletor has some difference and limitations.
-```ruby
-[0, 'a'].sample.
-# Steep completes intersection of Integer methods and String methods
-# IRB::TypeCompletor completes both Integer and String methods
-```
-
-Some features like type narrowing is not implemented.
-```ruby
-def f(arg = [0, 'a'].sample)
-  if arg.is_a?(String)
-    arg. # Completes both Integer and String methods
-```
+## Documentation
 
-Unlike other static type checker, IRB::TypeCompletor uses runtime information to provide better completion.
-```ruby
-irb(main):001> a = [1]
-=> [1]
-irb(main):002> a.first. # Completes Integer methods
-```
+https://ruby.github.io/irb/ provides a comprehensive guide to IRB's features and usage.
 
 ## Configuration
 
-### Environment Variables
-
-- `NO_COLOR`: Assigning a value to it disables IRB's colorization.
-- `IRB_USE_AUTOCOMPLETE`: Setting it to `false` disables IRB's autocompletion.
-- `IRB_COMPLETOR`: Configures IRB's auto-completion behavior, allowing settings for either `regexp` or `type`.
-- `VISUAL`: Its value would be used to open files by the `edit` command.
-- `EDITOR`: Its value would be used to open files by the `edit` command if `VISUAL` is unset.
-- `IRBRC`: The file specified would be evaluated as IRB's rc-file.
-
-## Documentation
-
-https://ruby.github.io/irb/
+See the [Configuration page](https://ruby.github.io/irb/Configurations_md.html) in the documentation.
 
 ## Extending IRB
 
 IRB `v1.13.0` and later versions allows users/libraries to extend its functionality through official APIs.
 
-For more information, please visit [EXTEND_IRB.md](./EXTEND_IRB.md).
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+For more information, please visit the [IRB Extension Guide](https://ruby.github.io/irb/EXTEND_IRB_md.html).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/irb.
-
-### Set up the environment
-
-1. Fork the project to your GithHub account
-2. Clone the fork with `git clone git@github.com:[your_username]/irb.git`
-3. Run `bundle install`
-4. Run `bundle exec rake` to make sure tests pass locally
-
-### Run integration tests
-
-If your changes affect component rendering, such as the autocompletion's dialog/dropdown, you may need to run IRB's integration tests, known as `yamatanooroti`.
-
-Before running these tests, ensure that you have `libvterm` installed. If you're using Homebrew, you can install it by running:
-
-```bash
-brew install libvterm
-```
-
-After installing `libvterm`, you can run the integration tests using the following commands:
-
-```bash
-WITH_VTERM=1 bundle install
-WITH_VTERM=1 bundle exec rake test test_yamatanooroti
-```
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for more information.
 
 ## Releasing
 

data/Rakefile

@@ -45,10 +45,8 @@ end
 task :default => :test
 
 RDoc::Task.new do |rdoc|
-  rdoc.title = "IRB"
-  rdoc.rdoc_files.include("*.md", "lib/**/*.rb")
-  rdoc.rdoc_files.exclude("lib/irb/xmp.rb")
-  rdoc.rdoc_dir = "docs"
-  rdoc.main = "README.md"
-  rdoc.options.push("--copy-files", "LICENSE.txt")
+  rdoc.title = "IRB Documentation"
+  rdoc.main = "Index.md"
+  rdoc.rdoc_dir = "_site"
+  rdoc.options.push("lib")
 end

data/irb.gemspec

@@ -18,11 +18,10 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["documentation_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = "https://ruby.github.io/irb/"
   spec.metadata["changelog_uri"] = "#{spec.homepage}/releases"
 
   spec.files         = [
-    ".document",
     "Gemfile",
     "LICENSE.txt",
     "README.md",
@@ -34,7 +33,9 @@ Gem::Specification.new do |spec|
     "exe/irb",
     "irb.gemspec",
     "man/irb.1",
-  ] + Dir.glob("lib/**/*")
+  ] + Dir.chdir(File.expand_path('..', __FILE__)) do
+    Dir.glob("lib/**/*").map {|f| f unless File.directory?(f) }.compact
+  end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
@@ -43,4 +44,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "reline", ">= 0.4.2"
   spec.add_dependency "rdoc", ">= 4.0.0"
+  spec.add_dependency "pp", ">= 0.6.0"
 end

data/lib/irb/color.rb

@@ -41,6 +41,7 @@ module IRB # :nodoc:
         on_embvar:          [[RED],                   ALL],
         on_float:           [[MAGENTA, BOLD],         ALL],
         on_gvar:            [[GREEN, BOLD],           ALL],
+        on_backref:         [[GREEN, BOLD],           ALL],
         on_heredoc_beg:     [[RED],                   ALL],
         on_heredoc_end:     [[RED],                   ALL],
         on_ident:           [[BLUE, BOLD],            Ripper::EXPR_ENDFN],

data/lib/irb/color_printer.rb

@@ -4,12 +4,9 @@ require_relative 'color'
 
 module IRB
   class ColorPrinter < ::PP
-    METHOD_RESPOND_TO = Object.instance_method(:respond_to?)
-    METHOD_INSPECT = Object.instance_method(:inspect)
-
     class << self
-      def pp(obj, out = $>, width = screen_width)
-        q = ColorPrinter.new(out, width)
+      def pp(obj, out = $>, width = screen_width, colorize: true)
+        q = ColorPrinter.new(out, width, colorize: colorize)
         q.guard_inspect_key {q.pp obj}
         q.flush
         out << "\n"
@@ -24,12 +21,16 @@ module IRB
       end
     end
 
+    def initialize(out, width, colorize: true)
+      @colorize = colorize
+
+      super(out, width)
+    end
+
     def pp(obj)
       if String === obj
         # Avoid calling Ruby 2.4+ String#pretty_print that splits a string by "\n"
         text(obj.inspect)
-      elsif !METHOD_RESPOND_TO.bind(obj).call(:inspect)
-        text(METHOD_INSPECT.bind(obj).call)
       else
         super
       end
@@ -46,9 +47,9 @@ module IRB
       when ',', '=>', '[', ']', '{', '}', '..', '...', /\A@\w+\z/
         super(str, width)
       when /\A#</, '=', '>'
-        super(Color.colorize(str, [:GREEN]), width)
+        super(@colorize ? Color.colorize(str, [:GREEN]) : str, width)
       else
-        super(Color.colorize_code(str, ignore_error: true), width)
+        super(@colorize ? Color.colorize_code(str, ignore_error: true) : str, width)
       end
     end
   end

data/lib/irb/command/base.rb

@@ -5,13 +5,13 @@
 #
 
 module IRB
-  # :stopdoc:
-
   module Command
-    class CommandArgumentError < StandardError; end
+    class CommandArgumentError < StandardError; end # :nodoc:
 
-    def self.extract_ruby_args(*args, **kwargs)
-      throw :EXTRACT_RUBY_ARGS, [args, kwargs]
+    class << self
+      def extract_ruby_args(*args, **kwargs) # :nodoc:
+        throw :EXTRACT_RUBY_ARGS, [args, kwargs]
+      end
     end
 
     class Base
@@ -31,6 +31,12 @@ module IRB
           @help_message
         end
 
+        def execute(irb_context, arg)
+          new(irb_context).execute(arg)
+        rescue CommandArgumentError => e
+          puts e.message
+        end
+
         private
 
         def highlight(text)
@@ -38,12 +44,6 @@ module IRB
         end
       end
 
-      def self.execute(irb_context, arg)
-        new(irb_context).execute(arg)
-      rescue CommandArgumentError => e
-        puts e.message
-      end
-
       def initialize(irb_context)
         @irb_context = irb_context
       end
@@ -55,8 +55,6 @@ module IRB
       end
     end
 
-    Nop = Base
+    Nop = Base # :nodoc:
   end
-
-  # :startdoc:
 end

data/lib/irb/command/cd.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module IRB
+  module Command
+    class CD < Base
+      category "Workspace"
+      description "Move into the given object or leave the current context."
+
+      help_message(<<~HELP)
+        Usage: cd ([target]|..)
+
+        IRB uses a stack of workspaces to keep track of context(s), with `pushws` and `popws` commands to manipulate the stack.
+        The `cd` command is an attempt to simplify the operation and will be subject to change.
+
+        When given:
+        - an object, cd will use that object as the new context by pushing it onto the workspace stack.
+        - "..", cd will leave the current context by popping the top workspace off the stack.
+        - no arguments, cd will move to the top workspace on the stack by popping off all workspaces.
+
+        Examples:
+
+          cd Foo
+          cd Foo.new
+          cd @ivar
+          cd ..
+          cd
+      HELP
+
+      def execute(arg)
+        case arg
+        when ".."
+          irb_context.pop_workspace
+        when ""
+          # TODO: decide what workspace commands should be kept, and underlying APIs should look like,
+          # and perhaps add a new API to clear the workspace stack.
+          prev_workspace = irb_context.pop_workspace
+          while prev_workspace
+            prev_workspace = irb_context.pop_workspace
+          end
+        else
+          begin
+            obj = eval(arg, irb_context.workspace.binding)
+            irb_context.push_workspace(obj)
+          rescue StandardError => e
+            warn "Error: #{e}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/irb/command/copy.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module IRB
+  module Command
+    class Copy < Base
+      category "Misc"
+      description "Copy expression output to clipboard"
+
+      help_message(<<~HELP)
+        Usage: copy ([expression])
+
+        When given:
+        - an expression, copy the inspect result of the expression to the clipboard.
+        - no arguments, copy the last evaluated result (`_`) to the clipboard.
+
+        Examples:
+
+          copy Foo.new
+          copy User.all.to_a
+          copy
+      HELP
+
+      def execute(arg)
+        # Copy last value if no expression was supplied
+        arg = '_' if arg.to_s.strip.empty?
+
+        value = irb_context.workspace.binding.eval(arg)
+        output = irb_context.inspect_method.inspect_value(value, +'', colorize: false).chomp
+
+        if clipboard_available?
+          copy_to_clipboard(output)
+        else
+          warn "System clipboard not found"
+        end
+      rescue StandardError => e
+        warn "Error: #{e}"
+      end
+
+      private
+
+      def copy_to_clipboard(text)
+        IO.popen(clipboard_program, 'w') do |io|
+          io.write(text)
+        end
+
+        raise IOError.new("Copying to clipboard failed") unless $? == 0
+
+        puts "Copied to system clipboard"
+      rescue Errno::ENOENT => e
+        warn e.message
+        warn "Is IRB.conf[:COPY_COMMAND] set to a bad value?"
+      end
+
+      def clipboard_program
+        @clipboard_program ||= if IRB.conf[:COPY_COMMAND]
+                                 IRB.conf[:COPY_COMMAND]
+                               elsif executable?("pbcopy")
+                                 "pbcopy"
+                               elsif executable?("xclip")
+                                 "xclip -selection clipboard"
+                               end
+      end
+
+      def executable?(command)
+        system("which #{command} > /dev/null 2>&1")
+      end
+
+      def clipboard_available?
+        !!clipboard_program
+      end
+    end
+  end
+end

data/lib/irb/command/debug.rb

@@ -58,13 +58,15 @@ module IRB
     end
 
     class DebugCommand < Debug
-      def self.category
-        "Debugging"
-      end
+      class << self
+        def category
+          "Debugging"
+        end
 
-      def self.description
-        command_name = self.name.split("::").last.downcase
-        "Start the debugger of debug.gem and run its `#{command_name}` command."
+        def description
+          command_name = self.name.split("::").last.downcase
+          "Start the debugger of debug.gem and run its `#{command_name}` command."
+        end
       end
     end
   end

data/lib/irb/command/help.rb

@@ -39,7 +39,7 @@ module IRB
 
         help_cmds = commands_grouped_by_categories.delete("Help")
         no_category_cmds = commands_grouped_by_categories.delete("No category")
-        aliases = irb_context.instance_variable_get(:@user_aliases).map do |alias_name, target|
+        aliases = irb_context.instance_variable_get(:@command_aliases).map do |alias_name, target|
           { display_name: alias_name, description: "Alias for `#{target}`" }
         end