restify 2.0.1 → 2.1.0

data/vendor/bundle/ruby/4.0.0/gems/msgpack-1.8.3/README.md

@@ -0,0 +1,302 @@
+# MessagePack
+
+[MessagePack](http://msgpack.org) is an efficient binary serialization format.
+It lets you exchange data among multiple languages like JSON but it's faster and smaller.
+For example, small integers (like flags or error code) are encoded into a single byte,
+and typical short strings only require an extra byte in addition to the strings themselves.
+
+If you ever wished to use JSON for convenience (storing an image with metadata) but could
+not for technical reasons (binary data, size, speed...), MessagePack is a perfect replacement.
+
+```ruby
+require 'msgpack'
+msg = [1,2,3].to_msgpack  #=> "\x93\x01\x02\x03"
+MessagePack.unpack(msg)   #=> [1,2,3]
+```
+
+Add msgpack to your Gemfile to install with Bundler:
+
+```ruby
+# Gemfile
+gem 'msgpack'
+```
+
+Or, use RubyGems to install:
+
+    gem install msgpack
+
+Or, build msgpack-ruby and install from a checked-out msgpack-ruby repository:
+
+    bundle
+    rake
+    gem install --local pkg/msgpack
+
+
+## Use cases
+
+* Create REST API returing MessagePack using Rails + [RABL](https://github.com/nesquena/rabl)
+* Store objects efficiently serialized by msgpack on memcached or Redis
+  * In fact Redis supports msgpack in [EVAL-scripts](https://redis.io/docs/latest/commands/eval/)
+* Upload data in efficient format from mobile devices such as smartphones
+  * MessagePack works on iPhone/iPad and Android. See also [Objective-C](https://github.com/msgpack/msgpack-objectivec) and [Java](https://github.com/msgpack/msgpack-java) implementations
+* Design a portable protocol to communicate with embedded devices
+  * Check also [Fluentd](https://www.fluentd.org) which is a log collector which uses msgpack for the log format (they say it uses JSON but actually it's msgpack, which is compatible with JSON)
+* Exchange objects between software components written in different languages
+  * You'll need a flexible but efficient format so that components exchange objects while keeping compatibility
+
+## Portability
+
+MessagePack for Ruby should run on x86, ARM, PowerPC, SPARC and other CPU architectures.
+
+And it works with MRI (CRuby) and Rubinius.
+Patches to improve portability are highly welcomed.
+
+
+## Serializing objects
+
+Use `MessagePack.pack` or `to_msgpack`:
+
+```ruby
+require 'msgpack'
+msg = MessagePack.pack(obj)  # or
+msg = obj.to_msgpack
+File.binwrite('mydata.msgpack', msg)
+```
+
+### Streaming serialization
+
+Packer provides advanced API to serialize objects in streaming style:
+
+```ruby
+# serialize a 2-element array [e1, e2]
+pk = MessagePack::Packer.new(io)
+pk.write_array_header(2).write(e1).write(e2).flush
+```
+
+See [API reference](http://ruby.msgpack.org/MessagePack/Packer.html) for details.
+
+## Deserializing objects
+
+Use `MessagePack.unpack`:
+
+```ruby
+require 'msgpack'
+msg = File.binread('mydata.msgpack')
+obj = MessagePack.unpack(msg)
+```
+
+### Streaming deserialization
+
+Unpacker provides advanced API to deserialize objects in streaming style:
+
+```ruby
+# deserialize objects from an IO
+u = MessagePack::Unpacker.new(io)
+u.each do |obj|
+  # ...
+end
+```
+
+or event-driven style which works well with EventMachine:
+
+```ruby
+# event-driven deserialization
+def on_read(data)
+  @u ||= MessagePack::Unpacker.new
+  @u.feed_each(data) {|obj|
+     # ...
+  }
+end
+```
+
+See [API reference](http://ruby.msgpack.org/MessagePack/Unpacker.html) for details.
+
+## Serializing and deserializing symbols
+
+By default, symbols are serialized as strings:
+
+```ruby
+packed = :symbol.to_msgpack     # => "\xA6symbol"
+MessagePack.unpack(packed)      # => "symbol"
+```
+
+This can be customized by registering an extension type for them:
+
+```ruby
+MessagePack::DefaultFactory.register_type(0x00, Symbol)
+
+# symbols now survive round trips
+packed = :symbol.to_msgpack     # => "\xc7\x06\x00symbol"
+MessagePack.unpack(packed)      # => :symbol
+```
+
+The extension type for symbols is configurable like any other extension type.
+For example, to customize how symbols are packed you can just redefine
+Symbol#to_msgpack_ext. Doing this gives you an option to prevent symbols from
+being serialized altogether by throwing an exception:
+
+```ruby
+class Symbol
+  def to_msgpack_ext
+    raise "Serialization of symbols prohibited"
+  end
+end
+
+MessagePack::DefaultFactory.register_type(0x00, Symbol)
+
+[1, :symbol, 'string'].to_msgpack  # => RuntimeError: Serialization of symbols prohibited
+```
+
+## Serializing and deserializing Time instances
+
+There are the timestamp extension type in MessagePack,
+but it is not registered by default.
+
+To map Ruby's Time to MessagePack's timestamp for the default factory:
+
+```ruby
+MessagePack::DefaultFactory.register_type(
+  MessagePack::Timestamp::TYPE, # or just -1
+  Time,
+  packer: MessagePack::Time::Packer,
+  unpacker: MessagePack::Time::Unpacker
+)
+```
+
+See [API reference](http://ruby.msgpack.org/) for details.
+
+## Extension Types
+
+Packer and Unpacker support [Extension types of MessagePack](https://github.com/msgpack/msgpack/blob/master/spec.md#types-extension-type).
+
+```ruby
+# register how to serialize custom class at first
+pk = MessagePack::Packer.new(io)
+pk.register_type(0x01, MyClass1, :to_msgpack_ext) # equal to pk.register_type(0x01, MyClass)
+pk.register_type(0x02, MyClass2){|obj| obj.how_to_serialize() } # blocks also available
+
+# almost same API for unpacker
+uk = MessagePack::Unpacker.new()
+uk.register_type(0x01, MyClass1, :from_msgpack_ext)
+uk.register_type(0x02){|data| MyClass2.create_from_serialized_data(data) }
+```
+
+`MessagePack::Factory` is to create packer and unpacker which have same extension types.
+
+```ruby
+factory = MessagePack::Factory.new
+factory.register_type(0x01, MyClass1) # same with next line
+factory.register_type(0x01, MyClass1, packer: :to_msgpack_ext, unpacker: :from_msgpack_ext)
+pk = factory.packer(options_for_packer)
+uk = factory.unpacker(options_for_unpacker)
+```
+
+For `MessagePack.pack` and `MessagePack.unpack`, default packer/unpacker refer `MessagePack::DefaultFactory`. Call `MessagePack::DefaultFactory.register_type` to enable types process globally.
+
+```ruby
+MessagePack::DefaultFactory.register_type(0x03, MyClass3)
+MessagePack.unpack(data_with_ext_typeid_03) #=> MyClass3 instance
+```
+
+Alternatively, extension types can call the packer or unpacker recursively to generate the extension data:
+
+```ruby
+Point = Struct.new(:x, :y)
+factory = MessagePack::Factory.new
+factory.register_type(
+  0x01,
+  Point,
+  packer: ->(point, packer) {
+    packer.write(point.x)
+    packer.write(point.y)
+  },
+  unpacker: ->(unpacker) {
+    x = unpacker.read
+    y = unpacker.read
+    Point.new(x, y)
+  },
+  recursive: true,
+)
+factory.load(factory.dump(Point.new(12, 34))) # => #<struct Point x=12, y=34>
+```
+
+## Pooling
+
+Creating `Packer` and `Unpacker` objects is expensive. For best performance it is preferable to re-use these objects.
+
+`MessagePack::Factory#pool` makes that easier:
+
+```ruby
+factory = MessagePack::Factory.new
+factory.register_type(
+  0x01,
+  Point,
+  packer: ->(point, packer) {
+    packer.write(point.x)
+    packer.write(point.y)
+  },
+  unpacker: ->(unpacker) {
+    x = unpacker.read
+    y = unpacker.read
+    Point.new(x, y)
+  },
+  recursive: true,
+)
+pool = factory.pool(5) # The pool size should match the number of threads expected to use the factory concurrently.
+
+pool.load(pool.dump(Point.new(12, 34))) # => #<struct Point x=12, y=34>
+```
+
+## Buffer API
+
+MessagePack for Ruby provides a buffer API so that you can read or write data by hand, not via Packer or Unpacker API.
+
+This [MessagePack::Buffer](http://ruby.msgpack.org/MessagePack/Buffer.html) is backed with a fixed-length shared memory pool which is very fast for small data (<= 4KB),
+and has zero-copy capability which significantly affects performance to handle large binary data.
+
+## How to build and run tests
+
+Before building msgpack, you need to install bundler and dependencies.
+
+    gem install bundler
+    bundle install
+
+Then, you can run the tasks as follows:
+
+### Build
+
+    bundle exec rake build
+
+### Run tests
+
+    bundle exec rake spec
+
+### Generating docs
+
+    bundle exec rake doc
+
+## How to build -java rubygems
+
+To build -java gems for JRuby, run:
+
+    rake build:java
+
+If this directory has Gemfile.lock (generated with MRI), remove it beforehand.
+
+## Updating documents
+
+Online documentation (https://ruby.msgpack.org) is generated from the gh-pages branch.
+To update documents in gh-pages branch:
+
+    bundle exec rake doc
+    git checkout gh-pages
+    cp -a doc/* ./
+
+## Copyright
+
+* Author
+  * Sadayuki Furuhashi <frsyuki@gmail.com>
+* Copyright
+  * Copyright (c) 2008-2015 Sadayuki Furuhashi
+* License
+  * Apache License, Version 2.0

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.