pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/COPYING

@@ -0,0 +1,56 @@
+rbs is copyrighted free software by Soutaro Matsumoto <matsumoto@soutaro.com>.
+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.

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/Dockerfile.jruby

@@ -0,0 +1,53 @@
+# JRuby verification image for RBS.
+#
+# RBS can't load its MRI C extension on JRuby, so it parses through a
+# WebAssembly build of the parser (see lib/rbs/wasm and docs/wasm_serialization.md).
+# This single-stage image installs the WASI SDK, compiles rbs_parser.wasm and
+# downloads the Chicory/ASM jars into ~/.m2 (via jar-dependencies), then runs the
+# test suite on JRuby. It mirrors .github/workflows/jruby.yml but is self-contained.
+#
+#   docker build -f Dockerfile.jruby -t rbs-jruby .
+#   docker run --rm rbs-jruby                                  # run the test suite
+#   docker run --rm -e RBS_PLATFORM=java rbs-jruby \
+#     gem build rbs.gemspec                                    # build the -java gem
+#
+# Bundler is intentionally not used: the development Gemfile pulls in CRuby-only
+# C extensions (bigdecimal, stackprof, ...) that cannot build on JRuby. The few
+# gems the suite needs are installed directly, exactly as the CI does.
+
+FROM jruby:10.1.1.0-jdk21
+
+# Keep in sync with .github/workflows/wasm.yml and .github/workflows/jruby.yml.
+ARG WASI_SDK_VERSION=33
+ARG WASI_SDK_RELEASE=33.0
+
+# build-essential supplies cc/make: on JRuby the prism gem builds libprism.so
+# (loaded via FFI) instead of an MRI C extension, so it needs a C toolchain.
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends git curl ca-certificates build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# The WASI SDK provides clang, the wasi-libc sysroot and the wasm32 compiler-rt
+# builtins that `rake wasm:build` needs to compile src/**/*.c to WebAssembly.
+RUN set -eux; \
+    case "$(uname -m)" in \
+      x86_64 | amd64)  wasi_arch=x86_64 ;; \
+      aarch64 | arm64) wasi_arch=arm64  ;; \
+      *) echo "unsupported arch: $(uname -m)" >&2; exit 1 ;; \
+    esac; \
+    mkdir -p /opt/wasi-sdk; \
+    curl -fsSL "https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_SDK_VERSION}/wasi-sdk-${WASI_SDK_RELEASE}-${wasi_arch}-linux.tar.gz" \
+      | tar xz --strip-components=1 -C /opt/wasi-sdk
+ENV WASI_SDK_PATH=/opt/wasi-sdk
+
+# Runtime/test gems the suite needs on JRuby (same set as the jruby.yml CI).
+RUN gem install prism rake rake-compiler test-unit rdoc rspec minitest json-schema pry --no-document
+
+WORKDIR /rbs
+COPY . .
+
+# Compile rbs_parser.wasm (clang is a subprocess, so the build is engine
+# independent) and download the Chicory + ASM jars into ~/.m2 via jar-dependencies.
+RUN rake wasm:jruby_setup wasm:install_jars
+
+CMD ["rake", "test"]

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/README.md

@@ -0,0 +1,240 @@
+# RBS
+
+RBS is a language to describe the structure of Ruby programs.
+You can write down the definition of a class or module: methods defined in the class, instance variables and their types, and inheritance/mix-in relations.
+It also allows declaring constants and global variables.
+
+The following is a small example of RBS for a chat app.
+
+<!-- run-start:a.rbs:bundle exec rbs -I a.rbs validate -->
+```rbs
+module ChatApp
+  VERSION: String
+
+  class User
+    attr_reader login: String
+    attr_reader email: String
+
+    def initialize: (login: String, email: String) -> void
+  end
+
+  class Bot
+    attr_reader name: String
+    attr_reader email: String
+    attr_reader owner: User
+
+    def initialize: (name: String, owner: User) -> void
+  end
+
+  class Message
+    attr_reader id: String
+    attr_reader string: String
+    attr_reader from: User | Bot                     # `|` means union types: `#from` can be `User` or `Bot`
+    attr_reader reply_to: Message?                   # `?` means optional type: `#reply_to` can be `nil`
+
+    def initialize: (from: User | Bot, string: String) -> void
+
+    def reply: (from: User | Bot, string: String) -> Message
+  end
+
+  class Channel
+    attr_reader name: String
+    attr_reader messages: Array[Message]
+    attr_reader users: Array[User]
+    attr_reader bots: Array[Bot]
+
+    def initialize: (name: String) -> void
+
+    def each_member: () { (User | Bot) -> void } -> void  # `{` and `}` means block.
+                   | () -> Enumerator[User | Bot, void]   # Method can be overloaded.
+  end
+end
+```
+<!-- run-end -->
+
+## The Target Version
+
+* The standard library signatures targets the [latest release of Ruby](https://www.ruby-lang.org/en/downloads/branches/). (`4.0` as of 2026.)
+* The library code targets [non-EOL versions of Ruby](https://www.ruby-lang.org/en/downloads/branches/). (`>= 3.3` as of 2026.)
+
+## Installation
+
+Install the `rbs` gem. `$ gem install rbs` from the command line, or add a line in your `Gemfile`.
+
+```rb
+gem "rbs"
+```
+
+## CLI
+
+The gem ships with the `rbs` command line tool to demonstrate what it can do and help develop RBS.
+
+```console
+$ rbs version
+$ rbs list
+$ rbs ancestors ::Object
+$ rbs methods ::Object
+$ rbs method Object then
+```
+
+An end user of `rbs` will probably find `rbs prototype` the most useful. This command generates boilerplate signature declarations for ruby files. For example, say you have written the below ruby script.
+
+```ruby
+# person.rb
+class Person
+  attr_reader :name
+  attr_reader :contacts
+
+  def initialize(name:)
+    @name = name
+    @contacts = []
+  end
+
+  def speak
+    "I'm #{@name} and I love Ruby!"
+  end
+end
+```
+
+Running prototype on the above will automatically generate
+
+```console
+$ rbs prototype rb person.rb
+class Person
+  @name: untyped
+
+  @contacts: untyped
+
+  attr_reader name: untyped
+
+  attr_reader contacts: untyped
+
+  def initialize: (name: untyped) -> void
+
+  def speak: () -> ::String
+end
+```
+
+It prints signatures for all methods, classes, instance variables, and constants.
+This is only a starting point, and you should edit the output to match your signature more accurately.
+
+`rbs prototype` offers three options.
+
+- `rb` generates from just the available Ruby code
+- `rbi` generates from Sorbet RBI
+- `runtime` generates from runtime API (**deprecated**; see [#2841](https://github.com/ruby/rbs/issues/2841))
+
+## Library
+
+There are two important concepts, _environment_ and _definition_.
+
+An _environment_ is a dictionary that keeps track of all declarations. What is the declaration associated with `String` class? An _environment_ will give you the answer.
+
+A _definition_ gives you the detail of the class. What is the type of the return value of `gsub` method of the `String` class? The _definition_ for `String` class knows the list of methods it provides and their types.
+
+The following is a small code to retrieve the definition of the `String#gsub` method.
+
+<!-- run-start:a.rb:bundle exec ruby a.rb -->
+```rb
+require "rbs"
+
+loader = RBS::EnvironmentLoader.new()
+
+# loader.add(path: Pathname("sig"))   # Load .rbs files from `sig` directory
+# loader.add(library: "logger")       # Load logger library
+
+environment = RBS::Environment.from_loader(loader).resolve_type_names
+
+# ::String
+string = RBS::TypeName.new(name: :String, namespace: RBS::Namespace.root)
+
+# Class declaration for ::String
+decl = environment.class_decls[string]
+
+# Builder provides the translation from `declaration` to `definition`
+builder = RBS::DefinitionBuilder.new(env: environment)
+
+# Definition of instance of String
+instance = builder.build_instance(string)
+
+# Print the types of `gsub` method:
+puts instance.methods[:gsub].method_types.join("\n")
+# Outputs =>
+#  (::Regexp | ::string pattern, ::string replacement) -> ::String
+#  (::Regexp | ::string pattern, ::Hash[::String, ::String] hash) -> ::String
+#  (::Regexp | ::string pattern) { (::String match) -> ::_ToS } -> ::String
+#  (::Regexp | ::string pattern) -> ::Enumerator[::String, self]
+
+# Definition of singleton of String
+singleton = builder.build_singleton(string)
+# No `gsub` method for String singleton
+puts singleton.methods[:gsub]
+```
+<!-- run-end -->
+
+## Guides
+
+- [Architecture](docs/architecture.md)
+- [Core and standard library signature contribution guide](docs/CONTRIBUTING.md)
+- [Writing signatures guide](docs/sigs.md)
+- [Stdlib signatures guide](docs/stdlib.md)
+- [Syntax](docs/syntax.md)
+- [RBS by Example](docs/rbs_by_example.md)
+- [RBS collection](docs/collection.md)
+- [Using `Data` and `Struct`](docs/data_and_struct.md)
+- [Releasing a gem with RBS](docs/gem.md)
+
+## Community
+
+Here is a list of some places you can talk with active maintainers.
+
+- [Ruby Discord Server (invite link)](https://discord.gg/ad2acQFtkh) -- We have `rbs` channel in Ruby Discord server.
+- [ruby-jp Slack Workspace (in Japanese)](https://ruby-jp.github.io/) -- We have `types` channel in ruby-jp slack workspace.
+- [gem_rbs_collection](https://github.com/ruby/gem_rbs_collection) -- We have a repository of third-party RBS type definitions, for the case your dependency doesn't ship with RBS files.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec 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`. Releases are cut by the `Release gems` workflow rather than from a working copy -- see [docs/release.md](docs/release.md).
+
+### C Code Formatting
+
+This project uses `clang-format` to enforce consistent formatting of C code with a `.clang-format` configuration in the root directory.
+
+#### Setup
+
+First, install clang-format:
+
+```bash
+# macOS
+brew install clang-format
+
+# Ubuntu/Debian
+sudo apt-get install clang-format
+
+# Windows
+choco install llvm
+```
+
+#### Usage
+
+Format all C source files:
+
+```bash
+rake format:c
+```
+
+Check formatting without making changes:
+
+```bash
+rake format:c_check
+```
+
+#### Editor Integration
+
+For VS Code users, install the "clangd" extension which will automatically use the project's `.clang-format` file.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/rbs.