rails-rfc6570 3.1.0 → 3.2.0

data/vendor/bundle/ruby/3.3.0/gems/irb-1.14.0/README.md

@@ -0,0 +1,405 @@
+# IRB
+
+[![Gem Version](https://badge.fury.io/rb/irb.svg)](https://badge.fury.io/rb/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]
+>
+> IRB is a default gem of Ruby so you shouldn't need to install it separately.
+>
+> But if you're using Ruby 2.6 or later and want to upgrade/install a specific version of IRB, please follow these steps.
+
+To install it with `bundler`, add this line to your application's Gemfile:
+
+```ruby
+gem 'irb'
+```
+
+And then execute:
+
+```shell
+$ bundle
+```
+
+Or install it directly with:
+
+```shell
+$ gem install irb
+```
+
+## Usage
+
+> [!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).
+
+### The `irb` Executable
+
+You can start a fresh IRB session by typing `irb` in your terminal.
+
+In the session, you can evaluate Ruby expressions or even prototype a small Ruby script. An input is executed when it is syntactically complete.
+
+```shell
+$ irb
+irb(main):001> 1 + 2
+=> 3
+irb(main):002* class Foo
+irb(main):003*   def foo
+irb(main):004*     puts 1
+irb(main):005*   end
+irb(main):006> end
+=> :foo
+irb(main):007> Foo.new.foo
+1
+=> nil
+```
+
+### The `binding.irb` Breakpoint
+
+If you use Ruby 2.5 or later versions, you can also use `binding.irb` in your program as breakpoints.
+
+Once a `binding.irb` is evaluated, a new IRB session will be started with the surrounding context:
+
+```shell
+$ ruby test.rb
+
+From: test.rb @ line 2 :
+
+    1: def greet(word)
+ => 2:   binding.irb
+    3:   puts "Hello #{word}"
+    4: end
+    5:
+    6: greet("World")
+
+irb(main):001:0> word
+=> "World"
+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)
+```
+
+```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
+```
+
+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
+```
+
+## 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/
+
+## 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).
+
+## 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
+```
+
+## Releasing
+
+```
+rake release
+gh release create vX.Y.Z --generate-notes
+```
+
+## License
+
+The gem is available as open source under the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).

data/vendor/bundle/ruby/3.3.0/gems/irb-1.14.0/irb.gemspec

@@ -0,0 +1,46 @@
+begin
+  require_relative "lib/irb/version"
+rescue LoadError
+  # for Ruby core repository
+  require_relative "version"
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = "irb"
+  spec.version       = IRB::VERSION
+  spec.authors       = ["aycabta", "Keiju ISHITSUKA"]
+  spec.email         = ["aycabta@gmail.com", "keiju@ruby-lang.org"]
+
+  spec.summary       = %q{Interactive Ruby command-line tool for REPL (Read Eval Print Loop).}
+  spec.description   = %q{Interactive Ruby command-line tool for REPL (Read Eval Print Loop).}
+  spec.homepage      = "https://github.com/ruby/irb"
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/releases"
+
+  spec.files         = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "bin/console",
+    "bin/setup",
+    "doc/irb/irb-tools.rd.ja",
+    "doc/irb/irb.rd.ja",
+    "exe/irb",
+    "irb.gemspec",
+    "man/irb.1",
+  ] + Dir.glob("lib/**/*")
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7")
+
+  spec.add_dependency "reline", ">= 0.4.2"
+  spec.add_dependency "rdoc", ">= 4.0.0"
+end

data/vendor/bundle/ruby/3.3.0/gems/json-2.7.2/LICENSE

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.