irb 1.14.3 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f1a9b1cbe12db08853604fff0b28f7b66ae1e724d54580ce507e15feb9e0f63
-  data.tar.gz: ce18f088328360ab8d39c4c3902984f0110e704b5a6d953e171d8d35c7b545a8
+  metadata.gz: 5167476c1b7e39f80080c2970d4974dac3a84a6721c027f0429ae9c793dfba92
+  data.tar.gz: 357002e006b01bbfd46dc36bae924c9b79adefc9b213b341fcc0f80134d0579c
 SHA512:
-  metadata.gz: a3a46b3c4b9b03dd97175f71cb1a41b02482b996f63b98fa1128c91e741dd17eff1c5af6d314c6756050f4b0e92c398aed1a3ad7adac035d1df0c266e8bd8de0
-  data.tar.gz: 57a389d3e32a394e256beb720d9e124f0f48d9bddb26cc8f4913eba2bb7cdd258f30cda97c87cc3bd028f0501d6247a9cbc97eff7279652805d65cdadef67d4c
+  metadata.gz: baeace22dd0cc116af8ddc4126fa6fee4b314008ffa56632547047501aefd6d8806e3d9a3518cd576422b8751ec285cb837c93b924a1f12c6230cd701c72f802
+  data.tar.gz: b9bce4b85a77cada09e1d4f06394aee7540cd307e9ce321a2ce5d609a3f6ee2f80dbcb1fce04374bddffb9f2a5370792a4b1498aa9479f8fd11d5340dd24da6a

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,310 +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
-  context        Displays current configuration.
-  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.
-  disable_irb    Disable binding.irb.
-
-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.
-  cd             Move into the given object or leave the current context.
-
-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       Look up documentation with RI.
-  ls             Show methods, constants, and variables.
-  show_source    Show the source code of a given method, class/module, or constant.
-  whereami       Show the source code around binding.irb again.
-
-Helper methods
-  conf           Returns the current IRB context.
-
-Aliases
-  $              Alias for `show_source`
-  @              Alias for `whereami`
-```
-
-## Debugging with IRB
-
-### Getting Started
-
-- In `binding.irb`, use the `debug` command to start a `irb:rdbg` session with access to all `debug.gem` commands.
-- Use `RUBY_DEBUG_IRB_CONSOLE=1` environment variable to make `debug.gem` use IRB as the debugging console.
-
-### Details
-
-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`
+### Debugging
 
-`debug.gem` offers many advanced debugging features that simple REPLs can't provide, including:
+You can use IRB as a debugging console with `debug.gem` with these options:
 
-- Step-debugging
-- Frame navigation
-- Setting breakpoints with commands
-- Thread control
-- ...and many more
+- 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.
 
-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
-```
+To learn more about debugging with IRB, see [Debugging with IRB](https://ruby.github.io/irb/#label-Debugging+with+IRB).
 
-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)
-```
-
-```ruby
-irb(main):001> 10.times.map(&:to_s).each do |s|
-irb(main):002>   s.up # String methods (upcase, upcase!, upto)
-```
-
-```ruby
-irb(main):001> class User < ApplicationRecord
-irb(main):002>   def foo
-irb(main):003>     sa # save, save!
-```
-
-As a trade-off, completion calculation takes more time than IRB::RegexpCompletor.
-
-### 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.
-- `XDG_CONFIG_HOME`: If it is set and `IRBRC` is unset, the file `$XDG_CONFIG_HOME/irb/irbrc` would be evaluated as IRB's rc-file.
-- `RI_PAGER`: The command specified would be used as a pager.
-- `PAGER`: The command specified would be used as a pager if `RI_PAGER` is unset.
-- `IRB_LANG`, `LC_MESSAGES`, `LC_ALL`, `LANG`: The first of these that is set would be used as the locale value.
-
-## 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,8 +45,8 @@ end
 task :default => :test
 
 RDoc::Task.new do |rdoc|
-  rdoc.title = "IRB"
-  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",
@@ -43,4 +42,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/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/history.rb

@@ -14,7 +14,7 @@ module IRB
 
       def execute(arg)
 
-        if (match = arg&.match(/(-g|-G)\s+(?<grep>.+)\s*\n\z/))
+        if (match = arg&.match(/(-g|-G)\s+(?<grep>.+)\s*\z/))
           grep = Regexp.new(match[:grep])
         end