webri 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c4bc8110feecac22d65e1e47e5fda7dc5315ea7dd4f1d4ab67c62d30af6bb8cb
+  data.tar.gz: 9574bb0c08d78ffd32a6627d0c19ecf0f81e7f7ba0303d64c0b6e92e93f2395f
+SHA512:
+  metadata.gz: c7b52fa6deb5b9b2029d70ff7ea2b226b2734aa39a2cd6aeb8dce1e7ee2f3e6a687321997beea7b9d958a11cf3b8017d149bcd8dee82a5a98e645619be50db48
+  data.tar.gz: 1942e35d5aca012c2c8843cdf222502e787226ee5834b10d88409d0a4ccde8178c874a79a52d38c0bf36325a01ca5dcfec4ff6188360493ba2d2f3b5cd42e9f6

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-11-28
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+https://github.com/BurdetteLamar/webri/issues.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 BurdetteLamar
+
+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/README.md

@@ -0,0 +1,456 @@
+# WebRI
+
+WebRI has a command-line utility, `webri`, for displaying Ruby online documentation.
+
+It is in some ways similar to [Ruby's RI utility](https://ruby.github.io/rdoc/RI_md.html),
+but differs mainly in that:
+
+- **RI:** displays text-only documentation the the user's command window.
+- **WebRI:** opens documentation web pages
+  from [Ruby official on-line documentation](https://docs.ruby-lang.org/en)
+  in the user's default web browser.
+
+WebRI displays documentation for:
+
+- A **class** or **module**: opens its web page.
+- A **method**: opens the web page for its class/module _scrolled to the method's documentation_.
+- A Ruby **file**: opens a free-standing web page.
+
+## Usage
+
+```
+webri [options]
+```
+
+`webri` is an interactive program;
+when invoked, it prints its prompt:
+
+```
+$ webri
+webri>
+```
+
+To exit, type `exit`:
+
+```bash
+$ webri
+webri> exit
+$
+```
+
+At the prompt, you can type:
+
+- The name of a [class or module][1].
+- The name of a [singleton method][2].
+- The name of an [instance method][3].
+- The name of a [Ruby file][4].
+- An abbreviation of any of the above.
+- One of the [special names][5] `@help` or `@readme`.
+
+### Class or Module
+
+For a `name` beginning with a capital letter,
+WebRI finds the names of classes and modules beginning with that name.
+
+When exactly one such class/module name is found:
+
+- If `name` is the exact name of a class/module, opens its page:
+
+```
+webri> Array
+Found one class/module name starting with 'Array'
+  Array (Array.html)
+Opening web page https://docs.ruby-lang.org/en/3.4/Array.html.
+```
+
+- If `name` is the start of one class/module, offers to open its page:
+
+```
+webri> Arr
+Found one class/module name starting with 'Arr'
+  Array (Array.html)
+Open page Array.html? (y or n):  y
+Opening web page https://docs.ruby-lang.org/en/3.4/Array.html.
+```
+
+When multiple such class/module names are found, offers to list the found names:
+
+```
+webri> Ar
+Found 2 class/module names starting with 'Ar'.
+Show 2 class/module names?' (y or n):  y
+       0:  ArgumentError (ArgumentError.html)
+       1:  Array (Array.html)
+Type a number to choose, or Return to skip:  0
+Opening web page https://docs.ruby-lang.org/en/3.4/ArgumentError.html.
+```
+
+
+When no such class/module name is found, offers to list all class/module names:
+
+```
+webri> Nosuch
+Found no class/module name starting with 'Nosuch'.
+Show 1364 class/module names? (y or n):  n
+```
+
+### Singleton Method
+
+For a `name` beginning with `::`,
+WebRI finds the names of singleton methods beginning
+with that name.
+
+When exactly one such singleton method name is found:
+
+- If `name` is the exact name of one singleton method, opens its class/module page at that method:
+
+```
+webri> ::zcat
+Found one singleton method name starting with '::zcat'
+  ::zcat
+Opening web page https://docs.ruby-lang.org/en/3.4/Zlib/GzipReader.html at method ::zcat.
+
+```
+
+- If `name` is the start of the found name, offers to open its page:
+
+```
+webri> ::zca
+Found one singleton method name starting with '::zca'
+  ::zcat
+Open page Zlib/GzipReader.html at method ::zcat? (y or n):  y
+Opening web page https://docs.ruby-lang.org/en/3.4/Zlib/GzipReader.html at method ::zcat.
+```
+
+When multiple such singleton method names are found offer to list the found names:
+
+```
+webri> ::z
+Found 5 singleton method names starting with '::z'.
+Show 5 names?' (y or n):  y
+       0:  ::zcat (in Zlib::GzipReader)
+       1:  ::zero? (in File)
+       2:  ::zip? (in RDoc::Parser)
+       3:  ::zlib_version (in Zlib)
+       4:  ::zone_offset (in Time)
+Type a number to choose, or Return to skip:  3
+Opening web page https://docs.ruby-lang.org/en/3.4/Zlib.html at method ::zlib_version.
+
+```
+
+When no such singleton method name is found, offers to list all singleton method names:
+
+```
+webri> ::nosuch
+Found no singleton method name starting with '::nosuch'.
+Show names of all 2288 singleton methods? (y or n):  n
+```
+
+### Instance Method
+
+For a `name` beginning with `#`,
+WebRI finds the names of instance methods beginning
+with that name.
+
+When exactly one such instance method name is found:
+
+- If `name` is the exact name of one instance method, opens its class/module page at that method:
+
+```
+webri> #yield_self
+Found one instance method name starting with '#yield_self'
+  #yield_self
+Opening web page https://docs.ruby-lang.org/en/3.4/Kernel.html at method #yield_self.
+```
+
+- If `name` is the start of the found name, offers to open its page:
+
+```
+webri> #yield_s
+Found one instance method name starting with '#yield_s'
+  #yield_self
+Open page Kernel.html at method #yield_self? (y or n):  y
+Opening web page https://docs.ruby-lang.org/en/3.4/Kernel.html at method #yield_self.
+```
+
+When multiple such instance method names are found offer to list the found names:
+
+```
+webri> #yield
+Found 4 instance method names starting with '#yield'.
+Show 4 names?' (y or n):  y
+       0:  #yield (in Proc)
+       1:  #yield_node (in Prism::DSL)
+       2:  #yield_self (in Kernel)
+       3:  #yields_directive (in RDoc::MarkupReference)
+Type a number to choose, or Return to skip:  0
+Opening web page https://docs.ruby-lang.org/en/3.4/Proc.html at method #yield.
+```
+
+When no such instance method name is found, offers to list all instance method names:
+
+```
+webri>
+webri> #nosuch
+Found no instance method name starting with '#nosuch'.
+Show names of all 10370 instance methods? (y or n):  n
+```
+
+### Ruby 'File'
+
+For a name beginning with `ruby:`,
+finds the names of ruby files beginning
+with that name.
+
+When exactly one such file name is found:
+
+- If the name is the exact name of the found name, opens its page:
+
+```
+webri> ruby:operators
+Found one file name starting with 'operators'
+  operators (syntax/operators_rdoc.html)
+```
+
+- If `name` is the start of the found name, offers to open its page:
+
+```
+webri> ruby:opera
+Found one file name starting with 'opera'
+  operators (syntax/operators_rdoc.html)
+Open page syntax/operators_rdoc.html? (y or n):  y
+Opening web page https://docs.ruby-lang.org/en/3.4/syntax/operators_rdoc.html.
+
+```
+
+When multiple such file names are found offer to list the found names:
+
+```
+webri> ruby:o
+Found 4 file names starting with 'o'.
+Show 4 names?' (y or n):  y
+       0:  operators (syntax/operators_rdoc.html)
+       1:  option_dump (ruby/option_dump_md.html)
+       2:  option_params (optparse/option_params_rdoc.html)
+       3:  options (ruby/options_md.html)
+Type a number to choose, or Return to skip:  2
+
+```
+
+When no such file name is found, offers to list all file names:
+
+```
+webri> ruby:nosuch
+Found no file name starting with 'nosuch'.
+Show names of all 83 files? (y or n):  y
+       0:  COPYING (COPYING.html)
+       1:  COPYING.ja (COPYING_ja.html)
+       2:  LEGAL (LEGAL.html)
+       3:  NEWS (NEWS_md.html)
+       4:  NEWS-1.8.7 (NEWS/NEWS-1_8_7.html)
+       5:  NEWS-1.9.1 (NEWS/NEWS-1_9_1.html)
+       6:  NEWS-1.9.2 (NEWS/NEWS-1_9_2.html)
+       7:  NEWS-1.9.3 (NEWS/NEWS-1_9_3.html)
+       8:  NEWS-2.0.0 (NEWS/NEWS-2_0_0.html)
+       9:  NEWS-2.1.0 (NEWS/NEWS-2_1_0.html)
+      10:  NEWS-2.2.0 (NEWS/NEWS-2_2_0.html)
+      11:  NEWS-2.3.0 (NEWS/NEWS-2_3_0.html)
+      12:  NEWS-2.4.0 (NEWS/NEWS-2_4_0.html)
+      13:  NEWS-2.5.0 (NEWS/NEWS-2_5_0.html)
+      14:  NEWS-2.6.0 (NEWS/NEWS-2_6_0.html)
+      15:  NEWS-2.7.0 (NEWS/NEWS-2_7_0.html)
+      16:  NEWS-3.0.0 (NEWS/NEWS-3_0_0_md.html)
+      17:  NEWS-3.1.0 (NEWS/NEWS-3_1_0_md.html)
+      18:  NEWS-3.2.0 (NEWS/NEWS-3_2_0_md.html)
+      19:  NEWS-3.3.0 (NEWS/NEWS-3_3_0_md.html)
+      20:  README (README_md.html)
+      21:  README.ja (README_ja_md.html)
+      22:  argument_converters (optparse/argument_converters_rdoc.html)
+      23:  assignment (syntax/assignment_rdoc.html)
+      24:  bsearch (bsearch_rdoc.html)
+      25:  bug_triaging (bug_triaging_rdoc.html)
+      26:  building_ruby (contributing/building_ruby_md.html)
+      27:  calendars (date/calendars_rdoc.html)
+      28:  calling_methods (syntax/calling_methods_rdoc.html)
+      29:  case_mapping (case_mapping_rdoc.html)
+      30:  character_selectors (character_selectors_rdoc.html)
+      31:  command_injection (command_injection_rdoc.html)
+      32:  comments (syntax/comments_rdoc.html)
+      33:  contributing (contributing_md.html)
+      34:  control_expressions (syntax/control_expressions_rdoc.html)
+      35:  creates_option (optparse/creates_option_rdoc.html)
+      36:  dig_methods (dig_methods_rdoc.html)
+      37:  distribution (distribution_md.html)
+      38:  documentation_guide (contributing/documentation_guide_md.html)
+      39:  dtrace_probes (dtrace_probes_rdoc.html)
+      40:  encodings (encodings_rdoc.html)
+      41:  exceptions (exceptions_md.html)
+      42:  exceptions (syntax/exceptions_rdoc.html)
+      43:  extension (extension_rdoc.html)
+      44:  extension.ja (extension_ja_rdoc.html)
+      45:  fiber (fiber_md.html)
+      46:  format_specifications (format_specifications_rdoc.html)
+      47:  globals (globals_rdoc.html)
+      48:  glossary (contributing/glossary_md.html)
+      49:  implicit_conversion (implicit_conversion_rdoc.html)
+      50:  index (index_md.html)
+      51:  keywords (syntax/keywords_rdoc.html)
+      52:  literals (syntax/literals_rdoc.html)
+      53:  maintainers (maintainers_md.html)
+      54:  making_changes_to_ruby (contributing/making_changes_to_ruby_md.html)
+      55:  making_changes_to_stdlibs (contributing/making_changes_to_stdlibs_md.html)
+      56:  marshal (marshal_rdoc.html)
+      57:  memory_view (memory_view_md.html)
+      58:  methods (regexp/methods_rdoc.html)
+      59:  methods (syntax/methods_rdoc.html)
+      60:  miscellaneous (syntax/miscellaneous_rdoc.html)
+      61:  modules_and_classes (syntax/modules_and_classes_rdoc.html)
+      62:  operators (syntax/operators_rdoc.html)
+      63:  option_dump (ruby/option_dump_md.html)
+      64:  option_params (optparse/option_params_rdoc.html)
+      65:  options (ruby/options_md.html)
+      66:  packed_data (packed_data_rdoc.html)
+      67:  pattern_matching (syntax/pattern_matching_rdoc.html)
+      68:  precedence (syntax/precedence_rdoc.html)
+      69:  ractor (ractor_md.html)
+      70:  refinements (syntax/refinements_rdoc.html)
+      71:  reporting_issues (contributing/reporting_issues_md.html)
+      72:  rjit (rjit/rjit_md.html)
+      73:  security (security_rdoc.html)
+      74:  signals (signals_rdoc.html)
+      75:  standard_library (standard_library_md.html)
+      76:  strftime_formatting (strftime_formatting_rdoc.html)
+      77:  syntax (syntax_rdoc.html)
+      78:  testing_ruby (contributing/testing_ruby_md.html)
+      79:  tutorial (optparse/tutorial_rdoc.html)
+      80:  unicode_properties (regexp/unicode_properties_rdoc.html)
+      81:  windows (windows_md.html)
+      82:  yjit (yjit/yjit_md.html)
+Type a number to choose, or Return to skip:  80
+Opening web page https://docs.ruby-lang.org/en/3.4/regexp/unicode_properties_rdoc.html.
+```
+
+### Special Names
+
+To display the WebRI help text, use the special name `@help`:
+
+```
+webri> @help
+Showing help.
+webri is a console application for displaying Ruby online HTML documentation.
+Documentation pages are opened in the default web browser.
+
+Usage: webri [options]
+
+For more information, see https://github.com/BurdetteLamar/webri/blob/main/README.md.
+
+Options:
+    -i, --info                       Prints information about webri.
+    -r, --release=RELEASE            Sets the Ruby release to document.
+    -n, --noop                       Does not actually open web pages.
+    -h, --help                       Prints this help.
+    -v, --version                    Prints the version of webri.
+```
+
+To open the WebRI README page, use the special name `@readme`:
+
+```
+webri> @readme
+Opening web page https://github.com/BurdetteLamar/webri/blob/main/README.md.
+```
+
+### Options
+
+Option `--info` prints information about WebRI,
+including the documentation release to be used (`3.4` in this example),
+then exits:
+
+```
+$ webri --info
+Ruby documentation release:  '3.4'
+Ruby documentation URL:      'https://docs.ruby-lang.org/en/3.4/table_of_contents.html'
+Executable to open page:     'start'
+Names:
+   1364 class names
+   1175 singleton_method names
+   4407 instance_method names
+     81 file names
+```
+
+Option `--release` sets the release of the documentation to be used.
+The collections of names will vary among releases:
+
+```
+$ webri --release=3.2 --info
+Ruby documentation release:  '3.2'
+Ruby documentation URL:      'https://docs.ruby-lang.org/en/3.2/table_of_contents.html'
+Executable to open page:     'start'
+Names:
+   1262 class names
+   1301 singleton_method names
+   4397 instance_method names
+     73 file names
+$ webri --release=3.3 --info
+Ruby documentation release:  '3.3'
+Ruby documentation URL:      'https://docs.ruby-lang.org/en/3.3/table_of_contents.html'
+Executable to open page:     'start'
+Names:
+   1469 class names
+   1270 singleton_method names
+   4638 instance_method names
+     77 file names
+```
+
+Issues a message if the given release is unknown:
+
+```
+$ webri --release foo
+Unknown documentation release:  foo
+Master release:                 master
+Supported releases:             3.4, 3.3, 3.2
+Unsupported releases:           3.1, 3.0
+```
+
+Option `--noop` suppresses the actual opening of a web page,
+instead reporting the relevant command:
+
+```
+$ webri --noop Array
+Found one class/module name starting with 'Array'
+  Array (Array.html)
+Opening web page https://docs.ruby-lang.org/en/3.4/Array.html.
+Command: 'start https://docs.ruby-lang.org/en/3.4/Array.html'
+```
+
+Option `--help` prints the WebRI help text.
+
+Option `--version` prints the WebRI version.
+
+## Installation
+
+To install the gem:
+
+```
+$ gem install webri
+```
+
+## Bugs and Issues
+
+Bug reports and comments are welcome at https://github.com/BurdetteLamar/webri/issues.
+
+## License
+
+The gem is available as open source under the terms
+of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Webri project's codebases,
+issue trackers, chat rooms and mailing lists is expected
+to follow the [code of conduct](https://github.com/BurdetteLamar/webri/blob/master/CODE_OF_CONDUCT.md).
+
+[1]: rdoc-ref:README.md@Class+or+Module
+[2]: rdoc-ref:README.md@Singleton+Method
+[3]: rdoc-ref:README.md@Instance+Method
+[4]: rdoc-ref:README.md@Ruby+File
+[5]: rdoc-ref:README.md@Special+Names

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/bin/webri

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+# A console application to display Ruby HTML documentation.
+
+require 'optparse'
+require_relative '../lib/webri/version'
+require_relative '../lib/webri'
+
+options = {}
+
+parser = OptionParser.new
+
+parser.version = WebRI::VERSION
+parser.banner = <<-BANNER
+webri is a console application for displaying Ruby online HTML documentation.
+Documentation pages are opened in the default web browser.
+
+Usage: #{parser.program_name} [options]
+
+For more information, see https://github.com/BurdetteLamar/webri/blob/main/README.md.
+
+BANNER
+
+parser.separator('Options:')
+parser.on('-i', '--info', 'Prints information about webri.') do
+  options[:info] = true
+end
+parser.on('-r=RELEASE', '--release=RELEASE', 'Sets the Ruby release to document.') do |value|
+  options[:release] = value
+end
+parser.on('-n', '--noop', 'Does not actually open web pages.') do |value|
+  options[:noop] = true
+end
+parser.on('-h', '--help', 'Prints this help.') do
+  puts parser
+  exit
+end
+parser.on('-v', '--version', 'Prints the version of webri.') do
+  puts WebRI::VERSION
+  exit
+end
+
+parser.parse!
+
+unless ARGV.empty?
+  $stderr.puts "Argument error: No arguments allowed."
+  $stderr.puts ''
+  $stdout.puts parser.help
+  exit
+end
+
+WebRI.new(options)

data/lib/webri/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class WebRI
+  VERSION = "1.0.1"
+end

data/lib/webri.rb

@@ -0,0 +1,589 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+require 'open-uri'
+require 'rexml'
+require 'cgi'
+
+# TODO: Use reline.
+#
+# TODO: Subroutinize.
+# TODO: Make initialization faster.
+
+# TODO: Build test names from ruby-lang.org (not webri).
+#
+# TODO: Choose dynamically the test names (rather than fixed)?
+# TODO: Test methods with trailing special chars, and with all special chars
+# TODO: Test on Linux.
+# TODO: Test all releases.
+# TODO: Test all pages(?).
+
+# TODO: Make it work for naked method ('parse') or dotted method ('.parse').
+
+# TODO: Support pager.
+
+# TODO: Support .webrirc.
+# TODO: Make it save options to .webrirc.
+# TODO: Make it show .webrirc.
+
+# A class to display Ruby online HTML documentation.
+class WebRI
+
+  # Site of the official documentation.
+  DocSite = 'https://docs.ruby-lang.org/en/'
+
+  # Get the info from the Ruby doc site's table of contents
+  # and build our @index_for_type.
+  def initialize(options = {})
+    capture_options(options)
+    set_doc_release
+    get_toc_html
+    build_indexes
+    print_info if @info
+    while true
+      $stdout.write('webri> ')
+      $stdout.flush
+      response = $stdin.gets.chomp
+      exit if response == 'exit'
+      next if response.empty?
+      if response.split(' ').size > 1
+        puts "One name at a time, please."
+        next
+      end
+      show(response)
+    end
+  end
+
+  def set_doc_release
+    supported_releases = []
+    unsupported_releases = []
+    master_release = nil
+    io = URI.open('https://docs.ruby-lang.org/en/')
+    lines = io.readlines
+    lines.each do |line|
+      next unless line.match(/<a/)
+      doc = REXML::Document.new(line)
+      _, release, end_of_support = doc.root.text.split(' ')
+      break if release.start_with?('2')
+      if end_of_support
+        unsupported_releases.push(release)
+      elsif release == 'master'
+        master_release = release
+      else
+        supported_releases.push(release)
+      end
+    end
+    all_releases = [master_release] + supported_releases + unsupported_releases
+    if @doc_release
+      unless all_releases.include?(@doc_release)
+        puts "Unknown documentation release:  #{@doc_release}"
+        puts "Available releases: #{all_releases.join(' ')}"
+        exit
+      end
+    else
+      a = RUBY_VERSION.split('.')
+      @doc_release ||= a[0..1].join('.')
+    end
+  end
+
+  def print_info
+    puts "Ruby documentation release:  #{@doc_release}"
+    puts "Ruby documentation URL:      #{@toc_url}"
+    puts "Executable to open page:     #{opener_name}"
+    puts "Names:"
+    @index_for_type.each_pair do |type, items|
+      puts format("  %5d %s names", items.count, type)
+    end
+    exit
+  end
+
+  def build_indexes
+    # Index for each type of entry.
+    # Each index has a hash; key is name, value is array of URIs.
+    @index_for_type = {
+      class: {}, # Has both classes and modules.
+      singleton_method: {},
+      instance_method: {},
+      file: {},
+    }
+    # Iterate over the lines of the TOC page.
+    lines = @toc_html.split("\n")
+    i = 0
+    while i < lines.count
+      item_line = lines[i]
+      i += 1
+      next unless item_line.match('<li class="(\w+)"')
+      class_attr_value = $1 # Save for later.
+      # We have a pair of lines such as:
+      #     <li class="file">
+      #       <a href="COPYING.html">COPYING</a>
+      anchor_line = lines[i] # Second line of pair.
+      # Consume anchor_line.
+      i += 1
+      # We capture variables thus:
+      # - +type+ is the value of attribute 'class'.
+      # - +path+ is the value of attribute 'href'.
+      # - +full_name+ is the HTML text.
+      type = class_attr_value
+      _, path, rest = anchor_line.split('"')
+      full_name = rest.split(/<|>/)[1]
+      full_name = CGI.unescapeHTML(full_name)
+      case type
+      when 'class', 'module'
+        index = @index_for_type[:class]
+        if index.include?(full_name)
+          entry = index[full_name]
+        else
+          entry = ClassEntry.new(full_name)
+          index[full_name] = entry
+        end
+        entry.paths.push(path) unless entry.paths.include?(path)
+      when 'file'
+        index = @index_for_type[:file]
+        if index.include?(full_name)
+          entry = index[full_name]
+        else
+          entry = FileEntry.new(full_name)
+          index[full_name] = entry
+        end
+        entry.paths.push(path) unless entry.paths.include?(path)
+      when 'method'
+        case anchor_line
+        when /method-c-/
+          index = @index_for_type[:singleton_method]
+          if index.include?(full_name)
+            entry = index[full_name]
+          else
+            entry = SingletonMethodEntry.new(full_name)
+            index[full_name] = entry
+          end
+          entry.paths.push(path) unless entry.paths.include?(path)
+        when /method-i-/
+          index = @index_for_type[:instance_method]
+          if index.include?(full_name)
+            entry = index[full_name]
+          else
+            entry = InstanceMethodEntry.new(full_name)
+            index[full_name] = entry
+          end
+          entry.paths.push(path) unless entry.paths.include?(path)
+        else
+          fail anchor_line
+        end
+      else
+        fail class_attr_val
+      end
+    end
+  end
+
+  def capture_options(options)
+    @noop = options[:noop]
+    @info = options[:info]
+    @doc_release = options[:release]
+  end
+
+  def get_toc_html
+    # Construct the doc release; e.g., '3.4'.
+    # Get the doc table of contents as a temp file.
+    @toc_url = DocSite + @doc_release + '/table_of_contents.html'
+    begin
+      toc_file = URI.open(@toc_url)
+      @toc_html = toc_file.read
+    rescue Socket::ResolutionError => x
+      message = "#{x.class}: #{x.message}\nPossibly not connected to internet."
+      $stderr.puts(message)
+      exit
+    end
+  end
+
+  class Entry
+
+    attr_accessor :full_name, :paths
+
+    def initialize(full_name)
+      self.full_name = full_name
+      self.paths = []
+    end
+
+    # Return hash of choice strings for entries.
+    def self.choices(entries)
+      choices = {}
+      entries.each_pair do |name, entry|
+        entry.paths.each do |path|
+          choice = self.choice(name, path)
+          choices[choice] = path
+        end
+      end
+      Hash[choices.sort]
+    end
+
+    def self.uri(path)
+      URI.parse(path)
+    end
+
+    # Return the full name from a choice string.
+    def self.full_name_for_choice(choice)
+      choice.split(' ').first.sub(/:$/, '')
+    end
+
+  end
+
+  class ClassEntry < Entry
+
+    # Return a choice for a path.
+    def self.choice(name, path)
+      "#{name} (#{path})"
+    end
+
+  end
+
+  class FileEntry < Entry
+
+    # Return a choice for a path.
+    def self.choice(name, path)
+      "#{name} (#{path})"
+    end
+
+  end
+
+  class SingletonMethodEntry < Entry
+
+    # Return a choice string for a path.
+    def self.choice(full_name, path)
+      class_name, _ = path.split('.html#method-c-')
+      class_name.gsub!('/', '::')
+      "#{full_name} (in #{class_name})"
+    end
+
+  end
+
+  class InstanceMethodEntry < Entry
+
+    # Return a choice string for a path.
+    def self.choice(full_name, path)
+      class_name, _ = path.split('.html#method-i-')
+      class_name.gsub!('/', '::')
+      "#{full_name} (in #{class_name})"
+    end
+
+  end
+
+  # Show a page of Ruby documentation.
+  def show(name)
+    # Figure out what's asked for.
+    case
+    when name.match(/^[A-Z]/)
+      show_class(name, @index_for_type[:class])
+    when %w[fatal fata fat fa f].include?(name)
+      show_class(name, @index_for_type[:class])
+    when name.start_with?('ruby:')
+      show_file(name, @index_for_type[:file])
+    when name.start_with?('::')
+      show_singleton_method(name, @index_for_type[:singleton_method])
+    when name.start_with?('#')
+      show_instance_method(name, @index_for_type[:instance_method])
+    when name == '@help'
+      show_help
+    when name == '@readme'
+      open_readme
+    # when name.start_with?('.')
+    #   show_method(name, @index_for_type[:singleton_method], @index_for_type[:instance_method])
+    # when name.match(/^[a-z]/)
+    #   show_method(name, @index_for_type[:singleton_method], @index_for_type[:instance_method])
+    else
+      puts "No documentation available for name '#{name}'."
+    end
+  end
+
+  # Show class.
+  def show_class(name, class_index)
+    all_entries = @index_for_type[:class]
+    all_choices = ClassEntry.choices(all_entries)
+    # Find entries whose names that start with name.
+    selected_entries = all_entries.select do |key, value|
+      key.start_with?(name)
+    end
+    # Find paths for selected_choices
+    selected_paths = []
+    selected_entries.each_pair do |name, entry|
+      entry.paths.each do |path|
+        selected_paths.push(path)
+      end
+    end
+    case selected_paths.size
+    when 1
+      selected_choices = ClassEntry.choices(selected_entries)
+      choice = selected_choices.keys.first
+      path = selected_choices.values.first
+      puts "Found one class/module name starting with '#{name}'\n  #{choice}"
+      full_name = ClassEntry.full_name_for_choice(choice)
+      if name != full_name
+        message = "Open page #{path}?"
+        return unless get_boolean_answer(message)
+      end
+      path
+    when 0
+      puts "Found no class/module name starting with '#{name}'."
+      message = "Show #{all_choices.size} class/module names?"
+      return unless get_boolean_answer(message)
+      choice_index = get_choice(all_choices.keys)
+      return if choice_index.nil?
+      path = all_choices[choice_index]
+    else
+      selected_choices = ClassEntry.choices(selected_entries)
+      puts "Found #{selected_choices.size} class/module names starting with '#{name}'."
+      message = "Show #{selected_choices.size} class/module names?'"
+      return unless get_boolean_answer(message)
+      key = get_choice(selected_choices.keys)
+      return if key.nil?
+      path = selected_choices[key]
+    end
+    uri = Entry.uri(path)
+    open_page(name, uri)
+  end
+
+  # Show file.
+  def show_file(name, file_index)
+    # Target page is a free-standing page such as 'COPYING'.
+    name = name.sub(/^ruby:/, '') # Discard leading 'ruby:'
+    all_entries = @index_for_type[:file]
+    all_choices = FileEntry.choices(all_entries)
+    # Find entries whose names that start with name.
+    selected_entries = all_entries.select do |key, value|
+      key.start_with?(name)
+    end
+    # Find paths for selected_choices
+    selected_paths = []
+    selected_entries.each_pair do |name, entry|
+      entry.paths.each do |path|
+        selected_paths.push(path)
+      end
+    end
+    case selected_paths.size
+    when 1
+      selected_choices = FileEntry.choices(selected_entries)
+      choice = selected_choices.keys.first
+      path = selected_choices.values.first
+      puts "Found one file name starting with '#{name}'\n  #{choice}"
+      full_name = FileEntry.full_name_for_choice(choice)
+      if name != full_name
+        message = "Open page #{path}?"
+        return unless get_boolean_answer(message)
+      end
+      path
+    when 0
+      puts "Found no file name starting with '#{name}'."
+      message = "Show names of all #{all_choices.size} files?"
+      return unless get_boolean_answer(message)
+      key = get_choice(all_choices.keys)
+      return if key.nil?
+      path = all_choices[key]
+    else
+      selected_choices = FileEntry.choices(selected_entries)
+      puts "Found #{selected_choices.size} file names starting with '#{name}'."
+      message = "Show #{selected_choices.size} names?'"
+      return unless get_boolean_answer(message)
+      key = get_choice(selected_choices.keys)
+      return if key.nil?
+      path = selected_choices[key]
+    end
+    uri = Entry.uri(path)
+    open_page(name, uri)
+  end
+
+  # Show singleton method.
+  def show_singleton_method(name, singleton_method_index)
+    # Target page is a singleton method such as ::new.
+    all_entries = @index_for_type[:singleton_method]
+    all_choices = SingletonMethodEntry.choices(all_entries)
+    # Find entries whose names that start with name.
+    selected_entries = all_entries.select do |key, value|
+      key.start_with?(name)
+    end
+    # Find paths for selected_choices
+    selected_paths = []
+    selected_entries.each_pair do |name, entry|
+      entry.paths.each do |path|
+        selected_paths.push(path)
+      end
+    end
+    selected_choices = SingletonMethodEntry.choices(selected_entries)
+    case selected_paths.size
+    when 1
+      full_name = selected_entries.keys.first
+      path = selected_choices.values.first
+      puts "Found one singleton method name starting with '#{name}'\n  #{full_name}"
+      if name != full_name
+        uri = URI.parse(path)
+        message = "Open page #{uri.path} at method #{full_name}?"
+        return unless get_boolean_answer(message)
+      end
+      path
+    when 0
+      puts "Found no singleton method name starting with '#{name}'."
+      message = "Show names of all #{all_choices.size} singleton methods?"
+      return unless get_boolean_answer(message)
+      choice = get_choice(all_choices.keys)
+      return if choice.nil?
+      full_name = SingletonMethodEntry.full_name_for_choice(choice)
+      path = all_choices[choice]
+    else
+      puts "Found #{selected_paths.size} singleton method names starting with '#{name}'."
+      message = "Show #{selected_paths.size} names?'"
+      return unless get_boolean_answer(message)
+      choice = get_choice(selected_choices.keys)
+      return if choice.nil?
+      full_name = SingletonMethodEntry.full_name_for_choice(choice)
+      path = all_choices[choice]
+    end
+    uri = Entry.uri(path)
+    open_page(full_name, uri)
+  end
+
+  # Show instance method.
+  def show_instance_method(name, instance_method_index)
+    # Target page is an instance method such as #to_s.
+    all_entries = @index_for_type[:instance_method]
+    all_choices = InstanceMethodEntry.choices(all_entries)
+    # Find entries whose names that start with name.
+    selected_entries = all_entries.select do |key, value|
+      key.start_with?(name)
+    end
+    # Find paths for selected_choices
+    selected_paths = []
+    selected_entries.each_pair do |name, entry|
+      entry.paths.each do |path|
+        selected_paths.push(path)
+      end
+    end
+    selected_choices = InstanceMethodEntry.choices(selected_entries)
+    case selected_paths.size
+    when 1
+      full_name = selected_entries.keys.first
+      path = selected_choices.values.first
+      puts "Found one instance method name starting with '#{name}'\n  #{full_name}"
+      if name != full_name
+        uri = URI.parse(path)
+        message = "Open page #{uri.path} at method #{full_name}?"
+        return unless get_boolean_answer(message)
+      end
+      path
+    when 0
+      puts "Found no instance method name starting with '#{name}'."
+      message = "Show names of all #{all_choices.size} instance methods?"
+      return unless get_boolean_answer(message)
+      choice = get_choice(all_choices.keys)
+      return if choice.nil?
+      path = all_choices[choice]
+      full_name = InstanceMethodEntry.full_name_for_choice(choice)
+    else
+      puts "Found #{selected_paths.size} instance method names starting with '#{name}'."
+      message = "Show #{selected_paths.size} names?'"
+      return unless get_boolean_answer(message)
+      choice = get_choice(selected_choices.keys)
+      return if choice.nil?
+      path = all_choices[choice]
+      full_name = InstanceMethodEntry.full_name_for_choice(choice)
+    end
+    uri = Entry.uri(path)
+    open_page(full_name, uri)
+  end
+
+  def show_help
+    puts 'Showing help.'
+    puts `ruby bin/webri --help`
+  end
+
+  def show_readme
+    open_readme
+  end
+
+  # Present choices; return choice.
+  def get_choice(choices)
+    index = nil
+    range = (0..choices.size - 1)
+    until range.include?(index)
+      choices.each_with_index do |choice, i|
+        s = "%6d" % i
+        puts "  #{s}:  #{choice}"
+      end
+      while true
+        print "Type a number to choose, or Return to skip:  "
+        $stdout.flush
+        response = $stdin.gets
+        case response
+        when /(\d+)/
+          return choices[$1.to_i]
+        when "\n"
+          return nil
+        else
+
+        end
+      end
+    end
+  end
+
+  # Present question; return answer.
+  def get_boolean_answer(question)
+    print "#{question} (y or n):  "
+    $stdout.flush
+    $stdin.gets.match(/y/i) ? true : false
+  end
+
+  def open_readme
+    url = 'https://github.com/BurdetteLamar/webri/blob/main/README.md'
+    uri = URI.parse(url)
+    open_uri('README',uri)
+  end
+
+  # Open URL in browser.
+  def open_page(name, target_uri)
+    uri = URI.parse(File.join(DocSite, @doc_release, target_uri.to_s))
+    open_uri(name, uri)
+  end
+
+  def os_type
+    case RbConfig::CONFIG['host_os']
+    when /linux|bsd|arch/
+      :linux
+    when /darwin/
+      :macos
+    when /mswin|windows|32/
+      :windows
+    else
+      :unknown
+    end
+  end
+
+  def opener_name
+    case os_type
+    when :linux
+      'xdg-open'
+    when :windows
+      'start'
+    when :macos
+      'open'
+    else
+      message = "No opener name for #{os_type}"
+      raise RuntimeError(message)
+    end
+  end
+
+  def open_uri(name, target_uri)
+    full_url = target_uri.to_s
+    url, fragment = full_url.split('#')
+    message = "Opening web page #{url}"
+    if fragment
+      message += " at method #{name}"
+    end
+    message += '.'
+    puts message
+    command = "#{opener_name} #{full_url}"
+    if @noop
+      puts "Command: '#{command}'"
+    else
+      system(command)
+    end
+  end
+
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: webri
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- BurdetteLamar
+bindir: bin
+cert_chain: []
+date: 2025-06-13 00:00:00.000000000 Z
+dependencies: []
+description: Command-line utility for displaying Ruby online documentation
+email:
+- burdettelamar@yahoo.com
+executables:
+- webri
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/webri
+- lib/webri.rb
+- lib/webri/version.rb
+homepage: https://github.com/BurdetteLamar/webri
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/BurdetteLamar/webri
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: RI for web pages
+test_files: []