restify 2.0.1 → 2.0.2

data/vendor/bundle/ruby/3.4.0/gems/hitimes-3.1.0/README.md

@@ -0,0 +1,187 @@
+# Hitimes
+[![Build Status](https://copiousfreetime.semaphoreci.com/badges/hitimes/branches/main.svg)](https://copiousfreetime.semaphoreci.com/projects/hitimes)
+
+* [Homepage](http://github.com/copiousfreetime/hitimes)
+* [Github project](http://github.com/copiousfreetime/hitimes)
+
+## DESCRIPTION
+
+A fast, high resolution timer library for recording performance metrics.
+
+## TABLE OF CONTENTS
+
+* [Requirements](#requirements)
+* [Usage](#usage)
+* [Contributing](#contributing)
+* [Support](#support)
+* [License](#license)
+
+
+## REQUIREMENTS
+
+Hitimes requires the following to run:
+
+  * Ruby
+
+## USAGE
+
+Hitimes easiest to use when installed with `rubygems`:
+
+```sh
+gem install hitimes
+```
+
+Or as part of your bundler `Gemfile`:
+
+```ruby
+gem "hitimes"
+```
+
+You can load it with the standard ruby require statement.
+
+```ruby
+require "hitimes"
+```
+
+### Interval
+
+Use `Hitimes::Interval` to calculate only the duration of a block of code.
+Returns the time as seconds.
+
+```ruby
+duration = Hitimes::Interval.measure do
+  1_000_000.times do |x|
+    2 + 2
+  end
+end
+
+puts duration  # => 0.047414297 (seconds)
+```
+
+### TimedMetric
+
+Use a `Hitimes::TimedMetric` to calculate statistics about an iterative operation
+
+```ruby
+timed_metric = Hitimes::TimedMetric.new("operation on items")
+```
+
+Explicitly use `start` and `stop`:
+
+```ruby
+collection.each do |item|
+  timed_metric.start
+  # .. do something with item
+  timed_metric.stop
+end
+```
+
+Or use the block. In `TimedMetric` the return value of `measure` is the return
+value of the block.
+
+```ruby
+collection.each do |item|
+  result_of_do_something = timed_metric.measure { do_something(item) }
+  # do something with result_of_do_something
+end
+```
+And then look at the stats
+
+```ruby
+puts timed_metric.mean
+puts timed_metric.max
+puts timed_metric.min
+puts timed_metric.stddev
+puts timed_metric.rate
+```
+
+### ValueMetric
+
+Use a `Hitimes::ValueMetric` to calculate statistics about measured samples.
+
+``` ruby
+value_metric = Hitimes::ValueMetric.new("size of thing")
+loop do
+  # ... do stuff changing sizes of 'thing'
+  value_metric.measure(thing.size)
+  # ... do other stuff that may change size of thing
+end
+
+puts value_metric.mean
+puts value_metric.max
+puts value_metric.min
+puts value_metric.stddev
+puts value_metric.rate
+```
+
+### TimedValueMetric
+
+Use a `Hitimes::TimedValueMetric` to calculate statistics about batches of samples.
+
+``` ruby
+timed_value_metric = Hitimes::TimedValueMetric.new("batch times")
+loop do
+  batch = ... # get a batch of things
+  timed_value_metric.start
+  # .. do something with batch
+  timed_value_metric.stop(batch.size)
+end
+
+puts timed_value_metric.rate
+
+puts timed_value_metric.timed_stats.mean
+puts timed_value_metric.timed_stats.max
+puts timed_value_metric.timed_stats.min
+puts timed_value_metric.timed_stats.stddev
+
+puts timed_value_metric.value_stats.mean
+puts timed_value_metric.value_stats.max
+puts timed_value_metric.value_stats.min
+puts timed_value_metric.value_stats.stddev
+```
+
+### Implementation details
+
+Hitimes uses the internal ruby `Process::clock_gettime()` to
+get the highest granularity time increment possible. Generally this is
+nanosecond resolution, or whatever the hardware in the CPU supports.
+
+## SUPPORT
+
+Hitimes is supported on whatever versions of ruby are currently supported.
+Hitimes also follows [semantic versioning](http://semver.org/).
+
+The current officially supported versions of Ruby are:
+
+* MRI Ruby (all platforms) 3.0 - current
+* JRuby 9.4.x.x
+* Truffleruby 24
+
+Unofficially supported versions, any version of MRI from Ruby 2.1 and up. Since
+the C Extension has been removed Hitimes should work with any ruby that is 2.1
+or greater as that is when `Process.clock_gettime()` was implemented.
+
+For versions of Ruby before 2.1 please use Hitimes 1.3, the extension code is
+still in there and they should still work.
+
+## CONTRIBUTING
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for instructions on development
+and bug reporting.
+
+## Credits
+
+* [Bruce Williams](https://github.com/bruce) for suggesting the idea.
+* [Benoit Daloze](https://github.com/eregon) and [Thomas Hurst](https://github.com/Freaky) for conversations around clock_ids.
+
+## License
+
+Hitimes is licensed under the [ISC](https://opensource.org/licenses/ISC)
+license.
+
+## Related Works
+
+* [monotime](https://github.com/Freaky/monotime) - A sensible interface to Ruby's monotonic clock.
+* [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby) - [Concurrent.monotonic_time](https://github.com/ruby-concurrency/concurrent-ruby) is a straight pass through to `Process.clock_gettime(Process::CLOCK_MONOTONIC,...)`.
+* [Instant](https://doc.rust-lang.org/src/std/time.rs.html) - The rust equivalent.
+* [time.Now](https://pkg.go.dev/time) - The go monotonic time interface is part of this package.

data/vendor/bundle/ruby/3.4.0/gems/i18n-1.14.7/MIT-LICENSE

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

data/vendor/bundle/ruby/3.4.0/gems/i18n-1.14.7/README.md

@@ -0,0 +1,127 @@
+# Ruby I18n
+
+[![Gem Version](https://badge.fury.io/rb/i18n.svg)](https://badge.fury.io/rb/i18n)
+[![Build Status](https://github.com/ruby-i18n/i18n/workflows/Ruby/badge.svg)](https://github.com/ruby-i18n/i18n/actions?query=workflow%3ARuby)
+
+Ruby internationalization and localization (i18n) solution.
+
+Currently maintained by @radar.
+
+## Usage
+
+### Rails
+
+You will most commonly use this library within a Rails app.
+
+We support Rails versions from 6.0 and up.
+
+[See the Rails Guide](https://guides.rubyonrails.org/i18n.html) for an example of its usage.
+
+### Ruby (without Rails)
+
+We support Ruby versions from 3.0 and up.
+
+If you want to use this library without Rails, you can simply add `i18n` to your `Gemfile`:
+
+```ruby
+gem 'i18n'
+```
+
+Then configure I18n with some translations, and a default locale:
+
+```ruby
+I18n.load_path += Dir[File.expand_path("config/locales") + "/*.yml"]
+I18n.default_locale = :en # (note that `en` is already the default!)
+```
+
+A simple translation file in your project might live at `config/locales/en.yml` and look like:
+
+```yml
+en:
+  test: "This is a test"
+```
+
+You can then access this translation by doing:
+
+```ruby
+I18n.t(:test)
+```
+
+You can switch locales in your project by setting `I18n.locale` to a different value:
+
+```ruby
+I18n.locale = :de
+I18n.t(:test) # => "Dies ist ein Test"
+```
+
+## Features
+
+* Translation and localization
+* Interpolation of values to translations
+* Pluralization (CLDR compatible)
+* Customizable transliteration to ASCII
+* Flexible defaults
+* Bulk lookup
+* Lambdas as translation data
+* Custom key/scope separator
+* Custom exception handlers
+* Extensible architecture with a swappable backend
+
+## Pluggable Features
+
+* Cache
+* Pluralization: lambda pluralizers stored as translation data
+* Locale fallbacks, RFC4647 compliant (optionally: RFC4646 locale validation)
+* [Gettext support](https://github.com/ruby-i18n/i18n/wiki/Gettext)
+* Translation metadata
+
+## Alternative Backend
+
+* Chain
+* ActiveRecord (optionally: ActiveRecord::Missing and ActiveRecord::StoreProcs)
+* KeyValue (uses active_support/json and cannot store procs)
+
+For more information and lots of resources see [the 'Resources' page on the wiki](https://github.com/ruby-i18n/i18n/wiki/Resources).
+
+## Tests
+
+You can run tests both with
+
+* `rake test` or just `rake`
+* run any test file directly, e.g. `ruby -Ilib:test test/api/simple_test.rb`
+
+You can run all tests against all Gemfiles with
+
+* `ruby test/run_all.rb`
+
+The structure of the test suite is a bit unusual as it uses modules to reuse
+particular tests in different test cases.
+
+The reason for this is that we need to enforce the I18n API across various
+combinations of extensions. E.g. the Simple backend alone needs to support
+the same API as any combination of feature and/or optimization modules included
+to the Simple backend. We test this by reusing the same API definition (implemented
+as test methods) in test cases with different setups.
+
+You can find the test cases that enforce the API in test/api. And you can find
+the API definition test methods in test/api/tests.
+
+All other test cases (e.g. as defined in test/backend, test/core_ext) etc.
+follow the usual test setup and should be easy to grok.
+
+## More Documentation
+
+Additional documentation can be found here: https://github.com/ruby-i18n/i18n/wiki
+
+## Contributors
+
+* @radar
+* @carlosantoniodasilva
+* @josevalim
+* @knapo
+* @tigrish
+* [and many more](https://github.com/ruby-i18n/i18n/graphs/contributors)
+
+## License
+
+MIT License. See the included MIT-LICENSE file.

data/vendor/bundle/ruby/3.4.0/gems/little-plugger-1.1.4/README.rdoc

@@ -0,0 +1,53 @@
+= Little Plugger
+* by Tim Pease
+* http://github.com/TwP/little-plugger/tree/master
+
+=== DESCRIPTION:
+
+LittlePlugger is a module that provides Gem based plugin management.
+By extending your own class or module with LittlePlugger you can easily
+manage the loading and initializing of plugins provided by other gems.
+
+=== FEATURES:
+
+* List of plugins so that some plugins can be excluded while others are
+  loaded by default.
+* Loading and initializing of plugins.
+* Access to the plugin classes and modules.
+
+LittlePlugger is a distallation of the plugin system from Hoe. It has been
+"genericized" and encapsulated into its own easy to use module.
+
+=== REQUIREMENTS:
+
+Since Little Plugger is a Gem based plugin system, Ruby Gems must be
+installed on your system.
+
+=== INSTALL:
+
+  gem install little-plugger
+
+=== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009-2011
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/README.md

@@ -0,0 +1,104 @@
+# Logger
+
+Logger is a simple but powerful logging utility to output messages in your Ruby program.
+
+Logger has the following features:
+
+ * Print messages to different levels such as `info` and `error`
+ * Auto-rolling of log files
+ * Setting the format of log messages
+ * Specifying a program name in conjunction with the message
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'logger'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install logger
+
+## Usage
+
+### Simple Example
+
+```ruby
+require 'logger'
+
+# Create a Logger that prints to STDOUT
+log = Logger.new(STDOUT)
+log.debug("Created Logger")
+
+log.info("Program finished")
+
+# Create a Logger that prints to STDERR
+error_log = Logger.new(STDERR)
+error_log = error_log.error("fatal error")
+```
+
+## Development
+
+After checking out the repo, run the following to install dependencies.
+
+```
+$ bin/setup
+```
+
+Then, run the tests as:
+
+```
+$ rake test
+```
+
+To install this gem onto your local machine, run
+
+```
+$ rake install
+```
+
+To release a new version, update the version number in `lib/logger/version.rb`, and then run
+
+```
+$ rake release
+```
+
+which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Advanced Development
+
+### Run tests of a specific file
+
+```
+$ ruby test/logger/test_logger.rb
+```
+
+### Run tests filtering test methods by a name
+
+`--name` option is available as:
+
+```
+$ ruby test/logger/test_logger.rb --name test_lshift
+```
+
+### Publish documents to GitHub Pages
+
+```
+$ rake gh-pages
+```
+
+Then, git commit and push the generated HTMLs onto `gh-pages` branch.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/logger.
+
+## License
+
+The gem is available as open source under the terms of the [BSD-2-Clause](BSDL).

data/vendor/bundle/ruby/3.4.0/gems/logging-2.4.0/LICENSE

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

data/vendor/bundle/ruby/3.4.0/gems/logging-2.4.0/README.md

@@ -0,0 +1,140 @@
+[![.github/workflows/ruby.yml](https://github.com/TwP/logging/actions/workflows/ruby.yml/badge.svg)](https://github.com/TwP/logging/actions/workflows/ruby.yml)
+
+## Logging
+by Tim Pease
+
+* [Homepage](http://rubygems.org/gems/logging)
+* [Github Project](https://github.com/TwP/logging)
+
+### Description
+
+**Logging** is a flexible logging library for use in Ruby programs based on the
+design of Java's log4j library. It features a hierarchical logging system,
+custom level names, multiple output destinations per log event, custom
+formatting, and more.
+
+### Installation
+
+```
+gem install logging
+```
+
+### Examples
+
+This example configures a logger to output messages in a format similar to the
+core ruby Logger class. Only log messages that are warnings or higher will be
+logged.
+
+```ruby
+require 'logging'
+
+logger = Logging.logger(STDOUT)
+logger.level = :warn
+
+logger.debug "this debug message will not be output by the logger"
+logger.warn "this is your last warning"
+```
+
+In this example, a single logger is created that will append to STDOUT and to a
+file. Only log messages that are informational or higher will be logged.
+
+```ruby
+require 'logging'
+
+logger = Logging.logger['example_logger']
+logger.level = :info
+
+logger.add_appenders \
+    Logging.appenders.stdout,
+    Logging.appenders.file('example.log')
+
+logger.debug "this debug message will not be output by the logger"
+logger.info "just some friendly advice"
+```
+
+The Logging library was created to allow each class in a program to have its
+own configurable logger. The logging level for a particular class can be
+changed independently of all other loggers in the system. This example shows
+the recommended way of accomplishing this.
+
+```ruby
+require 'logging'
+
+Logging.logger['FirstClass'].level = :warn
+Logging.logger['SecondClass'].level = :debug
+
+class FirstClass
+  def initialize
+    @logger = Logging.logger[self]
+  end
+
+  def some_method
+    @logger.debug "some method was called on #{self.inspect}"
+  end
+end
+
+class SecondClass
+  def initialize
+    @logger = Logging.logger[self]
+  end
+
+  def another_method
+    @logger.debug "another method was called on #{self.inspect}"
+  end
+end
+```
+
+There are many more examples in the [examples folder](/examples) of the logging
+package. The recommended reading order is the following:
+
+* [simple.rb](/examples/simple.rb)
+* [rspec_integration.rb](/examples/rspec_integration.rb)
+* [loggers.rb](/examples/loggers.rb)
+* [classes.rb](/examples/classes.rb)
+* [hierarchies.rb](/examples/hierarchies.rb)
+* [names.rb](/examples/names.rb)
+* [lazy.rb](/examples/lazy.rb)
+* [appenders.rb](/examples/appenders.rb)
+* [layouts.rb](/examples/layouts.rb)
+* [reusing_layouts.rb](/examples/reusing_layouts.rb)
+* [formatting.rb](/examples/formatting.rb)
+* [colorization.rb](/examples/colorization.rb)
+* [fork.rb](/examples/fork.rb)
+* [mdc.rb](/examples/mdc.rb)
+
+### Extending
+
+The Logging framework is extensible via the [little-plugger](https://github.com/twp/little-plugger)
+gem-based plugin system. New appenders, layouts, or filters can be released as ruby
+gems. When installed locally, the Logging framework will automatically detect
+these gems as plugins and make them available for use.
+
+The [logging-email](https://github.com/twp/logging-email) plugin is a good
+example to follow. It includes a [`lib/logging/plugins/email.rb`](https://github.com/twp/logging-email/tree/master/lib/logging/plugins/email.rb)
+file which is detected by the plugin framework. This file declares a
+`Logging::Plugins::Email.initialize_email` method that is called when the plugin
+is loaded.
+
+The three steps for creating a plugin are:
+
+* create a new Ruby gem: `logging-<name>`
+* include a plugin file: `lib/logging/plugins/<name>.rb`
+* define a plugin initializer: `Logging::Plugins::<Name>.initialize_<name>`
+
+### Development
+
+The Logging source code relies on the Mr Bones project for default rake tasks.
+You will need to install the Mr Bones gem if you want to build or test the
+logging gem. Conveniently there is a bootstrap script that you can run to setup
+your development environment.
+
+```
+script/bootstrap
+```
+
+This will install the Mr Bones gem and the required Ruby gems for development.
+After this is done you can rake `rake -T` to see the available rake tasks.
+
+### License
+
+The MIT License - see the [LICENSE](/LICENSE) file for the full text.