RubyGems - tdiary - Versions diffs - 5.2.2 → 5.2.3 - Mend

tdiary 5.2.2 → 5.2.3

Files changed (1533) hide show

data/vendor/bundle/ruby/3.1.0/gems/debug-1.5.0/misc/README.md.erb DELETED Viewed

@@ -1,584 +0,0 @@
-[![Ruby](https://github.com/ruby/debug/actions/workflows/ruby.yml/badge.svg?branch=master)](https://github.com/ruby/debug/actions/workflows/ruby.yml?query=branch%3Amaster) [![Protocol](https://github.com/ruby/debug/actions/workflows/protocol.yml/badge.svg)](https://github.com/ruby/debug/actions/workflows/protocol.yml)
-# debug.rb
-This library provides debugging functionality to Ruby (MRI) 2.6 and later.
-This debug.rb is replacement of traditional lib/debug.rb standard library which is implemented by `set_trace_func`.
-New debug.rb has several advantages:
-* Fast: No performance penalty on non-stepping mode and non-breakpoints.
-* [Remote debugging](#remote-debugging): Support remote debugging natively.
-  * UNIX domain socket
-  * TCP/IP
-  * Integration with rich debugger frontend
-    * VSCode/DAP ([VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg))
-    * Chrome DevTools
-* Extensible: application can introduce debugging support with several ways:
-  * By `rdbg` command
-  * By loading libraries with `-r` command line option
-  * By calling Ruby's method explicitly
-* Misc
-  * Support threads (almost done) and ractors (TODO).
-  * Support suspending and entering to the console debugging with `Ctrl-C` at most of timing.
-  * Show parameters on backtrace command.
-  * Support recording & reply debugging.
-# Installation
-```
-$ gem install debug
-```
-or specify `-Ipath/to/debug/lib` in `RUBYOPT` or each ruby command-line option, especially for debug this gem development.
-If you use Bundler, write the following line to your Gemfile.
-```
-gem "debug", ">= 1.0.0"
-```
-# HOW TO USE
-To use a debugger, roughly you will do the following steps:
-1. Set breakpoints.
-2. Run a program with the debugger.
-3. At the breakpoint, enter the debugger console.
-4. Use debug commands.
-    * [Evaluate Ruby expressions](#evaluate) (e.g. `p lvar` to see the local variable `lvar`).
-    * [Query the program status](#information) (e.g. `info` to see information about the current frame).
-    * [Control program flow](#control-flow) (e.g. move to the another line with `step`, to the next line with `next`).
-    * [Set another breakpoint](#breakpoint) (e.g. `catch Exception` to set a breakpoint that'll be triggered when `Exception` is raised).
-    * [Activate tracing in your program](#trace) (e.g. `trace call` to trace method calls).
-    * [Change the configuration](#configuration-1) (e.g. `config set no_color true` to disable coloring).
-    * Continue the program (`c` or `continue`) and goto 3.
-## Invoke with the debugger
-There are several options for (1) and (2). Please choose your favorite way.
-### Modify source code with [`binding.break`](#bindingbreak-method) (similar to `binding.pry` or `binding.irb`)
-If you can modify the source code, you can use the debugger by adding `require 'debug'` at the top of your program and putting [`binding.break`](#bindingbreak-method) method into lines where you want to stop as breakpoints like `binding.pry` and `binding.irb`.
-You can also use its 2 aliases in the same way:
-- `binding.b`
-- `debugger`
-After that, run the program as usual and you will enter the debug console at breakpoints you inserted.
-The following example shows the demonstration of [`binding.break`](#bindingbreak-method).
-```shell
-$ cat target.rb                        # Sample program
-require 'debug'
-a = 1
-b = 2
-binding.break                          # Program will stop here
-c = 3
-d = 4
-binding.break                          # Program will stop here
-p [a, b, c, d]
-$ ruby target.rb                       # Run the program normally.
-DEBUGGER: Session start (pid: 7604)
-[1, 10] in target.rb
-      1| require 'debug'
-      2|
-      3| a = 1
-      4| b = 2
-=>    5| binding.break                 # Now you can see it stops at this line
-      6| c = 3
-      7| d = 4
-      8| binding.break
-      9| p [a, b, c, d]
-     10|
-=>#0    <main> at target.rb:5
-(rdbg) info locals                     # You can show local variables
-=>#0    <main> at target.rb:5
-%self => main
-a => 1
-b => 2
-c => nil
-d => nil
-(rdbg) continue                        # Continue the execution
-[3, 11] in target.rb
-      3| a = 1
-      4| b = 2
-      5| binding.break
-      6| c = 3
-      7| d = 4
-=>    8| binding.break                 # Again the program stops here
-      9| p [a, b, c, d]
-     10|
-     11| __END__
-=>#0    <main> at target.rb:8
-(rdbg) info locals                     # And you can see the updated local variables
-=>#0    <main> at target.rb:8
-%self => main
-a => 1
-b => 2
-c => 3
-d => 4
-(rdbg) continue
-[1, 2, 3, 4]
-```
-### Invoke the program from the debugger as a traditional debuggers
-If you don't want to modify the source code, you can set breakpoints with a debug command `break` (`b` for short).
-Using `rdbg` command to launch the program without any modifications, you can run the program with the debugger.
-```shell
-$ cat target.rb                        # Sample program
-a = 1
-b = 2
-c = 3
-d = 4
-p [a, b, c, d]
-$ rdbg target.rb                       # run like `ruby target.rb`
-DEBUGGER: Session start (pid: 7656)
-[1, 7] in target.rb
-=>    1| a = 1
-      2| b = 2
-      3| c = 3
-      4| d = 4
-      5| p [a, b, c, d]
-      6|
-      7| __END__
-=>#0    <main> at target.rb:1
-(rdbg)
-```
-`rdbg` command suspends the program at the beginning of the given script (`target.rb` in this case) and you can use debug commands. `(rdbg)` is prompt. Let's set breakpoints on line 3 and line 5 with `break` command (`b` for short).
-```shell
-(rdbg) break 3                         # set breakpoint at line 3
-#0  BP - Line  /mnt/c/ko1/src/rb/ruby-debug/target.rb:3 (line)
-(rdbg) b 5                             # set breakpoint at line 5
-#1  BP - Line  /mnt/c/ko1/src/rb/ruby-debug/target.rb:5 (line)
-(rdbg) break                           # show all registered breakpoints
-#0  BP - Line  /mnt/c/ko1/src/rb/ruby-debug/target.rb:3 (line)
-#1  BP - Line  /mnt/c/ko1/src/rb/ruby-debug/target.rb:5 (line)
-```
-You can see that two breakpoints are registered. Let's continue the program by `continue` command.
-```shell
-(rdbg) continue
-[1, 7] in target.rb
-      1| a = 1
-      2| b = 2
-=>    3| c = 3
-      4| d = 4
-      5| p [a, b, c, d]
-      6|
-      7| __END__
-=>#0    <main> at target.rb:3
-Stop by #0  BP - Line  /mnt/c/ko1/src/rb/ruby-debug/target.rb:3 (line)
-(rdbg)
-```
-You can see that we can stop at line 3.
-Let's see the local variables with `info` command, and continue.
-You can also confirm that the program will suspend at line 5 and you can use `info` command again.
-```shell
-(rdbg) info
-=>#0    <main> at target.rb:3
-%self => main
-a => 1
-b => 2
-c => nil
-d => nil
-(rdbg) continue
-[1, 7] in target.rb
-      1| a = 1
-      2| b = 2
-      3| c = 3
-      4| d = 4
-=>    5| p [a, b, c, d]
-      6|
-      7| __END__
-=>#0    <main> at target.rb:5
-Stop by #1  BP - Line  /mnt/c/ko1/src/rb/ruby-debug/target.rb:5 (line)
-(rdbg) info
-=>#0    <main> at target.rb:5
-%self => main
-a => 1
-b => 2
-c => 3
-d => 4
-(rdbg) continue
-[1, 2, 3, 4]
-```
-By the way, using `rdbg` command you can suspend your application with `C-c` (SIGINT) and enter the debug console.
-It will help that if you want to know what the program is doing.
-### Use `rdbg` with commands written in Ruby
-If you want to run a command written in Ruby like like `rake`, `rails`, `bundle`, `rspec` and so on, you can use `rdbg -c` option.
-* Without `-c` option, `rdbg <name>` means that `<name>` is Ruby script and invoke it like `ruby <name>` with the debugger.
-* With `-c` option, `rdbg -c <name>` means that `<name>` is command in `PATH` and simply invoke it with the debugger.
-Examples:
-* `rdbg -c -- rails server`
-* `rdbg -c -- bundle exec ruby foo.rb`
-* `rdbg -c -- bundle exec rake test`
-* `rdbg -c -- ruby target.rb` is same as `rdbg target.rb`
-NOTE: `--` is needed to separate the command line options for `rdbg` and invoking command. For example, `rdbg -c rake -T` is recognized like `rdbg -c -T -- rake`. It should be `rdbg -c -- rake -T`.
-NOTE: If you want to use bundler (`bundle` command), you need to write `gem debug` line in your `Gemfile`.
-### Using VSCode
-Like other languages, you can use this debugger on the VSCode.
-1. Install [VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg)
-2. Open `.rb` file (e.g. `target.rb`)
-3. Register breakpoints with "Toggle breakpoint" in Run menu (or type F9 key)
-4. Choose "Start debugging" in "Run" menu (or type F5 key)
-5. You will see a dialog "Debug command line" and you can choose your favorite command line your want to run.
-6. Chosen command line is invoked with `rdbg -c` and VSCode shows the details at breakpoints.
-Please refer [Debugging in Visual Studio Code](https://code.visualstudio.com/docs/editor/debugging) for operations on VSCode.
-You can configure the extension in `.vscode/launch.json`.
-Please see the extension page for more details.
-## Remote debugging
-You can use this debugger as a remote debugger. For example, it will help the following situations:
-* Your application does not run on TTY and it is hard to use `binding.pry` or `binding.irb`.
-  * Your application is running on Docker container and there is no TTY.
-  * Your application is running as a daemon.
-  * Your application uses pipe for STDIN or STDOUT.
-* Your application is running as a daemon and you want to query the running status (checking a backtrace and so on).
-You can run your application as a remote debuggee and the remote debugger console can attach to the debuggee anytime.
-### Invoke as a remote debuggee
-There are two ways to invoke a script as remote debuggee: Use `rdbg --open` and require `debug/open` (or `debug/open_nonstop`).
-#### `rdbg --open` (or `rdbg -O` for short)
-You can run a script with `rdbg --open target.rb` command and run a `target.rb` as a debuggee program. It also opens the network port and suspends at the beginning of `target.rb`.
-```shell
-$ exe/rdbg --open target.rb
-DEBUGGER: Session start (pid: 7773)
-DEBUGGER: Debugger can attach via UNIX domain socket (/home/ko1/.ruby-debug-sock/ruby-debug-ko1-7773)
-DEBUGGER: wait for debugger connection...
-```
-By default, `rdbg --open` uses UNIX domain socket and generates path name automatically (`/home/ko1/.ruby-debug-sock/ruby-debug-ko1-7773` in this case).
-You can connect to the debuggee with `rdbg --attach` command (`rdbg -A` for short).
-```shell
-$ rdbg -A
-[1, 7] in target.rb
-=>    1| a = 1
-      2| b = 2
-      3| c = 3
-      4| d = 4
-      5| p [a, b, c, d]
-      6|
-      7| __END__
-=>#0    <main> at target.rb:1
-(rdbg:remote)
-```
-If there is no other opening ports on the default directory, `rdbg --attach` command chooses the only one opening UNIX domain socket and connect to it. If there are more files, you need to specify the file.
-When `rdbg --attach` connects to the debuggee, you can use any debug commands (set breakpoints, continue the program and so on) like local debug console. When an debuggee program exits, the remote console will also terminate.
-NOTE: If you use `quit` command, only remote console exits and the debuggee program continues to run (and you can connect it again). If you want to exit the debuggee program, use `kill` command.
-If you want to use TCP/IP for the remote debugging, you need to specify the port and host with `--port` like `rdbg --open --port 12345` and it binds to `localhost:12345`.
-To connect to the debuggee, you need to specify the port.
-```shell
-$ rdbg --attach 12345
-```
-If you want to choose the host to bind, you can use `--host` option.
-Note that all messages communicated between the debugger and the debuggee are *NOT* encrypted so please use remote debugging carefully.
-#### `require 'debug/open'` in a program
-If you can modify the program, you can open debugging port by adding `require 'debug/open'` line in the program.
-If you don't want to stop the program at the beginning, you can also use `require 'debug/open_nonstop'`.
-Using `debug/open_nonstop` is useful if you want to open a backdoor to the application.
-However, it is also danger because it can become another vulnerability.
-Please use it carefully.
-By default, UNIX domain socket is used for the debugging port. To use TCP/IP, you can set the `RUBY_DEBUG_PORT` environment variable.
-```shell
-$ RUBY_DEBUG_PORT=12345 ruby target.rb
-```
-### Integration with external debugger frontend
-You can attach with external debugger frontend with VSCode and Chrome.
-```
-$ rdbg --open=[frontend] target.rb
-```
-will open a debug port and `[frontend]` can attach to the port.
-Also `open` command allows opening the debug port.
-#### VSCode integration
-([vscode-rdbg v0.0.9](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg) or later is required)
-If you don't run a debuggee Ruby process on VSCode, you can attach with VSCode later with the following steps.
-`rdbg --open=vscode` opens the debug port and tries to invoke the VSCode (`code` command).
-```
-$ rdbg --open=vscode target.rb
-DEBUGGER: Debugger can attach via UNIX domain socket (/tmp/ruby-debug-sock-1000/ruby-debug-ko1-27706)
-DEBUGGER: wait for debugger connection...
-Launching: code /tmp/ruby-debug-vscode-20211014-27706-gd7e85/ /tmp/ruby-debug-vscode-20211014-27706-gd7e85/README.rb
-DEBUGGER: Connected.
-```
-And it tries to invoke the new VSCode window and VSCode starts attaching to the debuggee Ruby program automatically.
-You can also use `open vscode` command in REPL.
-```
-$ rdbg target.rb
-[1, 8] in target.rb
-     1|
-=>   2| p a = 1
-     3| p b = 2
-     4| p c = 3
-     5| p d = 4
-     6| p e = 5
-     7|
-     8| __END__
-=>#0    <main> at target.rb:2
-(rdbg) open vscode    # command
-DEBUGGER: wait for debugger connection...
-DEBUGGER: Debugger can attach via UNIX domain socket (/tmp/ruby-debug-sock-1000/ruby-debug-ko1-28337)
-Launching: code /tmp/ruby-debug-vscode-20211014-28337-kg9dm/ /tmp/ruby-debug-vscode-20211014-28337-kg9dm/README.rb
-DEBUGGER: Connected.
-```
-If the machine which runs the Ruby process doesn't have a `code` command, the following message will be shown:
-```
-(rdbg) open vscode
-DEBUGGER: wait for debugger connection...
-DEBUGGER: Debugger can attach via UNIX domain socket (/tmp/ruby-debug-sock-1000/ruby-debug-ko1-455)
-Launching: code /tmp/ruby-debug-vscode-20211014-455-gtjpwi/ /tmp/ruby-debug-vscode-20211014-455-gtjpwi/README.rb
-DEBUGGER: Can not invoke the command.
-Use the command-line on your terminal (with modification if you need).
-  code /tmp/ruby-debug-vscode-20211014-455-gtjpwi/ /tmp/ruby-debug-vscode-20211014-455-gtjpwi/README.rb
-If your application is running on a SSH remote host, please try:
-  code --remote ssh-remote+[SSH hostname] /tmp/ruby-debug-vscode-20211014-455-gtjpwi/ /tmp/ruby-debug-vscode-20211014-455-gtjpwi/README.rb
-```
-and try to use proposed commands.
-Note that you can attach with `rdbg --attach` and continue REPL debugging.
-#### Chrome DevTool integration
-With `rdbg --open=chrome` command will show the following message.
-```
-$ rdbg target.rb --open=chrome
-DEBUGGER: Debugger can attach via TCP/IP (127.0.0.1:43633)
-DEBUGGER: With Chrome browser, type the following URL in the address-bar:
-   devtools://devtools/bundled/inspector.html?ws=127.0.0.1:43633
-DEBUGGER: wait for debugger connection...
-```
-Type `devtools://devtools/bundled/inspector.html?ws=127.0.0.1:43633` in the address-bar on Chrome browser, and you can continue the debugging with chrome browser.
-Also `open chrome` command works like `open vscode`.
-For more information about how to use Chrome debugging, you might want to read [here](https://developer.chrome.com/docs/devtools/).
-## Configuration
-You can configure the debugger's behavior with debug commands and environment variables.
-When the debug session is started, initial scripts are loaded so you can put your favorite configurations in the initial scripts.
-### Configuration list
-You can configure debugger's behavior with environment variables and `config` command. Each configuration has environment variable and the name which can be specified by `config` command.
-```
-# configuration example
-config set log_level INFO
-config set no_color true
-```
-<% cat = nil; DEBUGGER__::CONFIG_SET.each do |key, (env, desc)| %>
-<% /\A(\w+): (.+)/ =~ desc; if cat != $1; cat = 1 %>
-* <%= $1 %>
-<% cat = $1; end %>  * `<%= env %>` (`<%= key %>`): <%= $2 %><% end %>
-### Initial scripts
-If there is `~/.rdbgrc`, the file is loaded as an initial script (which contains debug commands) when the debug session is started.
-* `RUBY_DEBUG_INIT_SCRIPT` environment variable can specify the initial script file.
-* You can specify the initial script with `rdbg -x initial_script` (like gdb's `-x` option).
-Initial scripts are useful to write your favorite configurations.
-For example, you can set break points with `break file:123` in `~/.rdbgrc`.
-If there are `~/.rdbgrc.rb` is available, it is also loaded as a ruby script at same timing.
-## Debug command on the debug console
-On the debug console, you can use the following debug commands.
-There are additional features:
-* `<expr>` without debug command is almost same as `pp <expr>`.
-  * If the input line `<expr>` does *NOT* start with any debug command, the line `<expr>` will be evaluated as a Ruby expression and the result will be printed with `pp` method. So that the input `foo.bar` is same as `pp foo.bar`.
-  * If `<expr>` is recognized as a debug command, of course it is not evaluated as a Ruby expression, but is executed as debug command. For example, you can not evaluate such single letter local variables `i`, `b`, `n`, `c` because they are single letter debug commands. Use `p i` instead.
-* `Enter` without any input repeats the last command (useful when repeating `step`s).
-* `Ctrl-D` is equal to `quit` command.
-* [debug command compare sheet - Google Sheets](https://docs.google.com/spreadsheets/d/1TlmmUDsvwK4sSIyoMv-io52BUUz__R5wpu-ComXlsw0/edit?usp=sharing)
-You can use the following debug commands. Each command should be written in 1 line.
-The `[...]` notation means this part can be eliminate. For example, `s[tep]` means `s` or `step` are valid command. `ste` is not valid.
-The `<...>` notation means the argument.
-<%= DEBUGGER__.help %>
-## Debugger API
-### Start debugging
-#### Start by requiring a library
-You can start debugging without `rdbg` command by requiring the following libraries:
-* `require 'debug'`: Same as `rdbg --nonstop --no-sigint-hook`.
-* `require 'debug/start'`: Same as `rdbg`.
-* `require 'debug/open'`: Same as `rdbg --open`.
-* `require 'debug/open_nonstop'`: Same as `rdbg --open --nonstop`.
-You need to require one of them at the very beginning of the application.
-Using `ruby -r` (for example `ruby -r debug/start target.rb`) is another way to invoke with debugger.
-NOTE: Until Ruby 3.0, there is old `lib/debug.rb` standard library. So that if this gem is not installed, or if `Gemfile` missed to list this gem and `bundle exec` is used, you will see the following output:
-```shell
-$ ruby -r debug -e0
-.../2.7.3/lib/ruby/2.7.0/x86_64-linux/continuation.so: warning: callcc is obsolete; use Fiber instead
-Debug.rb
-Emacs support available.
-.../2.7.3/lib/ruby/2.7.0/rubygems/core_ext/kernel_require.rb:162:    if RUBYGEMS_ACTIVATION_MONITOR.respond_to?(:mon_owned?)
-(rdb:1)
-```
-`lib/debug.rb` was not maintained well in recent years, and the purpose of this library is to rewrite old `lib/debug.rb` with recent techniques.
-#### Start by method
-After loading `debug/session`, you can start debug session with the following methods. They are convenient if you want to specify debug configurations in your program.
-* `DEBUGGER__.start(**kw)`: start debug session with local console.
-* `DEBUGGER__.open(**kw)`: open debug port with configuration (without configurations open with UNIX domain socket)
-* `DEBUGGER__.open_unix(**kw)`: open debug port with UNIX domain socket
-* `DEBUGGER__.open_tcp(**kw)`: open debug port with TCP/IP
-For example:
-```ruby
-require 'debug/session'
-DEBUGGER__.start(no_color: true,    # disable colorize
-                 log_level: 'INFO') # Change log_level to INFO
-... # your application code
-```
-### `binding.break` method
-`binding.break` (or `binding.b`) set breakpoints at written line. It also has several keywords.
-If `do: 'command'` is specified, the debugger suspends the program and run the `command` as a debug command and continue the program.
-It is useful if you only want to call a debug command and don't want to stop there.
-```
-def initialize
-  @a = 1
-  binding.b do: 'watch @a'
-end
-```
-On this case, register a watch breakpoint for `@a` and continue to run.
-If `pre: 'command'` is specified, the debugger suspends the program and run the `command` as a debug command, and keep suspend.
-It is useful if you have operations before suspend.
-```
-def foo
-  binding.b pre: 'p bar()'
-  ...
-end
-```
-On this case, you can see the result of `bar()` every time you stop there.
-## rdbg command help
-```
-<%= `exe/rdbg --help` %>
-```
-# Contributing
-Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/debug.
-This debugger is not mature so your feedback will help us.
-Please also check the [contributing guideline](/CONTRIBUTING.md).
-# Acknowledgement
-* Some tests are based on [deivid-rodriguez/byebug: Debugging in Ruby 2](https://github.com/deivid-rodriguez/byebug)
-* Several codes in `server_cdp.rb` are based on [geoffreylitt/ladybug: Visual Debugger](https://github.com/geoffreylitt/ladybug)

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.3.0/LICENSE.md DELETED Viewed

@@ -1,20 +0,0 @@
-Copyright (c) 2009-2020 Rick Olson, Zack Hobson
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.3.0/README.md DELETED Viewed

@@ -1,55 +0,0 @@
-# [![Faraday](./docs/assets/img/repo-card-slim.png)][website]
-[![Gem Version](https://badge.fury.io/rb/faraday.svg)](https://rubygems.org/gems/faraday)
-[![GitHub Actions CI](https://github.com/lostisland/faraday/workflows/CI/badge.svg)](https://github.com/lostisland/faraday/actions?query=workflow%3ACI)
-[![GitHub Discussions](https://img.shields.io/github/discussions/lostisland/faraday?logo=github)](https://github.com/lostisland/faraday/discussions)
-Faraday is an HTTP client library abstraction layer that provides a common interface over many
-adapters (such as Net::HTTP) and embraces the concept of Rack middleware when processing the request/response cycle.
-You probably don't want to use Faraday directly in your project, as it will lack an actual client library to perform
-requests. Instead, you probably want to have a look at [Awesome Faraday][awesome] for a list of available adapters.
-## Getting Started
-The best starting point is the [Faraday Website][website], with its introduction and explanation.
-Need more details? See the [Faraday API Documentation][apidoc] to see how it works internally.
-## Supported Ruby versions
-This library aims to support and is [tested against][actions] the currently officially supported Ruby
-implementations. This means that, even without a major release, we could add or drop support for Ruby versions,
-following their [EOL](https://endoflife.date/ruby).
-Currently that means we support Ruby 2.6+
-If something doesn't work on one of these Ruby versions, it's a bug.
-This library may inadvertently work (or seem to work) on other Ruby
-implementations and versions, however support will only be provided for the versions listed
-above.
-If you would like this library to support another Ruby version, you may
-volunteer to be a maintainer. Being a maintainer entails making sure all tests
-run and pass on that implementation. When something breaks on your
-implementation, you will be responsible for providing patches in a timely
-fashion. If critical issues for a particular implementation exist at the time
-of a major release, support for that Ruby version may be dropped.
-## Contribute
-Do you want to contribute to Faraday?
-Open the issues page and check for the `help wanted` label!
-But before you start coding, please read our [Contributing Guide][contributing]
-## Copyright
-&copy; 2009 - 2021, the [Faraday Team][faraday_team]. Website and branding design by [Elena Lo Piccolo](https://elelopic.design).
-[awesome]:      https://github.com/lostisland/awesome-faraday/#adapters
-[website]:      https://lostisland.github.io/faraday
-[faraday_team]: https://lostisland.github.io/faraday/team
-[contributing]: https://github.com/lostisland/faraday/blob/master/.github/CONTRIBUTING.md
-[apidoc]:       https://www.rubydoc.info/github/lostisland/faraday
-[actions]:      https://github.com/lostisland/faraday/actions
-[jruby]:        http://jruby.org/
-[rubinius]:     http://rubini.us/
-[license]:      LICENSE.md