restify 2.0.1 → 2.1.0

data/vendor/bundle/ruby/4.0.0/gems/lint_roller-1.1.0/README.md

@@ -0,0 +1,173 @@
+# lint_roller - A plugin specification for linters
+
+`lint_roller` is an itty-bitty plugin API for code analysis tools like linters
+and formatters. It provides plugins for those tools to load extensions and
+specify custom rulesets.
+
+(As of this release, only [Standard
+Ruby](https://github.com/standardrb/standard) supports `lint_roller` plugins,
+but we think [RuboCop](https://github.com/rubocop/rubocop) could add support and
+most plugins would be compatible with both `rubocop` and `standardrb`.
+Additionally, there's nothing that would prevent other tools like
+[rufo](https://github.com/ruby-formatter/rufo) from adopting it.)
+
+## How to make a plugin
+
+If you want to make a plugin, the first thing you should do is extend
+[LintRoller::Plugin](/lib/lint_roller/plugin.rb) with a custom class. Let's take
+this example plugin for banana-related static analysis:
+
+```ruby
+module BananaRoller
+  class Plugin < LintRoller::Plugin
+    # `config' is a Hash of options passed to the plugin by the user
+    def initialize(config = {})
+      @alternative = config["alternative"] ||= "chocolate"
+    end
+
+    def about
+      LintRoller::About.new(
+        name: "banana_roller",
+        version: "1.0", # or, in a gem, probably BananaRoller::VERSION
+        homepage: "https://github.com/example/banana_roller",
+        description: "Configuration of banana-related code"
+      )
+    end
+
+    # `context' is an instance of LintRoller::Context provided by the runner
+    def supported?(context)
+      context.engine == :rubocop
+    end
+
+    # `context' is an instance of LintRoller::Context provided by the runner
+    def rules(context)
+      LintRoller::Rules.new(
+        type: :path,
+        config_format: :rubocop,
+        value: Pathname.new(__dir__).join("../../config/default.yml")
+      )
+    end
+  end
+end
+```
+
+And that's pretty much it. Just a declarative way to identify your plugin,
+detect whether it supports the given
+[LintRoller::Context](/lib/lint_roller_context.rb) (e.g. the current `runner`
+and `engine` and their respective `_version`s), for which the plugin will
+ultimately its configuration as a [LintRoller::Rules](/lib/lint_roller/rules.rb)
+object.
+
+## Packaging a plugin in a gem
+
+In order for a formatter to use your plugin, it needs to know what path to
+require as well as the name of the plugin class to instantiate and invoke.
+
+To make this work seamlessly for your users without additional configuration of
+their own, all you need to do is specify a metadata attribute called
+`default_lint_roller_plugin` in your gemspec.
+
+Taking [standard-custom](https://github.com/standardrb/standard-custom) as an
+example, its gemspec contains:
+
+```ruby
+Gem::Specification.new do |spec|
+  # …
+  spec.metadata["default_lint_roller_plugin"] = "Standard::Custom::Plugin"
+  # …
+end
+```
+
+Because gem specs are loaded by RubyGems and Bundler very early, remember to
+specify the plugin as a string representation of the constant, as load order
+usually matters, and most tools will need to be loaded before any custom
+extensions. Hence, `"Standard::Custom::Plugin"` instead of
+`Standard::Custom::Plugin`.
+
+## Using your plugin
+
+Once you've made your plugin, here's how it's configured from a Standard Ruby
+`.standard.yml` file.
+
+### If your plugin is packaged as a gem
+
+Packaging your plugin in a gem is the golden path, both because distributing
+code via [RubyGems.org](https://rubygems.org) is very neat, but also because it
+makes the least work for your users.
+
+If your gem name is `banana_roller` and you've set
+`spec.metadata["default_lint_roller_plugin"]` to `"BananaRoller::Plugin"`, then
+your users could just add this to their `.standard.yml` file:
+
+```yaml
+plugins:
+  - banana_roller
+```
+
+And that's it! During initialization, `standardrb` will `require
+"banana_roller"` and know to call `BananaRoller::Plugin.new(config)` to
+instantiate it.
+
+### If your plugin ISN'T in a gem
+
+If you're developing a plugin for internal use or in conjunction with a single
+project, you may want it to live in the same repo as opposed to packaging it in
+a gem.
+
+To do this, then—in lieu of a gem name—provide the path you want to be required
+as its name, and (since there is no `spec.metadata` to learn of your plugin's
+class name), specify it as an option on the plugin:
+
+```yaml
+plugins:
+  - lib/banana_roller/plugin:
+      plugin_class_name: BananaRoller::Plugin
+```
+
+(Be careful with the indentation here! Any configuration under a plugin must be
+indented in order for it to be parsed as a hash under the
+`"lib/banana_roller/plugin"` key.)
+
+Additionally, if you want the plugin's name to make more sense, you can give
+it whatever name you like in the configuration and specify the `require_path`
+explicitly:
+
+```yaml
+plugins:
+  - banana_roller:
+      require_path: lib/banana_roller/plugin
+      plugin_class_name: BananaRoller::Plugin
+```
+
+### Passing user configuration to the plugin
+
+When a `LintRoller::Plugin` is instantiated, users can pass a configuration hash
+that tells your plugin how to behave.
+
+To illustrate how this works in Standard Ruby, anything passed as a hash beneath
+a plugin will be passed to the class's `initialize` method:
+
+```yaml
+plugins:
+  - apple_roller
+  - banana_roller:
+      require_path: lib/banana_roller/plugin
+      plugin_class_name: BananaRoller::Plugin
+      alternative: "apples"
+  - orange_roller:
+      rind: false
+```
+
+In the above case, `apple_roller`'s plugin class will be instantiated with
+`new({})`, `banana_roller` will get all 3 of those parameters passed
+`BananaRoller::Plugin.new({require_path…})`, and `orange_roller`'s class will be
+called with `new({rind: false})`.
+
+## Code of Conduct
+
+This project follows Test Double's [code of
+conduct](https://testdouble.com/code-of-conduct) for all community interactions,
+including (but not limited to) one-on-one communications, public posts/comments,
+code reviews, pull requests, and GitHub issues. If violations occur, Test Double
+will take any action they deem appropriate for the infraction, up to and
+including blocking a user from the organization's repositories.

data/vendor/bundle/ruby/4.0.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/4.0.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/4.0.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/4.0.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.