direct7 0.0.10 → 0.0.12

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/CONTRIBUTING.md

@@ -0,0 +1,26 @@
+# Help and Discussion
+
+If you need help or just want to talk about the http.rb,
+visit the http.rb Google Group:
+
+https://groups.google.com/forum/#!forum/httprb
+
+You can join by email by sending a message to:
+
+[httprb+subscribe@googlegroups.com](mailto:httprb+subscribe@googlegroups.com)
+
+
+# Reporting bugs
+
+The best way to report a bug is by providing a reproduction script. A half
+working script with comments for the parts you were unable to automate is still
+appreciated.
+
+In any case, specify following info in description of your issue:
+
+- What you're trying to accomplish
+- What you expected to happen
+- What actually happened
+- The exception backtrace(s), if any
+- Version of gem or commit ref you are using
+- Version of ruby you are using

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/Gemfile

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+ruby RUBY_VERSION
+
+gem "rake"
+
+# Ruby 3.0 does not ship it anymore.
+# TODO: We should probably refactor specs to avoid need for it.
+gem "webrick"
+
+group :development do
+  gem "guard-rspec", :require => false
+  gem "nokogiri",    :require => false
+  gem "pry",         :require => false
+
+  # RSpec formatter
+  gem "fuubar", :require => false
+
+  platform :mri do
+    gem "pry-byebug"
+  end
+end
+
+group :test do
+  gem "certificate_authority", "~> 1.0", :require => false
+
+  gem "backports"
+
+  gem "rubocop", "~> 1.30.0"
+  gem "rubocop-performance"
+  gem "rubocop-rake"
+  gem "rubocop-rspec"
+
+  gem "simplecov",      :require => false
+  gem "simplecov-lcov", :require => false
+
+  gem "rspec", "~> 3.10"
+  gem "rspec-its"
+
+  gem "yardstick"
+end
+
+group :doc do
+  gem "kramdown"
+  gem "yard"
+end
+
+# Specify your gem's dependencies in http.gemspec
+gemspec

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/Guardfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, :cmd => "GUARD_RSPEC=1 bundle exec rspec --no-profile" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper)  { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2022 Tony Arcieri, Erik Michaels-Ober, Alexey V. Zapparov, Zachary Anker
+
+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/2.7.0/gems/http-5.1.1/README.md

@@ -0,0 +1,164 @@
+# ![http.rb](https://raw.github.com/httprb/http.rb/main/logo.png)
+
+[![Gem Version][gem-image]][gem-link]
+[![MIT licensed][license-image]][license-link]
+[![Build Status][build-image]][build-link]
+[![Code Climate][codeclimate-image]][codeclimate-link]
+
+[Documentation]
+
+## About
+
+HTTP (The Gem! a.k.a. http.rb) is an easy-to-use client library for making requests
+from Ruby. It uses a simple method chaining system for building requests, similar to
+Python's [Requests].
+
+Under the hood, http.rb uses the [llhttp] parser, a fast HTTP parsing native extension.
+This library isn't just yet another wrapper around `Net::HTTP`. It implements the HTTP
+protocol natively and outsources the parsing to native extensions.
+
+### Why http.rb?
+
+- **Clean API**: http.rb offers an easy-to-use API that should be a
+   breath of fresh air after using something like Net::HTTP.
+
+- **Maturity**: http.rb is one of the most mature Ruby HTTP clients, supporting
+   features like persistent connections and fine-grained timeouts.
+
+- **Performance**: using native parsers and a clean, lightweight implementation,
+   http.rb achieves high performance while implementing HTTP in Ruby instead of C.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+```ruby
+gem "http"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install http
+```
+
+Inside of your Ruby program do:
+```ruby
+require "http"
+```
+
+...to pull it in as a dependency.
+
+
+## Documentation
+
+[Please see the http.rb wiki][documentation]
+for more detailed documentation and usage notes.
+
+The following API documentation is also available:
+
+- [YARD API documentation](https://www.rubydoc.info/github/httprb/http)
+- [Chainable module (all chainable methods)](https://www.rubydoc.info/github/httprb/http/HTTP/Chainable)
+
+
+### Basic Usage
+
+Here's some simple examples to get you started:
+
+```ruby
+>> HTTP.get("https://github.com").to_s
+=> "\n\n\n<!DOCTYPE html>\n<html lang=\"en\" class=\"\">\n  <head prefix=\"o..."
+```
+
+That's all it takes! To obtain an `HTTP::Response` object instead of the response
+body, all we have to do is omit the `#to_s` on the end:
+
+```ruby
+>> HTTP.get("https://github.com")
+=> #<HTTP::Response/1.1 200 OK {"Server"=>"GitHub.com", "Date"=>"Tue, 10 May...>
+```
+
+We can also obtain an `HTTP::Response::Body` object for this response:
+
+```ruby
+>> HTTP.get("https://github.com").body
+=> #<HTTP::Response::Body:3ff756862b48 @streaming=false>
+```
+
+The response body can be streamed with `HTTP::Response::Body#readpartial`.
+In practice, you'll want to bind the `HTTP::Response::Body` to a local variable
+and call `#readpartial` on it repeatedly until it returns `nil`:
+
+```ruby
+>> body = HTTP.get("https://github.com").body
+=> #<HTTP::Response::Body:3ff756862b48 @streaming=false>
+>> body.readpartial
+=> "\n\n\n<!DOCTYPE html>\n<html lang=\"en\" class=\"\">\n  <head prefix=\"o..."
+>> body.readpartial
+=> "\" href=\"/apple-touch-icon-72x72.png\">\n    <link rel=\"apple-touch-ic..."
+# ...
+>> body.readpartial
+=> nil
+```
+
+## Supported Ruby Versions
+
+This library aims to support and is [tested against][build-link]
+the following Ruby  versions:
+
+- Ruby 2.6
+- Ruby 2.7
+- Ruby 3.0
+- Ruby 3.1
+- JRuby 9.3
+
+If something doesn't work on one of these versions, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby versions,
+however support will only be provided for the versions listed above.
+
+If you would like this library to support another Ruby version or
+implementation, 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.
+
+
+## Contributing to http.rb
+
+- Fork http.rb on GitHub
+- Make your changes
+- Ensure all tests pass (`bundle exec rake`)
+- Send a pull request
+- If we like them we'll merge them
+- If we've accepted a patch, feel free to ask for commit access!
+
+
+## Copyright
+
+Copyright © 2011-2022 Tony Arcieri, Alexey V. Zapparov, Erik Michaels-Ober, Zachary Anker.
+See LICENSE.txt for further details.
+
+
+[//]: # (badges)
+
+[gem-image]: https://img.shields.io/gem/v/http?logo=ruby
+[gem-link]: https://rubygems.org/gems/http
+[license-image]: https://img.shields.io/badge/license-MIT-blue.svg
+[license-link]: https://github.com/httprb/http/blob/main/LICENSE.txt
+[build-image]: https://github.com/httprb/http/workflows/CI/badge.svg
+[build-link]: https://github.com/httprb/http/actions/workflows/ci.yml
+[codeclimate-image]: https://codeclimate.com/github/httprb/http.svg?branch=main
+[codeclimate-link]: https://codeclimate.com/github/httprb/http
+
+[//]: # (links)
+
+[documentation]: https://github.com/httprb/http/wiki
+[requests]: http://docs.python-requests.org/en/latest/
+[llhttp]: https://llhttp.org/

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/Rakefile

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+require "yardstick/rake/measurement"
+Yardstick::Rake::Measurement.new do |measurement|
+  measurement.output = "measurement/report.txt"
+end
+
+require "yardstick/rake/verify"
+Yardstick::Rake::Verify.new do |verify|
+  verify.require_exact_threshold = false
+  verify.threshold = 55
+end
+
+task :generate_status_codes do
+  require "http"
+  require "nokogiri"
+
+  url = "http://www.iana.org/assignments/http-status-codes/http-status-codes.xml"
+  xml = Nokogiri::XML HTTP.get url
+  arr = xml.xpath("//xmlns:record").reduce([]) do |a, e|
+    code = e.xpath("xmlns:value").text.to_s
+    desc = e.xpath("xmlns:description").text.to_s
+
+    next a if %w[Unassigned (Unused)].include?(desc)
+
+    a << "#{code} => #{desc.inspect}"
+  end
+
+  File.open("./lib/http/response/status/reasons.rb", "w") do |io|
+    io.puts <<~TPL
+      # AUTO-GENERATED FILE, DO NOT CHANGE IT MANUALLY
+
+      require "delegate"
+
+      module HTTP
+        class Response
+          class Status < ::Delegator
+            # Code to Reason map
+            #
+            # @example Usage
+            #
+            #   REASONS[400] # => "Bad Request"
+            #   REASONS[414] # => "Request-URI Too Long"
+            #
+            # @return [Hash<Fixnum => String>]
+            REASONS = {
+              #{arr.join ",\n              "}
+            }.each { |_, v| v.freeze }.freeze
+          end
+        end
+      end
+    TPL
+  end
+end
+
+task :default => %i[spec rubocop verify_measurements]

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/SECURITY.md

@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report security issues to `bascule@gmail.com`

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/http.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "http/version"
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tony Arcieri", "Erik Michaels-Ober", "Alexey V. Zapparov", "Zachary Anker"]
+  gem.email         = ["bascule@gmail.com"]
+
+  gem.description   = <<-DESCRIPTION.strip.gsub(/\s+/, " ")
+    An easy-to-use client library for making requests from Ruby.
+    It uses a simple method chaining system for building requests,
+    similar to Python's Requests.
+  DESCRIPTION
+
+  gem.summary       = "HTTP should be easy"
+  gem.homepage      = "https://github.com/httprb/http"
+  gem.licenses      = ["MIT"]
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "http"
+  gem.require_paths = ["lib"]
+  gem.version       = HTTP::VERSION
+
+  gem.required_ruby_version = ">= 2.6"
+
+  gem.add_runtime_dependency "addressable",    "~> 2.8"
+  gem.add_runtime_dependency "http-cookie",    "~> 1.0"
+  gem.add_runtime_dependency "http-form_data", "~> 2.2"
+  gem.add_runtime_dependency "llhttp-ffi",     "~> 0.4.0"
+
+  gem.add_development_dependency "bundler", "~> 2.0"
+
+  gem.metadata = {
+    "source_code_uri"       => "https://github.com/httprb/http",
+    "wiki_uri"              => "https://github.com/httprb/http/wiki",
+    "bug_tracker_uri"       => "https://github.com/httprb/http/issues",
+    "changelog_uri"         => "https://github.com/httprb/http/blob/v#{HTTP::VERSION}/CHANGES.md",
+    "rubygems_mfa_required" => "true"
+  }
+end

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/lib/http/chainable.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "base64"
+
+require "http/headers"
+
+module HTTP
+  module Chainable
+    # Request a get sans response body
+    # @param uri
+    # @option options [Hash]
+    def head(uri, options = {})
+      request :head, uri, options
+    end
+
+    # Get a resource
+    # @param uri
+    # @option options [Hash]
+    def get(uri, options = {})
+      request :get, uri, options
+    end
+
+    # Post to a resource
+    # @param uri
+    # @option options [Hash]
+    def post(uri, options = {})
+      request :post, uri, options
+    end
+
+    # Put to a resource
+    # @param uri
+    # @option options [Hash]
+    def put(uri, options = {})
+      request :put, uri, options
+    end
+
+    # Delete a resource
+    # @param uri
+    # @option options [Hash]
+    def delete(uri, options = {})
+      request :delete, uri, options
+    end
+
+    # Echo the request back to the client
+    # @param uri
+    # @option options [Hash]
+    def trace(uri, options = {})
+      request :trace, uri, options
+    end
+
+    # Return the methods supported on the given URI
+    # @param uri
+    # @option options [Hash]
+    def options(uri, options = {})
+      request :options, uri, options
+    end
+
+    # Convert to a transparent TCP/IP tunnel
+    # @param uri
+    # @option options [Hash]
+    def connect(uri, options = {})
+      request :connect, uri, options
+    end
+
+    # Apply partial modifications to a resource
+    # @param uri
+    # @option options [Hash]
+    def patch(uri, options = {})
+      request :patch, uri, options
+    end
+
+    # Make an HTTP request with the given verb
+    # @param (see Client#request)
+    def request(*args)
+      branch(default_options).request(*args)
+    end
+
+    # Prepare an HTTP request with the given verb
+    # @param (see Client#build_request)
+    def build_request(*args)
+      branch(default_options).build_request(*args)
+    end
+
+    # @overload timeout(options = {})
+    #   Adds per operation timeouts to the request
+    #   @param [Hash] options
+    #   @option options [Float] :read Read timeout
+    #   @option options [Float] :write Write timeout
+    #   @option options [Float] :connect Connect timeout
+    # @overload timeout(global_timeout)
+    #   Adds a global timeout to the full request
+    #   @param [Numeric] global_timeout
+    def timeout(options)
+      klass, options = case options
+                       when Numeric then [HTTP::Timeout::Global, {:global => options}]
+                       when Hash    then [HTTP::Timeout::PerOperation, options.dup]
+                       when :null   then [HTTP::Timeout::Null, {}]
+                       else raise ArgumentError, "Use `.timeout(global_timeout_in_seconds)` or `.timeout(connect: x, write: y, read: z)`."
+
+                       end
+
+      %i[global read write connect].each do |k|
+        next unless options.key? k
+
+        options["#{k}_timeout".to_sym] = options.delete k
+      end
+
+      branch default_options.merge(
+        :timeout_class   => klass,
+        :timeout_options => options
+      )
+    end
+
+    # @overload persistent(host, timeout: 5)
+    #   Flags as persistent
+    #   @param  [String] host
+    #   @option [Integer] timeout Keep alive timeout
+    #   @raise  [Request::Error] if Host is invalid
+    #   @return [HTTP::Client] Persistent client
+    # @overload persistent(host, timeout: 5, &block)
+    #   Executes given block with persistent client and automatically closes
+    #   connection at the end of execution.
+    #
+    #   @example
+    #
+    #       def keys(users)
+    #         HTTP.persistent("https://github.com") do |http|
+    #           users.map { |u| http.get("/#{u}.keys").to_s }
+    #         end
+    #       end
+    #
+    #       # same as
+    #
+    #       def keys(users)
+    #         http = HTTP.persistent "https://github.com"
+    #         users.map { |u| http.get("/#{u}.keys").to_s }
+    #       ensure
+    #         http.close if http
+    #       end
+    #
+    #
+    #   @yieldparam [HTTP::Client] client Persistent client
+    #   @return [Object] result of last expression in the block
+    def persistent(host, timeout: 5)
+      options  = {:keep_alive_timeout => timeout}
+      p_client = branch default_options.merge(options).with_persistent host
+      return p_client unless block_given?
+
+      yield p_client
+    ensure
+      p_client&.close
+    end
+
+    # Make a request through an HTTP proxy
+    # @param [Array] proxy
+    # @raise [Request::Error] if HTTP proxy is invalid
+    def via(*proxy)
+      proxy_hash = {}
+      proxy_hash[:proxy_address]  = proxy[0] if proxy[0].is_a?(String)
+      proxy_hash[:proxy_port]     = proxy[1] if proxy[1].is_a?(Integer)
+      proxy_hash[:proxy_username] = proxy[2] if proxy[2].is_a?(String)
+      proxy_hash[:proxy_password] = proxy[3] if proxy[3].is_a?(String)
+      proxy_hash[:proxy_headers]  = proxy[2] if proxy[2].is_a?(Hash)
+      proxy_hash[:proxy_headers]  = proxy[4] if proxy[4].is_a?(Hash)
+
+      raise(RequestError, "invalid HTTP proxy: #{proxy_hash}") unless (2..5).cover?(proxy_hash.keys.size)
+
+      branch default_options.with_proxy(proxy_hash)
+    end
+    alias through via
+
+    # Make client follow redirects.
+    # @param options
+    # @return [HTTP::Client]
+    # @see Redirector#initialize
+    def follow(options = {})
+      branch default_options.with_follow options
+    end
+
+    # Make a request with the given headers
+    # @param headers
+    def headers(headers)
+      branch default_options.with_headers(headers)
+    end
+
+    # Make a request with the given cookies
+    def cookies(cookies)
+      branch default_options.with_cookies(cookies)
+    end
+
+    # Force a specific encoding for response body
+    def encoding(encoding)
+      branch default_options.with_encoding(encoding)
+    end
+
+    # Accept the given MIME type(s)
+    # @param type
+    def accept(type)
+      headers Headers::ACCEPT => MimeType.normalize(type)
+    end
+
+    # Make a request with the given Authorization header
+    # @param [#to_s] value Authorization header value
+    def auth(value)
+      headers Headers::AUTHORIZATION => value.to_s
+    end
+
+    # Make a request with the given Basic authorization header
+    # @see http://tools.ietf.org/html/rfc2617
+    # @param [#fetch] opts
+    # @option opts [#to_s] :user
+    # @option opts [#to_s] :pass
+    def basic_auth(opts)
+      user  = opts.fetch(:user)
+      pass  = opts.fetch(:pass)
+      creds = "#{user}:#{pass}"
+
+      auth("Basic #{Base64.strict_encode64(creds)}")
+    end
+
+    # Get options for HTTP
+    # @return [HTTP::Options]
+    def default_options
+      @default_options ||= HTTP::Options.new
+    end
+
+    # Set options for HTTP
+    # @param opts
+    # @return [HTTP::Options]
+    def default_options=(opts)
+      @default_options = HTTP::Options.new(opts)
+    end
+
+    # Set TCP_NODELAY on the socket
+    def nodelay
+      branch default_options.with_nodelay(true)
+    end
+
+    # Turn on given features. Available features are:
+    # * auto_inflate
+    # * auto_deflate
+    # * instrumentation
+    # * logging
+    # * normalize_uri
+    # @param features
+    def use(*features)
+      branch default_options.with_features(features)
+    end
+
+    private
+
+    # :nodoc:
+    def branch(options)
+      HTTP::Client.new(options)
+    end
+  end
+end