vagrant-unbundled 2.2.4.0 → 2.2.5.0

data/vendor/bundle/ruby/2.6.0/gems/gssapi-1.3.0/lib/gssapi/simple.rb

@@ -0,0 +1,269 @@
+=begin
+Copyright © 2010 Dan Wanek <dan.wanek@gmail.com>
+
+Licensed under the MIT License: http://www.opensource.org/licenses/mit-license.php
+=end
+module GSSAPI
+
+  # This class is a simple wrapper around the most common usage of GSSAPI. If you are looking at doing
+  #   something a bit more advanced you may want to check out the LibGSSAPI module.
+  class Simple
+
+    attr_reader :context
+    attr_reader :delegated_credentials
+
+    # Initialize a new GSSAPI::Simple object
+    # @param [String] host_name the fully qualified host name
+    # @param [String] service_name The service name. This can either be a
+    #   GSS_KRB5_NT_PRINCIPAL_NAME in the form of srvc/fqdn@REALM
+    #   or
+    #   GSS_C_NT_HOSTBASED_SERVICE in the form of srvc@fqdn
+    #   If there is no '@fqdn' part, the host_name will be appended.
+    #   If no service_name is given at all the default service of 'host@fqdn' will be used.
+    def initialize(host_name, service_name=nil, keytab=nil)
+      @host = host_name
+      @service = service_name.nil? ? "host@#{@host}" : (service_name.include?('@') ? service_name : "#{service_name}@#{@host}")
+      @int_svc_name = import_name(@service)
+      @context = nil # the security context
+      @scred = nil # the service credentials.  really only used for the server-side via acquire_credentials
+      set_keytab(keytab) unless keytab.nil?
+      @delegated_credentials = nil
+    end
+
+
+    # Convert a String to a GSSAPI usable buffer (gss_buffer_desc)
+    # @param [String] str the string to convert
+    def import_name(str)
+      buff_str = LibGSSAPI::UnManagedGssBufferDesc.new
+      buff_str.value = str
+      # Choose the appropriate mechanism based on the string passed.
+      if (str =~ /[A-Za-z0-9]+\/[^@]+@.+$/)
+        mech = LibGSSAPI::GssOID.gss_c_no_oid
+      else
+        mech = LibGSSAPI::GSS_C_NT_HOSTBASED_SERVICE
+      end
+      name = FFI::MemoryPointer.new :pointer # gss_name_t
+      min_stat = FFI::MemoryPointer.new :OM_uint32
+
+      maj_stat = LibGSSAPI.gss_import_name(min_stat, buff_str.pointer, mech, name)
+      raise GssApiError.new(maj_stat, min_stat), "gss_import_name did not return GSS_S_COMPLETE" if maj_stat != 0
+
+      LibGSSAPI::GssNameT.new(name.get_pointer(0))
+    end
+
+    # Initialize the GSS security context (client initiator).  If there was a previous call that issued a
+    #   continue you can pass the continuation token in via the token param.
+    #   If no flags are set the default flags are LibGSSAPI::GSS_C_MUTUAL_FLAG | LibGSSAPI::GSS_C_SEQUENCE_FLAG
+    # @param [String] in_token an input token sent from the remote service in a continuation.
+    # @param [Hash] opts misc opts to be set
+    # @option opts [Fixnum] :flags override all other flags.  If you set the :delegate option this option will override it.
+    #   @see http://tools.ietf.org/html/rfc4121#section-4.1.1.1
+    # @option opts [Boolean] :delegate if true set the credential delegate flag
+    #              [Credentials] :credentials set to open the context in behalf of someone (delegated_credentials)
+    # @return [String, true] if a continuation flag is set it will return the output token that is needed to send
+    #   to the remote host.  Otherwise it returns true and the GSS security context has been established.
+    def init_context(in_token = nil, opts = {})
+      min_stat = FFI::MemoryPointer.new :OM_uint32
+      pctx = (@context.nil? ? LibGSSAPI::GssCtxIdT.gss_c_no_context.address_of : @context.address_of)
+      mech = LibGSSAPI::GssOID.gss_c_no_oid
+      if(opts[:flags])
+        flags = opts[:flags]
+      else
+        flags = (LibGSSAPI::GSS_C_MUTUAL_FLAG | LibGSSAPI::GSS_C_SEQUENCE_FLAG | LibGSSAPI::GSS_C_CONF_FLAG | LibGSSAPI::GSS_C_INTEG_FLAG)
+        flags |= LibGSSAPI::GSS_C_DELEG_FLAG  if opts[:delegate]
+        flags |= LibGSSAPI::GSS_C_DELEG_POLICY_FLAG  if opts[:delegate]
+      end
+      in_tok = LibGSSAPI::UnManagedGssBufferDesc.new
+      in_tok.value = in_token
+      out_tok = LibGSSAPI::ManagedGssBufferDesc.new
+      ret_flags = FFI::MemoryPointer.new :OM_uint32
+
+
+      maj_stat = LibGSSAPI.gss_init_sec_context(min_stat,
+                                                opts[:credentials],
+                                                pctx,
+                                                @int_svc_name,
+                                                mech,
+                                                flags,
+                                                0,
+                                                nil,
+                                                in_tok.pointer,
+                                                nil,
+                                                out_tok.pointer,
+                                                ret_flags,
+                                                nil)
+
+      raise GssApiError.new(maj_stat, min_stat), "gss_init_sec_context did not return GSS_S_COMPLETE" if maj_stat > 1
+
+      # The returned context may be equal to the passed in @context. If so, we
+      # must not create another AutoPointer to the same gss_buffer_t. If we do
+      # we will double delete it.
+      ctx = pctx.get_pointer(0)
+      @context = LibGSSAPI::GssCtxIdT.new(ctx) if ctx != @context
+
+      maj_stat == 1 ? out_tok.value : true
+    end
+
+
+    # Accept a security context that was initiated by a remote peer.
+    # @param [String] in_token The token sent by the remote client to initiate the context
+    # @return [String, true] If this is part of a continuation it will return a token to be passed back to the remote
+    #   otherwise it will simply return true.
+    def accept_context(in_token)
+      raise GssApiError, "No credentials yet acquired. Call #{self.class.name}#acquire_credentials first" if @scred.nil?
+
+      min_stat = FFI::MemoryPointer.new :OM_uint32
+      pctx = (@context.nil? ? LibGSSAPI::GssCtxIdT.gss_c_no_context.address_of : @context.address_of)
+      no_chn_bind = LibGSSAPI::GSS_C_NO_CHANNEL_BINDINGS
+      @client = FFI::MemoryPointer.new :pointer  # Will hold the initiating client name after the call
+      mech = FFI::MemoryPointer.new :pointer  # Will hold the mech being used after the call
+      in_tok = GSSAPI::LibGSSAPI::UnManagedGssBufferDesc.new
+      in_tok.value = in_token
+      out_tok = GSSAPI::LibGSSAPI::ManagedGssBufferDesc.new
+      ret_flags = FFI::MemoryPointer.new :OM_uint32
+      delegated_cred_handle = FFI::MemoryPointer.new :pointer
+
+      maj_stat = LibGSSAPI.gss_accept_sec_context(min_stat,
+                                                  pctx,
+                                                  @scred,
+                                                  in_tok.pointer,
+                                                  no_chn_bind,
+                                                  @client,
+                                                  mech,
+                                                  out_tok.pointer,
+                                                  ret_flags,
+                                                  nil,
+                                                  delegated_cred_handle)
+
+      raise GssApiError.new(maj_stat, min_stat), "gss_accept_sec_context did not return GSS_S_COMPLETE" if maj_stat > 1
+
+      if (ret_flags.read_uint32 & LibGSSAPI::GSS_C_DELEG_FLAG) != 0
+        @delegated_credentials = LibGSSAPI::GssCredIdT.new(delegated_cred_handle.get_pointer(0))
+      end
+
+      # The returned context may be equal to the passed in @context. If so, we
+      # must not create another AutoPointer to the same gss_buffer_t. If we do
+      # we will double delete it.
+      ctx = pctx.get_pointer(0)
+      @context = LibGSSAPI::GssCtxIdT.new(ctx) if ctx != @context
+
+      out_tok.length > 0 ? out_tok.value : true
+    end
+
+
+    def get_mic(token)
+
+      min_stat = FFI::MemoryPointer.new :OM_uint32
+      qop_req = GSSAPI::LibGSSAPI::GSS_C_QOP_DEFAULT
+      in_buff = GSSAPI::LibGSSAPI::UnManagedGssBufferDesc.new
+      in_buff.value = token
+      out_buff = GSSAPI::LibGSSAPI::ManagedGssBufferDesc.new
+      maj_stat = GSSAPI::LibGSSAPI.gss_get_mic(min_stat, @context, qop_req, in_buff.pointer, out_buff.pointer)
+      raise GssApiError.new(maj_stat, min_stat), "Failed to gss_get_mic" if maj_stat != 0
+      out_buff.value
+    end
+
+    def verify_mic(token,mic)
+      min_stat = FFI::MemoryPointer.new :OM_uint32
+      in_buff = GSSAPI::LibGSSAPI::UnManagedGssBufferDesc.new
+      in_buff.value = token
+      mic_buff = GSSAPI::LibGSSAPI::UnManagedGssBufferDesc.new
+      mic_buff.value = mic
+      maj_stat = GSSAPI::LibGSSAPI.gss_verify_mic(min_stat, @context, in_buff.pointer, mic_buff.pointer, 0)
+      raise GssApiError.new(maj_stat, min_stat), "Failed to gss_verify_mic" if maj_stat != 0
+      return (maj_stat == 0)
+    end
+
+    # Get textual representation of internal GSS name
+    # @return [String] textual representation of internal GSS name
+    def display_name
+      raise GssApiError.new(), "No context accepted yet. Call #{self.class.name}#accept_context(in_token) first" if @client.nil?
+
+      output_name = GSSAPI::LibGSSAPI::ManagedGssBufferDesc.new
+
+      min_stat = FFI::MemoryPointer.new :OM_uint32
+      maj_stat = LibGSSAPI.gss_display_name(min_stat,
+                                            @client.get_pointer(0),
+                                            output_name.pointer,
+                                            nil)
+
+      if maj_stat != GSSAPI::LibGSSAPI::GSS_S_COMPLETE
+        raise GssApiError.new(maj_stat, min_stat),
+          "gss_display_name did not return GSS_S_COMPLETE but #{ maj_stat }"
+      end
+
+      output_name.value
+    end
+
+    # Acquire security credentials. This does not log you in. It grabs the credentials from a cred cache or keytab.
+    # @param [Hash] opts options to pass to the gss_acquire_cred function.
+    # @option opts [String] :usage The credential usage type (:accept, :initiate, :both).  It defaults to 'accept' since
+    #   this method is most usually called on the server only.
+    # @return [true] It will return true if everything succeeds and the @scred variable will be set for future methods. If
+    #   an error ocurrs an exception will be raised.
+    def acquire_credentials(princ = @int_svc_name, opts = {:usage => :accept})
+      min_stat = FFI::MemoryPointer.new :OM_uint32
+      scred = FFI::MemoryPointer.new :pointer
+
+      case opts[:usage]
+      when :accept
+        usage = LibGSSAPI::GSS_C_ACCEPT
+      when :initiate
+        usage = LibGSSAPI::GSS_C_INITIATE
+      when :both
+        usage = LibGSSAPI::GSS_C_BOTH
+      else
+        raise GssApiError, "Bad option passed to #{self.class.name}#acquire_credentials"
+      end
+
+      maj_stat = LibGSSAPI.gss_acquire_cred(min_stat, princ, 0, LibGSSAPI::GSS_C_NO_OID_SET, usage, scred, nil, nil)
+      raise GssApiError.new(maj_stat, min_stat), "gss_acquire_cred did not return GSS_S_COMPLETE" if maj_stat != 0
+
+      @scred = LibGSSAPI::GssCredIdT.new(scred.get_pointer(0))
+      true
+    end
+
+    # Wrap a message using gss_wrap. It can either encrypt the message (confidentiality) or simply sign it (integrity).
+    # @param [String] msg The message to wrap
+    # @param [Boolean] encrypt Whether or not to encrypt the message or just sign it.  The default is to encrypt.
+    # @return [String] The wrapped message. It will raise an exception on error
+    def wrap_message(msg, encrypt = true)
+      min_stat = FFI::MemoryPointer.new :OM_uint32
+      conf_req = (encrypt ? 1 : 0)
+      qop_req = GSSAPI::LibGSSAPI::GSS_C_QOP_DEFAULT
+      in_buff = GSSAPI::LibGSSAPI::UnManagedGssBufferDesc.new
+      in_buff.value = msg
+      conf_state = FFI::MemoryPointer.new :OM_uint32
+      out_buff = GSSAPI::LibGSSAPI::ManagedGssBufferDesc.new
+      maj_stat = GSSAPI::LibGSSAPI.gss_wrap(min_stat, @context, conf_req, qop_req, in_buff.pointer, conf_state, out_buff.pointer)
+      raise GssApiError.new(maj_stat, min_stat), "Failed to gss_wrap message" if maj_stat != 0
+      out_buff.value
+    end
+
+    # Unwrap a message previously wrapped with gss_wrap.
+    # @param [String] msg The message to unwrap
+    # @param [Boolean] encrypted Whether or not this message was encrypted (true) or just signed (false)
+    def unwrap_message(msg, encrypted = true)
+      min_stat = FFI::MemoryPointer.new :OM_uint32
+      in_buff = GSSAPI::LibGSSAPI::UnManagedGssBufferDesc.new
+      in_buff.value = msg
+      out_buff = GSSAPI::LibGSSAPI::ManagedGssBufferDesc.new
+      conf_state = FFI::MemoryPointer.new :int
+      conf_state.write_int((encrypted ? 1 : 0))
+      q_op = FFI::MemoryPointer.new :OM_uint32
+      q_op.write_int(0)
+      maj_stat = GSSAPI::LibGSSAPI.gss_unwrap(min_stat, @context, in_buff.pointer, out_buff.pointer, conf_state, q_op)
+      raise GssApiError.new(maj_stat, min_stat), "Failed to gss_unwrap message" if maj_stat != 0
+      out_buff.value
+    end
+
+    # Add a path to a custom keytab file
+    # @param [String] keytab the path to the keytab
+    def set_keytab(keytab)
+      maj_stat = LibGSSAPI.krb5_gss_register_acceptor_identity(keytab)
+      raise GssApiError.new(maj_stat, min_stat), "krb5_gss_register_acceptor_identity did not return GSS_S_COMPLETE" if maj_stat != 0
+      true
+    end
+
+  end # Simple
+end # GSSAPI

data/vendor/bundle/ruby/2.6.0/gems/gssapi-1.3.0/lib/gssapi.rb

@@ -0,0 +1,18 @@
+=begin
+Copyright © 2010 Dan Wanek <dan.wanek@gmail.com>
+
+Licensed under the MIT License: http://www.opensource.org/licenses/mit-license.php
+=end
+require 'ffi'
+module GSSAPI
+  module LibGSSAPI
+    extend FFI::Library
+    FFI::add_typedef(:uint32, :OM_uint32)
+
+    GSSAPI_LIB_TYPE = :mit unless defined?(GSSAPI_LIB_TYPE)
+  end
+end
+
+require 'gssapi/exceptions'
+require 'gssapi/lib_gssapi'
+require 'gssapi/simple'

data/vendor/bundle/ruby/2.6.0/gems/gssapi-1.3.0/preamble

@@ -0,0 +1,5 @@
+=begin
+Copyright © 2010 Dan Wanek <dan.wanek@gmail.com>
+
+Licensed under the MIT License: http://www.opensource.org/licenses/mit-license.php
+=end

data/vendor/bundle/ruby/2.6.0/gems/gssapi-1.3.0/test/spec/gssapi_simple_spec.rb

@@ -0,0 +1,70 @@
+$: << File.dirname(__FILE__) + '/../../lib/'
+require 'gssapi'
+require 'base64'
+require 'yaml'
+
+
+describe GSSAPI::Simple, 'Test the Simple GSSAPI interface' do
+
+  let(:conf) { YAML.load_file "#{File.dirname(__FILE__)}/conf_file.yaml" }
+  let(:cli) { GSSAPI::Simple.new(conf['s_host'], conf['s_service']) }
+  let(:srv ) { GSSAPI::Simple.new(conf['s_host'], conf['s_service'], conf['keytab']) }
+
+  it 'should get the initial context for a client' do
+    token = cli.init_context
+    expect(token).not_to be_empty
+  end
+
+  it 'should acquire credentials for a server service' do
+    expect(srv.acquire_credentials).to eq(true)
+  end
+
+  def play_handshake(cli,srv,clioptions={})
+    clitoken = cli.init_context(nil, clioptions)
+    expect(clitoken).not_to be_empty
+
+    expect(srv.acquire_credentials).to eq(true)
+
+    srvoktok = srv.accept_context(clitoken)
+    expect(srvoktok).not_to be_empty
+
+    ret = cli.init_context(srvoktok)
+    expect(ret).to eq(true)
+  end
+
+  it 'client server should handshake' do
+    play_handshake(cli,srv)
+  end
+
+  it 'mic' do
+    play_handshake(cli,srv)
+
+    secret = "this is secreta"
+
+    mic = cli.get_mic(secret)
+
+    expect(srv.verify_mic(secret,mic)).to eq(true)
+  end
+
+  context "no delegation" do
+    it "sets delegated_credentials to nil" do
+      play_handshake(cli,srv,:delegate => false)
+      expect(srv.delegated_credentials).to be_nil
+    end
+  end
+
+  describe "delegation" do
+    it "sets delegated_credentials to valid" do
+      play_handshake(cli,srv,:delegate => true)
+      expect(srv.delegated_credentials).not_to be_nil
+      delegated_display_name = srv.display_name
+
+      host2 = conf['s_host2'] || conf['s_host']
+      service2 = conf['s_service2'] || conf['s_service']
+      cli_del = GSSAPI::Simple.new(host2, service2)
+      srv_del = GSSAPI::Simple.new(host2, service2, conf['keytab2'])
+      play_handshake(cli_del,srv_del,:credentials => srv.delegated_credentials)
+      expect(srv_del.display_name).to eq(delegated_display_name)
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/gssapi-1.3.0/test/spec/test_buffer_spec.rb

@@ -0,0 +1,15 @@
+$: << File.dirname(__FILE__) + '/../../lib/'
+require 'gssapi'
+
+describe GSSAPI::LibGSSAPI::UnManagedGssBufferDesc, 'Unmanaged Buffer Test' do
+  it 'should create a new UnManagedGssBufferDesc and assign to it and test GC' do
+    0.upto 100 do |i|
+      b = GSSAPI::LibGSSAPI::UnManagedGssBufferDesc.new
+      GC.start
+      b.value = 'asdf'
+    end
+
+    # If we get here without any errors we should be golden
+    expect(true).to eq(true)
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/mime-types-3.3/Code-of-Conduct.md

@@ -0,0 +1,73 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [INSERT EMAIL ADDRESS]. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org

data/vendor/bundle/ruby/2.6.0/gems/mime-types-3.3/Contributing.md

@@ -0,0 +1,141 @@
+## Contributing
+
+I value any contribution to mime-types you can provide: a bug report, a feature
+request, or code contributions.
+
+There are a few guidelines for contributing to mime-types:
+
+* Code changes *will* *not* be accepted without tests. The test suite is
+  written with [minitest][].
+* Match my coding style.
+* Use a thoughtfully-named topic branch that contains your change. Rebase your
+  commits into logical chunks as necessary.
+* Use [quality commit messages][].
+* Do not change the version number; when your patch is accepted and a release
+  is made, the version will be updated at that point.
+* Submit a GitHub pull request with your changes.
+* New or changed behaviours require new or updated documentation.
+
+### Adding or Modifying MIME Types
+
+The mime-types registry is no longer contained in mime-types, but in
+[mime-types-data][]. Please see that project for contributions there.
+
+### Test Dependencies
+
+mime-types uses Ryan Davis’s [Hoe][] to manage the release process, and it adds
+a number of rake tasks. You will mostly be interested in:
+
+    $ rake
+
+which runs the tests the same way that:
+
+    $ rake test
+    $ rake travis
+
+will do.
+
+To assist with the installation of the development dependencies for mime-types,
+I have provided the simplest possible Gemfile pointing to the (generated)
+`mime-types.gemspec` file. This will permit you to do:
+
+    $ bundle install
+
+to get the development dependencies. If you aleady have +hoe+ installed, you
+can accomplish the same thing with:
+
+    $ rake newb
+
+This task will install any missing dependencies, run the tests/specs, and
+generate the RDoc.
+
+You can run tests with code coverage analysis by running:
+
+    $ rake test:coverage
+
+### Benchmarks
+
+mime-types offers several benchmark tasks to measure different measures of
+performance.
+
+There is a repeated load test, measuring how long it takes to start and load
+mime-types with its full registry. By default, it runs fifty loops and uses the
+built-in benchmark library.
+
+    $ rake benchmark:load
+
+There are two allocation tracing benchmarks (for normal and columnar loads).
+These can only be run on Ruby 2.1 or better and requires the
+[allocation\_tracer][] gem (not installed by default).
+
+    $ rake benchmark:allocations
+    $ rake benchmark:allocations:columnar
+
+There are two loaded object count benchmarks (for normal and columnar loads).
+These use `ObjectSpace.count_objects`.
+
+    $ rake benchmark:objects
+    $ rake benchmark:objects:columnar
+
+### Workflow
+
+Here's the most direct way to get your work merged into the project:
+
+* Fork the project.
+* Clone down your fork (`git clone git://github.com/<username>/ruby-mime-types.git`).
+* Create a topic branch to contain your change (`git checkout -b my_awesome_feature`).
+* Hack away, add tests. Not necessarily in that order.
+* Make sure everything still passes by running `rake`.
+* If necessary, rebase your commits into logical chunks, without errors.
+* Push the branch up (`git push origin my_awesome_feature`).
+* Create a pull request against mime-types/ruby-mime-types and describe what
+  your change does and the why you think it should be merged.
+
+### Contributors
+
+*   Austin Ziegler created mime-types.
+
+Thanks to everyone else who has contributed to mime-types over the years:
+
+*   Aaron Patterson
+*   Aggelos Avgerinos
+*   Andre Pankratz
+*   Andy Brody
+*   Arnaud Meuret
+*   Brandon Galbraith
+*   Burke Libbey
+*   Chris Gat
+*   David Genord
+*   Dillon Welch
+*   Eric Marden
+*   Edward Betts
+*   Garret Alfert
+*   Godfrey Chan
+*   Greg Brockman
+*   Hans de Graaff
+*   Henrik Hodne
+*   Janko Marohnić
+*   Jean Boussier
+*   Jeremy Evans
+*   Juanito Fatas
+*   Jun Aruga
+*   Łukasz Śliwa
+*   Keerthi Siva
+*   Ken Ip
+*   Martin d'Allens
+*   Mauricio Linhares
+*   Nicolas Leger
+*   Nicholas La Roux
+*   nycvotes-dev
+*   Postmodern
+*   Richard Hirner
+*   Richard Hurt
+*   Richard Schneeman
+*   Tibor Szolár
+*   Todd Carrico
+
+[minitest]: https://github.com/seattlerb/minitest
+[quality commit messages]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
+[mime-types-data]: https://github.com/mime-types/mime-types-data
+[Hoe]: https://github.com/seattlerb/hoe
+[allocation\_tracer]: https://github.com/ko1/allocation_tracer