restify 2.0.2 → 2.1.0

data/vendor/bundle/ruby/{3.4.0/gems/minitest-5.25.5 → 4.0.0/gems/minitest-6.0.6}/README.rdoc

@@ -1,16 +1,17 @@
-= minitest/{test,spec,mock,benchmark}
+= minitest/{test,spec,benchmark}
 
-home :: https://github.com/minitest/minitest
+home :: https://minite.st/
+code :: https://github.com/minitest/minitest
 bugs :: https://github.com/minitest/minitest/issues
 rdoc :: https://docs.seattlerb.org/minitest
 clog :: https://github.com/minitest/minitest/blob/master/History.rdoc
-vim  :: https://github.com/sunaku/vim-ruby-minitest
 emacs:: https://github.com/arthurnn/minitest-emacs
+vim  :: https://github.com/vim-test/vim-test
 
 == DESCRIPTION:
 
 minitest provides a complete suite of testing facilities supporting
-TDD, BDD, mocking, and benchmarking.
+TDD, BDD, and benchmarking.
 
     "I had a class with Jim Weirich on testing last week and we were
      allowed to choose our testing frameworks. Kirk Haines and I were
@@ -36,9 +37,6 @@ algorithms in a repeatable manner. Now you can assert that your newb
 co-worker doesn't replace your linear algorithm with an exponential
 one!
 
-minitest/mock by Steven Baker, is a beautifully tiny mock (and stub)
-object framework.
-
 minitest/pride shows pride in testing and adds coloring to your test
 output. I guess it is an example of how to write IO pipes too. :P
 
@@ -68,7 +66,6 @@ extract-method refactorings still apply.
 * minitest/autorun - the easy and explicit way to run all your tests.
 * minitest/test - a very fast, simple, and clean test system.
 * minitest/spec - a very fast, simple, and clean spec system.
-* minitest/mock - a simple and clean mock/stub system.
 * minitest/benchmark - an awesome way to assert your algorithm's performance.
 * minitest/pride - show your pride in testing!
 * minitest/test_task - a full-featured and clean rake task generator.
@@ -95,7 +92,9 @@ Given that you'd like to test the following class:
 
 === Unit tests
 
-Define your tests as methods beginning with +test_+.
+Define your tests as methods beginning with +test_+. Use
+{assertions}[/minitest/Minitest/Assertions.html] to test for results
+or state.
 
   require "minitest/autorun"
 
@@ -119,6 +118,9 @@ Define your tests as methods beginning with +test_+.
 
 === Specs
 
+Use {expectations}[/minitest/Minitest/Expectations.html] to check
+results or state. They must be wrapped in a value call (eg +_+).
+
   require "minitest/autorun"
 
   describe Meme do
@@ -146,7 +148,7 @@ For matchers support check out:
 
 === Benchmarks
 
-Add benchmarks to your tests.
+Add {benchmarks}[/minitest/Minitest/Benchmark.html] to your tests.
 
   # optionally run benchmarks, good for CI-only work!
   require "minitest/benchmark" if ENV["BENCH"]
@@ -185,85 +187,6 @@ outputs something like:
 
 Output is tab-delimited to make it easy to paste into a spreadsheet.
 
-=== Mocks
-
-Mocks and stubs defined using terminology by Fowler & Meszaros at
-https://www.martinfowler.com/bliki/TestDouble.html:
-
-"Mocks are pre-programmed with expectations which form a specification
-of the calls they are expected to receive. They can throw an exception
-if they receive a call they don't expect and are checked during
-verification to ensure they got all the calls they were expecting."
-
-  class MemeAsker
-    def initialize(meme)
-      @meme = meme
-    end
-
-    def ask(question)
-      method = question.tr(" ", "_") + "?"
-      @meme.__send__(method)
-    end
-  end
-
-  require "minitest/autorun"
-
-  describe MemeAsker, :ask do
-    describe "when passed an unpunctuated question" do
-      it "should invoke the appropriate predicate method on the meme" do
-        @meme = Minitest::Mock.new
-        @meme_asker = MemeAsker.new @meme
-        @meme.expect :will_it_blend?, :return_value
-
-        @meme_asker.ask "will it blend"
-
-        @meme.verify
-      end
-    end
-  end
-
-==== Multi-threading and Mocks
-
-Minitest mocks do not support multi-threading. If it works, fine, if it doesn't
-you can use regular ruby patterns and facilities like local variables. Here's
-an example of asserting that code inside a thread is run:
-
-  def test_called_inside_thread
-    called = false
-    pr = Proc.new { called = true }
-    thread = Thread.new(&pr)
-    thread.join
-    assert called, "proc not called"
-  end
-
-=== Stubs
-
-Mocks and stubs are defined using terminology by Fowler & Meszaros at
-https://www.martinfowler.com/bliki/TestDouble.html:
-
-"Stubs provide canned answers to calls made during the test".
-
-Minitest's stub method overrides a single method for the duration of
-the block.
-
-  def test_stale_eh
-    obj_under_test = Something.new
-
-    refute obj_under_test.stale?
-
-    Time.stub :now, Time.at(0) do   # stub goes away once the block is done
-      assert obj_under_test.stale?
-    end
-  end
-
-A note on stubbing: In order to stub a method, the method must
-actually exist prior to stubbing. Use a singleton method to create a
-new non-existing method:
-
-  def obj_under_test.fake_method
-    ...
-  end
-
 === Running Your Tests
 
 Ideally, you'll use a rake task to run your tests (see below), either
@@ -422,13 +345,10 @@ Current versions of rails: (https://endoflife.date/rails)
 
   | rails | min ruby | minitest | status   |  EOL Date  |
   |-------+----------+----------+----------+------------|
+  |   8.1 | >= 3.2   | >= 5.1   | Current  | 2027-10-07 |
   |   8.0 | >= 3.2   | >= 5.1   | Current  | 2026-11-07 |
-  |   7.2 | >= 3.1   | >= 5.1   | Current  | 2026-08-09 |
-  |   7.1 | >= 2.7   | >= 5.1   | Security | 2025-10-01 |
-  |   7.0 | >= 2.7   | >= 5.1   | Security | 2025-04-01 |
-  |   6.1 | >= 2.5   | >= 5.1   | EOL      | 2024-10-01 |
-  |   6.0 | >= 2.5   | >= 5.1   | EOL      | 2023-06-01 |
-  |   5.2 | >= 2.2.2 | ~> 5.1   | EOL      | 2022-06-01 |
+  |   7.2 | >= 3.1   | >= 5.1   | Security | 2026-08-09 |
+  |   7.1 | >= 2.7   | >= 5.1   | EOL      | 2025-10-01 |
 
 If you want to look at the requirements for a specific version, run:
 
@@ -684,6 +604,9 @@ minitest-happy              :: GLOBALLY ACTIVATE MINITEST PRIDE! RAWR!
 minitest-have_tag           :: Adds Minitest assertions to test for the existence of
                                HTML tags, including contents, within a provided string.
 minitest-heat               :: Reporting that builds a heat map of failure locations
+minitest-holdify            :: Stop maintaining large expected values in your
+                               test/fixture files! Hold them automatically.
+                               Update them effortlessly.
 minitest-hooks              :: Around and before_all/after_all/around_all hooks
 minitest-hyper              :: Pretty, single-page HTML reports for your Minitest runs
 minitest-implicit-subject   :: Implicit declaration of the test subject.
@@ -758,12 +681,10 @@ mongoid-minitest            :: Minitest matchers for Mongoid.
 mutant-minitest             :: Minitest integration for mutant.
 pry-rescue                  :: A pry plugin w/ minitest support. See
                                pry-rescue/minitest.rb.
-rematch                     :: Declutter your test files from large hardcoded data
-                               and update them automatically when your code changes.
 rspec2minitest              :: Easily translate any RSpec matchers to Minitest
                                assertions and expectations.
-stubberry                   :: Multiple stubbing 'berries', sweet and useful 
-                               stub helpers and assertions. ( stub_must, 
+stubberry                   :: Multiple stubbing 'berries', sweet and useful
+                               stub helpers and assertions. ( stub_must,
                                assert_method_called, stubbing ORM objects by id )
 
 == Unknown Extensions:
@@ -794,7 +715,7 @@ Authors... Please send me a pull request with a description of your minitest ext
 
 == REQUIREMENTS:
 
-* Ruby 2.3+. No magic is involved. I hope.
+* Ruby 3.2+. No magic is involved. I hope.
 
 == INSTALL:
 

data/vendor/bundle/ruby/{3.4.0/gems/msgpack-1.8.0 → 4.0.0/gems/msgpack-1.8.3}/ChangeLog

@@ -1,3 +1,18 @@
+2026-06-10 1.8.3
+
+* Fix an integer overflow when parsing maps.
+
+2026-06-09 1.8.2
+
+* Fix `Buffer#clear` to properly reset memory chunks before adding them back to the pool.
+  This could have caused data to leak across buffers when using the MessagePack::Buffer API
+  directly. [CVE-PENDING].
+
+2026-05-28 1.8.1
+
+* Workaround rare compilation issue when `rb_hash_new_capa` isn't properly detected.
+* Never pre-allocate strings larger than the buffered size.
+
 2025-02-06 1.8.0
 
 * Numerous small optimizations.

data/vendor/bundle/ruby/{3.4.0/gems/msgpack-1.8.0 → 4.0.0/gems/msgpack-1.8.3}/README.md

@@ -290,7 +290,7 @@ To update documents in gh-pages branch:
 
     bundle exec rake doc
     git checkout gh-pages
-    cp doc/* ./ -a
+    cp -a doc/* ./
 
 ## Copyright
 

data/vendor/bundle/ruby/4.0.0/gems/multi_json-1.21.1/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2026 Erik Berlin, Michael Bleigh, Josh Kalderimis, Pavel Pravosud
+
+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/4.0.0/gems/multi_json-1.21.1/README.md

@@ -0,0 +1,281 @@
+# MultiJSON
+
+[![Tests](https://github.com/sferik/multi_json/actions/workflows/tests.yml/badge.svg)][tests]
+[![Linter](https://github.com/sferik/multi_json/actions/workflows/linter.yml/badge.svg)][linter]
+[![Mutant](https://github.com/sferik/multi_json/actions/workflows/mutant.yml/badge.svg)][mutant]
+[![Typecheck](https://github.com/sferik/multi_json/actions/workflows/typecheck.yml/badge.svg)][typecheck]
+[![Docs](https://github.com/sferik/multi_json/actions/workflows/docs.yml/badge.svg)][docs]
+[![Maintainability](https://qlty.sh/badges/fde3f4a8-c331-44be-b1e6-45842137def9/maintainability.svg)][qlty]
+[![Gem Version](https://badge.fury.io/rb/multi_json.svg)][gem]
+
+Lots of Ruby libraries parse JSON and everyone has their favorite JSON coder.
+Instead of choosing a single JSON coder and forcing users of your library to be
+stuck with it, you can use MultiJSON instead, which will simply choose the
+fastest available JSON coder. Here's how to use it:
+
+```ruby
+require "multi_json"
+
+MultiJSON.parse('{"abc":"def"}')                        #=> {"abc" => "def"}
+MultiJSON.parse('{"abc":"def"}', symbolize_names: true) #=> {abc: "def"}
+MultiJSON.generate({abc: "def"})                       # convert Ruby back to JSON
+MultiJSON.generate({abc: "def"}, pretty: true)         # encoded in a pretty form (if supported by the coder)
+```
+
+> [!IMPORTANT]
+> **1.21.0 renames the public API to match Ruby stdlib `JSON`.** The canonical
+> verbs are now `MultiJSON.parse` / `MultiJSON.generate`, and the canonical
+> module is `MultiJSON` (all-caps). The legacy `MultiJson` constant,
+> `MultiJSON.load` / `MultiJSON.dump`, `:symbolize_keys`, and friends still
+> work but emit one-time deprecation warnings and **will be removed in 2.0.0**.
+> Run your app with `ruby -W:deprecated` to surface them; the warnings are
+> tagged with the `:deprecated` category so you can silence the whole set with
+> `Warning[:deprecated] = false`. See [Deprecated in 1.21.0](#deprecated-in-1210)
+> for the full list.
+
+`MultiJSON.parse` returns `nil` for `nil`, empty, and whitespace-only inputs
+instead of raising, so a missing or blank payload is observable as a `nil`
+return value rather than an exception. When parsing invalid JSON, MultiJSON
+will throw a `MultiJSON::ParseError`. `MultiJSON::DecodeError` and
+`MultiJSON::LoadError` are aliases for backwards compatibility.
+
+```ruby
+begin
+  MultiJSON.parse("{invalid json}")
+rescue MultiJSON::ParseError => exception
+  exception.data    #=> "{invalid json}"
+  exception.cause   #=> JSON::ParserError: ...
+  exception.line    #=> 1 (for adapters that report a location, e.g. Oj or the json gem)
+  exception.column  #=> 2
+end
+```
+
+### Drop-in replacement for stdlib `JSON`
+
+MultiJSON mirrors the surface of Ruby's stdlib [`JSON`][json-gem] so
+most call sites swap in with a one-line change:
+
+```diff
+- require "json"
++ require "multi_json"
+
+- JSON.parse(text, symbolize_names: true)
++ MultiJSON.parse(text, symbolize_names: true)
+
+- JSON.generate(object, pretty: true)
++ MultiJSON.generate(object, pretty: true)
+```
+
+Method names and the common options line up with stdlib so existing
+pretty-print calls and option keys keep working without changes:
+
+| stdlib `JSON`          | `MultiJSON`                | Status |
+| ---------------------- | -------------------------- | :---:  |
+| `JSON.parse(str)`      | `MultiJSON.parse(str)`     | ✓ |
+| `JSON.generate(obj)`   | `MultiJSON.generate(obj)`  | ✓ |
+| `pretty: true`         | `pretty: true`             | ✓ |
+| `symbolize_names: true` | `symbolize_names: true`   | ✓ |
+
+### Deprecated in 1.21.0
+
+The module constant and primary verbs were renamed to match Ruby
+stdlib `JSON.parse` / `JSON.generate` and the JSON spec (RFC 8259).
+The old names still work in 1.x but now emit a one-time deprecation
+warning; **they will be removed in 2.0.0**.
+
+| Deprecated                    | Use instead                     |
+| ----------------------------- | ------------------------------- |
+| `MultiJson` (constant)        | `MultiJSON` (all-caps)          |
+| `MultiJSON.load(str)`         | `MultiJSON.parse(str)`          |
+| `MultiJSON.dump(obj)`         | `MultiJSON.generate(obj)`       |
+| `MultiJSON.load_options=`     | `MultiJSON.parse_options=`      |
+| `MultiJSON.load_options`      | `MultiJSON.parse_options`       |
+| `MultiJSON.dump_options=`     | `MultiJSON.generate_options=`   |
+| `MultiJSON.dump_options`      | `MultiJSON.generate_options`    |
+| `symbolize_keys:` option      | `symbolize_names:` option       |
+
+The `MultiJson` constant (CamelCase) continues to work as a thin
+delegator; every method call, constant lookup, and rescue clause
+routes through `MultiJSON` transparently.
+
+> [!TIP]
+> The recommended upgrade path to 2.0 is: pin `~> 1.21` first, run
+> `ruby -W:deprecated` against your app or test suite to surface every
+> deprecation, migrate each call site to the canonical name, then bump to
+> `~> 2.0`. The 2.0 release deletes the deprecated aliases entirely, so the
+> warnings during 1.21.x are your map.
+
+`ParseError` instance has `cause` reader which contains the original exception.
+It also has `data` reader with the input that caused the problem, and `line`/`column`
+readers populated for adapters whose error messages include a location (Oj and the
+json gem). Adapters that don't include one (Yajl, fast_jsonparser) leave both nil.
+
+### Tuning the options cache
+
+MultiJSON memoizes the merged option hash for each `parse`/`generate` call so
+identical option hashes don't trigger repeated work. The cache is bounded —
+defaulting to 1000 entries per direction — and applications that generate many
+distinct option hashes can raise the ceiling at runtime:
+
+```ruby
+MultiJSON::OptionsCache.max_cache_size = 5000
+```
+
+`max_cache_size` must be a positive integer; `0`, negative values, and
+non-integers raise `ArgumentError`.
+
+Lowering the limit only takes effect for *new* inserts; existing cache
+entries are left in place until normal eviction trims them below the
+new ceiling. Call `MultiJSON::OptionsCache.reset` if you want to evict
+immediately.
+
+The `use` method, which sets the MultiJSON adapter, takes either a symbol or a
+class (to allow for custom JSON parsers) that responds to both `.load` and `.dump`
+at the class level.
+
+When MultiJSON fails to load the specified adapter, it'll throw `MultiJSON::AdapterError`
+which inherits from `ArgumentError`.
+
+### Writing a custom adapter
+
+A custom adapter is any class that responds to two class methods plus
+defines a `ParseError` constant:
+
+```ruby
+class MyAdapter
+  ParseError = Class.new(StandardError)
+
+  def self.load(string, options)
+    # parse string into a Ruby object, raising ParseError on failure
+  end
+
+  def self.dump(object, options)
+    # serialize object to a JSON string
+  end
+end
+
+MultiJSON.use(MyAdapter)
+```
+
+`ParseError` is required: `MultiJSON.parse` rescues `MyAdapter::ParseError`
+to wrap parse failures in `MultiJSON::ParseError`, and an adapter that
+omits the constant raises `MultiJSON::AdapterError` on the first parse
+attempt instead of producing a confusing `NameError`.
+
+For more, inherit from `MultiJSON::Adapter` to pick up shared option
+merging, the `defaults :load, ...` / `defaults :dump, ...` DSL, and the
+blank-input short-circuit. The built-in adapters in
+`lib/multi_json/adapters/` are working examples.
+
+> [!NOTE]
+> The adapter contract methods on the adapter class itself stay named
+> `.load` / `.dump` in 1.21.x (and the `defaults :load, ...` / `defaults
+> :dump, ...` DSL keys match). The 2.0 release renames them to `.parse` /
+> `.generate` to align with the public API; if you ship a custom adapter,
+> you'll need to rename those methods (and the `defaults` keys) when you
+> upgrade.
+
+MultiJSON tries to have intelligent defaulting. If any supported library is
+already loaded, MultiJSON uses it before attempting to load others. When no
+backend is preloaded, MultiJSON walks its preference list and uses the first
+one that loads successfully. The list is split per platform — JRuby's
+available adapter set differs from MRI's, and the bundled benchmark suite
+ranks `json_gem` ahead of `fast_jsonparser`/`oj`/`yajl` on Ruby 3.4+. CI
+re-runs the benchmark and fails if the observed ranking diverges from the
+table below.
+
+| rank | MRI / TruffleRuby | JRuby           |
+| ---- | ----------------- | --------------- |
+| 1    | The JSON gem      | `jrjackson`     |
+| 2    | `fast_jsonparser` | The JSON gem    |
+| 3    | `oj`              | `gson`          |
+| 4    | `yajl-ruby`       | —               |
+
+A dash means the adapter isn't usable on that runtime: `fast_jsonparser`,
+`oj`, and `yajl-ruby` are MRI/TruffleRuby C extensions with no JRuby builds;
+`jrjackson` and `gson` are JRuby-only. The JSON gem is a Ruby default gem,
+so it's always available as a last-resort fallback on any supported Ruby.
+If you have a workload where a different backend is faster, set it
+explicitly with `MultiJSON.use(:your_adapter)`.
+
+## Gem Variants
+
+MultiJSON ships as two platform-specific gems. Bundler and RubyGems
+automatically select the correct variant for your Ruby implementation:
+
+|                                                | `ruby` platform (MRI) | `java` platform (JRuby) |
+| ---------------------------------------------- | :---: | :---: |
+| Runtime dependency                             | none  | [concurrent-ruby][concurrent-ruby] `~> 1.2` |
+| [`fast_jsonparser`][fast_jsonparser] adapter   |   ✓   |       |
+| [`oj`][oj] adapter                             |   ✓   |       |
+| [`yajl`][yajl] adapter                         |   ✓   |       |
+| [`json_gem`][json-gem] adapter                 |   ✓   |   ✓   |
+| [`gson`][gson] adapter                         |       |   ✓   |
+| [`jr_jackson`][jrjackson] adapter              |       |   ✓   |
+| `OptionsCache` thread-safe store               | `Hash` + `Mutex` | `Concurrent::Map` |
+
+## Supported Ruby Versions
+
+This library aims to support and is [tested against](https://github.com/sferik/multi_json/actions/workflows/tests.yml) the following Ruby
+implementations:
+
+- Ruby 3.2
+- Ruby 3.3
+- Ruby 3.4
+- Ruby 4.0
+- [JRuby][jruby] 10.0 (targets Ruby 3.4 compatibility)
+- [TruffleRuby][truffleruby] 33.0 (native and JVM)
+
+If something doesn't work in one of these implementations, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby
+implementations, 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.
+
+## Versioning
+
+This library aims to adhere to [Semantic Versioning 2.0.0][semver]. Violations
+of this scheme should be reported as bugs. Specifically, if a minor or patch
+version is released that breaks backward compatibility, that version should be
+immediately yanked and/or a new version should be immediately released that
+restores compatibility. Breaking changes to the public API will only be
+introduced with new major versions. As a result of this policy, you can (and
+should) specify a dependency on this gem using the [Pessimistic Version
+Constraint][pvc] with two digits of precision. For example:
+
+```ruby
+spec.add_dependency 'multi_json', '~> 1.0'
+```
+
+## Copyright
+
+Copyright (c) 2010-2026 Erik Berlin, Michael Bleigh, Josh Kalderimis, and Pavel
+Pravosud. See [LICENSE][license] for details.
+
+[concurrent-ruby]: https://github.com/ruby-concurrency/concurrent-ruby
+[docs]: https://github.com/sferik/multi_json/actions/workflows/docs.yml
+[fast_jsonparser]: https://github.com/anilmaurya/fast_jsonparser
+[gem]: https://rubygems.org/gems/multi_json
+[gson]: https://github.com/avsej/gson.rb
+[jrjackson]: https://github.com/guyboertje/jrjackson
+[jruby]: http://www.jruby.org/
+[json-gem]: https://github.com/flori/json
+[license]: LICENSE.md
+[linter]: https://github.com/sferik/multi_json/actions/workflows/linter.yml
+[macruby]: http://www.macruby.org/
+[mutant]: https://github.com/sferik/multi_json/actions/workflows/mutant.yml
+[oj]: https://github.com/ohler55/oj
+[pvc]: http://docs.rubygems.org/read/chapter/16#page74
+[qlty]: https://qlty.sh/gh/sferik/projects/multi_json
+[semver]: http://semver.org/
+[tests]: https://github.com/sferik/multi_json/actions/workflows/tests.yml
+[truffleruby]: https://www.graalvm.org/ruby/
+[typecheck]: https://github.com/sferik/multi_json/actions/workflows/typecheck.yml
+[yajl]: https://github.com/brianmario/yajl-ruby

data/vendor/bundle/ruby/4.0.0/gems/nio4r-2.7.5/ext/libev/LICENSE

@@ -0,0 +1,37 @@
+All files in libev are
+Copyright (c)2007,2008,2009,2010,2011,2012,2013 Marc Alexander Lehmann.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Alternatively, the contents of this package may be used under the terms
+of the GNU General Public License ("GPL") version 2 or any later version,
+in which case the provisions of the GPL are applicable instead of the
+above. If you wish to allow the use of your version of this package only
+under the terms of the GPL and not to allow others to use your version of
+this file under the BSD license, indicate your decision by deleting the
+provisions above and replace them with the notice and other provisions
+required by the GPL in this and the other files of this package. If you do
+not delete the provisions above, a recipient may use your version of this
+file under either the BSD or the GPL.

data/vendor/bundle/ruby/4.0.0/gems/nio4r-2.7.5/ext/libev/README

@@ -0,0 +1,59 @@
+libev is a high-performance event loop/event model with lots of features.
+(see benchmark at http://libev.schmorp.de/bench.html)
+
+
+ABOUT
+
+   Homepage: http://software.schmorp.de/pkg/libev
+   Mailinglist: libev@lists.schmorp.de
+                http://lists.schmorp.de/cgi-bin/mailman/listinfo/libev
+   Library Documentation: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod
+
+   Libev is modelled (very losely) after libevent and the Event perl
+   module, but is faster, scales better and is more correct, and also more
+   featureful. And also smaller. Yay.
+
+   Some of the specialties of libev not commonly found elsewhere are:
+   
+   - extensive and detailed, readable documentation (not doxygen garbage).
+   - fully supports fork, can detect fork in various ways and automatically
+     re-arms kernel mechanisms that do not support fork.
+   - highly optimised select, poll, linux epoll, linux aio, bsd kqueue
+     and solaris event ports backends.
+   - filesystem object (path) watching (with optional linux inotify support).
+   - wallclock-based times (using absolute time, cron-like).
+   - relative timers/timeouts (handle time jumps).
+   - fast intra-thread communication between multiple
+     event loops (with optional fast linux eventfd backend).
+   - extremely easy to embed (fully documented, no dependencies,
+     autoconf supported but optional).
+   - very small codebase, no bloated library, simple code.
+   - fully extensible by being able to plug into the event loop,
+     integrate other event loops, integrate other event loop users.
+   - very little memory use (small watchers, small event loop data).
+   - optional C++ interface allowing method and function callbacks
+     at no extra memory or runtime overhead.
+   - optional Perl interface with similar characteristics (capable
+     of running Glib/Gtk2 on libev).
+   - support for other languages (multiple C++ interfaces, D, Ruby,
+     Python) available from third-parties.
+
+   Examples of programs that embed libev: the EV perl module, node.js,
+   auditd, rxvt-unicode, gvpe (GNU Virtual Private Ethernet), the
+   Deliantra MMORPG server (http://www.deliantra.net/), Rubinius (a
+   next-generation Ruby VM), the Ebb web server, the Rev event toolkit.
+
+
+CONTRIBUTORS
+
+   libev was written and designed by Marc Lehmann and Emanuele Giaquinta.
+
+   The following people sent in patches or made other noteworthy
+   contributions to the design (for minor patches, see the Changes
+   file. If I forgot to include you, please shout at me, it was an
+   accident):
+
+   W.C.A. Wijngaards
+   Christopher Layne
+   Chris Brody
+