logstash-codec-json 2.0.3 → 2.0.4

data/vendor/gems/cabin-0.7.2/test/test_metrics.rb

@@ -1,97 +0,0 @@
-$: << File.dirname(__FILE__)
-$: << File.join(File.dirname(__FILE__), "..", "lib")
-
-require "rubygems"
-require "minitest-patch"
-require "cabin"
-require "cabin/metrics"
-require "minitest/autorun" if __FILE__ == $0
-
-describe Cabin::Metrics do
-  before do
-    @metrics = Cabin::Metrics.new
-  end
-
-  #test "gauge" do
-    #gauge = @metrics.gauge(self) { 3 }
-    #assert_equal(3, gauge.value)
-    ## metrics.first == [identifier, Gauge]
-    #assert_equal(3, @metrics.first.last.value)
-  #end
-
-  test "counter" do
-    counter = @metrics.counter(self)
-    0.upto(30) do |i|
-      assert_equal(i, counter.value)
-      assert_equal({ :value => i }, counter.to_hash)
-      counter.incr
-    end
-    31.downto(0) do |i|
-      assert_equal(i, counter.value)
-      assert_equal({ :value => i }, counter.to_hash)
-      counter.decr
-    end
-  end
-
-  test "meter counter" do
-    meter = @metrics.meter(self)
-    30.times do |i|
-      assert_equal(i, meter.value)
-      assert_equal({ :value => i }, meter.to_hash)
-      meter.mark
-    end
-  end
-
-  test "meter time-based averages" # TODO(sissel): implement
-
-  test "timer first-run has max == min" do
-    timer = @metrics.timer(self)
-    timer.time { true }
-    assert_equal(timer.to_hash[:min], timer.to_hash[:max],
-                 "With a single event, min and max must be equal")
-  end
-
-  test "timer counter" do
-    timer = @metrics.timer(self)
-    30.times do |i|
-      assert_equal(i, timer.value)
-      assert_equal(i, timer.to_hash[:count])
-      timer.time { sleep(0.01) }
-      assert(timer.to_hash[:total] > 0, "total should be nonzero")
-      assert(timer.to_hash[:mean] > 0, "mean should be nonzero")
-      assert(timer.to_hash[:max] > 0, "max should be nonzero")
-    end
-  end
-
-  test "timer.time without block" do
-    timer = @metrics.timer(self)
-    30.times do |i|
-      assert_equal(i, timer.value)
-      assert_equal(i, timer.to_hash[:count])
-      t = timer.time
-      sleep(0.01)
-      t.stop
-      assert(timer.to_hash[:total] > 0, "total should be nonzero")
-      assert(timer.to_hash[:mean] > 0, "mean should be nonzero")
-      assert(timer.to_hash[:max] > 0, "max should be nonzero")
-    end
-  end
-
-  test "metrics from Cabin::Metrics" do
-    # Verify the Metrics api for creating new metrics.
-    metrics = Cabin::Metrics.new
-    assert(metrics.timer(self).is_a?(Cabin::Metrics::Timer))
-    assert(metrics.counter(self).is_a?(Cabin::Metrics::Counter))
-    assert(metrics.histogram(self).is_a?(Cabin::Metrics::Histogram))
-    assert(metrics.meter(self).is_a?(Cabin::Metrics::Meter))
-  end
-
-  test "metrics from logger" do
-    logger = Cabin::Channel.new
-    meter = logger.metrics.meter(self)
-    assert_equal(0, meter.value)
-  end
-
-  test "timer histogram" # TODO(sissel): implement
-  test "histogram" # TODO(sissel): implement
-end # describe Cabin::Channel do

data/vendor/gems/cabin-0.7.2/test/test_pipe.rb

@@ -1,84 +0,0 @@
-$: << File.dirname(__FILE__)
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'rubygems'
-require 'minitest-patch'
-require 'cabin'
-require 'stringio'
-require 'minitest/autorun' if __FILE__ == $0
-
-describe Cabin::Channel do
-  class Receiver
-    attr_accessor :data
-
-    public
-    def initialize
-      @data = []
-    end
-
-    def <<(data)
-      @data << data
-    end
-  end # class Receiver
-
-  before do
-    @logger = Cabin::Channel.new
-    @target = Receiver.new
-    @logger.subscribe(@target)
-
-    @info_reader,  @info_writer  = IO.pipe
-    @error_reader, @error_writer = IO.pipe
-  end
-
-  after do
-    @logger.unsubscribe(@target.object_id)
-    [ @info_reader, @info_writer,
-      @error_reader, @error_writer ].each do |io|
-      io.close unless io.closed?
-    end
-  end
-
-  test 'Piping one IO' do
-    @info_writer.puts 'Hello world'
-    @info_writer.close
-
-    @logger.pipe(@info_reader => :info)
-    assert_equal(1, @target.data.length)
-    assert_equal('Hello world', @target.data[0][:message])
-  end
-
-  test 'Piping multiple IOs' do
-    @info_writer.puts 'Hello world'
-    @info_writer.close
-
-    @error_writer.puts 'Goodbye world'
-    @error_writer.close
-
-    @logger.pipe(@info_reader => :info, @error_reader => :error)
-    assert_equal(2, @target.data.length)
-    assert_equal('Hello world',   @target.data[0][:message])
-    assert_equal(:info,           @target.data[0][:level])
-    assert_equal('Goodbye world', @target.data[1][:message])
-    assert_equal(:error,          @target.data[1][:level])
-  end
-
-  test 'Piping with a block' do
-    @info_writer.puts 'Hello world'
-    @info_writer.close
-
-    @error_writer.puts 'Goodbye world'
-    @error_writer.close
-
-    info  = StringIO.new
-    error = StringIO.new
-
-    @logger.pipe(@info_reader => :info, @error_reader => :error) do |message, level|
-      info  << message if level == :info
-      error << message if level == :error
-    end
-
-    assert_equal('Hello world',   info.string)
-    assert_equal('Goodbye world', error.string)
-  end
-end
-

data/vendor/gems/cabin-0.7.2/test/test_zeromq.rb

@@ -1,99 +0,0 @@
-$: << File.dirname(__FILE__)
-$: << File.join(File.dirname(__FILE__), "..", "lib")
-
-require "rubygems"
-require "minitest-patch"
-require "cabin/outputs/zeromq"
-require "minitest/autorun" if __FILE__ == $0
-
-describe Cabin::Outputs::ZeroMQ do
-
-  def error_check(rc, doing)
-    unless ZMQ::Util.resultcode_ok?(rc)
-      raise "ZeroMQ Error while #{doing}"
-    end
-  end
-
-  NonBlockingFlag = (ZMQ::LibZMQ.version2? ? ZMQ::NOBLOCK : ZMQ::DONTWAIT) unless defined?(NonBlockingFlag)
-  def receive(socket)
-    received = ""
-    error_check socket.recv_string(received, NonBlockingFlag), "receiving"
-    received
-  end
-
-  before do
-    @logger = Cabin::Channel.new
-    @address = "inproc://zeromq-output"
-    @pull   = Cabin::Outputs::ZeroMQ::CONTEXT.socket(ZMQ::PULL)
-    @sub    = Cabin::Outputs::ZeroMQ::CONTEXT.socket(ZMQ::SUB)
-  end
-
-  after do
-    @pull.close
-    @sub.close
-    @output.teardown if @output
-  end
-
-  test 'push messages' do
-    @pull.bind(@address); sleep 0.1 # sleeps are necessary for inproc transport
-    @output = Cabin::Outputs::ZeroMQ.new(@address)
-    @logger.subscribe(@output)
-    @logger.info("hello")
-    @logger.info("hello2")
-    assert_equal "hello", JSON.parse(receive(@pull))['message']
-    assert_equal "hello2", JSON.parse(receive(@pull))['message']
-  end
-
-  test "pub messages" do
-    @sub.bind(@address); sleep 0.1
-    error_check @sub.setsockopt(ZMQ::SUBSCRIBE, ""), "subscribing"
-    @output = Cabin::Outputs::ZeroMQ.new(@address, :topology => "pubsub")
-    @logger.subscribe(@output)
-    @logger.info("hi")
-    assert_equal "", receive(@sub)
-    assert_equal "hi", JSON.parse(receive(@sub))['message']
-  end
-
-  test "pub messages on a topic" do
-    @sub.bind(@address); sleep 0.1
-    error_check @sub.setsockopt(ZMQ::SUBSCRIBE, "topic"), "subscribing"
-    @output = Cabin::Outputs::ZeroMQ.new(@address, :topology => "pubsub", :topic => "topic")
-    @logger.subscribe(@output)
-    @logger.info("hi")
-    assert_equal "topic", receive(@sub)
-    assert_equal "hi", JSON.parse(receive(@sub))['message']
-  end
-
-  test "topic proc" do
-    @sub.bind(@address); sleep 0.1
-    error_check @sub.setsockopt(ZMQ::SUBSCRIBE, "topic2"), "subscribing"
-    @output = Cabin::Outputs::ZeroMQ.new(@address, :topology => "pubsub", :topic => Proc.new { |event| event[:message] })
-    @logger.subscribe(@output)
-    @logger.info("topic1")
-    @logger.info("topic2")
-    assert_equal "topic2", receive(@sub)
-    assert_equal "topic2", JSON.parse(receive(@sub))['message']
-  end
-
-  test "multiple addresses" do
-    @pull.bind(@address); sleep 0.1
-    @pull2 = Cabin::Outputs::ZeroMQ::CONTEXT.socket(ZMQ::PULL)
-    @pull2.bind(@address.succ); sleep 0.1
-
-    @output = Cabin::Outputs::ZeroMQ.new([@address, @address.succ])
-    @logger.subscribe(@output)
-    @logger.info("yo")
-    @logger.info("yo")
-
-    assert_equal "yo", JSON.parse(receive(@pull))['message']
-    assert_equal "yo", JSON.parse(receive(@pull2))['message']
-  end
-
-  test "options" do
-    @pull.bind(@address); sleep 0.1
-    @output = Cabin::Outputs::ZeroMQ.new(@address, :hwm => 10, :linger => 100)
-
-    assert_equal 10, @output.hwm
-    assert_equal 100, @output.linger
-  end
-end

data/vendor/gems/clamp-0.6.5/CHANGES.md

@@ -1,33 +0,0 @@
-# Changelog
-
-## 0.6.5 (2015-05-02)
-
-* Catch signals and exit appropriately.
-
-## 0.6.4 (2015-02-26)
-
-* Ensure computed defaults are only computed once.
-
-## 0.6.3 (2013-11-14)
-
-* Specify (MIT) license.
-
-## 0.6.2 (2013-11-06)
-
-* Refactoring around multi-valued attributes.
-* Allow injection of a custom help-builder.
-
-## 0.6.1 (2013-05-07)
-
-* Signal a usage error when an environment_variable fails validation.
-* Refactor setting, defaulting and inheritance of attributes.
-
-## 0.6.0 (2013-04-28)
-
-* Introduce "banner" to describe a command (replacing "self.description=").
-* Introduce "Clamp do ... end" syntax sugar.
-* Allow parameters to be specified before a subcommand.
-* Add support for :multivalued options.
-* Multi valued options and parameters get an "#append_to_foo_list" method, rather than
-  "#foo_list=".
-* default_subcommand must be specified before any subcommands.

data/vendor/gems/clamp-0.6.5/Gemfile

@@ -1,9 +0,0 @@
-source "http://rubygems.org"
-
-gemspec
-
-group :test do
-  gem "rake", "~> 10.4"
-  gem "rspec", "~> 3.1.0"
-  gem "rr", "~> 1.1.2"
-end

data/vendor/gems/clamp-0.6.5/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2010 Mike Williams <mdub@dogbiscuit.org>
-
-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/gems/clamp-0.6.5/README.md

@@ -1,403 +0,0 @@
-Clamp
-=====
-
-[![Gem Version](https://badge.fury.io/rb/clamp.png)](http://badge.fury.io/rb/clamp)
-[![Build Status](https://secure.travis-ci.org/mdub/clamp.png?branch=master)](http://travis-ci.org/mdub/clamp)
-
-"Clamp" is a minimal framework for command-line utilities.
-
-It handles boring stuff like parsing the command-line, and generating help, so you can get on with making your command actually do stuff.
-
-Not another one!
-----------------
-
-Yeah, sorry.  There are a bunch of existing command-line parsing libraries out there, and Clamp draws inspiration from a variety of sources, including [Thor], [optparse], and [Clip].  In the end, though, I wanted a slightly rounder wheel.  (Although, Clamp has a _lot_ in common with Ara T. Howard's [main.rb]. Had I been aware of that project at the time, I might not have written Clamp.)
-
-[optparse]: http://ruby-doc.org/stdlib/libdoc/optparse/rdoc/index.html
-[Thor]: http://github.com/wycats/thor
-[Clip]: http://clip.rubyforge.org/
-[main.rb]: https://github.com/ahoward/main
-
-Quick Start
------------
-
-A typical Clamp script looks like this:
-
-```ruby
-require 'clamp'
-
-Clamp do
-
-  option "--loud", :flag, "say it loud"
-  option ["-n", "--iterations"], "N", "say it N times", :default => 1 do |s|
-    Integer(s)
-  end
-
-  parameter "WORDS ...", "the thing to say", :attribute_name => :words
-
-  def execute
-    the_truth = words.join(" ")
-    the_truth.upcase! if loud?
-    iterations.times do
-      puts the_truth
-    end
-  end
-
-end
-```
-
-Internally, Clamp models a command as a Ruby class (a subclass of `Clamp::Command`), and a command execution as an instance of that class.  The example above is really just syntax-sugar for:
-
-```ruby
-require 'clamp'
-
-class SpeakCommand < Clamp::Command
-
-  option "--loud", :flag, "say it loud"
-  option ["-n", "--iterations"], "N", "say it N times", :default => 1 do |s|
-    Integer(s)
-  end
-
-  parameter "WORDS ...", "the thing to say", :attribute_name => :words
-
-  def execute
-    the_truth = words.join(" ")
-    the_truth.upcase! if loud?
-    iterations.times do
-      puts the_truth
-    end
-  end
-
-end
-
-SpeakCommand.run
-```
-
-Class-level methods like `option` and `parameter` declare attributes, in a similar way to `attr_accessor`, and arrange for them to be populated automatically based on command-line arguments.  They are also used to generate `help` documentation.
-
-There are more examples demonstrating various features of Clamp [on Github][examples].
-
-[examples]: https://github.com/mdub/clamp/tree/master/examples
-
-Declaring options
------------------
-
-Options are declared using the `option` method.  The three required arguments are:
-
-  1. the option switch (or switches),
-  2. an option argument name
-  3. a short description
-
-For example:
-
-```ruby
-option "--flavour", "FLAVOUR", "ice-cream flavour"
-```
-
-It works a little like `attr_accessor`, defining reader and writer methods on the command class.  The attribute name is inferred from the switch (in this case, "`flavour`").  When you pass options to your command, Clamp will populate the attributes, which are then available for use in your `#execute` method.
-
-```ruby
-def execute
-  puts "You chose #{flavour}.  Excellent choice!"
-end
-```
-
-If you don't like the inferred attribute name, you can override it:
-
-```ruby
-option "--type", "TYPE", "type of widget", :attribute_name => :widget_type
-                                           # to avoid clobbering Object#type
-```
-
-### Short/long option switches
-
-The first argument to `option` can be an array, rather than a single string, in which case all the switches are treated as aliases:
-
-```ruby
-option ["-s", "--subject"], "SUBJECT", "email subject line"
-```
-
-### Flag options
-
-Some options are just boolean flags.  Pass "`:flag`" as the second parameter to tell Clamp not to expect an option argument:
-
-```ruby
-option "--verbose", :flag, "be chatty"
-```
-
-For flag options, Clamp appends "`?`" to the generated reader method; ie. you get a method called "`#verbose?`", rather than just "`#verbose`".
-
-Negatable flags are easy to generate, too:
-
-```ruby
-option "--[no-]force", :flag, "be forceful (or not)"
-```
-
-Clamp will handle both "`--force`" and "`--no-force`" options, setting the value of "`#force?`" appropriately.
-
-### Required options
-
-Although 'required option' is a an oxymoron, Clamp lets you mark an option as required, and will verify that a value is provided:
-
-```ruby
-option "--password", "PASSWORD", "the secret password", :required => true
-```
-
-Note that it makes no sense to mark a `:flag` option, or one with a `:default`, as `:required`.
-
-### Multivalued options
-
-Declaring an option "`:multivalued`" allows it to be specified multiple times on the command line.
-
-```ruby
-option "--format", "FORMAT", "output format", :multivalued => true
-```
-
-The underlying attribute becomes an Array, and the suffix "`_list`" is appended to the default attribute name.  In this case, an attribute called "`format_list`" would be generated (unless you override the default by specifying an `:attribute_name`).
-
-Declaring parameters
---------------------
-
-Positional parameters can be declared using `parameter`, specifying
-
-  1. the parameter name, and
-  2. a short description
-
-For example:
-
-```ruby
-parameter "SRC", "source file"
-```
-
-Like options, parameters are implemented as attributes of the command, with the default attribute name derived from the parameter name (in this case, "`src`"). By convention, parameter names are specified in uppercase, to make them obvious in usage help.
-
-### Optional parameters
-
-Wrapping a parameter name in square brackets indicates that it's optional, e.g.
-
-```ruby
-parameter "[TARGET_DIR]", "target directory"
-```
-
-### Multivalued (aka "greedy") parameters
-
-Three dots at the end of a parameter name makes it "greedy" - it will consume all remaining command-line arguments.  For example:
-
-```ruby
-parameter "FILE ...", "input files", :attribute_name => :files
-```
-
-Like multivalued options, greedy parameters are backed by an Array attribute (named with a "`_list`" suffix, by default).
-
-Parsing and validation of options and parameters
-------------------------------------------------
-
-When you `#run` a command, it will first attempt to `#parse` command-line arguments, and map them onto the declared options and parameters, before invoking your `#execute` method.
-
-Clamp will verify that all required (ie. non-optional) parameters are present, and signal a error if they aren't.
-
-### Validation
-
-Both `option` and `parameter` accept an optional block.  If present, the block will be
-called with the raw string argument, and is expected to validate it.  The value returned by the block will be assigned to the underlying attribute, so it's also a good place to coerce the String to a different type, if appropriate.
-
-For example:
-
-```ruby
-option "--port", "PORT", "port to listen on" do |s|
-  Integer(s)
-end
-```
-
-If the block raises an ArgumentError, Clamp will catch it, and report that the value was bad:
-
-```ruby
-!!!plain
-ERROR: option '--port': invalid value for Integer: "blah"
-```
-
-For multivalued options and parameters, the validation block will be called for each value specified.
-
-More complex validation, e.g. those involving multiple options/parameters, should be performed within the `#execute` method.  Use `#signal_usage_error` to tell the user what they did wrong, e.g.
-
-```ruby
-def execute
-  if port < 1024 && user != 'root'
-    signal_usage_error "port restricted for non-root users"
-  end
-  # ... carry on ...
-end
-```
-
-### Advanced option/parameter handling
-
-While Clamp provides an attribute-writer method for each declared option or parameter, you always have the option of overriding it to provide custom argument-handling logic, e.g.
-
-```ruby
-parameter "SERVER", "location of server"
-
-def server=(server)
-  @server_address, @server_port = server.split(":")
-end
-```
-
-### Default values
-
-Default values can be specified for options, and optional parameters:
-
-```ruby
-option "--flavour", "FLAVOUR", "ice-cream flavour", :default => "chocolate"
-
-parameter "[HOST]", "server host", :default => "localhost"
-```
-
-For more advanced cases, you can also specify default values by defining a method called "`default_#{attribute_name}`":
-
-```ruby
-option "--http-port", "PORT", "web-server port", :default => 9000
-
-option "--admin-port", "PORT", "admin port"
-
-def default_admin_port
-   http_port + 1
-end
-```
-
-### Environment variable support
-
-Options (and optional parameters) can also be associated with environment variables:
-
-```ruby
-option "--port", "PORT", "the port to listen on", :environment_variable => "MYAPP_PORT" do |val|
-  val.to_i
-end
-
-parameter "[HOST]", "server address", :environment_variable => "MYAPP_HOST"
-```
-
-Clamp will check the specified envariables in the absence of values supplied on the command line, before looking for a default value.
-
-Declaring Subcommands
----------------------
-
-Subcommand support helps you wrap a number of related commands into a single script (ala tools like "`git`").  Clamp will inspect the first command-line argument (after options are parsed), and delegate to the named subcommand.
-
-Unsuprisingly, subcommands are declared using the `subcommand` method. e.g.
-
-```ruby
-Clamp do
-
-  subcommand "init", "Initialize the repository" do
-
-    def execute
-      # ...
-    end
-
-  end
-
-end
-```
-
-Clamp generates an anonymous subclass of the current class, to represent the subcommand.  Alternatively, you can provide an explicit subcommand class:
-
-```ruby
-class MainCommand < Clamp::Command
-
-  subcommand "init", "Initialize the repository", InitCommand
-
-end
-
-class InitCommand < Clamp::Command
-
-  def execute
-    # ...
-  end
-
-end
-```
-
-Like options, subcommands may have aliases:
-
-```ruby
-Clamp do
-
-  subcommand ["initialize", "init"], "Initialize the repository" do
-    # ...
-  end
-
-end
-```
-
-### Default subcommand
-
-You can set a default subcommand, at the class level, as follows:
-
-```ruby
-Clamp do
-
-  self.default_subcommand = "status"
-
-  subcommand "status", "Display current status" do
-
-    def execute
-      # ...
-    end
-
-  end
-
-end
-```
-
-Then, if when no SUBCOMMAND argument is provided, the default will be selected.
-
-### Subcommand options and parameters
-
-Options are inheritable, so any options declared for a command are supported by it's sub-classes (e.g. those created using the block form of `subcommand`).  Parameters, on the other hand, are not inherited - each subcommand must declare it's own parameter list.
-
-Note that, if a subcommand accepts options, they must be specified on the command-line _after_ the subcommand name.
-
-Getting help
-------------
-
-All Clamp commands support a "`--help`" option, which outputs brief usage documentation, based on those seemingly useless extra parameters that you had to pass to `option` and `parameter`.
-
-```sh
-$ speak --help
-Usage:
-    speak [OPTIONS] WORDS ...
-
-Arguments:
-    WORDS ...                     the thing to say
-
-Options:
-    --loud                        say it loud
-    -n, --iterations N            say it N times (default: 1)
-    -h, --help                    print help
-```
-
-License
--------
-
-Copyright (C) 2011 [Mike Williams](mailto:mdub@dogbiscuit.org)
-
-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 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.
-
-Contributing to Clamp
----------------------
-
-Source-code for Clamp is [on Github](https://github.com/mdub/clamp).