diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
deleted file mode 100644
index 496f228..0000000
--- a/.github/ISSUE_TEMPLATE.md
+++ /dev/null
@@ -1,14 +0,0 @@
-### Expected behaviour
-
-### Actual behaviour
-
-### Output of `checkmake --version`
-
-### Output of `checkmake --debug <your makefile>`
-
-### Output of `make --version`
-
-### Sample Makefile to reproduce issue
-
-(some of these things might not apply but the more you can provide the easier
-it will be to fix this bug. Thanks!)
diff --git a/.github/ISSUE_TEMPLATE/issue.md b/.github/ISSUE_TEMPLATE/issue.md
new file mode 100644
index 0000000..a4868ba
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/issue.md
@@ -0,0 +1,91 @@
+---
+name: Issue / Feature Request
+about: Report a bug or request a new feature
+title: '[BUG/Feature] '
+labels: ''
+assignees: ''
+---
+
+## Description
+
+<!--
+Please provide a clear and concise description of the issue or feature request.
+For bugs: What happened? What did you expect to happen?
+For feature requests: What would you like to see? What problem would it solve?
+-->
+
+## checkmake Version
+
+<!-- Please provide the output of `checkmake --version` -->
+
+```
+(checkmake --version output here)
+```
+
+## Debug Output
+
+<!-- For bugs: Please provide the output of `checkmake --debug <your makefile>` -->
+
+```
+(checkmake --debug output here)
+```
+
+## Environment
+
+<!-- Optional but helpful: OS, Go version, make version, etc. -->
+
+- OS: 
+- Go version (if applicable): 
+- Make version: <!-- Output of `make --version` --> 
+
+## Example Makefile
+
+<!--
+Please provide a minimal example Makefile that demonstrates the issue or the use case for the feature request.
+This helps us reproduce the problem or understand the need for the new feature.
+-->
+
+```makefile
+# Your Makefile content here
+```
+
+## checkmake Configuration (if applicable)
+
+<!--
+If you're using a custom configuration file, please provide its contents here.
+This helps us understand your rule settings and reproduce the issue.
+-->
+
+```ini
+# Your checkmake.ini or other configuration file content here
+```
+
+## Expected Behavior
+
+<!-- For bugs: What should happen? For feature requests: What should the new feature do? -->
+
+## Actual Behavior
+
+<!-- For bugs: What actually happens? -->
+
+## Steps to Reproduce
+
+<!-- For bugs: Steps to reproduce the issue -->
+
+1. 
+2. 
+3. 
+
+## Additional Context
+
+<!--
+Any other relevant information:
+- Error messages or logs
+- Screenshots (if applicable)
+- Related issues or discussions
+-->
+
+---
+
+**Note:** Some of these fields may not apply to all issues or feature requests, but the more information you can provide, the easier it will be to address your issue. Thanks!
+
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..6b3605b
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,31 @@
+# yaml-language-server: $jschema=https://json.schemastore.org/dependabot-2.0.json
+---
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+enable-beta-ecosystems: true
+updates:
+  # Dependencies listed in go.mod
+  - package-ecosystem: "gomod" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"
+    groups:
+      golang-dependencies:
+        patterns:
+          - "github.com/golang*"
+  # Dependencies listed in .github/workflows/*.yml
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  # Dockerfile base images
+  - package-ecosystem: docker
+    directories:
+      - /
+      - buildenv/
+    schedule:
+      interval: weekly
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0c6893c..c0b47ae 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,35 +1,56 @@
 name: CI
-on: push
+on:
+  workflow_dispatch:
+  pull_request:
+    types: [opened, synchronize]
+
 jobs:
 
   build:
     name: build and test
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
     env:
       BUILDER_NAME: "GitHub Actions"
       BUILDER_EMAIL: noreply@actions.github.com
 
     steps:
 
-    - name: Set up Go 1.17
-      uses: actions/setup-go@v2
+    - name: Set up Go
+      uses: actions/setup-go@v6
       with:
-        go-version: 1.17
+        go-version: 'stable'
       id: go
 
     - name: Check out code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
       with:
         fetch-depth: 1
 
-    - name: install dependencies
+    - name: Install dependencies (Windows)
+      if: matrix.os == 'windows-latest'
+      run: |
+        choco install -y make sed
+        choco install -y pandoc
+
+    - name: Install dependencies (macOS)
+      if: matrix.os == 'macos-latest'
+      run: |
+        brew install pandoc
+        
+    - name: Install dependencies (Linux/Ubuntu)
+      if: matrix.os == 'ubuntu-latest'
       run: |
-        sudo wget https://github.com/jgm/pandoc/releases/download/2.7.3/pandoc-2.7.3-1-amd64.deb
-        sudo dpkg -i pandoc-2.7.3-1-amd64.deb
+        sudo apt update
+        sudo apt install -y pandoc
 
-    - name: build and run unit tests
+    - name: Build and run unit tests
       run: make clean all test
+      shell: bash
 
     - name: Run checkmake on Makefile
       run: ./checkmake Makefile
+      shell: bash
 
diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
new file mode 100644
index 0000000..55d908b
--- /dev/null
+++ b/.github/workflows/golangci-lint.yml
@@ -0,0 +1,25 @@
+name: golangci-lint
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  golangci:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-go@v6
+        with:
+          go-version: stable
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v9
+        with:
+          version: v2.5
+          only-new-issues: true
diff --git a/.github/workflows/image-build.yml b/.github/workflows/image-build.yml
new file mode 100644
index 0000000..fbc7f76
--- /dev/null
+++ b/.github/workflows/image-build.yml
@@ -0,0 +1,47 @@
+name: checkmake  container image
+
+on:
+  push:
+    tags:
+      - v*
+    branches:
+      - main
+      - release-*
+  pull_request:
+    branches:
+      - main
+      - release-*
+
+
+permissions:
+  contents: read
+
+
+jobs:
+  ImageBuild:
+    runs-on: ubuntu-latest
+    env:
+      BUILDER_NAME: "GitHub Actions"
+      BUILDER_EMAIL: noreply@actions.github.com
+
+    steps:
+
+      - uses: actions/checkout@v6
+      - name: Build the container image
+        run: make CONTAINER_CMD=docker  image-build
+  # build and push images to quay.io - only on push, not on PRs.
+  ImagePush:
+    runs-on: ubuntu-latest
+    if: github.event_name=='push'
+    env:
+      BUILDER_NAME: "GitHub Actions"
+      BUILDER_EMAIL: noreply@actions.github.com
+
+    steps:
+      - uses: actions/checkout@v6
+      - name: Build the container image
+        run: make CONTAINER_CMD=docker image-build
+      - name: log in to quay.io
+        run: echo "${{ secrets.QUAY_PASS }}" | docker login -u "${{ secrets.QUAY_USER }}" --password-stdin quay.io
+      - name: Push  the container image to quay.io
+        run: echo "make CONTAINER_CMD=docker  image-push"
diff --git a/.github/workflows/packages.yml b/.github/workflows/packages.yml
index a63d2a9..f2d214b 100644
--- a/.github/workflows/packages.yml
+++ b/.github/workflows/packages.yml
@@ -14,22 +14,21 @@ jobs:
 
     steps:
 
-    - name: Set up Go 1.13
-      uses: actions/setup-go@v2
+    - name: Set up Go
+      uses: actions/setup-go@v6
       with:
-        go-version: 1.13
+        go-version: 'stable'
       id: go
 
     - name: Check out code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
       with:
         fetch-depth: 1
 
     - name: install dependencies
       run: |
-        sudo wget https://github.com/jgm/pandoc/releases/download/2.7.3/pandoc-2.7.3-1-amd64.deb
-        sudo dpkg -i pandoc-2.7.3-1-amd64.deb
-        rm -f pandoc-2.7.3-1-amd64.deb
+        sudo apt update
+        sudo apt install -y pandoc
         sudo gem install fpm package_cloud
 
     - name: build and run unit tests
@@ -49,27 +48,30 @@ jobs:
 
     steps:
 
-    - name: Set up Go 1.17
-      uses: actions/setup-go@v2
+    - name: Set up Go
+      uses: actions/setup-go@v6
       with:
-        go-version: 1.17
+        go-version: 'stable'
       id: go
 
     - name: Check out code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
       with:
         fetch-depth: 1
 
     - name: install dependencies
       run: |
-        sudo wget https://github.com/jgm/pandoc/releases/download/2.7.3/pandoc-2.7.3-1-amd64.deb
-        sudo dpkg -i pandoc-2.7.3-1-amd64.deb
+        sudo apt update
+        sudo apt install -y pandoc
 
     - name: build for platforms
       run: |
         BUILD_GOARCH=amd64 BUILD_GOOS=freebsd make build-standalone
         BUILD_GOARCH=amd64 BUILD_GOOS=linux   make build-standalone
         BUILD_GOARCH=amd64 BUILD_GOOS=darwin  make build-standalone
+        BUILD_GOARCH=arm64 BUILD_GOOS=darwin  make build-standalone
+        BUILD_GOARCH=amd64 BUILD_GOOS=windows make build-standalone
+        BUILD_GOARCH=arm64 BUILD_GOOS=windows make build-standalone
 
     - name: create release
       run: make github-release
@@ -85,7 +87,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
     - name: Build the Docker image
       run: docker build --build-arg BUILDER_NAME=CI --build-arg BUILDER_EMAIL=ci@test.only . --file Dockerfile --tag mrtazz/checkmake:${GITHUB_SHA} --tag mrtazz/checkmake:latest
 
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
index 2f7d9b7..93c3624 100644
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -27,11 +27,11 @@ jobs:
   pre-commit:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v3
-    - name: Set up Go 1.17
-      uses: actions/setup-go@v2
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
+    - name: Set up Go
+      uses: actions/setup-go@v6
       with:
-        go-version: 1.17
+        go-version: 'stable'
       id: go
-    - uses: pre-commit/action@v2.0.3
+    - uses: pre-commit/action@v3.0.1
diff --git a/.gitignore b/.gitignore
index 0e6ac9c..a9cd150 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@ checkmake
 !cmd/checkmake*
 cover.html
 cover.out
+main
 profile.out
 *.rpm
 *.deb
diff --git a/.golangci.yml b/.golangci.yml
new file mode 100644
index 0000000..c3a5560
--- /dev/null
+++ b/.golangci.yml
@@ -0,0 +1,34 @@
+version: "2"
+
+run:
+  tests: true
+  timeout: 5m
+
+linters:
+  enable:
+    - govet
+    - staticcheck
+    - ineffassign
+    - unused
+    - goconst
+    - prealloc
+    - unparam
+    - nolintlint
+    - misspell
+    - revive
+  disable:
+    - dupl
+    - errcheck
+    - gocyclo
+
+  settings:
+    revive:
+      severity: warning
+    staticcheck:
+      checks:
+        - all
+        - "-ST1005"
+
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 57d8cc3..d21318f 100755
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,14 +1,12 @@
 exclude: |
     (?x)^(
-        vendor/.*
     )$
 repos:
--   repo: https://github.com/mrtazz/checkmake.git
-    rev: main
+-   repo: https://github.com/checkmake/checkmake.git
+    rev: 0.2.2
     hooks:
     - id: checkmake
       exclude: |
         (?x)^(
-          vendor/.*|
           fixtures/missing_phony\.make
         )$
diff --git a/Containerfile b/Containerfile
new file mode 100644
index 0000000..631be26
--- /dev/null
+++ b/Containerfile
@@ -0,0 +1,17 @@
+FROM golang:1.25 AS builder
+
+ARG BUILDER_NAME
+ARG BUILDER_EMAIL
+
+ENV GOOS=linux GOARCH=amd64 CGO_ENABLED=0
+COPY . /go/src/github.com/checkmake/checkmake
+WORKDIR /go/src/github.com/checkmake/checkmake
+RUN make BUILDER_NAME="${BUILDER_NAME}" BUILDER_EMAIL="${BUILDER_EMAIL}" clean binaries
+RUN make test
+
+FROM alpine:3.23
+RUN apk add --no-cache make
+USER nobody
+
+COPY --from=builder /go/src/github.com/checkmake/checkmake/checkmake /
+ENTRYPOINT ["./checkmake", "/Makefile"]
diff --git a/Dockerfile b/Dockerfile
deleted file mode 100644
index 5ef7037..0000000
--- a/Dockerfile
+++ /dev/null
@@ -1,15 +0,0 @@
-FROM golang:1.13 as builder
-
-ARG BUILDER_NAME BUILDER_EMAIL
-
-COPY . /go/src/github.com/mrtazz/checkmake
-
-RUN cd /go/src/github.com/mrtazz/checkmake && GOOS=linux GOARCH=amd64 CGO_ENABLED=0 make binaries
-RUN cd /go/src/github.com/mrtazz/checkmake && make test
-
-FROM alpine:3.9
-RUN apk add make
-USER nobody
-
-COPY --from=builder /go/src/github.com/mrtazz/checkmake/checkmake /
-ENTRYPOINT ["./checkmake", "/Makefile"]
diff --git a/Makefile b/Makefile
index e792990..32ae367 100644
--- a/Makefile
+++ b/Makefile
@@ -3,11 +3,11 @@
 #
 
 export GO111MODULE = on
-export GOFLAGS = -mod=vendor
+export GOFLAGS = -mod=mod
 
 # variable definitions
 NAME := checkmake
-DESC := experimental linter for Makefiles
+DESC := linter for Makefiles
 PREFIX ?= usr/local
 VERSION := $(shell git describe --tags --always --dirty)
 GOVERSION := $(shell go version)
@@ -16,6 +16,37 @@ BUILDDATE := $(shell date -u +"%B %d, %Y")
 
 BUILD_GOOS ?= $(shell go env GOOS)
 BUILD_GOARCH ?= $(shell go env GOARCH)
+BUILD_GOPATH :=$(shell go env GOPATH)
+
+GOLANGCI_LINT_VERSION := latest
+GOLANGCI_LINT_MAJOR_VER := v2
+GOLANGCI_LINT_BIN:= $(BUILD_GOPATH)/bin/golangci-lint
+
+
+
+IMAGE_REGISTRY ?= quay.io
+REGISTRY_NAMESPACE ?= $(NAME)
+
+IMAGE_NAME ?= checkmake
+
+IMAGE_VERSION_TAG ?= latest
+
+IMG ?= $(IMAGE_REGISTRY)/$(REGISTRY_NAMESPACE)/$(IMAGE_NAME):$(IMAGE_VERSION_TAG)
+
+
+ifeq ($(origin CONTAINER_CMD),undefined)
+# try podman first
+CONTAINER_CMD=$(shell podman version >/dev/null 2>&1 && echo podman)
+ifeq ($(CONTAINER_CMD),)
+#try docker if podman is not available
+CONTAINER_CMD=$(shell docker version >/dev/null 2>&1 && echo docker)
+endif
+endif
+
+
+ifeq ($(BUILD_GOOS),windows)
+	EXTENSION := .exe
+endif
 
 RELEASE_ARTIFACTS_DIR := .release_artifacts
 CHECKSUM_FILE := checksums.txt
@@ -23,6 +54,8 @@ CHECKSUM_FILE := checksums.txt
 $(RELEASE_ARTIFACTS_DIR):
 	install -d $@
 
+CHECKMAKE_RELEASE_BINARY = "$(RELEASE_ARTIFACTS_DIR)/checkmake-$(VERSION).$(BUILD_GOOS).$(BUILD_GOARCH)$(EXTENSION)"
+
 BUILDER_NAME := $(if $(BUILDER_NAME),$(BUILDER_NAME),$(shell git config user.name))
 ifndef BUILDER_NAME
 $(error "You must set environment variable BUILDER_NAME or set a user.name in your git configuration.")
@@ -36,7 +69,7 @@ endif
 BUILDER := $(shell echo "${BUILDER_NAME} <${EMAIL}>")
 
 PKG_RELEASE ?= 1
-PROJECT_URL := "https://github.com/mrtazz/$(NAME)"
+PROJECT_URL := "https://github.com/checkmake/$(NAME)"
 LDFLAGS := -X 'main.version=$(VERSION)' \
            -X 'main.buildTime=$(BUILDTIME)' \
            -X 'main.builder=$(BUILDER)' \
@@ -59,7 +92,7 @@ INSTALLED_MAN_TARGETS = $(addprefix $(PREFIX)/share/man/man1/, $(MAN_TARGETS))
 %.1: man/man1/%.1.md
 	sed "s/REPLACE_DATE/$(BUILDDATE)/" $< | pandoc -s -t man -o $@
 
-all: require $(TARGETS) $(MAN_TARGETS)
+all: lint require $(TARGETS) $(MAN_TARGETS)
 .DEFAULT_GOAL:=all
 
 binaries: $(TARGETS)
@@ -69,9 +102,27 @@ require:
 	@pandoc --version >/dev/null 2>&1 || (echo "ERROR: pandoc is required."; exit 1)
 
 # development tasks
-test:
+
+test: lint
 	go test -v $(TEST_PKG)
 
+.PHONY: vet
+vet:
+	@go vet ./...
+
+.PHONY: golangci-lint
+golangci-lint: $(GOLANGCI_LINT_BIN)
+	@$(GOLANGCI_LINT_BIN) run
+
+$(GOLANGCI_LINT_BIN):
+	@go install github.com/golangci/golangci-lint/$(GOLANGCI_LINT_MAJOR_VER)/cmd/golangci-lint@$(GOLANGCI_LINT_VERSION)
+
+.PHONY: lint
+lint: vet golangci-lint
+
+
+
+
 coverage:
 	@echo "mode: set" > cover.out
 	@for package in $(PACKAGES); do \
@@ -104,12 +155,9 @@ local-install:
 packages: local-install rpm deb
 
 deploy-packages: packages
-	package_cloud push mrtazz/$(NAME)/el/8 *.rpm
-	package_cloud push mrtazz/$(NAME)/debian/trixie *.deb
-	package_cloud push mrtazz/$(NAME)/ubuntu/hirsute *.deb
+	package_cloud push mrtazz/$(NAME)/rpm_any *.rpm
+	package_cloud push mrtazz/$(NAME)/any/any *.deb
 
-vendor:
-	go mod vendor
 
 rpm: $(SOURCES)
 	  fpm -t rpm -s dir \
@@ -140,8 +188,8 @@ deb: $(SOURCES)
 .PHONY: build-standalone
 build-standalone: all $(RELEASE_ARTIFACTS_DIR)
 	mv checkmake.1 $(RELEASE_ARTIFACTS_DIR)
-	mv checkmake $(RELEASE_ARTIFACTS_DIR)/checkmake-$(VERSION).$(BUILD_GOOS).$(BUILD_GOARCH)
-	cd $(RELEASE_ARTIFACTS_DIR) && shasum -a 256 checkmake-$(VERSION).$(BUILD_GOOS).$(BUILD_GOARCH) >> $(CHECKSUM_FILE)
+	mv checkmake $(CHECKMAKE_RELEASE_BINARY)
+	shasum -a 256 $(CHECKMAKE_RELEASE_BINARY) >> $(RELEASE_ARTIFACTS_DIR)/$(CHECKSUM_FILE)
 
 .PHONY: github-release
 github-release:
@@ -164,4 +212,15 @@ pizza: # ignore checkmake
 	@echo ""
 	@echo ""
 
-.PHONY: all test rpm deb install local-install packages vendor coverage clean-deps clean clean-docs pizza binaries
+.PHONY: all test rpm deb install local-install packages coverage clean-deps clean clean-docs pizza binaries
+
+.PHONY: image-build
+image-build:
+	$(CONTAINER_CMD) build --build-arg BUILDER_NAME='$(BUILDER_NAME)' --build-arg BUILDER_EMAIL='$(EMAIL)' -t $(IMG) -f Containerfile .
+
+.PHONY: image-push
+image-push:
+	$(CONTAINER_CMD) push $(IMG)
+
+
+
diff --git a/README.md b/README.md
index d0c768e..21765e4 100644
--- a/README.md
+++ b/README.md
@@ -1,61 +1,113 @@
 # checkmake
 
-[![Build Status](https://travis-ci.org/mrtazz/checkmake.svg?branch=master)](https://travis-ci.org/mrtazz/checkmake)
+[![Build Status](https://github.com/checkmake/checkmake/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/checkmake/checkmake/actions)
 [![Coverage Status](https://coveralls.io/repos/github/mrtazz/checkmake/badge.svg?branch=master)](https://coveralls.io/github/mrtazz/checkmake?branch=master)
 [![Code Climate](https://codeclimate.com/github/mrtazz/checkmake/badges/gpa.svg)](https://codeclimate.com/github/mrtazz/checkmake)
+[![Go Report Card](https://goreportcard.com/badge/github.com/checkmake/checkmake)](https://goreportcard.com/report/github.com/checkmake/checkmake)
 [![Packagecloud](https://img.shields.io/badge/packagecloud-available-brightgreen.svg)](https://packagecloud.io/mrtazz/checkmake)
 [![MIT license](https://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)
 
 ## Overview
-checkmake is an experimental tool for linting and checking Makefiles. It may
-not do what you want it to.
+**checkmake** is a linter for Makefiles. It scans Makefiles for potential issues based on configurable rules.
 
 ## Usage
 
-```
+```console
 % checkmake Makefile
-
 % checkmake Makefile foo.mk bar.mk baz.mk
+```
 
-% checkmake --help
-checkmake.
+checkmake analyzes one or more Makefiles and reports potential issues according to configurable rules.
 
-Usage:
-checkmake [--debug|--config=<configPath>] <makefile>...
-checkmake -h | --help
-checkmake --version
 
-Options:
--h --help               Show this screen.
---version               Show version.
---debug                 Enable debug mode
---config=<configPath>   Configuration file to read
---list-rules            List registered rules
+### Command-line options
+```console
+Usage:
+  checkmake [flags] [makefile...]
+  checkmake [command]
+
+Available Commands:
+  completion  Generate the autocompletion script for the specified shell
+  help        Help about any command
+  list-rules  List registered rules
+
+Flags:
+      --config string   Configuration file to read (default "checkmake.ini")
+      --debug           Enable debug mode
+      --format string   Custom Go template for text output (ignored in JSON mode)
+  -h, --help            help for checkmake
+  -o, --output string   Output format: 'text' (default) or 'json' (mutually exclusive with --format) (default "text")
+  -v, --version         version for checkmake
+
+Use "checkmake [command] --help" for more information about a command.
+```
 
+### Example output
+```console
 % checkmake fixtures/missing_phony.make
-
-      RULE                 DESCRIPTION             LINE NUMBER
-
-  minphony        Missing required phony target    0
+      RULE                 DESCRIPTION                      FILE NAME            LINE NUMBER
+  minphony        Missing required phony target    fixtures/missing_phony.make   21
                   "all"
-  minphony        Missing required phony target    0
+  minphony        Missing required phony target    fixtures/missing_phony.make   21
                   "test"
-  phonydeclared   Target "all" should be           18
+  phonydeclared   Target "all" should be           fixtures/missing_phony.make   16
                   declared PHONY.
-
 ```
 
-## Docker usage
-Build the image, or pull it:
-```sh
+## Container  usage
+
+building or running a container image can be done with docker and podman.
+
+
+# building  an image
+
+
+```console
 docker build --build-arg BUILDER_NAME='Your Name' --build-arg BUILDER_EMAIL=your.name@example.com . -t checker
 ```
 
-Then run it with your Makefile attached, below is an example of it assuming the Makefile is in your current working directory:
-```sh
-docker run -v "$PWD"/Makefile:/Makefile checker
+Alternatively, the image can be built with the make target `image-build` :
+
+```console
+$ BUILDER_NAME='Your Name' BUILDER_EMAIL='your@mail' image-build
 ```
 
+By default, the image tag is constructed as `IMAGE_REGISTRY/checkmake/checkmake:IMAGE_VERSION_TAG`
+
+The image registry defaults to `quay.io` but can be overridden by the `IMAGE_REGISTRY` make variable.
+
+The image version tag defaults to `latest` and can be overridden with the make variable  `IMAGE_VERSION_TAG`.
+
+The container command used for building (docker or podman) is auto-detected with a preference for podman but can be overridden by the make variable `CONTAINER_CMD`.
+
+# publishing an image
+
+The locally built image can be published with a `make image-push`command corresponding to the previously described `make image-build`command or alrenatively directly using `docker push` or `podman push`  
+
+# published images on quay
+
+Official images are published on [quay.io](https://quay.io/repository/checkmake/checkmake) 
+
+
+
+# running checkmake in container
+
+
+Then checkmake can be run in a contaner based on a locally built or pulled image with a  Makefile attached. below is an example of it assuming the Makefile is in the  current working directory:
+```console
+docker run --workdir / -v "$PWD"/Makefile:/Makefile quay.io/checkmake/checkmake:latest 
+```
+
+Variant for using an additional config file:
+
+```console
+docker run --workdir / -v "$PWD"/Makefile:/Makefile -v "$PWD"/checkmake.ini:/checkmake.ini  quay.io/checkmake/checkmake:latest
+```
+Note that this uses the default config file name `checkmake.ini` in the CWD so that it will be picked up by checkmake automatically.
+
+
+
+
 ## `pre-commit` usage
 
 This repo includes a `pre-commit` hook, which you may choose to use in your own
@@ -63,13 +115,13 @@ repos. Simply add a `.pre-commit-config.yaml` to your repo's top-level directory
 
 ```yaml
 repos:
--   repo: https://github.com/mrtazz/checkmake.git
+-   repo: https://github.com/checkmake/checkmake.git
     # Or another commit hash or version
     rev: 0.2.2
     hooks:
     # Use this hook to let pre-commit build checkmake in its sandbox
     -   id: checkmake
-    # OR Use this hook to use a pre-installed checkmark executable
+    # OR Use this hook to use a pre-installed checkmake executable
     # -   id: checkmake-system
 ```
 
@@ -83,12 +135,12 @@ There are two hooks available:
 - `checkmake-system`
 
    pre-commit will look for `checkmake` on your `PATH`.
-   This hook requires you to install `checkmake` separately, e.g. with your package manager or [a prebuilt binary release](https://github.com/mrtazz/checkmake/releases).
+   This hook requires you to install `checkmake` separately, e.g. with your package manager or [a prebuilt binary release](https://github.com/checkmake/checkmake/releases).
    Only recommended if it's permissible to require all repository users install `checkmake` manually.
 
 Then, run `pre-commit` as usual as a part of `git commit` or explicitly, for example:
 
-```sh
+```console
 pre-commit run --all-files
 ```
 
@@ -139,34 +191,41 @@ jobs:
 
 ## Installation
 
-### Requirements
-The [pandoc](https://pandoc.org/) document converter utility is required to run checkmate. You can find out if you have it via `which pandoc`. [Install pandoc](https://pandoc.org/installing.html) if the command was not found.
-
-## With Go
+### With Go
 
 With `go` 1.16 or higher:
 
-```sh
-go install github.com/mrtazz/checkmake/cmd/checkmake@latest
+```console
+go install github.com/checkmake/checkmake/cmd/checkmake@latest
 checkmake Makefile
 ```
 
 Or alternatively, run it directly:
 
-```sh
-go run github.com/mrtazz/checkmake/cmd/checkmake@latest Makefile
+```console
+go run github.com/checkmake/checkmake/cmd/checkmake@latest Makefile
 ```
 
-### Packages
-There are packages for linux up [on packagecloud.io](https://packagecloud.io/mrtazz/checkmake) or build it yourself with the steps below.
+### From Packages
+checkmake is available in many Linux distributions and package managers. See [Repology](https://repology.org/project/checkmake/versions) for full list:
+
+[![Repology](https://repology.org/badge/vertical-allrepos/checkmake.svg?exclude_unsupported=1)](https://repology.org/project/checkmake/versions)
+
+Packages are also available [on packagecloud.io](https://packagecloud.io/mrtazz/checkmake).
 
 ### Build
-To build checkmake you will need to have [golang](https://golang.org/) installed. Once you have Go installed, you can simply clone the repo and build the binary and man page yourself with the following commands.
+You'll need [Go](https://golang.org/) installed.
 
-```sh
-git clone https://github.com/mrtazz/checkmake
+```console
+git clone https://github.com/checkmake/checkmake
 cd checkmake
-make
+make checkmake
+```
+
+To build the man page (optional), install [pandoc](https://pandoc.org/installing.html) and run:
+
+```console
+make checkmake.1
 ```
 
 ## Use in CI
@@ -179,4 +238,4 @@ To install it, run `npx mega-linter-runner --install` (requires Node.js)
 
 ## Inspiration
 This is totally inspired by an idea by [Dan
-Buch](https://twitter.com/meatballhat/status/768112351924985856).
+Buch](https://web.archive.org/web/20200916193234/https://twitter.com/meatballhat/status/768112351924985856).
diff --git a/buildenv/Dockerfile b/buildenv/Dockerfile
index 7725ce2..3182bd9 100644
--- a/buildenv/Dockerfile
+++ b/buildenv/Dockerfile
@@ -1,2 +1,2 @@
-FROM golang:1.13.8
+FROM golang:1.25.5
 RUN apt-get update && apt-get install -y pandoc
\ No newline at end of file
diff --git a/checkmake.go b/checkmake.go
deleted file mode 120000
index 01d14d2..0000000
--- a/checkmake.go
+++ /dev/null
@@ -1 +0,0 @@
-./cmd/checkmake/main.go
\ No newline at end of file
diff --git a/cmd/checkmake/main.go b/cmd/checkmake/main.go
index 3256adf..34eab53 100644
--- a/cmd/checkmake/main.go
+++ b/cmd/checkmake/main.go
@@ -1,141 +1,198 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
 	"io"
 	"log"
 	"os"
-
-	docopt "github.com/docopt/docopt-go"
-	"github.com/mrtazz/checkmake/config"
-	"github.com/mrtazz/checkmake/formatters"
-	"github.com/mrtazz/checkmake/logger"
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
-	"github.com/mrtazz/checkmake/validator"
+	"path/filepath"
+	"strings"
+
+	"github.com/checkmake/checkmake/config"
+	"github.com/checkmake/checkmake/formatters"
+	"github.com/checkmake/checkmake/logger"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
+	"github.com/checkmake/checkmake/validator"
 	"github.com/olekukonko/tablewriter"
+	"github.com/olekukonko/tablewriter/tw"
+	"github.com/spf13/cobra"
 )
 
 var (
-	usage = `checkmake.
-
-  Usage:
-  checkmake [options] <makefile>...
-  checkmake -h | --help
-  checkmake --version
-  checkmake --list-rules
-
-  Options:
-  -h --help               Show this screen.
-  --version               Show version.
-  --debug                 Enable debug mode
-  --config=<configPath>   Configuration file to read
-  --format=<format>       Output format as a Golang text/template template
-  --list-rules            List registered rules
-`
-
 	version   = ""
 	buildTime = ""
 	builder   = ""
 	goversion = ""
 
-	configPath = "checkmake.ini"
+	cfgPath string
+	debug   bool
+	format  string
+	output  string
 )
 
-func main() {
-
-	args, err := docopt.Parse(usage, nil, true,
-		fmt.Sprintf("%s %s built at %s by %s with %s",
-			"checkmake", version, buildTime, builder, goversion), false)
-	if err != nil {
-		log.Fatal(err)
-		os.Exit(1)
+func newRootCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:          "checkmake [flags] [makefile...]",
+		Short:        "Validate Makefiles for common issues",
+		Long:         "checkmake scans Makefiles and reports potential issues according to configurable rules.",
+		Args:         cobra.ArbitraryArgs,
+		SilenceUsage: true,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if len(args) == 0 {
+				_ = cmd.Help()
+				return nil
+			}
+			return runCheckmake(args)
+		},
 	}
 
-	formatter, violations := parseArgsAndGetFormatter(args)
-
-	if len(violations) > 0 {
-		formatter.Format(violations)
-	}
-
-	os.Exit(len(violations))
+	cmd.PersistentFlags().BoolVar(&debug, "debug", false, "Enable debug mode")
+	cmd.PersistentFlags().StringVar(&cfgPath, "config", "checkmake.ini", "Configuration file to read")
+	cmd.PersistentFlags().StringVar(&format, "format", "", "Custom Go template for text output (ignored in JSON mode)")
+	cmd.PersistentFlags().StringVarP(&output, "output", "o", "text", "Output format: 'text' (default) or 'json' (mutually exclusive with --format)")
+	cmd.MarkFlagsMutuallyExclusive("format", "output")
+
+	cmd.Version = fmt.Sprintf("%s %s built at %s by %s with %s",
+		"checkmake", version, buildTime, builder, goversion)
+
+	cmd.AddCommand(&cobra.Command{
+		Use:   "list-rules",
+		Short: "List registered rules",
+		Run: func(cmd *cobra.Command, args []string) {
+			cfg := loadConfig()
+			listRules(cmd.OutOrStdout(), cfg)
+		},
+	})
+
+	return cmd
 }
 
-func parseArgsAndGetFormatter(args map[string]interface{}) (formatters.Formatter,
-	rules.RuleViolationList) {
-	if args["--debug"] == true {
+func loadConfig() *config.Config {
+	if debug {
 		logger.SetLogLevel(logger.DebugLevel)
 	}
 
-	if args["--list-rules"] == true {
-		listRules(os.Stdout)
-		os.Exit(0)
+	if _, err := os.Stat(cfgPath); err != nil {
+		if os.IsNotExist(err) {
+			home := os.Getenv("HOME")
+			cfgPath = filepath.Join(home, "checkmake.ini")
+		} else {
+			logger.Error(fmt.Sprintf("error accessing config file %q: %v", cfgPath, err))
+			return &config.Config{}
+		}
 	}
 
-	if args["--config"] != nil {
-		configPath = args["--config"].(string)
+	cfg, cfgError := config.NewConfigFromFile(cfgPath)
+	if cfgError != nil {
+		logger.Info(fmt.Sprintf("Unable to parse config file %q, running with defaults", cfgPath))
+		return &config.Config{}
 	}
 
-	cfg, cfgError := config.NewConfigFromFile(configPath)
+	logger.Debug(fmt.Sprintf("Using configuration file: %q", cfgPath))
+	if debug {
+		if iniFile := cfg.Ini(); iniFile != nil {
+			var buf bytes.Buffer
+			if _, err := iniFile.WriteTo(&buf); err == nil {
+				logger.Debug(fmt.Sprintf("Parsed configuration:\n%s", buf.String()))
+			}
+		}
+	}
 
-	if cfgError != nil {
-		logger.Info(fmt.Sprintf("Unable to parse config file %q, running with defaults",
-			configPath))
+	return cfg
+}
+
+func main() {
+	if err := newRootCmd().Execute(); err != nil {
+		os.Exit(1)
 	}
+}
+
+func runCheckmake(makefiles []string) error {
+	cfg := loadConfig()
+	logger.Debug(fmt.Sprintf("Makefiles passed: %q", makefiles))
 
 	var violations rules.RuleViolationList
-	makefileArray := args["<makefile>"].([]string)
-	logger.Debug(fmt.Sprintf("Makefiles passed: %q",
-		makefileArray))
-	for _, mkf := range makefileArray {
-		logger.Info(fmt.Sprintf("Parsing file %q",
-			mkf))
-		makefile, parseError := parser.Parse(mkf)
-		if parseError != nil {
-			log.Fatal(parseError)
-			os.Exit(1)
+	for _, mkf := range makefiles {
+		logger.Info(fmt.Sprintf("Parsing file %q", mkf))
+		makefile, parseErr := parser.Parse(mkf)
+		if parseErr != nil {
+			return fmt.Errorf("failed to parse %q: %w", mkf, parseErr)
 		}
 		violations = append(violations, validator.Validate(makefile, cfg)...)
 	}
 
 	var formatter formatters.Formatter
+	var err error
 
-	if args["--format"] != nil {
-		format := args["--format"].(string)
-		var err error
+	// Priority: format flag > output flag > config format > default
+	if format != "" {
 		formatter, err = formatters.NewCustomFormatter(format)
-		if err != nil {
-			logger.Error(fmt.Sprintf("Unable to create formatter: %q", err.Error()))
-			os.Exit(1)
+	} else {
+		// Use output flag if specified, otherwise check config
+		outputMode := strings.ToLower(output)
+		if outputMode == "" {
+			if o, oerr := cfg.GetConfigValue("output"); oerr == nil {
+				outputMode = strings.ToLower(o)
+			} else {
+				outputMode = "text" // default
+			}
 		}
-	} else if format, formatErr := cfg.GetConfigValue("format"); formatErr == nil {
-		var err error
-		formatter, err = formatters.NewCustomFormatter(format)
-		if err != nil {
-			logger.Error(fmt.Sprintf("Unable to create formatter: %q", err.Error()))
-			os.Exit(1)
+
+		switch outputMode {
+		case "json":
+			formatter = formatters.NewJSONFormatter()
+		case "text":
+			if format != "" {
+				formatter, err = formatters.NewCustomFormatter(format)
+			} else if f, ferr := cfg.GetConfigValue("format"); ferr == nil {
+				formatter, err = formatters.NewCustomFormatter(f)
+			} else {
+				formatter = formatters.NewDefaultFormatter()
+			}
+		default:
+			return fmt.Errorf("invalid output format: %q (supported: text, json)", outputMode)
 		}
+		logger.Debug(fmt.Sprintf("Using output mode: %s", outputMode))
+	}
+	if err != nil {
+		logger.Error(fmt.Sprintf("Unable to create formatter: %q", err.Error()))
+		return err
+	}
 
-	} else {
-		formatter = formatters.NewDefaultFormatter()
+	// Output
+	if len(violations) > 0 {
+		formatter.Format(violations)
+		return fmt.Errorf("violations found (%d)", len(violations))
 	}
 
-	return formatter, violations
+	return nil
 }
 
-func listRules(w io.Writer) {
+func listRules(w io.Writer, cfg *config.Config) {
 	data := [][]string{}
-	for _, rule := range rules.GetRegisteredRules() {
-		data = append(data, []string{rule.Name(), rule.Description()})
+	for _, rule := range rules.GetRulesSorted() {
+		cfgForRule := cfg.GetRuleConfig(rule.Name())
+		data = append(data, []string{rule.Name(), rule.Description(cfgForRule)})
 	}
 
-	table := tablewriter.NewWriter(w)
-	table.SetHeader([]string{"Name", "Description"})
-	table.SetCenterSeparator(" ")
-	table.SetColumnSeparator(" ")
-	table.SetRowSeparator(" ")
-	table.SetAutoWrapText(true)
-
-	table.AppendBulk(data)
+	table := tablewriter.NewTable(w,
+		tablewriter.WithRendition(tw.Rendition{
+			Borders: tw.BorderNone,
+			Symbols: tw.NewSymbols(tw.StyleNone),
+			Settings: tw.Settings{
+				Lines:      tw.LinesNone,
+				Separators: tw.SeparatorsNone,
+			},
+		}),
+		tablewriter.WithRowAutoWrap(tw.WrapNormal),
+		tablewriter.WithMaxWidth(72),
+	)
+	table.Header("Name", "Description")
+
+	if err := table.Bulk(data); err != nil {
+		log.Fatalf("Bulk append failed: %v", err)
+	}
 	table.Render()
 }
diff --git a/cmd/checkmake/main_test.go b/cmd/checkmake/main_test.go
index 1b1a77f..103ce31 100644
--- a/cmd/checkmake/main_test.go
+++ b/cmd/checkmake/main_test.go
@@ -3,38 +3,324 @@ package main
 
 import (
 	"bytes"
-	"fmt"
+	"encoding/json"
+	"io"
+	"log"
+	"os"
 	"testing"
 
-	"github.com/docopt/docopt-go"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func TestMain(t *testing.T) {
+// captureOutput temporarily redirects os.Stdout during f(), returning what was printed.
+// Useful for testing formatters that write directly to os.Stdout instead of Cobra's writer.
+func captureOutput(f func()) string {
+	var buf bytes.Buffer
+	stdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
 
-	args, err := docopt.Parse(usage, []string{"../../fixtures/simple.make"}, true,
-		fmt.Sprintf("%s %s built at %s by %s with %s",
-			"checkmake", version, buildTime, builder, goversion), false)
+	done := make(chan struct{})
+	go func() {
+		_, _ = io.Copy(&buf, r)
+		close(done)
+	}()
 
-	require.Equal(t, nil, err, "docopt parsing should work")
+	f()
 
-	formatter, violations := parseArgsAndGetFormatter(args)
+	w.Close()
+	<-done
+	os.Stdout = stdout
 
-	assert.NotNil(t, formatter)
-	assert.Equal(t, 0, len(violations))
+	return buf.String()
 }
 
-func TestListRules(t *testing.T) {
-	out := new(bytes.Buffer)
+func TestCheckmake_NoArgsShowsHelp(t *testing.T) {
+	out := captureOutput(func() {
+		cmd := newRootCmd()
+		cmd.SetArgs([]string{}) // no args
+		err := cmd.Execute()
+		require.NoError(t, err, "command without args should not fail")
+	})
 
-	listRules(out)
+	assert.Contains(t, out, "Usage:", "expected help output to be shown")
+	assert.Contains(t, out, "checkmake [flags]", "should display root usage line")
+}
+
+func TestCheckmake_RunWithSimpleMakefile(t *testing.T) {
+	t.Parallel()
+	cmd := newRootCmd()
+	cmd.SetArgs([]string{"../../fixtures/simple.make"})
+
+	var buf bytes.Buffer
+	cmd.SetOut(&buf)
+	cmd.SetErr(&buf)
+
+	err := cmd.Execute()
+	require.NoError(t, err, "command should run successfully")
+
+	output := buf.String()
+	assert.NotContains(t, output, "error", "should not print errors")
+}
+
+func TestCheckmake_RunWithViolations(t *testing.T) {
+	cmd := newRootCmd()
+	cmd.SilenceErrors = true
+	cmd.SetArgs([]string{"../../fixtures/missing_phony.make"})
+
+	var err error
+	out := captureOutput(func() {
+		err = cmd.Execute()
+	})
+
+	require.Error(t, err, "expected command to fail for a makefile with violations")
+
+	// matching full sentences with table output is complex, search partially
+	assert.Contains(t, out, "Required target", "should mention violation description")
+	assert.Contains(t, out, "declared PHONY.", "should mention target type")
+	assert.Contains(t, out, "phonydeclared", "should mention phonydeclared error")
+}
+
+func TestCheckmake_ListRules(t *testing.T) {
+	t.Parallel()
+	cmd := newRootCmd()
+	cmd.SetArgs([]string{"list-rules"})
+
+	var buf bytes.Buffer
+	cmd.SetOut(&buf)
+	cmd.SetErr(&buf)
+
+	err := cmd.Execute()
+	require.NoError(t, err, "list-rules should run successfully")
+
+	output := buf.String()
+	t.Logf("list-rules output:\n%s", output)
+
+	assert.Regexp(t, `\s+NAME\s+DESCRIPTION\s+`, output)
+	assert.Regexp(t, `phonydeclared\s+Every target without a body`, output)
+	assert.Regexp(t, `\s+needs\s+to be marked PHONY`, output)
+	assert.Regexp(t, `minphony\s+Minimum required phony`, output)
+	assert.Regexp(t, `\s+must be present(.*)`, output)
+}
+
+func TestCheckmake_WithCustomFormatFlag(t *testing.T) {
+	out := captureOutput(func() {
+		cmd := newRootCmd()
+		cmd.SilenceErrors = true
+		cmd.SetArgs([]string{
+			"--format", "{{.Rule}} on {{.LineNumber}}",
+			"../../fixtures/missing_phony.make",
+		})
+		_ = cmd.Execute()
+	})
+
+	t.Logf("custom format output:\n%s", out)
+
+	require.NotEmpty(t, out, "output should not be empty for custom format")
+
+	// There are three expected rules in missing_phony.make: phonydeclared and minphony twice
+	assert.Contains(t, out, "phonydeclared on 16")
+	assert.Contains(t, out, "minphony on 22")
+}
+
+func TestCheckmake_DebugLogsMakefilesPassed(t *testing.T) {
+	var logBuf bytes.Buffer
+
+	originalLoggerOutput := log.Writer()
+	log.SetOutput(&logBuf)
+
+	defer log.SetOutput(originalLoggerOutput)
+
+	cmd := newRootCmd()
+	cmd.SetArgs([]string{
+		"--debug",
+		"../../fixtures/simple.make",
+		"../../fixtures/missing_phony.make",
+	})
+	_ = cmd.Execute()
+
+	logs := logBuf.String()
+	t.Logf("debug output:\n%s", logs)
+
+	// The --debug flag should trigger the "Makefiles passed" log.
+	require.Contains(t, logs, "Makefiles passed:", "debug output should list the Makefiles provided")
+
+	// And it should contain both files.
+	assert.Contains(t, logs, "simple.make")
+	assert.Contains(t, logs, "missing_phony.make")
+}
+
+func TestCheckmake_ListRules_UsesConfig(t *testing.T) {
+	cmd := newRootCmd()
+	cmd.SetArgs([]string{"--config", "../../fixtures/custom_rules.ini", "list-rules"})
+
+	var buf bytes.Buffer
+	cmd.SetOut(&buf)
+	cmd.SetErr(&buf)
+
+	err := cmd.Execute()
+	require.NoError(t, err, "list-rules should run successfully with config")
+
+	output := buf.String()
+	t.Logf("list-rules output:\n%s", output)
+
+	assert.Regexp(t, `3\s+lines`, output, "custom maxBodyLength from config should appear in output")
+	assert.Regexp(t, `foo,\s*bar`, output, "custom required phonies from config should appear in output")
+}
+
+func TestCheckmake_MinPhonyPassesWhenAllTargetsExist(t *testing.T) {
+	cmd := newRootCmd()
+	cmd.SilenceErrors = true
+	cmd.SetArgs([]string{"../../fixtures/all_targets_present.make"})
+
+	var err error
+	_ = captureOutput(func() {
+		err = cmd.Execute()
+	})
+
+	require.NoError(t, err, "expected no violations when all required targets exist and are PHONY")
+}
+
+func TestCheckmake_MinPhonyDetectsMissingTargets(t *testing.T) {
+	cmd := newRootCmd()
+	cmd.SilenceErrors = true
+	cmd.SetArgs([]string{"../../fixtures/missing_targets.make"})
+
+	var err error
+	out := captureOutput(func() {
+		err = cmd.Execute()
+	})
+
+	require.Error(t, err, "expected command to fail when PHONY declares missing targets")
+
+	assert.Contains(t, out, "Required target", "should mention missing target violation")
+	assert.Contains(t, out, "from the Makefile", "should identify missing targets")
+	assert.Contains(t, out, "minphony", "should include rule name in output")
+}
+
+func TestCheckmake_WithJSONOutput(t *testing.T) {
+	out := captureOutput(func() {
+		cmd := newRootCmd()
+		cmd.SilenceErrors = true
+		cmd.SetArgs([]string{
+			"-o", "json",
+			"../../fixtures/missing_phony.make",
+		})
+		_ = cmd.Execute()
+	})
+
+	t.Logf("JSON output:\n%s", out)
+
+	require.NotEmpty(t, out, "output should not be empty for JSON format")
+
+	// Verify it's valid JSON
+	var violations []struct {
+		Rule       string `json:"rule"`
+		Violation  string `json:"violation"`
+		FileName   string `json:"file_name"`
+		LineNumber int    `json:"line_number"`
+	}
+
+	err := json.Unmarshal([]byte(out), &violations)
+	require.NoError(t, err, "output should be valid JSON")
+
+	// Verify we have violations
+	assert.Greater(t, len(violations), 0, "should have at least one violation")
+
+	// Verify structure
+	for _, v := range violations {
+		assert.NotEmpty(t, v.Rule, "rule should not be empty")
+		assert.NotEmpty(t, v.Violation, "violation should not be empty")
+		assert.NotEmpty(t, v.FileName, "file_name should not be empty")
+		assert.Greater(t, v.LineNumber, 0, "line_number should be greater than 0")
+	}
+
+	// Verify specific violations are present
+	ruleNames := make(map[string]bool)
+	for _, v := range violations {
+		ruleNames[v.Rule] = true
+	}
+	assert.Contains(t, ruleNames, "phonydeclared", "should contain phonydeclared violation")
+}
+
+func TestCheckmake_WithJSONOutputFlag(t *testing.T) {
+	out := captureOutput(func() {
+		cmd := newRootCmd()
+		cmd.SilenceErrors = true
+		cmd.SetArgs([]string{
+			"--output", "json",
+			"../../fixtures/missing_phony.make",
+		})
+		_ = cmd.Execute()
+	})
+
+	require.NotEmpty(t, out, "output should not be empty for JSON format")
+
+	// Verify it's valid JSON
+	var violations []struct {
+		Rule       string `json:"rule"`
+		Violation  string `json:"violation"`
+		FileName   string `json:"file_name"`
+		LineNumber int    `json:"line_number"`
+	}
+
+	err := json.Unmarshal([]byte(out), &violations)
+	require.NoError(t, err, "output should be valid JSON")
+}
+
+func TestCheckmake_WithTextOutput(t *testing.T) {
+	out := captureOutput(func() {
+		cmd := newRootCmd()
+		cmd.SilenceErrors = true
+		cmd.SetArgs([]string{
+			"-o", "text",
+			"../../fixtures/missing_phony.make",
+		})
+		_ = cmd.Execute()
+	})
+
+	require.NotEmpty(t, out, "output should not be empty for text format")
+
+	// Text output should contain table-like structure
+	assert.Contains(t, out, "Required target", "should mention violation description")
+	assert.Contains(t, out, "declared PHONY.", "should mention target type")
+	assert.Contains(t, out, "phonydeclared", "should mention phonydeclared error")
+}
+
+func TestCheckmake_WithInvalidOutput(t *testing.T) {
+	cmd := newRootCmd()
+	cmd.SilenceErrors = true
+	cmd.SetArgs([]string{
+		"-o", "invalid",
+		"../../fixtures/missing_phony.make",
+	})
+
+	err := cmd.Execute()
+	require.Error(t, err, "expected command to fail with invalid output format")
+	assert.Contains(t, err.Error(), "invalid output format", "error should mention invalid output format")
+}
+
+func TestCheckmake_FormatAndOutputAreMutuallyExclusive(t *testing.T) {
+	cmd := newRootCmd()
+	cmd.SetArgs([]string{
+		"--format", "{{.Rule}}: {{.Violation}}",
+		"--output", "json",
+		"../../fixtures/missing_phony.make",
+	})
+
+	var errBuf bytes.Buffer
+	cmd.SetErr(&errBuf)
 
-	assert.Regexp(t, `\s+NAME\s+DESCRIPTION\s+`, out.String())
-	assert.Regexp(t, `phonydeclared\s+Every target without a body`, out.String())
-	assert.Regexp(t, `\s+needs to be marked PHONY`, out.String())
+	err := cmd.Execute()
+	require.Error(t, err, "expected command to fail when both format and output flags are set")
 
-	assert.Regexp(t, `minphony\s+Minimum required phony targets`, out.String())
-	assert.Regexp(t, `\s+must be present`, out.String())
+	errorOutput := errBuf.String()
+	require.NotEmpty(t, errorOutput, "should produce error output")
 
+	// Cobra handles exclusivity and prints a standard error message.
+	// The actual message format:
+	// "if any flags in the group [format output] are set none of the others can be; [format output] were all set"
+	assert.Contains(t, errorOutput, "[format output]", "should reference the conflicting flags")
+	assert.Contains(t, errorOutput, "can be", "should mention that flags cannot be set together")
 }
diff --git a/config/config.go b/config/config.go
index 76e950e..25a52c8 100644
--- a/config/config.go
+++ b/config/config.go
@@ -3,9 +3,10 @@ package config
 
 import (
 	"fmt"
+
+	"github.com/checkmake/checkmake/logger"
+	"github.com/checkmake/checkmake/rules"
 	"github.com/go-ini/ini"
-	"github.com/mrtazz/checkmake/logger"
-	"github.com/mrtazz/checkmake/rules"
 )
 
 // Config is a struct to configure the validator and rules
@@ -27,7 +28,6 @@ func NewConfigFromFile(path string) (*Config, error) {
 // GetRuleConfig returns a rules.RuleConfig for the given rule. A rule
 // corresponds to a section in the config ini file
 func (c *Config) GetRuleConfig(rule string) (ret rules.RuleConfig) {
-
 	if c.iniFile == nil {
 		logger.Debug("iniFile not initialized")
 		return
@@ -73,3 +73,8 @@ func (c *Config) GetConfigValue(keyName string) (value string, err error) {
 
 	return "", fmt.Errorf("config has no default section")
 }
+
+// Ini returns the underlying ini.File instance for debugging or advanced inspection.
+func (c *Config) Ini() *ini.File {
+	return c.iniFile
+}
diff --git a/config/config_test.go b/config/config_test.go
index 25ed8a4..08e97c6 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -4,13 +4,12 @@ package config
 import (
 	"testing"
 
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/rules"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestSimpleConfig(t *testing.T) {
-
 	cfg, err := NewConfigFromFile("../fixtures/exampleConfig.ini")
 
 	require.Equal(t, nil, err, "Parsing of the fixture config file should have worked.")
@@ -19,11 +18,9 @@ func TestSimpleConfig(t *testing.T) {
 
 	assert.Equal(t, "true", ruleCfg["disabled"])
 	assert.Equal(t, "bla", ruleCfg["foo"])
-
 }
 
 func TestFailConfig(t *testing.T) {
-
 	cfg, err := NewConfigFromFile("../fixtures/idontexist.ini")
 
 	assert.NotEqual(t, nil, err)
@@ -34,7 +31,6 @@ func TestFailConfig(t *testing.T) {
 }
 
 func TestGetConfigValue(t *testing.T) {
-
 	cfg, err := NewConfigFromFile("../fixtures/exampleConfig.ini")
 
 	require.Equal(t, nil, err, "Parsing of the fixture config file should have worked.")
@@ -47,7 +43,6 @@ func TestGetConfigValue(t *testing.T) {
 }
 
 func TestGetConfigValueOnMissingConfigFile(t *testing.T) {
-
 	cfg, err := NewConfigFromFile("../fixtures/idontexist.ini")
 
 	assert.NotEqual(t, nil, err)
@@ -61,7 +56,6 @@ func TestGetConfigValueOnMissingConfigFile(t *testing.T) {
 }
 
 func TestGetMissingConfigValue(t *testing.T) {
-
 	cfg, err := NewConfigFromFile("../fixtures/exampleConfig.ini")
 
 	require.Equal(t, nil, err, "Parsing of the fixture config file should have worked.")
@@ -74,7 +68,6 @@ func TestGetMissingConfigValue(t *testing.T) {
 }
 
 func TestGetConfigValueOnMissingDefaultSection(t *testing.T) {
-
 	cfg, err := NewConfigFromFile("../fixtures/exampleConfigNoDefault.ini")
 
 	require.Equal(t, nil, err, "Parsing of the fixture config file should have worked.")
diff --git a/docs/validation.md b/docs/validation.md
index 8b919b2..7f2e167 100644
--- a/docs/validation.md
+++ b/docs/validation.md
@@ -8,4 +8,4 @@ downside of not being super configurable for special rules.
 A generic way to extend rulesets could be a goal later. For now they would
 have to be added as code patches to the project itself.
 
-[parsing]: https://github.com/mrtazz/checkmake/blob/master/docs/parsing.md
+[parsing]: https://github.com/checkmake/checkmake/blob/main/docs/parsing.md
diff --git a/fixtures/all_targets_present.make b/fixtures/all_targets_present.make
new file mode 100644
index 0000000..e311844
--- /dev/null
+++ b/fixtures/all_targets_present.make
@@ -0,0 +1,9 @@
+.PHONY: all clean test
+
+all:
+	@echo all
+clean:
+	@echo clean
+test:
+	@echo test
+
diff --git a/fixtures/custom_rules.ini b/fixtures/custom_rules.ini
new file mode 100644
index 0000000..72d0969
--- /dev/null
+++ b/fixtures/custom_rules.ini
@@ -0,0 +1,4 @@
+[maxbodylength]
+maxBodyLength = 3
+[minphony]
+required = foo, bar
diff --git a/fixtures/missing_targets.make b/fixtures/missing_targets.make
new file mode 100644
index 0000000..feeff91
--- /dev/null
+++ b/fixtures/missing_targets.make
@@ -0,0 +1,2 @@
+# .PHONY declares targets that are not actually defined in the file
+.PHONY: all clean test
diff --git a/fixtures/unknown_lines.make b/fixtures/unknown_lines.make
new file mode 100644
index 0000000..e768d9f
--- /dev/null
+++ b/fixtures/unknown_lines.make
@@ -0,0 +1,18 @@
+# This file tests how the parser handles empty and unknown lines
+# Empty line follows
+
+thisisnotarule
+
+all:
+	@echo all
+.PHONY: all
+
+clean:
+	@echo clean
+.PHONY: clean
+
+test:
+	@echo test
+.PHONY: test
+
+
diff --git a/formatters/custom.go b/formatters/custom.go
index cdb1e8e..a9a15d1 100644
--- a/formatters/custom.go
+++ b/formatters/custom.go
@@ -5,8 +5,8 @@ import (
 	"os"
 	"text/template"
 
-	"github.com/mrtazz/checkmake/logger"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/logger"
+	"github.com/checkmake/checkmake/rules"
 )
 
 // CustomFormatter is a formatter that is configurable via a template string
@@ -32,12 +32,11 @@ func NewCustomFormatter(templateString string) (ret *CustomFormatter, err error)
 
 // Format is the function to call to get the formatted output
 func (f *CustomFormatter) Format(violations rules.RuleViolationList) {
-
 	for _, val := range violations {
 		err := f.template.Execute(f.out, val)
+		f.out.Write([]byte("\n"))
 		if err != nil {
 			logger.Error(err.Error())
 		}
 	}
-
 }
diff --git a/formatters/custom_test.go b/formatters/custom_test.go
index b09e653..ba1e5cc 100644
--- a/formatters/custom_test.go
+++ b/formatters/custom_test.go
@@ -2,16 +2,18 @@ package formatters
 
 import (
 	"bytes"
+	"strings"
 	"testing"
 	"text/template"
 
-	"github.com/mrtazz/checkmake/config"
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/validator"
+	"github.com/checkmake/checkmake/config"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/validator"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestCustomFormatter(t *testing.T) {
+	t.Parallel()
 	out := new(bytes.Buffer)
 
 	tmpl, _ := template.New("test").Parse("{{.FileName}}:{{.LineNumber}}:{{.Rule}}:{{.Violation}}")
@@ -21,18 +23,21 @@ func TestCustomFormatter(t *testing.T) {
 
 	violations := validator.Validate(makefile, &config.Config{})
 	formatter.Format(violations)
-	assert.Regexp(t, `../fixtures/missing_phony.make:21:minphony:Missing required phony target "all"`, out.String())
-	assert.Regexp(t, `../fixtures/missing_phony.make:21:minphony:Missing required phony target "test"`, out.String())
+	assert.Regexp(t, `../fixtures/missing_phony.make:22:minphony:Required target "all" must be declared PHONY.`, out.String())
+	assert.Regexp(t, `../fixtures/missing_phony.make:22:minphony:Required target "test" must be declared PHONY.`, out.String())
 	assert.Regexp(t, `../fixtures/missing_phony.make:16:phonydeclared:Target "all" should be declared PHONY.`, out.String())
+	assert.Equal(t, strings.Count(out.String(), "\n"), 3)
 }
 
 func TestCustomFormatterNewMethod(t *testing.T) {
+	t.Parallel()
 	_, err := NewCustomFormatter("{{.FileName}}:{{.LineNumber}}:{{.Rule}}:{{.Violation}}")
 
 	assert.Equal(t, nil, err)
 }
 
 func TestCustomFormatterNewMethodFailing(t *testing.T) {
+	t.Parallel()
 	_, err := NewCustomFormatter("{{.LineNumber}}:{{.Rule}}:{{.Violation}}{{end}}")
 
 	assert.NotEqual(t, nil, err)
diff --git a/formatters/default.go b/formatters/default.go
index 0f67d4a..e2f7ef4 100644
--- a/formatters/default.go
+++ b/formatters/default.go
@@ -2,11 +2,13 @@ package formatters
 
 import (
 	"io"
+	"log"
 	"os"
 	"strconv"
 
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/rules"
 	"github.com/olekukonko/tablewriter"
+	"github.com/olekukonko/tablewriter/tw"
 )
 
 // DefaultFormatter is the formatter used by default for CLI output
@@ -24,22 +26,31 @@ func (f *DefaultFormatter) Format(violations rules.RuleViolationList) {
 	data := make([][]string, len(violations))
 
 	for idx, val := range violations {
-		data[idx] = []string{val.Rule,
+		data[idx] = []string{
+			val.Rule,
 			val.Violation,
 			val.FileName,
-			strconv.Itoa(val.LineNumber)}
+			strconv.Itoa(val.LineNumber),
+		}
 	}
 
-	table := tablewriter.NewWriter(f.out)
-
-	table.SetHeader([]string{"Rule", "Description", "File Name", "Line Number"})
-
-	table.SetCenterSeparator(" ")
-	table.SetColumnSeparator(" ")
-	table.SetRowSeparator(" ")
-	table.SetBorder(false)
-	table.SetAutoWrapText(true)
-
-	table.AppendBulk(data)
+	table := tablewriter.NewTable(f.out,
+		tablewriter.WithRendition(tw.Rendition{
+			Borders: tw.BorderNone,
+			Symbols: tw.NewSymbols(tw.StyleNone),
+			Settings: tw.Settings{
+				Lines:      tw.LinesNone,
+				Separators: tw.SeparatorsNone,
+			},
+		}),
+		tablewriter.WithRowAutoWrap(tw.WrapNormal),
+		tablewriter.WithMaxWidth(80),
+	)
+
+	table.Header("Rule", "Description", "File Name", "Line Number")
+
+	if err := table.Bulk(data); err != nil {
+		log.Fatalf("Bulk append failed: %v", err)
+	}
 	table.Render()
 }
diff --git a/formatters/default_test.go b/formatters/default_test.go
index 85c478c..b9c4d12 100644
--- a/formatters/default_test.go
+++ b/formatters/default_test.go
@@ -4,9 +4,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/mrtazz/checkmake/config"
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/validator"
+	"github.com/checkmake/checkmake/config"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/validator"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -19,7 +19,7 @@ func TestDefaultFormatter(t *testing.T) {
 	violations := validator.Validate(makefile, &config.Config{})
 	formatter.Format(violations)
 
-	assert.Regexp(t, `\s+RULE\s+DESCRIPTION\s+FILE NAME\s+LINE NUMBER\s+`, out.String())
-	assert.Regexp(t, `phonydeclared\s+Target "all" should be.+\s+16`, out.String())
-	assert.Regexp(t, `\s+declared PHONY`, out.String())
+	assert.Regexp(t, `(?s)\s+RULE\s+DESCRIPTION\s+FILE NAME\s+LINE NUMBER\s+`, out.String())
+	assert.Regexp(t, `(?s)phonydeclared\s+Target "all".+\s+16`, out.String())
+	assert.Regexp(t, `(?s)declared\s+PHONY`, out.String())
 }
diff --git a/formatters/formatters.go b/formatters/formatters.go
index 5e99891..2959214 100644
--- a/formatters/formatters.go
+++ b/formatters/formatters.go
@@ -3,7 +3,7 @@
 package formatters
 
 import (
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/rules"
 )
 
 // Formatter is the base interface type to implement for formatters
diff --git a/formatters/json.go b/formatters/json.go
new file mode 100644
index 0000000..a14f32f
--- /dev/null
+++ b/formatters/json.go
@@ -0,0 +1,48 @@
+package formatters
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+
+	"github.com/checkmake/checkmake/rules"
+)
+
+// JSONFormatter is the formatter used for JSON output
+type JSONFormatter struct {
+	out io.Writer
+}
+
+// NewJSONFormatter returns a JSONFormatter struct
+func NewJSONFormatter() *JSONFormatter {
+	return &JSONFormatter{out: os.Stdout}
+}
+
+// Format is the function to call to get the formatted JSON output
+func (f *JSONFormatter) Format(violations rules.RuleViolationList) {
+	// Convert violations to JSON-serializable structure
+	type ViolationJSON struct {
+		Rule       string `json:"rule"`
+		Violation  string `json:"violation"`
+		FileName   string `json:"file_name"`
+		LineNumber int    `json:"line_number"`
+	}
+
+	violationsJSON := make([]ViolationJSON, len(violations))
+	for i, v := range violations {
+		violationsJSON[i] = ViolationJSON{
+			Rule:       v.Rule,
+			Violation:  v.Violation,
+			FileName:   v.FileName,
+			LineNumber: v.LineNumber,
+		}
+	}
+
+	encoder := json.NewEncoder(f.out)
+	encoder.SetIndent("", "  ")
+	if err := encoder.Encode(violationsJSON); err != nil {
+		// If encoding fails, we can't really recover, so we'll just return
+		// The error will be visible in the output stream
+		return
+	}
+}
diff --git a/formatters/json_test.go b/formatters/json_test.go
new file mode 100644
index 0000000..74f074b
--- /dev/null
+++ b/formatters/json_test.go
@@ -0,0 +1,71 @@
+package formatters
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"github.com/checkmake/checkmake/config"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
+	"github.com/checkmake/checkmake/validator"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestJSONFormatter(t *testing.T) {
+	out := new(bytes.Buffer)
+	formatter := JSONFormatter{out: out}
+
+	makefile, _ := parser.Parse("../fixtures/missing_phony.make")
+
+	violations := validator.Validate(makefile, &config.Config{})
+	formatter.Format(violations)
+
+	// Verify JSON output
+	var violationsJSON []struct {
+		Rule       string `json:"rule"`
+		Violation  string `json:"violation"`
+		FileName   string `json:"file_name"`
+		LineNumber int    `json:"line_number"`
+	}
+
+	err := json.Unmarshal(out.Bytes(), &violationsJSON)
+	require.NoError(t, err, "output should be valid JSON")
+
+	// Verify we have violations
+	assert.Greater(t, len(violationsJSON), 0, "should have at least one violation")
+
+	// Verify structure
+	for _, v := range violationsJSON {
+		assert.NotEmpty(t, v.Rule, "rule should not be empty")
+		assert.NotEmpty(t, v.Violation, "violation should not be empty")
+		assert.NotEmpty(t, v.FileName, "file_name should not be empty")
+		assert.Greater(t, v.LineNumber, 0, "line_number should be greater than 0")
+	}
+
+	// Verify specific violations are present
+	ruleNames := make(map[string]bool)
+	for _, v := range violationsJSON {
+		ruleNames[v.Rule] = true
+	}
+	assert.Contains(t, ruleNames, "phonydeclared", "should contain phonydeclared violation")
+}
+
+func TestJSONFormatter_EmptyViolations(t *testing.T) {
+	out := new(bytes.Buffer)
+	formatter := JSONFormatter{out: out}
+
+	var violations []struct {
+		Rule       string `json:"rule"`
+		Violation  string `json:"violation"`
+		FileName   string `json:"file_name"`
+		LineNumber int    `json:"line_number"`
+	}
+
+	formatter.Format(rules.RuleViolationList{})
+
+	err := json.Unmarshal(out.Bytes(), &violations)
+	require.NoError(t, err, "output should be valid JSON even with no violations")
+	assert.Equal(t, 0, len(violations), "should have empty array for no violations")
+}
diff --git a/go.mod b/go.mod
index b36ebfd..4a3d990 100644
--- a/go.mod
+++ b/go.mod
@@ -1,16 +1,29 @@
-module github.com/mrtazz/checkmake
+module github.com/checkmake/checkmake
 
-go 1.17
+go 1.25
 
 require (
-	github.com/docopt/docopt-go v0.0.0-20141128170934-854c423c8108
-	github.com/go-ini/ini v1.11.0
-	github.com/olekukonko/tablewriter v0.0.0-20150822215231-b9346ac189c5
-	github.com/stretchr/testify v1.1.4-0.20160615092844-d77da356e56a
+	github.com/go-ini/ini v1.67.0
+	github.com/olekukonko/tablewriter v1.1.2
+	github.com/spf13/cobra v1.10.2
+	github.com/stretchr/testify v1.11.1
 )
 
 require (
+	github.com/clipperhouse/displaywidth v0.6.0 // indirect
+	github.com/clipperhouse/stringish v0.1.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.19 // indirect
+	github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6 // indirect
+	github.com/olekukonko/errors v1.1.0 // indirect
+	github.com/olekukonko/ll v0.1.3 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/smartystreets/goconvey v1.7.2 // indirect
+	github.com/spf13/pflag v1.0.9 // indirect
+	golang.org/x/sys v0.37.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index 612b731..f256e5c 100644
--- a/go.sum
+++ b/go.sum
@@ -1,25 +1,46 @@
+github.com/clipperhouse/displaywidth v0.6.0 h1:k32vueaksef9WIKCNcoqRNyKbyvkvkysNYnAWz2fN4s=
+github.com/clipperhouse/displaywidth v0.6.0/go.mod h1:R+kHuzaYWFkTm7xoMmK1lFydbci4X2CicfbGstSGg0o=
+github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
+github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
+github.com/clipperhouse/uax29/v2 v2.3.0 h1:SNdx9DVUqMoBuBoW3iLOj4FQv3dN5mDtuqwuhIGpJy4=
+github.com/clipperhouse/uax29/v2 v2.3.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/docopt/docopt-go v0.0.0-20141128170934-854c423c8108 h1:WJse1njqIlgvQjtOPAALBLhopGR+FKKo9OjxT7Sb6s0=
-github.com/docopt/docopt-go v0.0.0-20141128170934-854c423c8108/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
-github.com/go-ini/ini v1.11.0 h1:EDp2zFK6TR11mvDrWDask1bXLBUgqbIqG4R6Lq3EoKI=
-github.com/go-ini/ini v1.11.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
-github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
-github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
-github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
-github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
-github.com/olekukonko/tablewriter v0.0.0-20150822215231-b9346ac189c5 h1:ZxRrPRTX45eVRfhXfZUgH1MG173pWRdOMFsnJoTaxwU=
-github.com/olekukonko/tablewriter v0.0.0-20150822215231-b9346ac189c5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
+github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
+github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6 h1:zrbMGy9YXpIeTnGj4EljqMiZsIcE09mmF8XsD5AYOJc=
+github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6/go.mod h1:rEKTHC9roVVicUIfZK7DYrdIoM0EOr8mK1Hj5s3JjH0=
+github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
+github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
+github.com/olekukonko/ll v0.1.3 h1:sV2jrhQGq5B3W0nENUISCR6azIPf7UBUpVq0x/y70Fg=
+github.com/olekukonko/ll v0.1.3/go.mod h1:b52bVQRRPObe+yyBl0TxNfhesL0nedD4Cht0/zx55Ew=
+github.com/olekukonko/tablewriter v1.1.2 h1:L2kI1Y5tZBct/O/TyZK1zIE9GlBj/TVs+AY5tZDCDSc=
+github.com/olekukonko/tablewriter v1.1.2/go.mod h1:z7SYPugVqGVavWoA2sGsFIoOVNmEHxUAAMrhXONtfkg=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/smartystreets/assertions v1.2.0 h1:42S6lae5dvLc7BrLu/0ugRtcFVjoJNMC/N3yZFZkDFs=
-github.com/smartystreets/assertions v1.2.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=
-github.com/smartystreets/goconvey v1.7.2 h1:9RBaZCeXEQ3UselpuwUQHltGVXvdwm6cv1hgR6gDIPg=
-github.com/smartystreets/goconvey v1.7.2/go.mod h1:Vw0tHAZW6lzCRk3xgdin6fKYcG+G3Pg9vgXWeJpQFMM=
-github.com/stretchr/testify v1.1.4-0.20160615092844-d77da356e56a h1:UWu0XgfW9PCuyeZYNe2eGGkDZjooQKjVQqY/+d/jYmc=
-github.com/stretchr/testify v1.1.4-0.20160615092844-d77da356e56a/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
+github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
+github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/logger/logger.go b/logger/logger.go
index 95979dc..57cc0c4 100644
--- a/logger/logger.go
+++ b/logger/logger.go
@@ -17,9 +17,7 @@ const (
 	DebugLevel
 )
 
-var (
-	level = ErrorLevel
-)
+var level = ErrorLevel
 
 // SetLogLevel allows consumers to set the logging level
 func SetLogLevel(lvl LogLevel) {
diff --git a/man/man1/checkmake.1.md b/man/man1/checkmake.1.md
index 9e3c24e..ca6ac13 100644
--- a/man/man1/checkmake.1.md
+++ b/man/man1/checkmake.1.md
@@ -5,43 +5,95 @@ date: REPLACE_DATE
 ---
 
 # NAME
-**checkmake** -- experimental linter for Makefiles
+**checkmake** -- linter for Makefiles
 
 # SYNOPSIS
 
 **checkmake** \[options\] makefile ...
 
 # DESCRIPTION
-`checkmake` is an experimental linter for Makefiles. It allows for a set of
+`checkmake` is a linter for Makefiles. It allows for a set of
 configurable rules being run against a Makefile or a set of `\*.mk` files.
 
-# OPTIONS
+# FLAGS
 
 **-h**, **--help**
-:    Show a friendly help message.
+:    Show this help message and exit.
 
 **--version**
-:    Show version.
+:    Show version information.
 
 **--debug**
-:    Enable debug mode
+:    Enable debug output for troubleshooting.
 
-**--config=\<configPath\>**
-:    Configuration file to read
+**--config** *path*
+:    Specify the configuration file to read (default: `checkmake.ini`).
 
-**--format=\<format\>**
-:    Output format as a Golang text/template template
+**--format** *format*
+:    Set a custom output format using Go’s `text/template` syntax.
+     This option customizes how violations are displayed in **text mode**.
+     Cannot be used together with **--output** (mutually exclusive).
 
-**--list-rules**
-:    List registered rules
+     Example:
+
+     ```
+     checkmake --format '{{.Rule}}: {{.Violation}}' Makefile
+     ```
+
+**-o**, **--output** *mode*
+:    Select the overall output mode. Supported values:
+
+     - `text` (default): human-readable table or formatted text output.
+     - `json`: structured machine-readable JSON output.
+
+     When **--output=json** is specified, **--format** is ignored and violations
+     are printed as a JSON array.
+
+     Example:
+
+     ```
+     checkmake -o json Makefile | jq
+     ```
+
+# SUBCOMMANDS
+
+**list-rules**
+:    Display all registered rules and their descriptions.
+
+# RULES
+
+ **maxbodylength**
+ :   Target bodies should be kept simple and short
+     (no more than 8 lines by default).
+      This is number is configurable (see below).
+
+ **minphony**
+ :   A minimum list of  required phony targets must be present
+     By default these are all,clean,and test.
+     This list is configurable (see below).
+
+ **phonydeclared**
+ :   Every target without a body needs
+     to be marked PHONY
+
+ **timestampexpanded**
+ :   timestamp variables should be
+     simply expanded
+
+ **uniquetargets**
+ :   Targets should be uniquely defined because
+     duplicates can cause recipe overrides or
+     unintended merges.
 
 # CONFIGURATION
-By default checkmake looks for a `checkmake.ini` file in the same folder it's
-executed in. This can be overridden by passing the `--config=` argument
-pointing it to a different configuration file. With the configuration file
-the `[default]` section is for checkmake itself while sections named after the
-rule names are passed to the rules as their configuration. All keys/values are
-hereby treated as strings and passed to the rule in a string/string map.
+By default checkmake looks for a `checkmake.ini` file in the same
+folder it's executed in, and then as fallback in `~/checkmake.ini`.
+This can be overridden by passing the `--config=` argument pointing it
+to a different configuration file. With the configuration file the
+`[default]` section is for checkmake itself while sections named after
+the rule names are passed to the rules as their configuration. All
+keys/values are hereby treated as strings and passed to the rule in a
+string/string map.
 
 The following configuration options for checkmake itself are supported within
 the `default` section:
@@ -50,21 +102,33 @@ the `default` section:
 :    This enables the custom output formatter with the given template string
 as a format
 
+maxBodylength.maxBodylength
+    This allows to override the maximum number of lines for a rule body
+    that checkmake will allow from the default of 5  to a different number
+
+minphony.required
+    This allows to override the list of minimum required phony targets
+    from the default of (all, test, clean) to any list of target name strings.
+    The value is a comma-separated list of strings.
+    Setting minphony.required to the empty string disabled the minphony rule altogether.
+
+
 
 # EXIT STATUS
-checkmake exits with the following status:
+`checkmake` exits with the following status codes:
 
 ```
- 0:   checkmake ran successfully and found 0 violations
->1:   checkmake found the number of violations reflected by the exit status
+ 0:   checkmake ran successfully and found no rule violations
+ 1:   checkmake found one or more rule violations, or encountered an execution error
 ```
 
-In addition to checkmake having found 1 violation, exit status 1 is also used
-to denote an error in execution happening.
+Unlike previous versions, `checkmake` no longer exits with the exact number of
+violations. Any nonzero exit status now indicates that either violations were
+detected or an error occurred during execution.
 
 # BUGS
 Please file bugs against the issue tracker:
-https://github.com/mrtazz/checkmake/issues
+https://github.com/checkmake/checkmake/issues
 
 # SEE ALSO
 make(1)
diff --git a/parser/parser.go b/parser/parser.go
index c8d4319..d3c2600 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -6,11 +6,11 @@
 package parser
 
 import (
-	"errors"
 	"fmt"
 	"regexp"
 	"strings"
-	"github.com/mrtazz/checkmake/logger"
+
+	"github.com/checkmake/checkmake/logger"
 )
 
 // Makefile provides a data structure to describe a parsed Makefile
@@ -46,11 +46,40 @@ type Variable struct {
 type VariableList []Variable
 
 var (
-	reFindRule             = regexp.MustCompile("^([a-zA-Z]+):(.*)")
-	reFindRuleBody         = regexp.MustCompile("^\t+(.*)")
-	reFindSimpleVariable   = regexp.MustCompile("^([a-zA-Z]+) ?:=(.*)")
-	reFindExpandedVariable = regexp.MustCompile("^([a-zA-Z]+) ?=(.*)")
-	reFindSpecialVariable  = regexp.MustCompile("^\\.([a-zA-Z_]+):(.*)")
+	// Group 1: The target(s). This is intentionally broad, allowing for special characters (%, .),
+	//          variables ($(), ${}), spaces (for multiple targets), and file paths.
+	// Group 2: Everything after the colon (prerequisites and/or an inline recipe).
+	// Notes: This pattern intentionally excludes variable assignments (":=", "?=", "+=", "!=")
+	//        by ensuring that ':' is not immediately followed by '='.
+	reFindRule = regexp.MustCompile(`^([A-Za-z0-9_.%/\-$(){}\s]+)\s*:(\s*[^=].*)?$`)
+
+	// reFindRuleBody captures a line belonging to a rule's recipe.
+	// It must start with a tab.
+	// Group 1: The command to be executed.
+	reFindRuleBody = regexp.MustCompile(`^\t+(.*)`)
+
+	// reFindSimpleVariable captures simple/immediate variable assignments.
+	// This includes ':=', '::=', and ':::='.
+	// Group 1: The variable name (alphanumeric, underscore, dot, hyphen).
+	// Group 2: The value being assigned.
+	reFindSimpleVariable = regexp.MustCompile(`^([A-Za-z0-9_.-]+)\s*:{1,3}=\s*(.*)`)
+
+	// reFindExpandedVariable captures recursively expanded variable assignments ('=').
+	// Group 1: The variable name.
+	// Group 2: The value being assigned.
+	reFindExpandedVariable = regexp.MustCompile(`^([A-Za-z0-9_.-]+)\s*=\s*(.*)`)
+
+	// reFindOtherVariable captures all other assignment operators.
+	// This includes conditional ('?='), shell ('!='), and append ('+=').
+	// Group 1: The variable name.
+	// Group 2: The operator itself ('?=', '!=', or '+=').
+	// Group 3: The value being assigned.
+	reFindOtherVariable = regexp.MustCompile(`^([A-Za-z0-9_.-]+)\s*([?!+]=)\s*(.*)`)
+
+	// reFindSpecialTarget captures special Make targets that start with a dot, like .PHONY.
+	// Group 1: The special target name (e.g., ".PHONY").
+	// Group 2: The prerequisites/dependencies (e.g., "all clean test").
+	reFindSpecialTarget = regexp.MustCompile(`^(\.[A-Za-z_]+)\s*:(.*)`)
 )
 
 // Parse is the main function to parse a Makefile from a file path string to a
@@ -58,7 +87,6 @@ var (
 // of the heavy lifting will live in the specific parsing functions below that
 // know how to deal with individual lines.
 func Parse(filepath string) (ret Makefile, err error) {
-
 	ret.FileName = filepath
 	var scanner *MakefileScanner
 	scanner, err = NewMakefileScanner(filepath)
@@ -72,14 +100,16 @@ func Parse(filepath string) (ret Makefile, err error) {
 			// parse comments here, ignoring them for now
 			scanner.Scan()
 		case strings.HasPrefix(scanner.Text(), "."):
-			if matches := reFindSpecialVariable.FindStringSubmatch(scanner.Text()); matches != nil {
-				specialVar := Variable{
-					Name:            strings.TrimSpace(matches[1]),
-					Assignment:      strings.TrimSpace(matches[2]),
-					SpecialVariable: true,
-					FileName:        filepath,
-					LineNumber:      scanner.LineNumber}
-				ret.Variables = append(ret.Variables, specialVar)
+			if matches := reFindSpecialTarget.FindStringSubmatch(scanner.Text()); matches != nil {
+				// Treat special targets like .PHONY or .DEFAULT_GOAL as rules, not variables
+				specialRule := Rule{
+					Target:       strings.TrimSpace(matches[1]),
+					Dependencies: strings.Fields(strings.TrimSpace(matches[2])),
+					Body:         nil,
+					FileName:     filepath,
+					LineNumber:   scanner.LineNumber,
+				}
+				ret.Rules = append(ret.Rules, specialRule)
 			}
 			scanner.Scan()
 		default:
@@ -89,23 +119,16 @@ func Parse(filepath string) (ret Makefile, err error) {
 			if parseError != nil {
 				return ret, parseError
 			}
-			switch ruleOrVariable.(type) {
+			switch v := ruleOrVariable.(type) {
 			case Rule:
-				rule, found := ruleOrVariable.(Rule)
-				if found != true {
-					return ret, errors.New("Parse error")
-				}
-				ret.Rules = append(ret.Rules, rule)
+				ret.Rules = append(ret.Rules, v)
 			case Variable:
-				variable, found := ruleOrVariable.(Variable)
-				if found != true {
-					return ret, errors.New("Parse error")
-				}
-				ret.Variables = append(ret.Variables, variable)
+				ret.Variables = append(ret.Variables, v)
 			}
+
 		}
 
-		if scanner.Finished == true {
+		if scanner.Finished {
 			return
 		}
 	}
@@ -119,61 +142,113 @@ func Parse(filepath string) (ret Makefile, err error) {
 // returned struct. The parsing of line details is done via regexing for now
 // since it seems ok as a first pass but will likely have to change later into
 // a proper lexer/parser setup.
+//
+//nolint:unparam // parseRuleOrVariable never returns an error yet, placeholder for future error handling
 func parseRuleOrVariable(scanner *MakefileScanner) (ret interface{}, err error) {
 	line := scanner.Text()
 
-	if matches := reFindRule.FindStringSubmatch(line); matches != nil {
-		// we found a rule so we need to advance the scanner to figure out if
-		// there is a body
-		beginLineNumber := scanner.LineNumber - 1
-		scanner.Scan()
-		bodyMatches := reFindRuleBody.FindStringSubmatch(scanner.Text())
-		ruleBody := make([]string, 0, 20)
-		for bodyMatches != nil {
-
-			ruleBody = append(ruleBody, strings.TrimSpace(bodyMatches[1]))
-
-			// done parsing the rule body line, advance the scanner and potentially
-			// go into the next loop iteration
-			scanner.Scan()
-			bodyMatches = reFindRuleBody.FindStringSubmatch(scanner.Text())
-		}
-		// trim whitespace from all dependencies
-		deps := strings.Split(matches[2], " ")
-		filteredDeps := make([]string, 0, cap(deps))
-
-		for idx := range deps {
-			item := strings.TrimSpace(deps[idx])
-			if item != "" {
-				filteredDeps = append(filteredDeps, item)
-			}
-		}
-		ret = Rule{
-			Target:       strings.TrimSpace(matches[1]),
-			Dependencies: filteredDeps,
-			Body:         ruleBody,
-			FileName:     scanner.FileHandle.Name(),
-			LineNumber:   beginLineNumber}
-	} else if matches := reFindSimpleVariable.FindStringSubmatch(line); matches != nil {
+	if matches := reFindSimpleVariable.FindStringSubmatch(line); matches != nil {
 		ret = Variable{
 			Name:           strings.TrimSpace(matches[1]),
 			Assignment:     strings.TrimSpace(matches[2]),
 			SimplyExpanded: true,
 			FileName:       scanner.FileHandle.Name(),
-			LineNumber:     scanner.LineNumber}
+			LineNumber:     scanner.LineNumber,
+		}
 		scanner.Scan()
-	} else if matches := reFindExpandedVariable.FindStringSubmatch(line); matches != nil {
+		return
+	}
+
+	if matches := reFindExpandedVariable.FindStringSubmatch(line); matches != nil {
 		ret = Variable{
 			Name:           strings.TrimSpace(matches[1]),
 			Assignment:     strings.TrimSpace(matches[2]),
 			SimplyExpanded: false,
 			FileName:       scanner.FileHandle.Name(),
-			LineNumber:     scanner.LineNumber}
+			LineNumber:     scanner.LineNumber,
+		}
 		scanner.Scan()
-	} else {
-		logger.Debug(fmt.Sprintf("Unable to match line '%s' to a Rule or Variable", line))
+		return
+	}
+	if matches := reFindOtherVariable.FindStringSubmatch(line); matches != nil {
+		op := strings.TrimSpace(matches[2])
+		isSimple := false // Default to recursive/false
+
+		switch op {
+		case "!=":
+			// Shell assignment is immediate, like simple expansion.
+			isSimple = true
+		case "?=":
+			// Conditional assignment is recursive, just like '='.
+			isSimple = false
+		case "+=":
+			// Append ('+=') inherits its expansion behavior. If the variable was
+			// undefined, '+=' acts like '=' (recursive). Since this parser doesn't
+			// track variable history, we default to recursive (false) as the
+			// safest and most common-case behavior.
+			isSimple = false
+		}
+
+		ret = Variable{
+			Name:           strings.TrimSpace(matches[1]),
+			Assignment:     strings.TrimSpace(matches[3]), // Use index 3 for value
+			SimplyExpanded: isSimple,
+			FileName:       scanner.FileHandle.Name(),
+			LineNumber:     scanner.LineNumber,
+		}
+		scanner.Scan()
+		return
+	}
+
+	if matches := reFindRule.FindStringSubmatch(line); matches != nil {
+		beginLineNumber := scanner.LineNumber - 1
 		scanner.Scan()
+
+		// Handle inline recipe syntax: target: deps ; recipe
+		rawDeps := strings.TrimSpace(matches[2])
+		inlineRecipe := ""
+		if idx := strings.IndexAny(rawDeps, ";"); idx != -1 {
+			inlineRecipe = strings.TrimSpace(rawDeps[idx+1:])
+			rawDeps = strings.TrimSpace(rawDeps[:idx])
+		}
+
+		// Clean up dependencies (space-separated)
+		deps := []string{}
+		for _, d := range strings.Fields(rawDeps) {
+			if d != "" {
+				deps = append(deps, d)
+			}
+		}
+
+		// Collect recipe body (inline + tab-indented)
+		ruleBody := []string{}
+		if inlineRecipe != "" {
+			ruleBody = append(ruleBody, inlineRecipe)
+		}
+
+		// collect tab-indented body lines after the rule
+		for bodyMatches := reFindRuleBody.FindStringSubmatch(scanner.Text()); bodyMatches != nil; bodyMatches = reFindRuleBody.FindStringSubmatch(scanner.Text()) {
+			ruleBody = append(ruleBody, strings.TrimSpace(bodyMatches[1]))
+			scanner.Scan()
+		}
+
+		ret = Rule{
+			Target:       strings.TrimSpace(matches[1]),
+			Dependencies: deps,
+			Body:         ruleBody,
+			FileName:     scanner.FileHandle.Name(),
+			LineNumber:   beginLineNumber,
+		}
+		return
 	}
 
+	// Fallback: unrecognized line
+	if strings.TrimSpace(line) != "" {
+		if strings.Contains(line, ":") && strings.Contains(line, "=") {
+			logger.Debug(fmt.Sprintf("Ambiguous line detected: %q (could be variable or rule)", line))
+		}
+		logger.Debug(fmt.Sprintf("Unable to match line '%s' to a Rule or Variable", line))
+	}
+	scanner.Scan()
 	return
 }
diff --git a/parser/parser_test.go b/parser/parser_test.go
index f81e594..e0c207b 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -1,19 +1,24 @@
 package parser
 
 import (
+	"bytes"
+	"log"
+	"os"
 	"testing"
 
+	"github.com/checkmake/checkmake/logger"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParseSimpleMakefile(t *testing.T) {
-
+	t.Parallel()
 	ret, err := Parse("../fixtures/simple.make")
 
 	assert.Equal(t, err, nil)
 	assert.Equal(t, ret.FileName, "../fixtures/simple.make")
-	assert.Equal(t, len(ret.Rules), 5)
-	assert.Equal(t, len(ret.Variables), 4)
+	assert.Equal(t, len(ret.Rules), 7)
+	assert.Equal(t, len(ret.Variables), 2)
 	assert.Equal(t, ret.Rules[0].Target, "clean")
 	assert.Equal(t, ret.Rules[0].Body, []string{"rm bar", "rm foo"})
 	assert.Equal(t, ret.Rules[0].FileName, "../fixtures/simple.make")
@@ -31,6 +36,14 @@ func TestParseSimpleMakefile(t *testing.T) {
 	assert.Equal(t, ret.Rules[3].Dependencies, []string{"foo"})
 	assert.Equal(t, ret.Rules[3].FileName, "../fixtures/simple.make")
 
+	assert.Equal(t, ".PHONY", ret.Rules[5].Target)
+	assert.Equal(t, []string{"all", "clean", "test"}, ret.Rules[5].Dependencies)
+	assert.Equal(t, "../fixtures/simple.make", ret.Rules[5].FileName)
+
+	assert.Equal(t, ".DEFAULT_GOAL", ret.Rules[6].Target)
+	assert.Equal(t, []string{"all"}, ret.Rules[6].Dependencies)
+	assert.Equal(t, "../fixtures/simple.make", ret.Rules[6].FileName)
+
 	assert.Equal(t, ret.Variables[0].Name, "expanded")
 	assert.Equal(t, ret.Variables[0].Assignment, "\"$(simple)\"")
 	assert.Equal(t, ret.Variables[0].SimplyExpanded, false)
@@ -42,16 +55,282 @@ func TestParseSimpleMakefile(t *testing.T) {
 	assert.Equal(t, ret.Variables[1].SimplyExpanded, true)
 	assert.Equal(t, ret.Variables[1].SpecialVariable, false)
 	assert.Equal(t, ret.Variables[1].FileName, "../fixtures/simple.make")
+}
+
+func TestParse_IgnoresEmptyLinesInDebug(t *testing.T) {
+	t.Parallel()
+	var buf bytes.Buffer
+	logger.SetLogLevel(logger.DebugLevel)
+	log.SetOutput(&buf)
+	defer log.SetOutput(os.Stderr)
+
+	_, err := Parse("../fixtures/unknown_lines.make")
+	require.NoError(t, err)
+
+	output := buf.String()
+
+	assert.Contains(t, output, "Unable to match line 'thisisnotarule'",
+		"non-empty invalid lines should trigger a debug message")
+
+	assert.NotContains(t, output, "Unable to match line ''",
+		"empty lines should not trigger debug messages")
+}
+
+func writeTempMakefile(t *testing.T, content string) string {
+	f, err := os.CreateTemp("", "*.mk")
+	require.NoError(t, err)
+	_, err = f.WriteString(content)
+	require.NoError(t, err)
+	require.NoError(t, f.Close())
+	return f.Name()
+}
+
+func TestParse_VariableVsRuleMisclassification(t *testing.T) {
+	t.Parallel()
+	makefile := `
+ifeq ($(OS), Windows_NT)
+MKDIR := $(shell which mkdir.exe)
+else
+MKDIR := mkdir
+endif
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+
+	varNames := []string{}
+	for _, v := range ret.Variables {
+		varNames = append(varNames, v.Name)
+	}
+
+	assert.Contains(t, varNames, "MKDIR", "MKDIR should be parsed as a variable, not a rule")
+	assert.Empty(t, ret.Rules, "no rules should be parsed in this makefile")
+}
+
+func TestParse_BuildRuleRecognized(t *testing.T) {
+	t.Parallel()
+	makefile := `
+build: clean ${BUILD_DIR}
+	@echo building...
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+
+	assert.Len(t, ret.Rules, 1)
+	assert.Equal(t, "build", ret.Rules[0].Target)
+	assert.Contains(t, ret.Rules[0].Dependencies, "${BUILD_DIR}")
+	assert.Equal(t, "@echo building...", ret.Rules[0].Body[0])
+}
+
+func TestParse_PatternAndPhonyRules(t *testing.T) {
+	t.Parallel()
+	makefile := `
+%.o: %.c
+	@echo compiling
+.PHONY: all clean
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+
+	targets := []string{}
+	for _, r := range ret.Rules {
+		targets = append(targets, r.Target)
+	}
+
+	assert.Contains(t, targets, "%.o")
+	assert.Contains(t, targets, ".PHONY")
+}
+
+func TestParse_TargetsWithSpecialChars(t *testing.T) {
+	t.Parallel()
+	makefile := `
+target_with_underscores:
+	echo "underscore"
+target-with-hyphens  :
+	echo "hyphen"
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+
+	targets := []string{}
+	for _, r := range ret.Rules {
+		targets = append(targets, r.Target)
+	}
+
+	assert.Contains(t, targets, "target_with_underscores")
+	assert.Contains(t, targets, "target-with-hyphens")
+}
+
+func TestParse_MultipleTargetsAndSpaces(t *testing.T) {
+	t.Parallel()
+	makefile := `
+target1 target2 : dep
+	echo "build both"
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+	require.Len(t, ret.Rules, 1)
+
+	assert.Equal(t, "target1 target2", ret.Rules[0].Target)
+	assert.Contains(t, ret.Rules[0].Dependencies, "dep")
+}
+
+func TestParse_InlineRecipeAfterColon(t *testing.T) {
+	t.Parallel()
+	makefile := `
+inline: dep ; echo "one-line recipe"
+no_deps:; echo "no deps"
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+
+	assert.Equal(t, "inline", ret.Rules[0].Target)
+	assert.Equal(t, []string{"dep"}, ret.Rules[0].Dependencies)
+	assert.Contains(t, ret.Rules[0].Body[0], "echo")
+
+	assert.Equal(t, "no_deps", ret.Rules[1].Target)
+	assert.Empty(t, ret.Rules[1].Dependencies)
+}
+
+func TestParse_MultiTargetWithDepsAndInlineRecipe(t *testing.T) {
+	t.Parallel()
+	makefile := `
+target1 target2 : dep1 dep2 ; echo "combo build"
+	@echo "more lines"
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+	require.Len(t, ret.Rules, 1)
+
+	rule := ret.Rules[0]
+	assert.Equal(t, "target1 target2", rule.Target)
+	assert.Equal(t, []string{"dep1", "dep2"}, rule.Dependencies)
+	assert.Contains(t, rule.Body[0], "combo build")
+	assert.Contains(t, rule.Body[1], "more lines")
+}
+
+func TestParse_FileExtAndVariableTargets(t *testing.T) {
+	t.Parallel()
+	makefile := `
+file.ext:
+	touch $@
+$(DIR_VAR):
+	echo "dir var"
+${DIR_VAR}/subdir:
+	echo "subdir rule"
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+
+	targets := []string{}
+	for _, r := range ret.Rules {
+		targets = append(targets, r.Target)
+	}
+
+	assert.Contains(t, targets, "file.ext")
+	assert.Contains(t, targets, "$(DIR_VAR)")
+	assert.Contains(t, targets, "${DIR_VAR}/subdir")
+}
+
+func TestParse_RuleWithEqualsInPrereq(t *testing.T) {
+	t.Parallel()
+	makefile := `
+target: prerequisite = value
+	@echo "rule with equals"
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+
+	require.Len(t, ret.Rules, 1)
+	assert.Equal(t, "target", ret.Rules[0].Target)
+	assert.Equal(t, []string{"prerequisite", "=", "value"}, ret.Rules[0].Dependencies)
+
+	require.Len(t, ret.Rules[0].Body, 1)
+	assert.Equal(t, "@echo \"rule with equals\"", ret.Rules[0].Body[0])
+}
+
+func TestParse_OtherVariableAssignments(t *testing.T) {
+	t.Parallel()
+	makefile := `
+CONDITIONAL ?= default-value
+SHELL_VAR != shell command
+APPEND_VAR += more stuff
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+
+	vars := make(map[string]Variable)
+	for _, v := range ret.Variables {
+		vars[v.Name] = v
+	}
+
+	condVar, ok := vars["CONDITIONAL"]
+	require.True(t, ok)
+	assert.Equal(t, "default-value", condVar.Assignment)
+	assert.False(t, condVar.SimplyExpanded, "?= should be recursive (false)")
+
+	shellVar, ok := vars["SHELL_VAR"]
+	require.True(t, ok)
+	assert.Equal(t, "shell command", shellVar.Assignment)
+	assert.True(t, shellVar.SimplyExpanded, "!= should be simple (true)")
+
+	appendVar, ok := vars["APPEND_VAR"]
+	require.True(t, ok)
+	assert.Equal(t, "more stuff", appendVar.Assignment)
+	assert.False(t, appendVar.SimplyExpanded, "+= should default to recursive (false)")
+}
+
+func TestParse_VariableLikeRuleIsNotRule(t *testing.T) {
+	t.Parallel()
+	makefile := `
+EXTENSION := .exe
+VAR ?= foo
+APPEND += bar
+SHELL != echo hi
+`
+	tmp := writeTempMakefile(t, makefile)
+	defer os.Remove(tmp)
+
+	ret, err := Parse(tmp)
+	require.NoError(t, err)
+
+	assert.Empty(t, ret.Rules, "variable assignments with ':=' or similar should not create rules")
 
-	assert.Equal(t, ret.Variables[2].Name, "PHONY")
-	assert.Equal(t, ret.Variables[2].Assignment, "all clean test")
-	assert.Equal(t, ret.Variables[2].SimplyExpanded, false)
-	assert.Equal(t, ret.Variables[2].SpecialVariable, true)
-	assert.Equal(t, ret.Variables[2].FileName, "../fixtures/simple.make")
-
-	assert.Equal(t, ret.Variables[3].Name, "DEFAULT_GOAL")
-	assert.Equal(t, ret.Variables[3].Assignment, "all")
-	assert.Equal(t, ret.Variables[3].SimplyExpanded, false)
-	assert.Equal(t, ret.Variables[3].SpecialVariable, true)
-	assert.Equal(t, ret.Variables[3].FileName, "../fixtures/simple.make")
+	varNames := []string{}
+	for _, v := range ret.Variables {
+		varNames = append(varNames, v.Name)
+	}
+	assert.Contains(t, varNames, "EXTENSION")
+	assert.Contains(t, varNames, "VAR")
+	assert.Contains(t, varNames, "APPEND")
+	assert.Contains(t, varNames, "SHELL")
 }
diff --git a/parser/scanner.go b/parser/scanner.go
index b4dbf54..fb7cca7 100644
--- a/parser/scanner.go
+++ b/parser/scanner.go
@@ -23,7 +23,7 @@ type MakefileScanner struct {
 func (s *MakefileScanner) Scan() bool {
 	s.LineNumber++
 	scanResult := s.Scanner.Scan()
-	if scanResult == false && s.Scanner.Err() == nil {
+	if !scanResult && s.Scanner.Err() == nil {
 		s.Finished = true
 	}
 	return scanResult
diff --git a/parser/scanner_test.go b/parser/scanner_test.go
index 088e1a5..5cfe4ac 100644
--- a/parser/scanner_test.go
+++ b/parser/scanner_test.go
@@ -5,16 +5,13 @@ import (
 )
 
 func TestCreateMakefileScanner(t *testing.T) {
-
 	_, err := NewMakefileScanner("../fixtures/simple.make")
-
 	if err != nil {
 		t.Errorf("Unable to create MakefileScanner for 'fixtures/simple.make': %s", err.Error())
 	}
 }
 
 func TestCreateMakefileScannerFailing(t *testing.T) {
-
 	_, err := NewMakefileScanner("fixtures/idontexist.make")
 
 	if err == nil {
diff --git a/rules/maxbodylength/maxbodylength.go b/rules/maxbodylength/maxbodylength.go
index fef187f..ac85b5f 100644
--- a/rules/maxbodylength/maxbodylength.go
+++ b/rules/maxbodylength/maxbodylength.go
@@ -6,25 +6,20 @@ import (
 	"fmt"
 	"strconv"
 
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
 )
 
-var (
-	maxBodyLength = 5
-)
+var maxBodyLength = 5
 
 func init() {
 	rules.RegisterRule(&MaxBodyLength{})
 }
 
 // MaxBodyLength is an empty struct on which to call the rule functions
-type MaxBodyLength struct {
-}
+type MaxBodyLength struct{}
 
-var (
-	vT = "Target body for %q exceeds allowed length of %d (%d)."
-)
+var vT = "Target body for %q exceeds allowed length of %d lines (%d)."
 
 // Name returns the name of the rule
 func (m *MaxBodyLength) Name() string {
@@ -32,8 +27,15 @@ func (m *MaxBodyLength) Name() string {
 }
 
 // Description returns the description of the rule
-func (m *MaxBodyLength) Description() string {
-	return "Target bodies should be kept simple and short."
+func (m *MaxBodyLength) Description(cfg rules.RuleConfig) string {
+	if cfg != nil {
+		if confLength, ok := cfg["maxBodyLength"]; ok {
+			if i, err := strconv.Atoi(confLength); err == nil {
+				return fmt.Sprintf("Target bodies should be kept simple and short (no more than %d lines).", i)
+			}
+		}
+	}
+	return fmt.Sprintf("Target bodies should be kept simple and short (no more than %d lines).", maxBodyLength)
 }
 
 // Run executes the rule logic
diff --git a/rules/maxbodylength/maxbodylength_test.go b/rules/maxbodylength/maxbodylength_test.go
index 354c8bb..1866921 100644
--- a/rules/maxbodylength/maxbodylength_test.go
+++ b/rules/maxbodylength/maxbodylength_test.go
@@ -3,25 +3,27 @@ package maxbodylength
 import (
 	"testing"
 
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestFooIsTooLong(t *testing.T) {
-
 	makefile := parser.Makefile{
 		FileName: "maxbodylength.mk",
-		Rules: []parser.Rule{parser.Rule{
+		Rules: []parser.Rule{{
 			Target: "foo",
-			Body: []string{"echo 'foo'",
+			Body: []string{
+				"echo 'foo'",
+				"echo 'foo'",
 				"echo 'foo'",
 				"echo 'foo'",
 				"echo 'foo'",
 				"echo 'foo'",
 				"echo 'foo'",
-				"echo 'foo'"},
-			LineNumber: 1}},
+			},
+			LineNumber: 1,
+		}},
 	}
 
 	rule := MaxBodyLength{}
@@ -29,24 +31,26 @@ func TestFooIsTooLong(t *testing.T) {
 	ret := rule.Run(makefile, rules.RuleConfig{})
 
 	assert.Equal(t, 1, len(ret))
-	assert.Equal(t, "Target bodies should be kept simple and short.",
-		rule.Description())
-	assert.Equal(t, "Target body for \"foo\" exceeds allowed length of 5 (7).", ret[0].Violation)
+	assert.Equal(t, "Target bodies should be kept simple and short (no more than 5 lines).",
+		rule.Description(nil))
+	assert.Equal(t, "Target body for \"foo\" exceeds allowed length of 5 lines (7).", ret[0].Violation)
 	assert.Equal(t, 1, ret[0].LineNumber)
 	assert.Equal(t, "maxbodylength.mk", ret[0].FileName)
 }
 
 func TestFooIsTooLongWithConfig(t *testing.T) {
-
 	makefile := parser.Makefile{
 		FileName: "maxbodylength.mk",
-		Rules: []parser.Rule{parser.Rule{
+		Rules: []parser.Rule{{
 			Target: "foo",
-			Body: []string{"echo 'foo'",
+			Body: []string{
+				"echo 'foo'",
+				"echo 'foo'",
 				"echo 'foo'",
 				"echo 'foo'",
-				"echo 'foo'"},
-			LineNumber: 1}},
+			},
+			LineNumber: 1,
+		}},
 	}
 
 	rule := MaxBodyLength{}
@@ -57,9 +61,9 @@ func TestFooIsTooLongWithConfig(t *testing.T) {
 	ret := rule.Run(makefile, cfg)
 
 	assert.Equal(t, 1, len(ret))
-	assert.Equal(t, "Target bodies should be kept simple and short.",
-		rule.Description())
-	assert.Equal(t, "Target body for \"foo\" exceeds allowed length of 3 (4).", ret[0].Violation)
+	assert.Equal(t, "Target bodies should be kept simple and short (no more than 3 lines).",
+		rule.Description(nil))
+	assert.Equal(t, "Target body for \"foo\" exceeds allowed length of 3 lines (4).", ret[0].Violation)
 	assert.Equal(t, 1, ret[0].LineNumber)
 	assert.Equal(t, "maxbodylength.mk", ret[0].FileName)
 }
diff --git a/rules/minphony/minphony.go b/rules/minphony/minphony.go
index 3ce452b..d722988 100644
--- a/rules/minphony/minphony.go
+++ b/rules/minphony/minphony.go
@@ -6,23 +6,21 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
 )
 
-var (
-	defaultRequired = []string{
-		"all",
-		"clean",
-		"test",
-	}
-)
+var defaultRequired = []string{
+	"all",
+	"clean",
+	"test",
+}
 
 func init() {
 	rules.RegisterRule(&MinPhony{required: defaultRequired})
 }
 
-// MinPhony is an empty struct on which to call the rule functions
+//MinPhony is an empty struct on which to call the rule functions
 type MinPhony struct {
 	required []string
 }
@@ -33,33 +31,99 @@ func (r *MinPhony) Name() string {
 }
 
 // Description returns the description of the rule
-func (r *MinPhony) Description() string {
-	return "Minimum required phony targets must be present"
+func (r *MinPhony) Description(cfg rules.RuleConfig) string {
+	if cfg != nil {
+		if req, ok := cfg["required"]; ok && req != "" {
+			return fmt.Sprintf("Minimum required phony targets must be present (%s).", req)
+		}
+	}
+	return fmt.Sprintf("Minimum required phony targets must be present (%s).", strings.Join(r.required, ","))
 }
 
-// Run executes the rule logic
-func (r *MinPhony) Run(makefile parser.Makefile, _ rules.RuleConfig) rules.RuleViolationList {
+// Run executes the rule logic.
+// It ensures all required phony targets are both defined as rules
+// and declared as PHONY. Missing or undeclared targets trigger violations.
+func (r *MinPhony) Run(makefile parser.Makefile, config rules.RuleConfig) rules.RuleViolationList {
 	ret := rules.RuleViolationList{}
 
-	ruleIndex := make(map[string]bool)
-	ruleLineNumber := 0
+	// Load configured required targets, if any
+	required := r.required
+	if confRequired, ok := config["required"]; ok {
+		if confRequired == "" {
+			required = []string{}
+		} else {
+			required = strings.Split(confRequired, ",")
+		}
+		for i := range required {
+			required[i] = strings.TrimSpace(required[i])
+		}
+	}
+
+	// Collect all declared phony targets
+	declaredPhony := map[string]bool{}
+	phonyLine := 0
+
+	// .PHONY parsed as variable (old behavior)
 	for _, variable := range makefile.Variables {
 		if variable.Name == "PHONY" {
-			ruleLineNumber = variable.LineNumber - 1
-			for _, phony := range strings.Split(variable.Assignment, " ") {
-				ruleIndex[phony] = true
+			phonyLine = variable.LineNumber
+			for _, phony := range strings.Fields(variable.Assignment) {
+				declaredPhony[phony] = true
 			}
 		}
 	}
 
-	for _, reqRule := range r.required {
-		_, ok := ruleIndex[reqRule]
-		if !ok {
+	// .PHONY parsed as rule (new parser behavior)
+	for _, rule := range makefile.Rules {
+		if rule.Target == ".PHONY" || rule.Target == "PHONY" {
+			phonyLine = rule.LineNumber
+			for _, phony := range rule.Dependencies {
+				declaredPhony[phony] = true
+			}
+		}
+	}
+
+	// NOTE: historically, when .PHONY was parsed as a variable,
+	// the reported line number was adjusted with `-1`. Now that
+	// .PHONY is parsed as a rule, we use the accurate line number.
+	// This change causes a +1 shift in violation line reporting.
+	//
+	// Fallback: ensure phonyLine is never undefined
+	if phonyLine == 0 {
+		if len(makefile.Rules) > 0 {
+			phonyLine = makefile.Rules[len(makefile.Rules)-1].LineNumber
+		}
+		if phonyLine == 0 {
+			phonyLine = -1 // match historical behavior for missing PHONY line
+		}
+	}
+
+	// Collect all defined targets in the Makefile
+	definedTargets := map[string]bool{}
+	for _, rule := range makefile.Rules {
+		definedTargets[rule.Target] = true
+	}
+
+	// Check for required targets being both defined and declared PHONY
+	for _, req := range required {
+		// Check if the required target is defined at all
+		if !definedTargets[req] {
+			ret = append(ret, rules.RuleViolation{
+				Rule:       r.Name(),
+				Violation:  fmt.Sprintf("Required target %q is missing from the Makefile.", req),
+				FileName:   makefile.FileName,
+				LineNumber: phonyLine,
+			})
+			continue
+		}
+
+		// Check if it’s declared PHONY
+		if !declaredPhony[req] {
 			ret = append(ret, rules.RuleViolation{
-				Rule:       "minphony",
-				Violation:  fmt.Sprintf("Missing required phony target %q", reqRule),
+				Rule:       r.Name(),
+				Violation:  fmt.Sprintf("Required target %q must be declared PHONY.", req),
 				FileName:   makefile.FileName,
-				LineNumber: ruleLineNumber,
+				LineNumber: phonyLine,
 			})
 		}
 	}
diff --git a/rules/minphony/minphony_test.go b/rules/minphony/minphony_test.go
index d95544f..dac14b1 100644
--- a/rules/minphony/minphony_test.go
+++ b/rules/minphony/minphony_test.go
@@ -1,10 +1,12 @@
 package minphony
 
 import (
+	"fmt"
+	"strings"
 	"testing"
 
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -26,20 +28,20 @@ var mpRunTests = []struct {
 		vl: rules.RuleViolationList{
 			rules.RuleViolation{
 				Rule:       "minphony",
-				Violation:  "Missing required phony target \"kleen\"",
-				FileName: "green-eggs.mk",
+				Violation:  "Required target \"kleen\" is missing from the Makefile.",
+				FileName:   "green-eggs.mk",
 				LineNumber: -1,
 			},
 			rules.RuleViolation{
 				Rule:       "minphony",
-				Violation:  "Missing required phony target \"awl\"",
-				FileName: "green-eggs.mk",
+				Violation:  "Required target \"awl\" is missing from the Makefile.",
+				FileName:   "green-eggs.mk",
 				LineNumber: -1,
 			},
 			rules.RuleViolation{
 				Rule:       "minphony",
-				Violation:  "Missing required phony target \"toast\"",
-				FileName: "green-eggs.mk",
+				Violation:  "Required target \"toast\" is missing from the Makefile.",
+				FileName:   "green-eggs.mk",
 				LineNumber: -1,
 			},
 		},
@@ -59,7 +61,7 @@ var mpRunTests = []struct {
 		vl: rules.RuleViolationList{
 			rules.RuleViolation{
 				Rule:       "minphony",
-				Violation:  "Missing required phony target \"toast\"",
+				Violation:  "Required target \"toast\" is missing from the Makefile.",
 				FileName:   "kleen.mk",
 				LineNumber: -1,
 			},
@@ -68,17 +70,82 @@ var mpRunTests = []struct {
 }
 
 func TestMinPhony_new(t *testing.T) {
+	t.Parallel()
 	mp := &MinPhony{required: []string{"oh", "hai"}}
 
 	assert.Equal(t, []string{"oh", "hai"}, mp.required)
 	assert.Equal(t, "minphony", mp.Name())
-	assert.Equal(t, "Minimum required phony targets must be present", mp.Description())
+	expectedDesc := fmt.Sprintf("Minimum required phony targets must be present (%s).", strings.Join(mp.required, ","))
+
+	assert.Equal(t, expectedDesc, mp.Description(nil))
 }
 
 func TestMinPhony_Run(t *testing.T) {
+	t.Parallel()
 	mp := &MinPhony{required: []string{"kleen", "awl", "toast"}}
 
 	for _, test := range mpRunTests {
 		assert.Equal(t, test.vl, mp.Run(test.mf, rules.RuleConfig{}))
 	}
 }
+
+func TestMinPhony_RunWithConfig(t *testing.T) {
+	t.Parallel()
+	mp := &MinPhony{required: []string{}}
+
+	mf := parser.Makefile{
+		FileName: "test.mk",
+		Rules: parser.RuleList{
+			{Target: "clone"},
+			{Target: "toast"},
+		},
+		Variables: parser.VariableList{
+			{Name: "PHONY", Assignment: "clone toast"},
+		},
+	}
+	vl := rules.RuleViolationList{
+		rules.RuleViolation{
+			Rule:       "minphony",
+			Violation:  "Required target \"foo\" is missing from the Makefile.",
+			FileName:   "test.mk",
+			LineNumber: -1,
+		},
+		rules.RuleViolation{
+			Rule:       "minphony",
+			Violation:  "Required target \"bar\" is missing from the Makefile.",
+			FileName:   "test.mk",
+			LineNumber: -1,
+		},
+	}
+	cfg := rules.RuleConfig{}
+	cfg["required"] = "foo, bar"
+
+	assert.Equal(t, vl, mp.Run(mf, cfg))
+
+	cfg["required"] = ""
+	vl = rules.RuleViolationList{}
+
+	assert.Equal(t, vl, mp.Run(mf, cfg))
+}
+
+func TestMinPhony_MissingPhonyDeclaration(t *testing.T) {
+	t.Parallel()
+	makefile := parser.Makefile{
+		FileName: "missing-phony.mk",
+		Rules: []parser.Rule{
+			{Target: "all"},
+			{Target: "clean"},
+			{Target: "test"},
+		},
+		Variables: []parser.Variable{
+			{Name: "PHONY", Assignment: "all"}, // only "all" declared
+		},
+	}
+
+	mp := &MinPhony{required: []string{"all", "clean", "test"}}
+	ret := mp.Run(makefile, rules.RuleConfig{})
+
+	assert.Len(t, ret, 2, "expected two missing PHONY declaration violations")
+	assert.Equal(t, "Required target \"clean\" must be declared PHONY.", ret[0].Violation)
+	assert.Equal(t, "Required target \"test\" must be declared PHONY.", ret[1].Violation)
+}
diff --git a/rules/phonydeclared/phonydeclared.go b/rules/phonydeclared/phonydeclared.go
index debb551..04b3317 100644
--- a/rules/phonydeclared/phonydeclared.go
+++ b/rules/phonydeclared/phonydeclared.go
@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
 )
 
 func init() {
@@ -15,8 +15,7 @@ func init() {
 }
 
 // Phonydeclared is an empty struct on which to call the rule functions
-type Phonydeclared struct {
-}
+type Phonydeclared struct{}
 
 // Name returns the name of the rule
 func (r *Phonydeclared) Name() string {
@@ -24,7 +23,7 @@ func (r *Phonydeclared) Name() string {
 }
 
 // Description returns the description of the rule
-func (r *Phonydeclared) Description() string {
+func (r *Phonydeclared) Description(cfg rules.RuleConfig) string {
 	return "Every target without a body needs to be marked PHONY"
 }
 
@@ -34,17 +33,32 @@ func (r *Phonydeclared) Run(makefile parser.Makefile, config rules.RuleConfig) r
 
 	ruleIndex := make(map[string]bool)
 
+	// Case 1: .PHONY parsed as variable (old parser behavior)
 	for _, variable := range makefile.Variables {
 		if variable.Name == "PHONY" {
-			for _, phony := range strings.Split(variable.Assignment, " ") {
+			for _, phony := range strings.Fields(variable.Assignment) {
 				ruleIndex[phony] = true
 			}
 		}
 	}
 
+	// Case 2: .PHONY parsed as rule (new parser behavior)
+	for _, rule := range makefile.Rules {
+		if rule.Target == ".PHONY" || rule.Target == "PHONY" {
+			for _, phony := range rule.Dependencies {
+				ruleIndex[phony] = true
+			}
+		}
+	}
+	// Check that every non-dot-prefixed target without a body is PHONY
 	for _, rule := range makefile.Rules {
+		// Skip special or dot-prefixed targets like .PHONY or .DEFAULT_GOAL
+		if strings.HasPrefix(rule.Target, ".") {
+			continue
+		}
+
 		_, ok := ruleIndex[rule.Target]
-		if len(rule.Body) == 0 && ok == false {
+		if len(rule.Body) == 0 && !ok {
 			ret = append(ret, rules.RuleViolation{
 				Rule:       "phonydeclared",
 				Violation:  fmt.Sprintf("Target %q should be declared PHONY.", rule.Target),
diff --git a/rules/phonydeclared/phonydeclared_test.go b/rules/phonydeclared/phonydeclared_test.go
index 935ec01..539bb29 100644
--- a/rules/phonydeclared/phonydeclared_test.go
+++ b/rules/phonydeclared/phonydeclared_test.go
@@ -3,40 +3,47 @@ package phonydeclared
 import (
 	"testing"
 
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestAllTargetsArePhony(t *testing.T) {
-
+	t.Parallel()
 	makefile := parser.Makefile{
-		FileName:  "phony-declared-all-phony.mk",
-		Variables: []parser.Variable{parser.Variable{
+		FileName: "phony-declared-all-phony.mk",
+		Variables: []parser.Variable{{
 			Name:       "PHONY",
-			Assignment: "all clean"}},
-		Rules: []parser.Rule{parser.Rule{
-			Target: "all"}, parser.Rule{Target: "clean"},
-		}}
+			Assignment: "all clean",
+		}},
+		Rules: []parser.Rule{
+			{
+				Target: "all",
+			}, {Target: "clean"},
+		},
+	}
 
 	rule := Phonydeclared{}
 
 	ret := rule.Run(makefile, rules.RuleConfig{})
 
 	assert.Equal(t, len(ret), 0)
-
 }
 
 func TestMissingOnePhonyTarget(t *testing.T) {
-
+	t.Parallel()
 	makefile := parser.Makefile{
-		FileName:  "phony-declared-missing-one-phony.mk",
-		Variables: []parser.Variable{parser.Variable{
+		FileName: "phony-declared-missing-one-phony.mk",
+		Variables: []parser.Variable{{
 			Name:       "PHONY",
-			Assignment: "all"}},
-		Rules: []parser.Rule{parser.Rule{
-			Target: "all"}, parser.Rule{Target: "clean"},
-		}}
+			Assignment: "all",
+		}},
+		Rules: []parser.Rule{
+			{
+				Target: "all",
+			}, {Target: "clean"},
+		},
+	}
 
 	rule := Phonydeclared{}
 
diff --git a/rules/rules.go b/rules/rules.go
index 2bdb0d7..649c3f9 100644
--- a/rules/rules.go
+++ b/rules/rules.go
@@ -2,13 +2,23 @@
 package rules
 
 import (
-	"github.com/mrtazz/checkmake/parser"
+	"sort"
+
+	"github.com/checkmake/checkmake/parser"
 )
 
-// Rule is the type of a rule function
+// Rule defines the interface that all validation rules must implement.
+//
+// Each rule provides:
+//   - Name(): a unique identifier string for the rule.
+//   - Description(cfg RuleConfig): a human-readable explanation of what the rule checks for.
+//     Implementations should adapt the description based on the provided configuration,
+//     but must remain safe to call with a nil config (using default values).
+//   - Run(makefile, cfg): performs the actual validation on the parsed Makefile,
+//     returning a list of any violations found.
 type Rule interface {
 	Name() string
-	Description() string
+	Description(cfg RuleConfig) string
 	Run(parser.Makefile, RuleConfig) RuleViolationList
 }
 
@@ -34,9 +44,7 @@ type RuleConfigMap map[string]RuleConfig
 // RuleRegistry is the type to hold rules keyed by their name
 type RuleRegistry map[string]Rule
 
-var (
-	ruleRegistry RuleRegistry
-)
+var ruleRegistry RuleRegistry
 
 func init() {
 	ruleRegistry = make(RuleRegistry)
@@ -51,3 +59,18 @@ func RegisterRule(r Rule) {
 func GetRegisteredRules() RuleRegistry {
 	return ruleRegistry
 }
+
+// GetRulesSorted returns all registered rules in alphabetical order by name.
+func GetRulesSorted() []Rule {
+	keys := make([]string, 0, len(ruleRegistry))
+	for name := range ruleRegistry {
+		keys = append(keys, name)
+	}
+	sort.Strings(keys)
+
+	sorted := make([]Rule, 0, len(keys))
+	for _, name := range keys {
+		sorted = append(sorted, ruleRegistry[name])
+	}
+	return sorted
+}
diff --git a/rules/timestampexpanded/timestampexpanded.go b/rules/timestampexpanded/timestampexpanded.go
index e20e2c1..a748f9c 100644
--- a/rules/timestampexpanded/timestampexpanded.go
+++ b/rules/timestampexpanded/timestampexpanded.go
@@ -10,8 +10,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
 )
 
 func init() {
@@ -19,12 +19,9 @@ func init() {
 }
 
 // Timestampexpanded is an empty struct on which to call the rule functions
-type Timestampexpanded struct {
-}
+type Timestampexpanded struct{}
 
-var (
-	vT = "Variable %q possibly contains a timestamp and should be simply expanded."
-)
+var vT = "Variable %q possibly contains a timestamp and should be simply expanded."
 
 // Name returns the name of the rule
 func (r *Timestampexpanded) Name() string {
@@ -32,7 +29,7 @@ func (r *Timestampexpanded) Name() string {
 }
 
 // Description returns the description of the rule
-func (r *Timestampexpanded) Description() string {
+func (r *Timestampexpanded) Description(cfg rules.RuleConfig) string {
 	return "timestamp variables should be simply expanded"
 }
 
diff --git a/rules/timestampexpanded/timestampexpanded_test.go b/rules/timestampexpanded/timestampexpanded_test.go
index 801eeaf..c245c5e 100644
--- a/rules/timestampexpanded/timestampexpanded_test.go
+++ b/rules/timestampexpanded/timestampexpanded_test.go
@@ -3,19 +3,19 @@ package timestampexpanded
 import (
 	"testing"
 
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestVersionIsNotSimplyExpanded(t *testing.T) {
-
 	makefile := parser.Makefile{
-		FileName:  "timestamp-expanded.mk",
-		Variables: []parser.Variable{parser.Variable{
+		FileName: "timestamp-expanded.mk",
+		Variables: []parser.Variable{{
 			Name:           "BUILDTIME",
 			Assignment:     "$(shell date -u +\"%Y-%m-%dT%H:%M:%SZ\")",
-			SimplyExpanded: false}},
+			SimplyExpanded: false,
+		}},
 	}
 
 	rule := Timestampexpanded{}
@@ -24,20 +24,20 @@ func TestVersionIsNotSimplyExpanded(t *testing.T) {
 
 	assert.Equal(t, 1, len(ret))
 	assert.Equal(t, "timestamp variables should be simply expanded",
-		rule.Description())
+		rule.Description(nil))
 	for i := range ret {
 		assert.Equal(t, "timestamp-expanded.mk", ret[i].FileName)
 	}
 }
 
 func TestVersionIsSimplyExpanded(t *testing.T) {
-
 	makefile := parser.Makefile{
-		FileName:  "timestamp-simply-expanded.mk",
-		Variables: []parser.Variable{parser.Variable{
+		FileName: "timestamp-simply-expanded.mk",
+		Variables: []parser.Variable{{
 			Name:           "BUILDTIME",
 			Assignment:     "$(shell date -u +\"%Y-%m-%dT%H:%M:%SZ\")",
-			SimplyExpanded: true}},
+			SimplyExpanded: true,
+		}},
 	}
 
 	rule := Timestampexpanded{}
diff --git a/rules/uniquetargets/uniquetargets.go b/rules/uniquetargets/uniquetargets.go
new file mode 100644
index 0000000..65a8446
--- /dev/null
+++ b/rules/uniquetargets/uniquetargets.go
@@ -0,0 +1,76 @@
+// Package uniquetargets implements the ruleset ensuring no target is repeated.
+package uniquetargets
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
+)
+
+func init() {
+	rules.RegisterRule(&UniqueTargets{})
+}
+
+// UniqueTargets ensures targets are not defined multiple times.
+type UniqueTargets struct{}
+
+// Name returns the rule's identifier.
+func (r *UniqueTargets) Name() string {
+	return "uniquetargets"
+}
+
+// Description returns the human-readable description.
+func (r *UniqueTargets) Description(cfg rules.RuleConfig) string {
+	if cfg != nil {
+		if ignored, ok := cfg["ignore"]; ok && ignored != "" {
+			return fmt.Sprintf("Targets should be uniquely defined (ignoring: %s).", ignored)
+		}
+	}
+	return "Targets should be uniquely defined; duplicates can cause recipe overrides or unintended merges."
+}
+
+// Run detects non-unique target definitions, optionally skipping ignored ones.
+func (r *UniqueTargets) Run(makefile parser.Makefile, cfg rules.RuleConfig) rules.RuleViolationList {
+	seen := make(map[string]int)
+	violations := rules.RuleViolationList{}
+
+	// Load optional ignore list
+	ignoredTargets := map[string]bool{}
+	if cfg != nil {
+		if ignoreList, ok := cfg["ignore"]; ok {
+			for _, target := range strings.Split(ignoreList, ",") {
+				target = strings.TrimSpace(target)
+				if target != "" {
+					ignoredTargets[target] = true
+				}
+			}
+		}
+	}
+
+	for _, rule := range makefile.Rules {
+		// Skip ignored targets
+		if ignoredTargets[rule.Target] {
+			continue
+		}
+
+		// Skip special built-ins like .PHONY
+		if rule.Target == ".PHONY" {
+			continue
+		}
+
+		if prevLine, exists := seen[rule.Target]; exists {
+			violations = append(violations, rules.RuleViolation{
+				Rule:       r.Name(),
+				Violation:  fmt.Sprintf(`Target "%s" defined multiple times (lines %d and %d).`, rule.Target, prevLine, rule.LineNumber),
+				FileName:   makefile.FileName,
+				LineNumber: rule.LineNumber,
+			})
+		} else {
+			seen[rule.Target] = rule.LineNumber
+		}
+	}
+
+	return violations
+}
diff --git a/rules/uniquetargets/uniquetargets_test.go b/rules/uniquetargets/uniquetargets_test.go
new file mode 100644
index 0000000..2da0fd0
--- /dev/null
+++ b/rules/uniquetargets/uniquetargets_test.go
@@ -0,0 +1,88 @@
+package uniquetargets
+
+import (
+	"testing"
+
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUniqueTargets(t *testing.T) {
+	t.Parallel()
+	makefile := parser.Makefile{
+		FileName: "no-duplicates.mk",
+		Rules: []parser.Rule{
+			{Target: "all", LineNumber: 1},
+			{Target: "test", LineNumber: 5},
+			{Target: "clean", LineNumber: 9},
+		},
+	}
+
+	rule := UniqueTargets{}
+	ret := rule.Run(makefile, rules.RuleConfig{})
+
+	assert.Equal(t, 0, len(ret), "no duplicates should produce no violations")
+}
+
+func TestNoUniqueTargetsDetected(t *testing.T) {
+	t.Parallel()
+	makefile := parser.Makefile{
+		FileName: "unique_targets.mk",
+		Rules: []parser.Rule{
+			{Target: "test", LineNumber: 2},
+			{Target: "build", LineNumber: 5},
+			{Target: "test", LineNumber: 8}, // duplicate
+		},
+	}
+
+	rule := UniqueTargets{}
+	ret := rule.Run(makefile, rules.RuleConfig{})
+
+	assert.Equal(t, 1, len(ret), "expected one duplicate violation")
+	assert.Contains(t, ret[0].Violation, `"test" defined multiple times`)
+	assert.Equal(t, "unique_targets.mk", ret[0].FileName)
+	assert.Equal(t, 8, ret[0].LineNumber)
+}
+
+func TestUniqueTargetsIgnoredByConfig(t *testing.T) {
+	t.Parallel()
+	makefile := parser.Makefile{
+		FileName: "unique_ignored.mk",
+		Rules: []parser.Rule{
+			{Target: "all", LineNumber: 1},
+			{Target: "test", LineNumber: 3},
+			{Target: "test", LineNumber: 6}, // duplicate but ignored
+			{Target: "deploy", LineNumber: 9},
+			{Target: "deploy", LineNumber: 12}, // not ignored
+		},
+	}
+
+	rule := UniqueTargets{}
+	cfg := rules.RuleConfig{"ignore": "test,clean"}
+
+	ret := rule.Run(makefile, cfg)
+
+	assert.Equal(t, 1, len(ret), "only non-ignored duplicates should trigger violations")
+	assert.Contains(t, ret[0].Violation, `"deploy" defined multiple times`)
+	assert.NotContains(t, ret[0].Violation, `"test"`)
+}
+
+func TestPhonyTargetsAreIgnored(t *testing.T) {
+	t.Parallel()
+	makefile := parser.Makefile{
+		FileName: "phony_targets.mk",
+		Rules: []parser.Rule{
+			{Target: ".PHONY", LineNumber: 1},
+			{Target: ".PHONY", LineNumber: 3},
+			{Target: "build", LineNumber: 5},
+			{Target: "build", LineNumber: 8}, // duplicate real target
+		},
+	}
+
+	rule := UniqueTargets{}
+	ret := rule.Run(makefile, rules.RuleConfig{})
+
+	assert.Equal(t, 1, len(ret), "only non-.PHONY duplicates should trigger violations")
+	assert.Contains(t, ret[0].Violation, `"build" defined multiple times`)
+}
diff --git a/validator/validator.go b/validator/validator.go
index c6e31cb..09098ac 100644
--- a/validator/validator.go
+++ b/validator/validator.go
@@ -5,21 +5,22 @@ package validator
 import (
 	"fmt"
 
-	"github.com/mrtazz/checkmake/config"
-	"github.com/mrtazz/checkmake/logger"
-	"github.com/mrtazz/checkmake/parser"
-	"github.com/mrtazz/checkmake/rules"
+	"github.com/checkmake/checkmake/config"
+	"github.com/checkmake/checkmake/logger"
+	"github.com/checkmake/checkmake/parser"
+	"github.com/checkmake/checkmake/rules"
+
 	// rules register themselves via their package's init function, so we can
 	// just blank import it
-	_ "github.com/mrtazz/checkmake/rules/maxbodylength"
-	_ "github.com/mrtazz/checkmake/rules/minphony"
-	_ "github.com/mrtazz/checkmake/rules/phonydeclared"
-	_ "github.com/mrtazz/checkmake/rules/timestampexpanded"
+	_ "github.com/checkmake/checkmake/rules/maxbodylength"
+	_ "github.com/checkmake/checkmake/rules/minphony"
+	_ "github.com/checkmake/checkmake/rules/phonydeclared"
+	_ "github.com/checkmake/checkmake/rules/timestampexpanded"
+	_ "github.com/checkmake/checkmake/rules/uniquetargets"
 )
 
 // Validate let's you validate a passed in Makefile with the provided config
 func Validate(makefile parser.Makefile, cfg *config.Config) (ret rules.RuleViolationList) {
-
 	rules := rules.GetRegisteredRules()
 
 	for name, rule := range rules {
diff --git a/validator/validator_test.go b/validator/validator_test.go
index 212f23f..29880a9 100644
--- a/validator/validator_test.go
+++ b/validator/validator_test.go
@@ -3,8 +3,8 @@ package validator
 import (
 	"testing"
 
-	"github.com/mrtazz/checkmake/config"
-	"github.com/mrtazz/checkmake/parser"
+	"github.com/checkmake/checkmake/config"
+	"github.com/checkmake/checkmake/parser"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/vendor/github.com/davecgh/go-spew/LICENSE b/vendor/github.com/davecgh/go-spew/LICENSE
deleted file mode 100644
index bc52e96..0000000
--- a/vendor/github.com/davecgh/go-spew/LICENSE
+++ /dev/null
@@ -1,15 +0,0 @@
-ISC License
-
-Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/vendor/github.com/davecgh/go-spew/spew/bypass.go b/vendor/github.com/davecgh/go-spew/spew/bypass.go
deleted file mode 100644
index 7929947..0000000
--- a/vendor/github.com/davecgh/go-spew/spew/bypass.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when the code is not running on Google App Engine, compiled by GopherJS, and
-// "-tags safe" is not added to the go build command line.  The "disableunsafe"
-// tag is deprecated and thus should not be used.
-// Go versions prior to 1.4 are disabled because they use a different layout
-// for interfaces which make the implementation of unsafeReflectValue more complex.
-// +build !js,!appengine,!safe,!disableunsafe,go1.4
-
-package spew
-
-import (
-	"reflect"
-	"unsafe"
-)
-
-const (
-	// UnsafeDisabled is a build-time constant which specifies whether or
-	// not access to the unsafe package is available.
-	UnsafeDisabled = false
-
-	// ptrSize is the size of a pointer on the current arch.
-	ptrSize = unsafe.Sizeof((*byte)(nil))
-)
-
-type flag uintptr
-
-var (
-	// flagRO indicates whether the value field of a reflect.Value
-	// is read-only.
-	flagRO flag
-
-	// flagAddr indicates whether the address of the reflect.Value's
-	// value may be taken.
-	flagAddr flag
-)
-
-// flagKindMask holds the bits that make up the kind
-// part of the flags field. In all the supported versions,
-// it is in the lower 5 bits.
-const flagKindMask = flag(0x1f)
-
-// Different versions of Go have used different
-// bit layouts for the flags type. This table
-// records the known combinations.
-var okFlags = []struct {
-	ro, addr flag
-}{{
-	// From Go 1.4 to 1.5
-	ro:   1 << 5,
-	addr: 1 << 7,
-}, {
-	// Up to Go tip.
-	ro:   1<<5 | 1<<6,
-	addr: 1 << 8,
-}}
-
-var flagValOffset = func() uintptr {
-	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
-	if !ok {
-		panic("reflect.Value has no flag field")
-	}
-	return field.Offset
-}()
-
-// flagField returns a pointer to the flag field of a reflect.Value.
-func flagField(v *reflect.Value) *flag {
-	return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset))
-}
-
-// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
-// the typical safety restrictions preventing access to unaddressable and
-// unexported data.  It works by digging the raw pointer to the underlying
-// value out of the protected value and generating a new unprotected (unsafe)
-// reflect.Value to it.
-//
-// This allows us to check for implementations of the Stringer and error
-// interfaces to be used for pretty printing ordinarily unaddressable and
-// inaccessible values such as unexported struct fields.
-func unsafeReflectValue(v reflect.Value) reflect.Value {
-	if !v.IsValid() || (v.CanInterface() && v.CanAddr()) {
-		return v
-	}
-	flagFieldPtr := flagField(&v)
-	*flagFieldPtr &^= flagRO
-	*flagFieldPtr |= flagAddr
-	return v
-}
-
-// Sanity checks against future reflect package changes
-// to the type or semantics of the Value.flag field.
-func init() {
-	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
-	if !ok {
-		panic("reflect.Value has no flag field")
-	}
-	if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() {
-		panic("reflect.Value flag field has changed kind")
-	}
-	type t0 int
-	var t struct {
-		A t0
-		// t0 will have flagEmbedRO set.
-		t0
-		// a will have flagStickyRO set
-		a t0
-	}
-	vA := reflect.ValueOf(t).FieldByName("A")
-	va := reflect.ValueOf(t).FieldByName("a")
-	vt0 := reflect.ValueOf(t).FieldByName("t0")
-
-	// Infer flagRO from the difference between the flags
-	// for the (otherwise identical) fields in t.
-	flagPublic := *flagField(&vA)
-	flagWithRO := *flagField(&va) | *flagField(&vt0)
-	flagRO = flagPublic ^ flagWithRO
-
-	// Infer flagAddr from the difference between a value
-	// taken from a pointer and not.
-	vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A")
-	flagNoPtr := *flagField(&vA)
-	flagPtr := *flagField(&vPtrA)
-	flagAddr = flagNoPtr ^ flagPtr
-
-	// Check that the inferred flags tally with one of the known versions.
-	for _, f := range okFlags {
-		if flagRO == f.ro && flagAddr == f.addr {
-			return
-		}
-	}
-	panic("reflect.Value read-only flag has changed semantics")
-}
diff --git a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
deleted file mode 100644
index 205c28d..0000000
--- a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when the code is running on Google App Engine, compiled by GopherJS, or
-// "-tags safe" is added to the go build command line.  The "disableunsafe"
-// tag is deprecated and thus should not be used.
-// +build js appengine safe disableunsafe !go1.4
-
-package spew
-
-import "reflect"
-
-const (
-	// UnsafeDisabled is a build-time constant which specifies whether or
-	// not access to the unsafe package is available.
-	UnsafeDisabled = true
-)
-
-// unsafeReflectValue typically converts the passed reflect.Value into a one
-// that bypasses the typical safety restrictions preventing access to
-// unaddressable and unexported data.  However, doing this relies on access to
-// the unsafe package.  This is a stub version which simply returns the passed
-// reflect.Value when the unsafe package is not available.
-func unsafeReflectValue(v reflect.Value) reflect.Value {
-	return v
-}
diff --git a/vendor/github.com/davecgh/go-spew/spew/common.go b/vendor/github.com/davecgh/go-spew/spew/common.go
deleted file mode 100644
index 1be8ce9..0000000
--- a/vendor/github.com/davecgh/go-spew/spew/common.go
+++ /dev/null
@@ -1,341 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"reflect"
-	"sort"
-	"strconv"
-)
-
-// Some constants in the form of bytes to avoid string overhead.  This mirrors
-// the technique used in the fmt package.
-var (
-	panicBytes            = []byte("(PANIC=")
-	plusBytes             = []byte("+")
-	iBytes                = []byte("i")
-	trueBytes             = []byte("true")
-	falseBytes            = []byte("false")
-	interfaceBytes        = []byte("(interface {})")
-	commaNewlineBytes     = []byte(",\n")
-	newlineBytes          = []byte("\n")
-	openBraceBytes        = []byte("{")
-	openBraceNewlineBytes = []byte("{\n")
-	closeBraceBytes       = []byte("}")
-	asteriskBytes         = []byte("*")
-	colonBytes            = []byte(":")
-	colonSpaceBytes       = []byte(": ")
-	openParenBytes        = []byte("(")
-	closeParenBytes       = []byte(")")
-	spaceBytes            = []byte(" ")
-	pointerChainBytes     = []byte("->")
-	nilAngleBytes         = []byte("<nil>")
-	maxNewlineBytes       = []byte("<max depth reached>\n")
-	maxShortBytes         = []byte("<max>")
-	circularBytes         = []byte("<already shown>")
-	circularShortBytes    = []byte("<shown>")
-	invalidAngleBytes     = []byte("<invalid>")
-	openBracketBytes      = []byte("[")
-	closeBracketBytes     = []byte("]")
-	percentBytes          = []byte("%")
-	precisionBytes        = []byte(".")
-	openAngleBytes        = []byte("<")
-	closeAngleBytes       = []byte(">")
-	openMapBytes          = []byte("map[")
-	closeMapBytes         = []byte("]")
-	lenEqualsBytes        = []byte("len=")
-	capEqualsBytes        = []byte("cap=")
-)
-
-// hexDigits is used to map a decimal value to a hex digit.
-var hexDigits = "0123456789abcdef"
-
-// catchPanic handles any panics that might occur during the handleMethods
-// calls.
-func catchPanic(w io.Writer, v reflect.Value) {
-	if err := recover(); err != nil {
-		w.Write(panicBytes)
-		fmt.Fprintf(w, "%v", err)
-		w.Write(closeParenBytes)
-	}
-}
-
-// handleMethods attempts to call the Error and String methods on the underlying
-// type the passed reflect.Value represents and outputes the result to Writer w.
-//
-// It handles panics in any called methods by catching and displaying the error
-// as the formatted value.
-func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
-	// We need an interface to check if the type implements the error or
-	// Stringer interface.  However, the reflect package won't give us an
-	// interface on certain things like unexported struct fields in order
-	// to enforce visibility rules.  We use unsafe, when it's available,
-	// to bypass these restrictions since this package does not mutate the
-	// values.
-	if !v.CanInterface() {
-		if UnsafeDisabled {
-			return false
-		}
-
-		v = unsafeReflectValue(v)
-	}
-
-	// Choose whether or not to do error and Stringer interface lookups against
-	// the base type or a pointer to the base type depending on settings.
-	// Technically calling one of these methods with a pointer receiver can
-	// mutate the value, however, types which choose to satisify an error or
-	// Stringer interface with a pointer receiver should not be mutating their
-	// state inside these interface methods.
-	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
-		v = unsafeReflectValue(v)
-	}
-	if v.CanAddr() {
-		v = v.Addr()
-	}
-
-	// Is it an error or Stringer?
-	switch iface := v.Interface().(type) {
-	case error:
-		defer catchPanic(w, v)
-		if cs.ContinueOnMethod {
-			w.Write(openParenBytes)
-			w.Write([]byte(iface.Error()))
-			w.Write(closeParenBytes)
-			w.Write(spaceBytes)
-			return false
-		}
-
-		w.Write([]byte(iface.Error()))
-		return true
-
-	case fmt.Stringer:
-		defer catchPanic(w, v)
-		if cs.ContinueOnMethod {
-			w.Write(openParenBytes)
-			w.Write([]byte(iface.String()))
-			w.Write(closeParenBytes)
-			w.Write(spaceBytes)
-			return false
-		}
-		w.Write([]byte(iface.String()))
-		return true
-	}
-	return false
-}
-
-// printBool outputs a boolean value as true or false to Writer w.
-func printBool(w io.Writer, val bool) {
-	if val {
-		w.Write(trueBytes)
-	} else {
-		w.Write(falseBytes)
-	}
-}
-
-// printInt outputs a signed integer value to Writer w.
-func printInt(w io.Writer, val int64, base int) {
-	w.Write([]byte(strconv.FormatInt(val, base)))
-}
-
-// printUint outputs an unsigned integer value to Writer w.
-func printUint(w io.Writer, val uint64, base int) {
-	w.Write([]byte(strconv.FormatUint(val, base)))
-}
-
-// printFloat outputs a floating point value using the specified precision,
-// which is expected to be 32 or 64bit, to Writer w.
-func printFloat(w io.Writer, val float64, precision int) {
-	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
-}
-
-// printComplex outputs a complex value using the specified float precision
-// for the real and imaginary parts to Writer w.
-func printComplex(w io.Writer, c complex128, floatPrecision int) {
-	r := real(c)
-	w.Write(openParenBytes)
-	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
-	i := imag(c)
-	if i >= 0 {
-		w.Write(plusBytes)
-	}
-	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
-	w.Write(iBytes)
-	w.Write(closeParenBytes)
-}
-
-// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
-// prefix to Writer w.
-func printHexPtr(w io.Writer, p uintptr) {
-	// Null pointer.
-	num := uint64(p)
-	if num == 0 {
-		w.Write(nilAngleBytes)
-		return
-	}
-
-	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
-	buf := make([]byte, 18)
-
-	// It's simpler to construct the hex string right to left.
-	base := uint64(16)
-	i := len(buf) - 1
-	for num >= base {
-		buf[i] = hexDigits[num%base]
-		num /= base
-		i--
-	}
-	buf[i] = hexDigits[num]
-
-	// Add '0x' prefix.
-	i--
-	buf[i] = 'x'
-	i--
-	buf[i] = '0'
-
-	// Strip unused leading bytes.
-	buf = buf[i:]
-	w.Write(buf)
-}
-
-// valuesSorter implements sort.Interface to allow a slice of reflect.Value
-// elements to be sorted.
-type valuesSorter struct {
-	values  []reflect.Value
-	strings []string // either nil or same len and values
-	cs      *ConfigState
-}
-
-// newValuesSorter initializes a valuesSorter instance, which holds a set of
-// surrogate keys on which the data should be sorted.  It uses flags in
-// ConfigState to decide if and how to populate those surrogate keys.
-func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
-	vs := &valuesSorter{values: values, cs: cs}
-	if canSortSimply(vs.values[0].Kind()) {
-		return vs
-	}
-	if !cs.DisableMethods {
-		vs.strings = make([]string, len(values))
-		for i := range vs.values {
-			b := bytes.Buffer{}
-			if !handleMethods(cs, &b, vs.values[i]) {
-				vs.strings = nil
-				break
-			}
-			vs.strings[i] = b.String()
-		}
-	}
-	if vs.strings == nil && cs.SpewKeys {
-		vs.strings = make([]string, len(values))
-		for i := range vs.values {
-			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
-		}
-	}
-	return vs
-}
-
-// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
-// directly, or whether it should be considered for sorting by surrogate keys
-// (if the ConfigState allows it).
-func canSortSimply(kind reflect.Kind) bool {
-	// This switch parallels valueSortLess, except for the default case.
-	switch kind {
-	case reflect.Bool:
-		return true
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		return true
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		return true
-	case reflect.Float32, reflect.Float64:
-		return true
-	case reflect.String:
-		return true
-	case reflect.Uintptr:
-		return true
-	case reflect.Array:
-		return true
-	}
-	return false
-}
-
-// Len returns the number of values in the slice.  It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Len() int {
-	return len(s.values)
-}
-
-// Swap swaps the values at the passed indices.  It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Swap(i, j int) {
-	s.values[i], s.values[j] = s.values[j], s.values[i]
-	if s.strings != nil {
-		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
-	}
-}
-
-// valueSortLess returns whether the first value should sort before the second
-// value.  It is used by valueSorter.Less as part of the sort.Interface
-// implementation.
-func valueSortLess(a, b reflect.Value) bool {
-	switch a.Kind() {
-	case reflect.Bool:
-		return !a.Bool() && b.Bool()
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		return a.Int() < b.Int()
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		return a.Uint() < b.Uint()
-	case reflect.Float32, reflect.Float64:
-		return a.Float() < b.Float()
-	case reflect.String:
-		return a.String() < b.String()
-	case reflect.Uintptr:
-		return a.Uint() < b.Uint()
-	case reflect.Array:
-		// Compare the contents of both arrays.
-		l := a.Len()
-		for i := 0; i < l; i++ {
-			av := a.Index(i)
-			bv := b.Index(i)
-			if av.Interface() == bv.Interface() {
-				continue
-			}
-			return valueSortLess(av, bv)
-		}
-	}
-	return a.String() < b.String()
-}
-
-// Less returns whether the value at index i should sort before the
-// value at index j.  It is part of the sort.Interface implementation.
-func (s *valuesSorter) Less(i, j int) bool {
-	if s.strings == nil {
-		return valueSortLess(s.values[i], s.values[j])
-	}
-	return s.strings[i] < s.strings[j]
-}
-
-// sortValues is a sort function that handles both native types and any type that
-// can be converted to error or Stringer.  Other inputs are sorted according to
-// their Value.String() value to ensure display stability.
-func sortValues(values []reflect.Value, cs *ConfigState) {
-	if len(values) == 0 {
-		return
-	}
-	sort.Sort(newValuesSorter(values, cs))
-}
diff --git a/vendor/github.com/davecgh/go-spew/spew/config.go b/vendor/github.com/davecgh/go-spew/spew/config.go
deleted file mode 100644
index 2e3d22f..0000000
--- a/vendor/github.com/davecgh/go-spew/spew/config.go
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-)
-
-// ConfigState houses the configuration options used by spew to format and
-// display values.  There is a global instance, Config, that is used to control
-// all top-level Formatter and Dump functionality.  Each ConfigState instance
-// provides methods equivalent to the top-level functions.
-//
-// The zero value for ConfigState provides no indentation.  You would typically
-// want to set it to a space or a tab.
-//
-// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
-// with default settings.  See the documentation of NewDefaultConfig for default
-// values.
-type ConfigState struct {
-	// Indent specifies the string to use for each indentation level.  The
-	// global config instance that all top-level functions use set this to a
-	// single space by default.  If you would like more indentation, you might
-	// set this to a tab with "\t" or perhaps two spaces with "  ".
-	Indent string
-
-	// MaxDepth controls the maximum number of levels to descend into nested
-	// data structures.  The default, 0, means there is no limit.
-	//
-	// NOTE: Circular data structures are properly detected, so it is not
-	// necessary to set this value unless you specifically want to limit deeply
-	// nested data structures.
-	MaxDepth int
-
-	// DisableMethods specifies whether or not error and Stringer interfaces are
-	// invoked for types that implement them.
-	DisableMethods bool
-
-	// DisablePointerMethods specifies whether or not to check for and invoke
-	// error and Stringer interfaces on types which only accept a pointer
-	// receiver when the current type is not a pointer.
-	//
-	// NOTE: This might be an unsafe action since calling one of these methods
-	// with a pointer receiver could technically mutate the value, however,
-	// in practice, types which choose to satisify an error or Stringer
-	// interface with a pointer receiver should not be mutating their state
-	// inside these interface methods.  As a result, this option relies on
-	// access to the unsafe package, so it will not have any effect when
-	// running in environments without access to the unsafe package such as
-	// Google App Engine or with the "safe" build tag specified.
-	DisablePointerMethods bool
-
-	// DisablePointerAddresses specifies whether to disable the printing of
-	// pointer addresses. This is useful when diffing data structures in tests.
-	DisablePointerAddresses bool
-
-	// DisableCapacities specifies whether to disable the printing of capacities
-	// for arrays, slices, maps and channels. This is useful when diffing
-	// data structures in tests.
-	DisableCapacities bool
-
-	// ContinueOnMethod specifies whether or not recursion should continue once
-	// a custom error or Stringer interface is invoked.  The default, false,
-	// means it will print the results of invoking the custom error or Stringer
-	// interface and return immediately instead of continuing to recurse into
-	// the internals of the data type.
-	//
-	// NOTE: This flag does not have any effect if method invocation is disabled
-	// via the DisableMethods or DisablePointerMethods options.
-	ContinueOnMethod bool
-
-	// SortKeys specifies map keys should be sorted before being printed. Use
-	// this to have a more deterministic, diffable output.  Note that only
-	// native types (bool, int, uint, floats, uintptr and string) and types
-	// that support the error or Stringer interfaces (if methods are
-	// enabled) are supported, with other types sorted according to the
-	// reflect.Value.String() output which guarantees display stability.
-	SortKeys bool
-
-	// SpewKeys specifies that, as a last resort attempt, map keys should
-	// be spewed to strings and sorted by those strings.  This is only
-	// considered if SortKeys is true.
-	SpewKeys bool
-}
-
-// Config is the active configuration of the top-level functions.
-// The configuration can be changed by modifying the contents of spew.Config.
-var Config = ConfigState{Indent: " "}
-
-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the formatted string as a value that satisfies error.  See NewFormatter
-// for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
-	return fmt.Errorf(format, c.convertArgs(a)...)
-}
-
-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprint(w, c.convertArgs(a)...)
-}
-
-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	return fmt.Fprintf(w, format, c.convertArgs(a)...)
-}
-
-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
-// passed with a Formatter interface returned by c.NewFormatter.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprintln(w, c.convertArgs(a)...)
-}
-
-// Print is a wrapper for fmt.Print that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
-	return fmt.Print(c.convertArgs(a)...)
-}
-
-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
-	return fmt.Printf(format, c.convertArgs(a)...)
-}
-
-// Println is a wrapper for fmt.Println that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
-	return fmt.Println(c.convertArgs(a)...)
-}
-
-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprint(a ...interface{}) string {
-	return fmt.Sprint(c.convertArgs(a)...)
-}
-
-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
-	return fmt.Sprintf(format, c.convertArgs(a)...)
-}
-
-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
-// were passed with a Formatter interface returned by c.NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintln(a ...interface{}) string {
-	return fmt.Sprintln(c.convertArgs(a)...)
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface.  As a result, it integrates cleanly with standard fmt package
-printing functions.  The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly.  It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-c.Printf, c.Println, or c.Printf.
-*/
-func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
-	return newFormatter(c, v)
-}
-
-// Fdump formats and displays the passed arguments to io.Writer w.  It formats
-// exactly the same as Dump.
-func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
-	fdump(c, w, a...)
-}
-
-/*
-Dump displays the passed parameters to standard out with newlines, customizable
-indentation, and additional debug information such as complete types and all
-pointer addresses used to indirect to the final value.  It provides the
-following features over the built-in printing facilities provided by the fmt
-package:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output
-
-The configuration options are controlled by modifying the public members
-of c.  See ConfigState for options documentation.
-
-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
-get the formatted result as a string.
-*/
-func (c *ConfigState) Dump(a ...interface{}) {
-	fdump(c, os.Stdout, a...)
-}
-
-// Sdump returns a string with the passed arguments formatted exactly the same
-// as Dump.
-func (c *ConfigState) Sdump(a ...interface{}) string {
-	var buf bytes.Buffer
-	fdump(c, &buf, a...)
-	return buf.String()
-}
-
-// convertArgs accepts a slice of arguments and returns a slice of the same
-// length with each argument converted to a spew Formatter interface using
-// the ConfigState associated with s.
-func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
-	formatters = make([]interface{}, len(args))
-	for index, arg := range args {
-		formatters[index] = newFormatter(c, arg)
-	}
-	return formatters
-}
-
-// NewDefaultConfig returns a ConfigState with the following default settings.
-//
-// 	Indent: " "
-// 	MaxDepth: 0
-// 	DisableMethods: false
-// 	DisablePointerMethods: false
-// 	ContinueOnMethod: false
-// 	SortKeys: false
-func NewDefaultConfig() *ConfigState {
-	return &ConfigState{Indent: " "}
-}
diff --git a/vendor/github.com/davecgh/go-spew/spew/doc.go b/vendor/github.com/davecgh/go-spew/spew/doc.go
deleted file mode 100644
index aacaac6..0000000
--- a/vendor/github.com/davecgh/go-spew/spew/doc.go
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/*
-Package spew implements a deep pretty printer for Go data structures to aid in
-debugging.
-
-A quick overview of the additional features spew provides over the built-in
-printing facilities for Go data types are as follows:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output (only when using
-	  Dump style)
-
-There are two different approaches spew allows for dumping Go data structures:
-
-	* Dump style which prints with newlines, customizable indentation,
-	  and additional debug information such as types and all pointer addresses
-	  used to indirect to the final value
-	* A custom Formatter interface that integrates cleanly with the standard fmt
-	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
-	  similar to the default %v while providing the additional functionality
-	  outlined above and passing unsupported format verbs such as %x and %q
-	  along to fmt
-
-Quick Start
-
-This section demonstrates how to quickly get started with spew.  See the
-sections below for further details on formatting and configuration options.
-
-To dump a variable with full newlines, indentation, type, and pointer
-information use Dump, Fdump, or Sdump:
-	spew.Dump(myVar1, myVar2, ...)
-	spew.Fdump(someWriter, myVar1, myVar2, ...)
-	str := spew.Sdump(myVar1, myVar2, ...)
-
-Alternatively, if you would prefer to use format strings with a compacted inline
-printing style, use the convenience wrappers Printf, Fprintf, etc with
-%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
-%#+v (adds types and pointer addresses):
-	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-
-Configuration Options
-
-Configuration of spew is handled by fields in the ConfigState type.  For
-convenience, all of the top-level functions use a global state available
-via the spew.Config global.
-
-It is also possible to create a ConfigState instance that provides methods
-equivalent to the top-level functions.  This allows concurrent configuration
-options.  See the ConfigState documentation for more details.
-
-The following configuration options are available:
-	* Indent
-		String to use for each indentation level for Dump functions.
-		It is a single space by default.  A popular alternative is "\t".
-
-	* MaxDepth
-		Maximum number of levels to descend into nested data structures.
-		There is no limit by default.
-
-	* DisableMethods
-		Disables invocation of error and Stringer interface methods.
-		Method invocation is enabled by default.
-
-	* DisablePointerMethods
-		Disables invocation of error and Stringer interface methods on types
-		which only accept pointer receivers from non-pointer variables.
-		Pointer method invocation is enabled by default.
-
-	* DisablePointerAddresses
-		DisablePointerAddresses specifies whether to disable the printing of
-		pointer addresses. This is useful when diffing data structures in tests.
-
-	* DisableCapacities
-		DisableCapacities specifies whether to disable the printing of
-		capacities for arrays, slices, maps and channels. This is useful when
-		diffing data structures in tests.
-
-	* ContinueOnMethod
-		Enables recursion into types after invoking error and Stringer interface
-		methods. Recursion after method invocation is disabled by default.
-
-	* SortKeys
-		Specifies map keys should be sorted before being printed. Use
-		this to have a more deterministic, diffable output.  Note that
-		only native types (bool, int, uint, floats, uintptr and string)
-		and types which implement error or Stringer interfaces are
-		supported with other types sorted according to the
-		reflect.Value.String() output which guarantees display
-		stability.  Natural map order is used by default.
-
-	* SpewKeys
-		Specifies that, as a last resort attempt, map keys should be
-		spewed to strings and sorted by those strings.  This is only
-		considered if SortKeys is true.
-
-Dump Usage
-
-Simply call spew.Dump with a list of variables you want to dump:
-
-	spew.Dump(myVar1, myVar2, ...)
-
-You may also call spew.Fdump if you would prefer to output to an arbitrary
-io.Writer.  For example, to dump to standard error:
-
-	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
-
-A third option is to call spew.Sdump to get the formatted output as a string:
-
-	str := spew.Sdump(myVar1, myVar2, ...)
-
-Sample Dump Output
-
-See the Dump example for details on the setup of the types and variables being
-shown here.
-
-	(main.Foo) {
-	 unexportedField: (*main.Bar)(0xf84002e210)({
-	  flag: (main.Flag) flagTwo,
-	  data: (uintptr) <nil>
-	 }),
-	 ExportedField: (map[interface {}]interface {}) (len=1) {
-	  (string) (len=3) "one": (bool) true
-	 }
-	}
-
-Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
-command as shown.
-	([]uint8) (len=32 cap=32) {
-	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
-	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
-	 00000020  31 32                                             |12|
-	}
-
-Custom Formatter
-
-Spew provides a custom formatter that implements the fmt.Formatter interface
-so that it integrates cleanly with standard fmt package printing functions. The
-formatter is useful for inline printing of smaller data types similar to the
-standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Custom Formatter Usage
-
-The simplest way to make use of the spew custom formatter is to call one of the
-convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
-functions have syntax you are most likely already familiar with:
-
-	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-	spew.Println(myVar, myVar2)
-	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-
-See the Index for the full list convenience functions.
-
-Sample Formatter Output
-
-Double pointer to a uint8:
-	  %v: <**>5
-	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
-	 %#v: (**uint8)5
-	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
-
-Pointer to circular struct with a uint8 field and a pointer to itself:
-	  %v: <*>{1 <*><shown>}
-	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
-	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
-	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
-
-See the Printf example for details on the setup of variables being shown
-here.
-
-Errors
-
-Since it is possible for custom Stringer/error interfaces to panic, spew
-detects them and handles them internally by printing the panic information
-inline with the output.  Since spew is intended to provide deep pretty printing
-capabilities on structures, it intentionally does not return any errors.
-*/
-package spew
diff --git a/vendor/github.com/davecgh/go-spew/spew/dump.go b/vendor/github.com/davecgh/go-spew/spew/dump.go
deleted file mode 100644
index f78d89f..0000000
--- a/vendor/github.com/davecgh/go-spew/spew/dump.go
+++ /dev/null
@@ -1,509 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"encoding/hex"
-	"fmt"
-	"io"
-	"os"
-	"reflect"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-var (
-	// uint8Type is a reflect.Type representing a uint8.  It is used to
-	// convert cgo types to uint8 slices for hexdumping.
-	uint8Type = reflect.TypeOf(uint8(0))
-
-	// cCharRE is a regular expression that matches a cgo char.
-	// It is used to detect character arrays to hexdump them.
-	cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`)
-
-	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
-	// char.  It is used to detect unsigned character arrays to hexdump
-	// them.
-	cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`)
-
-	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
-	// It is used to detect uint8_t arrays to hexdump them.
-	cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`)
-)
-
-// dumpState contains information about the state of a dump operation.
-type dumpState struct {
-	w                io.Writer
-	depth            int
-	pointers         map[uintptr]int
-	ignoreNextType   bool
-	ignoreNextIndent bool
-	cs               *ConfigState
-}
-
-// indent performs indentation according to the depth level and cs.Indent
-// option.
-func (d *dumpState) indent() {
-	if d.ignoreNextIndent {
-		d.ignoreNextIndent = false
-		return
-	}
-	d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
-}
-
-// unpackValue returns values inside of non-nil interfaces when possible.
-// This is useful for data types like structs, arrays, slices, and maps which
-// can contain varying types packed inside an interface.
-func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Interface && !v.IsNil() {
-		v = v.Elem()
-	}
-	return v
-}
-
-// dumpPtr handles formatting of pointers by indirecting them as necessary.
-func (d *dumpState) dumpPtr(v reflect.Value) {
-	// Remove pointers at or below the current depth from map used to detect
-	// circular refs.
-	for k, depth := range d.pointers {
-		if depth >= d.depth {
-			delete(d.pointers, k)
-		}
-	}
-
-	// Keep list of all dereferenced pointers to show later.
-	pointerChain := make([]uintptr, 0)
-
-	// Figure out how many levels of indirection there are by dereferencing
-	// pointers and unpacking interfaces down the chain while detecting circular
-	// references.
-	nilFound := false
-	cycleFound := false
-	indirects := 0
-	ve := v
-	for ve.Kind() == reflect.Ptr {
-		if ve.IsNil() {
-			nilFound = true
-			break
-		}
-		indirects++
-		addr := ve.Pointer()
-		pointerChain = append(pointerChain, addr)
-		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
-			cycleFound = true
-			indirects--
-			break
-		}
-		d.pointers[addr] = d.depth
-
-		ve = ve.Elem()
-		if ve.Kind() == reflect.Interface {
-			if ve.IsNil() {
-				nilFound = true
-				break
-			}
-			ve = ve.Elem()
-		}
-	}
-
-	// Display type information.
-	d.w.Write(openParenBytes)
-	d.w.Write(bytes.Repeat(asteriskBytes, indirects))
-	d.w.Write([]byte(ve.Type().String()))
-	d.w.Write(closeParenBytes)
-
-	// Display pointer information.
-	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
-		d.w.Write(openParenBytes)
-		for i, addr := range pointerChain {
-			if i > 0 {
-				d.w.Write(pointerChainBytes)
-			}
-			printHexPtr(d.w, addr)
-		}
-		d.w.Write(closeParenBytes)
-	}
-
-	// Display dereferenced value.
-	d.w.Write(openParenBytes)
-	switch {
-	case nilFound:
-		d.w.Write(nilAngleBytes)
-
-	case cycleFound:
-		d.w.Write(circularBytes)
-
-	default:
-		d.ignoreNextType = true
-		d.dump(ve)
-	}
-	d.w.Write(closeParenBytes)
-}
-
-// dumpSlice handles formatting of arrays and slices.  Byte (uint8 under
-// reflection) arrays and slices are dumped in hexdump -C fashion.
-func (d *dumpState) dumpSlice(v reflect.Value) {
-	// Determine whether this type should be hex dumped or not.  Also,
-	// for types which should be hexdumped, try to use the underlying data
-	// first, then fall back to trying to convert them to a uint8 slice.
-	var buf []uint8
-	doConvert := false
-	doHexDump := false
-	numEntries := v.Len()
-	if numEntries > 0 {
-		vt := v.Index(0).Type()
-		vts := vt.String()
-		switch {
-		// C types that need to be converted.
-		case cCharRE.MatchString(vts):
-			fallthrough
-		case cUnsignedCharRE.MatchString(vts):
-			fallthrough
-		case cUint8tCharRE.MatchString(vts):
-			doConvert = true
-
-		// Try to use existing uint8 slices and fall back to converting
-		// and copying if that fails.
-		case vt.Kind() == reflect.Uint8:
-			// We need an addressable interface to convert the type
-			// to a byte slice.  However, the reflect package won't
-			// give us an interface on certain things like
-			// unexported struct fields in order to enforce
-			// visibility rules.  We use unsafe, when available, to
-			// bypass these restrictions since this package does not
-			// mutate the values.
-			vs := v
-			if !vs.CanInterface() || !vs.CanAddr() {
-				vs = unsafeReflectValue(vs)
-			}
-			if !UnsafeDisabled {
-				vs = vs.Slice(0, numEntries)
-
-				// Use the existing uint8 slice if it can be
-				// type asserted.
-				iface := vs.Interface()
-				if slice, ok := iface.([]uint8); ok {
-					buf = slice
-					doHexDump = true
-					break
-				}
-			}
-
-			// The underlying data needs to be converted if it can't
-			// be type asserted to a uint8 slice.
-			doConvert = true
-		}
-
-		// Copy and convert the underlying type if needed.
-		if doConvert && vt.ConvertibleTo(uint8Type) {
-			// Convert and copy each element into a uint8 byte
-			// slice.
-			buf = make([]uint8, numEntries)
-			for i := 0; i < numEntries; i++ {
-				vv := v.Index(i)
-				buf[i] = uint8(vv.Convert(uint8Type).Uint())
-			}
-			doHexDump = true
-		}
-	}
-
-	// Hexdump the entire slice as needed.
-	if doHexDump {
-		indent := strings.Repeat(d.cs.Indent, d.depth)
-		str := indent + hex.Dump(buf)
-		str = strings.Replace(str, "\n", "\n"+indent, -1)
-		str = strings.TrimRight(str, d.cs.Indent)
-		d.w.Write([]byte(str))
-		return
-	}
-
-	// Recursively call dump for each item.
-	for i := 0; i < numEntries; i++ {
-		d.dump(d.unpackValue(v.Index(i)))
-		if i < (numEntries - 1) {
-			d.w.Write(commaNewlineBytes)
-		} else {
-			d.w.Write(newlineBytes)
-		}
-	}
-}
-
-// dump is the main workhorse for dumping a value.  It uses the passed reflect
-// value to figure out what kind of object we are dealing with and formats it
-// appropriately.  It is a recursive function, however circular data structures
-// are detected and handled properly.
-func (d *dumpState) dump(v reflect.Value) {
-	// Handle invalid reflect values immediately.
-	kind := v.Kind()
-	if kind == reflect.Invalid {
-		d.w.Write(invalidAngleBytes)
-		return
-	}
-
-	// Handle pointers specially.
-	if kind == reflect.Ptr {
-		d.indent()
-		d.dumpPtr(v)
-		return
-	}
-
-	// Print type information unless already handled elsewhere.
-	if !d.ignoreNextType {
-		d.indent()
-		d.w.Write(openParenBytes)
-		d.w.Write([]byte(v.Type().String()))
-		d.w.Write(closeParenBytes)
-		d.w.Write(spaceBytes)
-	}
-	d.ignoreNextType = false
-
-	// Display length and capacity if the built-in len and cap functions
-	// work with the value's kind and the len/cap itself is non-zero.
-	valueLen, valueCap := 0, 0
-	switch v.Kind() {
-	case reflect.Array, reflect.Slice, reflect.Chan:
-		valueLen, valueCap = v.Len(), v.Cap()
-	case reflect.Map, reflect.String:
-		valueLen = v.Len()
-	}
-	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
-		d.w.Write(openParenBytes)
-		if valueLen != 0 {
-			d.w.Write(lenEqualsBytes)
-			printInt(d.w, int64(valueLen), 10)
-		}
-		if !d.cs.DisableCapacities && valueCap != 0 {
-			if valueLen != 0 {
-				d.w.Write(spaceBytes)
-			}
-			d.w.Write(capEqualsBytes)
-			printInt(d.w, int64(valueCap), 10)
-		}
-		d.w.Write(closeParenBytes)
-		d.w.Write(spaceBytes)
-	}
-
-	// Call Stringer/error interfaces if they exist and the handle methods flag
-	// is enabled
-	if !d.cs.DisableMethods {
-		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
-			if handled := handleMethods(d.cs, d.w, v); handled {
-				return
-			}
-		}
-	}
-
-	switch kind {
-	case reflect.Invalid:
-		// Do nothing.  We should never get here since invalid has already
-		// been handled above.
-
-	case reflect.Bool:
-		printBool(d.w, v.Bool())
-
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		printInt(d.w, v.Int(), 10)
-
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		printUint(d.w, v.Uint(), 10)
-
-	case reflect.Float32:
-		printFloat(d.w, v.Float(), 32)
-
-	case reflect.Float64:
-		printFloat(d.w, v.Float(), 64)
-
-	case reflect.Complex64:
-		printComplex(d.w, v.Complex(), 32)
-
-	case reflect.Complex128:
-		printComplex(d.w, v.Complex(), 64)
-
-	case reflect.Slice:
-		if v.IsNil() {
-			d.w.Write(nilAngleBytes)
-			break
-		}
-		fallthrough
-
-	case reflect.Array:
-		d.w.Write(openBraceNewlineBytes)
-		d.depth++
-		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
-			d.indent()
-			d.w.Write(maxNewlineBytes)
-		} else {
-			d.dumpSlice(v)
-		}
-		d.depth--
-		d.indent()
-		d.w.Write(closeBraceBytes)
-
-	case reflect.String:
-		d.w.Write([]byte(strconv.Quote(v.String())))
-
-	case reflect.Interface:
-		// The only time we should get here is for nil interfaces due to
-		// unpackValue calls.
-		if v.IsNil() {
-			d.w.Write(nilAngleBytes)
-		}
-
-	case reflect.Ptr:
-		// Do nothing.  We should never get here since pointers have already
-		// been handled above.
-
-	case reflect.Map:
-		// nil maps should be indicated as different than empty maps
-		if v.IsNil() {
-			d.w.Write(nilAngleBytes)
-			break
-		}
-
-		d.w.Write(openBraceNewlineBytes)
-		d.depth++
-		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
-			d.indent()
-			d.w.Write(maxNewlineBytes)
-		} else {
-			numEntries := v.Len()
-			keys := v.MapKeys()
-			if d.cs.SortKeys {
-				sortValues(keys, d.cs)
-			}
-			for i, key := range keys {
-				d.dump(d.unpackValue(key))
-				d.w.Write(colonSpaceBytes)
-				d.ignoreNextIndent = true
-				d.dump(d.unpackValue(v.MapIndex(key)))
-				if i < (numEntries - 1) {
-					d.w.Write(commaNewlineBytes)
-				} else {
-					d.w.Write(newlineBytes)
-				}
-			}
-		}
-		d.depth--
-		d.indent()
-		d.w.Write(closeBraceBytes)
-
-	case reflect.Struct:
-		d.w.Write(openBraceNewlineBytes)
-		d.depth++
-		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
-			d.indent()
-			d.w.Write(maxNewlineBytes)
-		} else {
-			vt := v.Type()
-			numFields := v.NumField()
-			for i := 0; i < numFields; i++ {
-				d.indent()
-				vtf := vt.Field(i)
-				d.w.Write([]byte(vtf.Name))
-				d.w.Write(colonSpaceBytes)
-				d.ignoreNextIndent = true
-				d.dump(d.unpackValue(v.Field(i)))
-				if i < (numFields - 1) {
-					d.w.Write(commaNewlineBytes)
-				} else {
-					d.w.Write(newlineBytes)
-				}
-			}
-		}
-		d.depth--
-		d.indent()
-		d.w.Write(closeBraceBytes)
-
-	case reflect.Uintptr:
-		printHexPtr(d.w, uintptr(v.Uint()))
-
-	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
-		printHexPtr(d.w, v.Pointer())
-
-	// There were not any other types at the time this code was written, but
-	// fall back to letting the default fmt package handle it in case any new
-	// types are added.
-	default:
-		if v.CanInterface() {
-			fmt.Fprintf(d.w, "%v", v.Interface())
-		} else {
-			fmt.Fprintf(d.w, "%v", v.String())
-		}
-	}
-}
-
-// fdump is a helper function to consolidate the logic from the various public
-// methods which take varying writers and config states.
-func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
-	for _, arg := range a {
-		if arg == nil {
-			w.Write(interfaceBytes)
-			w.Write(spaceBytes)
-			w.Write(nilAngleBytes)
-			w.Write(newlineBytes)
-			continue
-		}
-
-		d := dumpState{w: w, cs: cs}
-		d.pointers = make(map[uintptr]int)
-		d.dump(reflect.ValueOf(arg))
-		d.w.Write(newlineBytes)
-	}
-}
-
-// Fdump formats and displays the passed arguments to io.Writer w.  It formats
-// exactly the same as Dump.
-func Fdump(w io.Writer, a ...interface{}) {
-	fdump(&Config, w, a...)
-}
-
-// Sdump returns a string with the passed arguments formatted exactly the same
-// as Dump.
-func Sdump(a ...interface{}) string {
-	var buf bytes.Buffer
-	fdump(&Config, &buf, a...)
-	return buf.String()
-}
-
-/*
-Dump displays the passed parameters to standard out with newlines, customizable
-indentation, and additional debug information such as complete types and all
-pointer addresses used to indirect to the final value.  It provides the
-following features over the built-in printing facilities provided by the fmt
-package:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output
-
-The configuration options are controlled by an exported package global,
-spew.Config.  See ConfigState for options documentation.
-
-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
-get the formatted result as a string.
-*/
-func Dump(a ...interface{}) {
-	fdump(&Config, os.Stdout, a...)
-}
diff --git a/vendor/github.com/davecgh/go-spew/spew/format.go b/vendor/github.com/davecgh/go-spew/spew/format.go
deleted file mode 100644
index b04edb7..0000000
--- a/vendor/github.com/davecgh/go-spew/spew/format.go
+++ /dev/null
@@ -1,419 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-)
-
-// supportedFlags is a list of all the character flags supported by fmt package.
-const supportedFlags = "0-+# "
-
-// formatState implements the fmt.Formatter interface and contains information
-// about the state of a formatting operation.  The NewFormatter function can
-// be used to get a new Formatter which can be used directly as arguments
-// in standard fmt package printing calls.
-type formatState struct {
-	value          interface{}
-	fs             fmt.State
-	depth          int
-	pointers       map[uintptr]int
-	ignoreNextType bool
-	cs             *ConfigState
-}
-
-// buildDefaultFormat recreates the original format string without precision
-// and width information to pass in to fmt.Sprintf in the case of an
-// unrecognized type.  Unless new types are added to the language, this
-// function won't ever be called.
-func (f *formatState) buildDefaultFormat() (format string) {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range supportedFlags {
-		if f.fs.Flag(int(flag)) {
-			buf.WriteRune(flag)
-		}
-	}
-
-	buf.WriteRune('v')
-
-	format = buf.String()
-	return format
-}
-
-// constructOrigFormat recreates the original format string including precision
-// and width information to pass along to the standard fmt package.  This allows
-// automatic deferral of all format strings this package doesn't support.
-func (f *formatState) constructOrigFormat(verb rune) (format string) {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range supportedFlags {
-		if f.fs.Flag(int(flag)) {
-			buf.WriteRune(flag)
-		}
-	}
-
-	if width, ok := f.fs.Width(); ok {
-		buf.WriteString(strconv.Itoa(width))
-	}
-
-	if precision, ok := f.fs.Precision(); ok {
-		buf.Write(precisionBytes)
-		buf.WriteString(strconv.Itoa(precision))
-	}
-
-	buf.WriteRune(verb)
-
-	format = buf.String()
-	return format
-}
-
-// unpackValue returns values inside of non-nil interfaces when possible and
-// ensures that types for values which have been unpacked from an interface
-// are displayed when the show types flag is also set.
-// This is useful for data types like structs, arrays, slices, and maps which
-// can contain varying types packed inside an interface.
-func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Interface {
-		f.ignoreNextType = false
-		if !v.IsNil() {
-			v = v.Elem()
-		}
-	}
-	return v
-}
-
-// formatPtr handles formatting of pointers by indirecting them as necessary.
-func (f *formatState) formatPtr(v reflect.Value) {
-	// Display nil if top level pointer is nil.
-	showTypes := f.fs.Flag('#')
-	if v.IsNil() && (!showTypes || f.ignoreNextType) {
-		f.fs.Write(nilAngleBytes)
-		return
-	}
-
-	// Remove pointers at or below the current depth from map used to detect
-	// circular refs.
-	for k, depth := range f.pointers {
-		if depth >= f.depth {
-			delete(f.pointers, k)
-		}
-	}
-
-	// Keep list of all dereferenced pointers to possibly show later.
-	pointerChain := make([]uintptr, 0)
-
-	// Figure out how many levels of indirection there are by derferencing
-	// pointers and unpacking interfaces down the chain while detecting circular
-	// references.
-	nilFound := false
-	cycleFound := false
-	indirects := 0
-	ve := v
-	for ve.Kind() == reflect.Ptr {
-		if ve.IsNil() {
-			nilFound = true
-			break
-		}
-		indirects++
-		addr := ve.Pointer()
-		pointerChain = append(pointerChain, addr)
-		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
-			cycleFound = true
-			indirects--
-			break
-		}
-		f.pointers[addr] = f.depth
-
-		ve = ve.Elem()
-		if ve.Kind() == reflect.Interface {
-			if ve.IsNil() {
-				nilFound = true
-				break
-			}
-			ve = ve.Elem()
-		}
-	}
-
-	// Display type or indirection level depending on flags.
-	if showTypes && !f.ignoreNextType {
-		f.fs.Write(openParenBytes)
-		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
-		f.fs.Write([]byte(ve.Type().String()))
-		f.fs.Write(closeParenBytes)
-	} else {
-		if nilFound || cycleFound {
-			indirects += strings.Count(ve.Type().String(), "*")
-		}
-		f.fs.Write(openAngleBytes)
-		f.fs.Write([]byte(strings.Repeat("*", indirects)))
-		f.fs.Write(closeAngleBytes)
-	}
-
-	// Display pointer information depending on flags.
-	if f.fs.Flag('+') && (len(pointerChain) > 0) {
-		f.fs.Write(openParenBytes)
-		for i, addr := range pointerChain {
-			if i > 0 {
-				f.fs.Write(pointerChainBytes)
-			}
-			printHexPtr(f.fs, addr)
-		}
-		f.fs.Write(closeParenBytes)
-	}
-
-	// Display dereferenced value.
-	switch {
-	case nilFound:
-		f.fs.Write(nilAngleBytes)
-
-	case cycleFound:
-		f.fs.Write(circularShortBytes)
-
-	default:
-		f.ignoreNextType = true
-		f.format(ve)
-	}
-}
-
-// format is the main workhorse for providing the Formatter interface.  It
-// uses the passed reflect value to figure out what kind of object we are
-// dealing with and formats it appropriately.  It is a recursive function,
-// however circular data structures are detected and handled properly.
-func (f *formatState) format(v reflect.Value) {
-	// Handle invalid reflect values immediately.
-	kind := v.Kind()
-	if kind == reflect.Invalid {
-		f.fs.Write(invalidAngleBytes)
-		return
-	}
-
-	// Handle pointers specially.
-	if kind == reflect.Ptr {
-		f.formatPtr(v)
-		return
-	}
-
-	// Print type information unless already handled elsewhere.
-	if !f.ignoreNextType && f.fs.Flag('#') {
-		f.fs.Write(openParenBytes)
-		f.fs.Write([]byte(v.Type().String()))
-		f.fs.Write(closeParenBytes)
-	}
-	f.ignoreNextType = false
-
-	// Call Stringer/error interfaces if they exist and the handle methods
-	// flag is enabled.
-	if !f.cs.DisableMethods {
-		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
-			if handled := handleMethods(f.cs, f.fs, v); handled {
-				return
-			}
-		}
-	}
-
-	switch kind {
-	case reflect.Invalid:
-		// Do nothing.  We should never get here since invalid has already
-		// been handled above.
-
-	case reflect.Bool:
-		printBool(f.fs, v.Bool())
-
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		printInt(f.fs, v.Int(), 10)
-
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		printUint(f.fs, v.Uint(), 10)
-
-	case reflect.Float32:
-		printFloat(f.fs, v.Float(), 32)
-
-	case reflect.Float64:
-		printFloat(f.fs, v.Float(), 64)
-
-	case reflect.Complex64:
-		printComplex(f.fs, v.Complex(), 32)
-
-	case reflect.Complex128:
-		printComplex(f.fs, v.Complex(), 64)
-
-	case reflect.Slice:
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-			break
-		}
-		fallthrough
-
-	case reflect.Array:
-		f.fs.Write(openBracketBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			numEntries := v.Len()
-			for i := 0; i < numEntries; i++ {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				f.ignoreNextType = true
-				f.format(f.unpackValue(v.Index(i)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeBracketBytes)
-
-	case reflect.String:
-		f.fs.Write([]byte(v.String()))
-
-	case reflect.Interface:
-		// The only time we should get here is for nil interfaces due to
-		// unpackValue calls.
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-		}
-
-	case reflect.Ptr:
-		// Do nothing.  We should never get here since pointers have already
-		// been handled above.
-
-	case reflect.Map:
-		// nil maps should be indicated as different than empty maps
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-			break
-		}
-
-		f.fs.Write(openMapBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			keys := v.MapKeys()
-			if f.cs.SortKeys {
-				sortValues(keys, f.cs)
-			}
-			for i, key := range keys {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				f.ignoreNextType = true
-				f.format(f.unpackValue(key))
-				f.fs.Write(colonBytes)
-				f.ignoreNextType = true
-				f.format(f.unpackValue(v.MapIndex(key)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeMapBytes)
-
-	case reflect.Struct:
-		numFields := v.NumField()
-		f.fs.Write(openBraceBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			vt := v.Type()
-			for i := 0; i < numFields; i++ {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				vtf := vt.Field(i)
-				if f.fs.Flag('+') || f.fs.Flag('#') {
-					f.fs.Write([]byte(vtf.Name))
-					f.fs.Write(colonBytes)
-				}
-				f.format(f.unpackValue(v.Field(i)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeBraceBytes)
-
-	case reflect.Uintptr:
-		printHexPtr(f.fs, uintptr(v.Uint()))
-
-	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
-		printHexPtr(f.fs, v.Pointer())
-
-	// There were not any other types at the time this code was written, but
-	// fall back to letting the default fmt package handle it if any get added.
-	default:
-		format := f.buildDefaultFormat()
-		if v.CanInterface() {
-			fmt.Fprintf(f.fs, format, v.Interface())
-		} else {
-			fmt.Fprintf(f.fs, format, v.String())
-		}
-	}
-}
-
-// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
-// details.
-func (f *formatState) Format(fs fmt.State, verb rune) {
-	f.fs = fs
-
-	// Use standard formatting for verbs that are not v.
-	if verb != 'v' {
-		format := f.constructOrigFormat(verb)
-		fmt.Fprintf(fs, format, f.value)
-		return
-	}
-
-	if f.value == nil {
-		if fs.Flag('#') {
-			fs.Write(interfaceBytes)
-		}
-		fs.Write(nilAngleBytes)
-		return
-	}
-
-	f.format(reflect.ValueOf(f.value))
-}
-
-// newFormatter is a helper function to consolidate the logic from the various
-// public methods which take varying config states.
-func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
-	fs := &formatState{value: v, cs: cs}
-	fs.pointers = make(map[uintptr]int)
-	return fs
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface.  As a result, it integrates cleanly with standard fmt package
-printing functions.  The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly.  It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-Printf, Println, or Fprintf.
-*/
-func NewFormatter(v interface{}) fmt.Formatter {
-	return newFormatter(&Config, v)
-}
diff --git a/vendor/github.com/davecgh/go-spew/spew/spew.go b/vendor/github.com/davecgh/go-spew/spew/spew.go
deleted file mode 100644
index 32c0e33..0000000
--- a/vendor/github.com/davecgh/go-spew/spew/spew.go
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"fmt"
-	"io"
-)
-
-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the formatted string as a value that satisfies error.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Errorf(format string, a ...interface{}) (err error) {
-	return fmt.Errorf(format, convertArgs(a)...)
-}
-
-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprint(w, convertArgs(a)...)
-}
-
-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	return fmt.Fprintf(w, format, convertArgs(a)...)
-}
-
-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
-// passed with a default Formatter interface returned by NewFormatter.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprintln(w, convertArgs(a)...)
-}
-
-// Print is a wrapper for fmt.Print that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
-func Print(a ...interface{}) (n int, err error) {
-	return fmt.Print(convertArgs(a)...)
-}
-
-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Printf(format string, a ...interface{}) (n int, err error) {
-	return fmt.Printf(format, convertArgs(a)...)
-}
-
-// Println is a wrapper for fmt.Println that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
-func Println(a ...interface{}) (n int, err error) {
-	return fmt.Println(convertArgs(a)...)
-}
-
-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprint(a ...interface{}) string {
-	return fmt.Sprint(convertArgs(a)...)
-}
-
-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprintf(format string, a ...interface{}) string {
-	return fmt.Sprintf(format, convertArgs(a)...)
-}
-
-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
-// were passed with a default Formatter interface returned by NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprintln(a ...interface{}) string {
-	return fmt.Sprintln(convertArgs(a)...)
-}
-
-// convertArgs accepts a slice of arguments and returns a slice of the same
-// length with each argument converted to a default spew Formatter interface.
-func convertArgs(args []interface{}) (formatters []interface{}) {
-	formatters = make([]interface{}, len(args))
-	for index, arg := range args {
-		formatters[index] = NewFormatter(arg)
-	}
-	return formatters
-}
diff --git a/vendor/github.com/docopt/docopt-go/.gitignore b/vendor/github.com/docopt/docopt-go/.gitignore
deleted file mode 100644
index 49ad16c..0000000
--- a/vendor/github.com/docopt/docopt-go/.gitignore
+++ /dev/null
@@ -1,25 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-
-# coverage droppings
-profile.cov
diff --git a/vendor/github.com/docopt/docopt-go/.travis.yml b/vendor/github.com/docopt/docopt-go/.travis.yml
deleted file mode 100644
index 4778a92..0000000
--- a/vendor/github.com/docopt/docopt-go/.travis.yml
+++ /dev/null
@@ -1,30 +0,0 @@
-# Travis CI (http://travis-ci.org/) is a continuous integration
-# service for open source projects. This file configures it
-# to run unit tests for docopt-go.
-
-language: go
-
-go:
-    - 1.2
-    - 1.3
-
-matrix:
-    fast_finish: true
-
-before_install:
-    - go get code.google.com/p/go.tools/cmd/vet
-    - go get code.google.com/p/go.tools/cmd/cover
-    - go get github.com/golang/lint/golint
-    - go get github.com/mattn/goveralls
-
-install:
-    - go get -d -v ./... && go build -v ./...
-
-script:
-    - go vet -x ./...
-    - $HOME/gopath/bin/golint ./...
-    - go test -v ./...
-    - go test -covermode=count -coverprofile=profile.cov .
-
-after_script:
-    - $HOME/gopath/bin/goveralls -coverprofile=profile.cov -service=travis-ci
diff --git a/vendor/github.com/docopt/docopt-go/LICENSE b/vendor/github.com/docopt/docopt-go/LICENSE
deleted file mode 100644
index 8841af1..0000000
--- a/vendor/github.com/docopt/docopt-go/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013 Keith Batten
-
-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.
diff --git a/vendor/github.com/docopt/docopt-go/README.md b/vendor/github.com/docopt/docopt-go/README.md
deleted file mode 100644
index 71c92aa..0000000
--- a/vendor/github.com/docopt/docopt-go/README.md
+++ /dev/null
@@ -1,88 +0,0 @@
-docopt-go
-=========
-
-[![Build Status](https://travis-ci.org/docopt/docopt.go.svg?branch=master)](https://travis-ci.org/docopt/docopt.go)
-[![Coverage Status](https://coveralls.io/repos/docopt/docopt.go/badge.png)](https://coveralls.io/r/docopt/docopt.go)
-[![GoDoc](https://godoc.org/github.com/docopt/docopt.go?status.png)](https://godoc.org/github.com/docopt/docopt.go)
-
-An implementation of [docopt](http://docopt.org/) in the
-[Go](http://golang.org/) programming language.
-
-**docopt** helps you create *beautiful* command-line interfaces easily:
-
-```go
-package main
-
-import (
-	"fmt"
-	"github.com/docopt/docopt-go"
-)
-
-func main() {
-	  usage := `Naval Fate.
-
-Usage:
-  naval_fate ship new <name>...
-  naval_fate ship <name> move <x> <y> [--speed=<kn>]
-  naval_fate ship shoot <x> <y>
-  naval_fate mine (set|remove) <x> <y> [--moored|--drifting]
-  naval_fate -h | --help
-  naval_fate --version
-
-Options:
-  -h --help     Show this screen.
-  --version     Show version.
-  --speed=<kn>  Speed in knots [default: 10].
-  --moored      Moored (anchored) mine.
-  --drifting    Drifting mine.`
-
-	  arguments, _ := docopt.Parse(usage, nil, true, "Naval Fate 2.0", false)
-	  fmt.Println(arguments)
-}
-```
-
-**docopt** parses command-line arguments based on a help message. Don't
-write parser code: a good help message already has all the necessary
-information in it.
-
-## Installation
-
-⚠ Use the alias “docopt-go”. To use docopt in your Go code:
-
-```go
-import "github.com/docopt/docopt-go"
-```
-
-To install docopt according to your `$GOPATH`:
-
-```console
-$ go get github.com/docopt/docopt-go
-```
-
-## API
-
-```go
-func Parse(doc string, argv []string, help bool, version string,
-    optionsFirst bool, exit ...bool) (map[string]interface{}, error)
-```
-Parse `argv` based on the command-line interface described in `doc`.
-
-Given a conventional command-line help message, docopt creates a parser and
-processes the arguments. See
-https://github.com/docopt/docopt#help-message-format for a description of the
-help message format. If `argv` is `nil`, `os.Args[1:]` is used.
-
-docopt returns a map of option names to the values parsed from `argv`, and an
-error or `nil`.
-
-More documentation for docopt is available at
-[GoDoc.org](https://godoc.org/github.com/docopt/docopt.go).
-
-## Testing
-
-All tests from the Python version are implemented and passing
-at [Travis CI](https://travis-ci.org/docopt/docopt.go). New
-language-agnostic tests have been added
-to [test_golang.docopt](test_golang.docopt).
-
-To run tests for docopt-go, use `go test`.
diff --git a/vendor/github.com/docopt/docopt-go/docopt.go b/vendor/github.com/docopt/docopt-go/docopt.go
deleted file mode 100644
index add84a2..0000000
--- a/vendor/github.com/docopt/docopt-go/docopt.go
+++ /dev/null
@@ -1,1239 +0,0 @@
-// Licensed under terms of MIT license (see LICENSE-MIT)
-// Copyright (c) 2013 Keith Batten, kbatten@gmail.com
-
-/*
-Package docopt parses command-line arguments based on a help message.
-
-⚠ Use the alias “docopt-go”:
-	import "github.com/docopt/docopt-go"
-or
-	$ go get github.com/docopt/docopt-go
-*/
-package docopt
-
-import (
-	"fmt"
-	"os"
-	"reflect"
-	"regexp"
-	"strings"
-	"unicode"
-)
-
-/*
-Parse `argv` based on the command-line interface described in `doc`.
-
-Given a conventional command-line help message, docopt creates a parser and
-processes the arguments. See
-https://github.com/docopt/docopt#help-message-format for a description of the
-help message format. If `argv` is `nil`, `os.Args[1:]` is used.
-
-docopt returns a map of option names to the values parsed from `argv`, and an
-error or `nil`.
-
-Set `help` to `false` to disable automatic help messages on `-h` or `--help`.
-If `version` is a non-empty string, it will be printed when `--version` is
-specified. Set `optionsFirst` to `true` to require that options always come
-before positional arguments; otherwise they can overlap.
-
-By default, docopt calls `os.Exit(0)` if it handled a built-in option such as
-`-h` or `--version`. If the user errored with a wrong command or options,
-docopt exits with a return code of 1. To stop docopt from calling `os.Exit()`
-and to handle your own return codes, pass an optional last parameter of `false`
-for `exit`.
-*/
-func Parse(doc string, argv []string, help bool, version string,
-	optionsFirst bool, exit ...bool) (map[string]interface{}, error) {
-	// if "false" was the (optional) last arg, don't call os.Exit()
-	exitOk := true
-	if len(exit) > 0 {
-		exitOk = exit[0]
-	}
-	args, output, err := parse(doc, argv, help, version, optionsFirst)
-	if _, ok := err.(*UserError); ok {
-		// the user gave us bad input
-		fmt.Println(output)
-		if exitOk {
-			os.Exit(1)
-		}
-	} else if len(output) > 0 && err == nil {
-		// the user asked for help or `--version`
-		fmt.Println(output)
-		if exitOk {
-			os.Exit(0)
-		}
-	}
-	return args, err
-}
-
-// parse and return a map of args, output and all errors
-func parse(doc string, argv []string, help bool, version string, optionsFirst bool) (args map[string]interface{}, output string, err error) {
-	if argv == nil && len(os.Args) > 1 {
-		argv = os.Args[1:]
-	}
-
-	usageSections := parseSection("usage:", doc)
-
-	if len(usageSections) == 0 {
-		err = newLanguageError("\"usage:\" (case-insensitive) not found.")
-		return
-	}
-	if len(usageSections) > 1 {
-		err = newLanguageError("More than one \"usage:\" (case-insensitive).")
-		return
-	}
-	usage := usageSections[0]
-
-	options := parseDefaults(doc)
-	formal, err := formalUsage(usage)
-	if err != nil {
-		output = handleError(err, usage)
-		return
-	}
-
-	pat, err := parsePattern(formal, &options)
-	if err != nil {
-		output = handleError(err, usage)
-		return
-	}
-
-	patternArgv, err := parseArgv(newTokenList(argv, errorUser), &options, optionsFirst)
-	if err != nil {
-		output = handleError(err, usage)
-		return
-	}
-	patFlat, err := pat.flat(patternOption)
-	if err != nil {
-		output = handleError(err, usage)
-		return
-	}
-	patternOptions := patFlat.unique()
-
-	patFlat, err = pat.flat(patternOptionSSHORTCUT)
-	if err != nil {
-		output = handleError(err, usage)
-		return
-	}
-	for _, optionsShortcut := range patFlat {
-		docOptions := parseDefaults(doc)
-		optionsShortcut.children = docOptions.unique().diff(patternOptions)
-	}
-
-	if output = extras(help, version, patternArgv, doc); len(output) > 0 {
-		return
-	}
-
-	err = pat.fix()
-	if err != nil {
-		output = handleError(err, usage)
-		return
-	}
-	matched, left, collected := pat.match(&patternArgv, nil)
-	if matched && len(*left) == 0 {
-		patFlat, err = pat.flat(patternDefault)
-		if err != nil {
-			output = handleError(err, usage)
-			return
-		}
-		args = append(patFlat, *collected...).dictionary()
-		return
-	}
-
-	err = newUserError("")
-	output = handleError(err, usage)
-	return
-}
-
-func handleError(err error, usage string) string {
-	if _, ok := err.(*UserError); ok {
-		return strings.TrimSpace(fmt.Sprintf("%s\n%s", err, usage))
-	}
-	return ""
-}
-
-func parseSection(name, source string) []string {
-	p := regexp.MustCompile(`(?im)^([^\n]*` + name + `[^\n]*\n?(?:[ \t].*?(?:\n|$))*)`)
-	s := p.FindAllString(source, -1)
-	if s == nil {
-		s = []string{}
-	}
-	for i, v := range s {
-		s[i] = strings.TrimSpace(v)
-	}
-	return s
-}
-
-func parseDefaults(doc string) patternList {
-	defaults := patternList{}
-	p := regexp.MustCompile(`\n[ \t]*(-\S+?)`)
-	for _, s := range parseSection("options:", doc) {
-		// FIXME corner case "bla: options: --foo"
-		_, _, s = stringPartition(s, ":") // get rid of "options:"
-		split := p.Split("\n"+s, -1)[1:]
-		match := p.FindAllStringSubmatch("\n"+s, -1)
-		for i := range split {
-			optionDescription := match[i][1] + split[i]
-			if strings.HasPrefix(optionDescription, "-") {
-				defaults = append(defaults, parseOption(optionDescription))
-			}
-		}
-	}
-	return defaults
-}
-
-func parsePattern(source string, options *patternList) (*pattern, error) {
-	tokens := tokenListFromPattern(source)
-	result, err := parseExpr(tokens, options)
-	if err != nil {
-		return nil, err
-	}
-	if tokens.current() != nil {
-		return nil, tokens.errorFunc("unexpected ending: %s" + strings.Join(tokens.tokens, " "))
-	}
-	return newRequired(result...), nil
-}
-
-func parseArgv(tokens *tokenList, options *patternList, optionsFirst bool) (patternList, error) {
-	/*
-		Parse command-line argument vector.
-
-		If options_first:
-			argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ;
-		else:
-			argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ;
-	*/
-	parsed := patternList{}
-	for tokens.current() != nil {
-		if tokens.current().eq("--") {
-			for _, v := range tokens.tokens {
-				parsed = append(parsed, newArgument("", v))
-			}
-			return parsed, nil
-		} else if tokens.current().hasPrefix("--") {
-			pl, err := parseLong(tokens, options)
-			if err != nil {
-				return nil, err
-			}
-			parsed = append(parsed, pl...)
-		} else if tokens.current().hasPrefix("-") && !tokens.current().eq("-") {
-			ps, err := parseShorts(tokens, options)
-			if err != nil {
-				return nil, err
-			}
-			parsed = append(parsed, ps...)
-		} else if optionsFirst {
-			for _, v := range tokens.tokens {
-				parsed = append(parsed, newArgument("", v))
-			}
-			return parsed, nil
-		} else {
-			parsed = append(parsed, newArgument("", tokens.move().String()))
-		}
-	}
-	return parsed, nil
-}
-
-func parseOption(optionDescription string) *pattern {
-	optionDescription = strings.TrimSpace(optionDescription)
-	options, _, description := stringPartition(optionDescription, "  ")
-	options = strings.Replace(options, ",", " ", -1)
-	options = strings.Replace(options, "=", " ", -1)
-
-	short := ""
-	long := ""
-	argcount := 0
-	var value interface{}
-	value = false
-
-	reDefault := regexp.MustCompile(`(?i)\[default: (.*)\]`)
-	for _, s := range strings.Fields(options) {
-		if strings.HasPrefix(s, "--") {
-			long = s
-		} else if strings.HasPrefix(s, "-") {
-			short = s
-		} else {
-			argcount = 1
-		}
-		if argcount > 0 {
-			matched := reDefault.FindAllStringSubmatch(description, -1)
-			if len(matched) > 0 {
-				value = matched[0][1]
-			} else {
-				value = nil
-			}
-		}
-	}
-	return newOption(short, long, argcount, value)
-}
-
-func parseExpr(tokens *tokenList, options *patternList) (patternList, error) {
-	// expr ::= seq ( '|' seq )* ;
-	seq, err := parseSeq(tokens, options)
-	if err != nil {
-		return nil, err
-	}
-	if !tokens.current().eq("|") {
-		return seq, nil
-	}
-	var result patternList
-	if len(seq) > 1 {
-		result = patternList{newRequired(seq...)}
-	} else {
-		result = seq
-	}
-	for tokens.current().eq("|") {
-		tokens.move()
-		seq, err = parseSeq(tokens, options)
-		if err != nil {
-			return nil, err
-		}
-		if len(seq) > 1 {
-			result = append(result, newRequired(seq...))
-		} else {
-			result = append(result, seq...)
-		}
-	}
-	if len(result) > 1 {
-		return patternList{newEither(result...)}, nil
-	}
-	return result, nil
-}
-
-func parseSeq(tokens *tokenList, options *patternList) (patternList, error) {
-	// seq ::= ( atom [ '...' ] )* ;
-	result := patternList{}
-	for !tokens.current().match(true, "]", ")", "|") {
-		atom, err := parseAtom(tokens, options)
-		if err != nil {
-			return nil, err
-		}
-		if tokens.current().eq("...") {
-			atom = patternList{newOneOrMore(atom...)}
-			tokens.move()
-		}
-		result = append(result, atom...)
-	}
-	return result, nil
-}
-
-func parseAtom(tokens *tokenList, options *patternList) (patternList, error) {
-	// atom ::= '(' expr ')' | '[' expr ']' | 'options' | long | shorts | argument | command ;
-	tok := tokens.current()
-	result := patternList{}
-	if tokens.current().match(false, "(", "[") {
-		tokens.move()
-		var matching string
-		pl, err := parseExpr(tokens, options)
-		if err != nil {
-			return nil, err
-		}
-		if tok.eq("(") {
-			matching = ")"
-			result = patternList{newRequired(pl...)}
-		} else if tok.eq("[") {
-			matching = "]"
-			result = patternList{newOptional(pl...)}
-		}
-		moved := tokens.move()
-		if !moved.eq(matching) {
-			return nil, tokens.errorFunc("unmatched '%s', expected: '%s' got: '%s'", tok, matching, moved)
-		}
-		return result, nil
-	} else if tok.eq("options") {
-		tokens.move()
-		return patternList{newOptionsShortcut()}, nil
-	} else if tok.hasPrefix("--") && !tok.eq("--") {
-		return parseLong(tokens, options)
-	} else if tok.hasPrefix("-") && !tok.eq("-") && !tok.eq("--") {
-		return parseShorts(tokens, options)
-	} else if tok.hasPrefix("<") && tok.hasSuffix(">") || tok.isUpper() {
-		return patternList{newArgument(tokens.move().String(), nil)}, nil
-	}
-	return patternList{newCommand(tokens.move().String(), false)}, nil
-}
-
-func parseLong(tokens *tokenList, options *patternList) (patternList, error) {
-	// long ::= '--' chars [ ( ' ' | '=' ) chars ] ;
-	long, eq, v := stringPartition(tokens.move().String(), "=")
-	var value interface{}
-	var opt *pattern
-	if eq == "" && v == "" {
-		value = nil
-	} else {
-		value = v
-	}
-
-	if !strings.HasPrefix(long, "--") {
-		return nil, newError("long option '%s' doesn't start with --", long)
-	}
-	similar := patternList{}
-	for _, o := range *options {
-		if o.long == long {
-			similar = append(similar, o)
-		}
-	}
-	if tokens.err == errorUser && len(similar) == 0 { // if no exact match
-		similar = patternList{}
-		for _, o := range *options {
-			if strings.HasPrefix(o.long, long) {
-				similar = append(similar, o)
-			}
-		}
-	}
-	if len(similar) > 1 { // might be simply specified ambiguously 2+ times?
-		similarLong := make([]string, len(similar))
-		for i, s := range similar {
-			similarLong[i] = s.long
-		}
-		return nil, tokens.errorFunc("%s is not a unique prefix: %s?", long, strings.Join(similarLong, ", "))
-	} else if len(similar) < 1 {
-		argcount := 0
-		if eq == "=" {
-			argcount = 1
-		}
-		opt = newOption("", long, argcount, false)
-		*options = append(*options, opt)
-		if tokens.err == errorUser {
-			var val interface{}
-			if argcount > 0 {
-				val = value
-			} else {
-				val = true
-			}
-			opt = newOption("", long, argcount, val)
-		}
-	} else {
-		opt = newOption(similar[0].short, similar[0].long, similar[0].argcount, similar[0].value)
-		if opt.argcount == 0 {
-			if value != nil {
-				return nil, tokens.errorFunc("%s must not have an argument", opt.long)
-			}
-		} else {
-			if value == nil {
-				if tokens.current().match(true, "--") {
-					return nil, tokens.errorFunc("%s requires argument", opt.long)
-				}
-				moved := tokens.move()
-				if moved != nil {
-					value = moved.String() // only set as string if not nil
-				}
-			}
-		}
-		if tokens.err == errorUser {
-			if value != nil {
-				opt.value = value
-			} else {
-				opt.value = true
-			}
-		}
-	}
-
-	return patternList{opt}, nil
-}
-
-func parseShorts(tokens *tokenList, options *patternList) (patternList, error) {
-	// shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;
-	tok := tokens.move()
-	if !tok.hasPrefix("-") || tok.hasPrefix("--") {
-		return nil, newError("short option '%s' doesn't start with -", tok)
-	}
-	left := strings.TrimLeft(tok.String(), "-")
-	parsed := patternList{}
-	for left != "" {
-		var opt *pattern
-		short := "-" + left[0:1]
-		left = left[1:]
-		similar := patternList{}
-		for _, o := range *options {
-			if o.short == short {
-				similar = append(similar, o)
-			}
-		}
-		if len(similar) > 1 {
-			return nil, tokens.errorFunc("%s is specified ambiguously %d times", short, len(similar))
-		} else if len(similar) < 1 {
-			opt = newOption(short, "", 0, false)
-			*options = append(*options, opt)
-			if tokens.err == errorUser {
-				opt = newOption(short, "", 0, true)
-			}
-		} else { // why copying is necessary here?
-			opt = newOption(short, similar[0].long, similar[0].argcount, similar[0].value)
-			var value interface{}
-			if opt.argcount > 0 {
-				if left == "" {
-					if tokens.current().match(true, "--") {
-						return nil, tokens.errorFunc("%s requires argument", short)
-					}
-					value = tokens.move().String()
-				} else {
-					value = left
-					left = ""
-				}
-			}
-			if tokens.err == errorUser {
-				if value != nil {
-					opt.value = value
-				} else {
-					opt.value = true
-				}
-			}
-		}
-		parsed = append(parsed, opt)
-	}
-	return parsed, nil
-}
-
-func newTokenList(source []string, err errorType) *tokenList {
-	errorFunc := newError
-	if err == errorUser {
-		errorFunc = newUserError
-	} else if err == errorLanguage {
-		errorFunc = newLanguageError
-	}
-	return &tokenList{source, errorFunc, err}
-}
-
-func tokenListFromString(source string) *tokenList {
-	return newTokenList(strings.Fields(source), errorUser)
-}
-
-func tokenListFromPattern(source string) *tokenList {
-	p := regexp.MustCompile(`([\[\]\(\)\|]|\.\.\.)`)
-	source = p.ReplaceAllString(source, ` $1 `)
-	p = regexp.MustCompile(`\s+|(\S*<.*?>)`)
-	split := p.Split(source, -1)
-	match := p.FindAllStringSubmatch(source, -1)
-	var result []string
-	l := len(split)
-	for i := 0; i < l; i++ {
-		if len(split[i]) > 0 {
-			result = append(result, split[i])
-		}
-		if i < l-1 && len(match[i][1]) > 0 {
-			result = append(result, match[i][1])
-		}
-	}
-	return newTokenList(result, errorLanguage)
-}
-
-func formalUsage(section string) (string, error) {
-	_, _, section = stringPartition(section, ":") // drop "usage:"
-	pu := strings.Fields(section)
-
-	if len(pu) == 0 {
-		return "", newLanguageError("no fields found in usage (perhaps a spacing error).")
-	}
-
-	result := "( "
-	for _, s := range pu[1:] {
-		if s == pu[0] {
-			result += ") | ( "
-		} else {
-			result += s + " "
-		}
-	}
-	result += ")"
-
-	return result, nil
-}
-
-func extras(help bool, version string, options patternList, doc string) string {
-	if help {
-		for _, o := range options {
-			if (o.name == "-h" || o.name == "--help") && o.value == true {
-				return strings.Trim(doc, "\n")
-			}
-		}
-	}
-	if version != "" {
-		for _, o := range options {
-			if (o.name == "--version") && o.value == true {
-				return version
-			}
-		}
-	}
-	return ""
-}
-
-type errorType int
-
-const (
-	errorUser errorType = iota
-	errorLanguage
-)
-
-func (e errorType) String() string {
-	switch e {
-	case errorUser:
-		return "errorUser"
-	case errorLanguage:
-		return "errorLanguage"
-	}
-	return ""
-}
-
-// UserError records an error with program arguments.
-type UserError struct {
-	msg   string
-	Usage string
-}
-
-func (e UserError) Error() string {
-	return e.msg
-}
-func newUserError(msg string, f ...interface{}) error {
-	return &UserError{fmt.Sprintf(msg, f...), ""}
-}
-
-// LanguageError records an error with the doc string.
-type LanguageError struct {
-	msg string
-}
-
-func (e LanguageError) Error() string {
-	return e.msg
-}
-func newLanguageError(msg string, f ...interface{}) error {
-	return &LanguageError{fmt.Sprintf(msg, f...)}
-}
-
-var newError = fmt.Errorf
-
-type tokenList struct {
-	tokens    []string
-	errorFunc func(string, ...interface{}) error
-	err       errorType
-}
-type token string
-
-func (t *token) eq(s string) bool {
-	if t == nil {
-		return false
-	}
-	return string(*t) == s
-}
-func (t *token) match(matchNil bool, tokenStrings ...string) bool {
-	if t == nil && matchNil {
-		return true
-	} else if t == nil && !matchNil {
-		return false
-	}
-
-	for _, tok := range tokenStrings {
-		if tok == string(*t) {
-			return true
-		}
-	}
-	return false
-}
-func (t *token) hasPrefix(prefix string) bool {
-	if t == nil {
-		return false
-	}
-	return strings.HasPrefix(string(*t), prefix)
-}
-func (t *token) hasSuffix(suffix string) bool {
-	if t == nil {
-		return false
-	}
-	return strings.HasSuffix(string(*t), suffix)
-}
-func (t *token) isUpper() bool {
-	if t == nil {
-		return false
-	}
-	return isStringUppercase(string(*t))
-}
-func (t *token) String() string {
-	if t == nil {
-		return ""
-	}
-	return string(*t)
-}
-
-func (tl *tokenList) current() *token {
-	if len(tl.tokens) > 0 {
-		return (*token)(&(tl.tokens[0]))
-	}
-	return nil
-}
-
-func (tl *tokenList) length() int {
-	return len(tl.tokens)
-}
-
-func (tl *tokenList) move() *token {
-	if len(tl.tokens) > 0 {
-		t := tl.tokens[0]
-		tl.tokens = tl.tokens[1:]
-		return (*token)(&t)
-	}
-	return nil
-}
-
-type patternType uint
-
-const (
-	// leaf
-	patternArgument patternType = 1 << iota
-	patternCommand
-	patternOption
-
-	// branch
-	patternRequired
-	patternOptionAL
-	patternOptionSSHORTCUT // Marker/placeholder for [options] shortcut.
-	patternOneOrMore
-	patternEither
-
-	patternLeaf = patternArgument +
-		patternCommand +
-		patternOption
-	patternBranch = patternRequired +
-		patternOptionAL +
-		patternOptionSSHORTCUT +
-		patternOneOrMore +
-		patternEither
-	patternAll     = patternLeaf + patternBranch
-	patternDefault = 0
-)
-
-func (pt patternType) String() string {
-	switch pt {
-	case patternArgument:
-		return "argument"
-	case patternCommand:
-		return "command"
-	case patternOption:
-		return "option"
-	case patternRequired:
-		return "required"
-	case patternOptionAL:
-		return "optional"
-	case patternOptionSSHORTCUT:
-		return "optionsshortcut"
-	case patternOneOrMore:
-		return "oneormore"
-	case patternEither:
-		return "either"
-	case patternLeaf:
-		return "leaf"
-	case patternBranch:
-		return "branch"
-	case patternAll:
-		return "all"
-	case patternDefault:
-		return "default"
-	}
-	return ""
-}
-
-type pattern struct {
-	t patternType
-
-	children patternList
-
-	name  string
-	value interface{}
-
-	short    string
-	long     string
-	argcount int
-}
-
-type patternList []*pattern
-
-func newBranchPattern(t patternType, pl ...*pattern) *pattern {
-	var p pattern
-	p.t = t
-	p.children = make(patternList, len(pl))
-	copy(p.children, pl)
-	return &p
-}
-
-func newRequired(pl ...*pattern) *pattern {
-	return newBranchPattern(patternRequired, pl...)
-}
-
-func newEither(pl ...*pattern) *pattern {
-	return newBranchPattern(patternEither, pl...)
-}
-
-func newOneOrMore(pl ...*pattern) *pattern {
-	return newBranchPattern(patternOneOrMore, pl...)
-}
-
-func newOptional(pl ...*pattern) *pattern {
-	return newBranchPattern(patternOptionAL, pl...)
-}
-
-func newOptionsShortcut() *pattern {
-	var p pattern
-	p.t = patternOptionSSHORTCUT
-	return &p
-}
-
-func newLeafPattern(t patternType, name string, value interface{}) *pattern {
-	// default: value=nil
-	var p pattern
-	p.t = t
-	p.name = name
-	p.value = value
-	return &p
-}
-
-func newArgument(name string, value interface{}) *pattern {
-	// default: value=nil
-	return newLeafPattern(patternArgument, name, value)
-}
-
-func newCommand(name string, value interface{}) *pattern {
-	// default: value=false
-	var p pattern
-	p.t = patternCommand
-	p.name = name
-	p.value = value
-	return &p
-}
-
-func newOption(short, long string, argcount int, value interface{}) *pattern {
-	// default: "", "", 0, false
-	var p pattern
-	p.t = patternOption
-	p.short = short
-	p.long = long
-	if long != "" {
-		p.name = long
-	} else {
-		p.name = short
-	}
-	p.argcount = argcount
-	if value == false && argcount > 0 {
-		p.value = nil
-	} else {
-		p.value = value
-	}
-	return &p
-}
-
-func (p *pattern) flat(types patternType) (patternList, error) {
-	if p.t&patternLeaf != 0 {
-		if types == patternDefault {
-			types = patternAll
-		}
-		if p.t&types != 0 {
-			return patternList{p}, nil
-		}
-		return patternList{}, nil
-	}
-
-	if p.t&patternBranch != 0 {
-		if p.t&types != 0 {
-			return patternList{p}, nil
-		}
-		result := patternList{}
-		for _, child := range p.children {
-			childFlat, err := child.flat(types)
-			if err != nil {
-				return nil, err
-			}
-			result = append(result, childFlat...)
-		}
-		return result, nil
-	}
-	return nil, newError("unknown pattern type: %d, %d", p.t, types)
-}
-
-func (p *pattern) fix() error {
-	err := p.fixIdentities(nil)
-	if err != nil {
-		return err
-	}
-	p.fixRepeatingArguments()
-	return nil
-}
-
-func (p *pattern) fixIdentities(uniq patternList) error {
-	// Make pattern-tree tips point to same object if they are equal.
-	if p.t&patternBranch == 0 {
-		return nil
-	}
-	if uniq == nil {
-		pFlat, err := p.flat(patternDefault)
-		if err != nil {
-			return err
-		}
-		uniq = pFlat.unique()
-	}
-	for i, child := range p.children {
-		if child.t&patternBranch == 0 {
-			ind, err := uniq.index(child)
-			if err != nil {
-				return err
-			}
-			p.children[i] = uniq[ind]
-		} else {
-			err := child.fixIdentities(uniq)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func (p *pattern) fixRepeatingArguments() {
-	// Fix elements that should accumulate/increment values.
-	var either []patternList
-
-	for _, child := range p.transform().children {
-		either = append(either, child.children)
-	}
-	for _, cas := range either {
-		casMultiple := patternList{}
-		for _, e := range cas {
-			if cas.count(e) > 1 {
-				casMultiple = append(casMultiple, e)
-			}
-		}
-		for _, e := range casMultiple {
-			if e.t == patternArgument || e.t == patternOption && e.argcount > 0 {
-				switch e.value.(type) {
-				case string:
-					e.value = strings.Fields(e.value.(string))
-				case []string:
-				default:
-					e.value = []string{}
-				}
-			}
-			if e.t == patternCommand || e.t == patternOption && e.argcount == 0 {
-				e.value = 0
-			}
-		}
-	}
-}
-
-func (p *pattern) match(left *patternList, collected *patternList) (bool, *patternList, *patternList) {
-	if collected == nil {
-		collected = &patternList{}
-	}
-	if p.t&patternRequired != 0 {
-		l := left
-		c := collected
-		for _, p := range p.children {
-			var matched bool
-			matched, l, c = p.match(l, c)
-			if !matched {
-				return false, left, collected
-			}
-		}
-		return true, l, c
-	} else if p.t&patternOptionAL != 0 || p.t&patternOptionSSHORTCUT != 0 {
-		for _, p := range p.children {
-			_, left, collected = p.match(left, collected)
-		}
-		return true, left, collected
-	} else if p.t&patternOneOrMore != 0 {
-		if len(p.children) != 1 {
-			panic("OneOrMore.match(): assert len(p.children) == 1")
-		}
-		l := left
-		c := collected
-		var lAlt *patternList
-		matched := true
-		times := 0
-		for matched {
-			// could it be that something didn't match but changed l or c?
-			matched, l, c = p.children[0].match(l, c)
-			if matched {
-				times++
-			}
-			if lAlt == l {
-				break
-			}
-			lAlt = l
-		}
-		if times >= 1 {
-			return true, l, c
-		}
-		return false, left, collected
-	} else if p.t&patternEither != 0 {
-		type outcomeStruct struct {
-			matched   bool
-			left      *patternList
-			collected *patternList
-			length    int
-		}
-		outcomes := []outcomeStruct{}
-		for _, p := range p.children {
-			matched, l, c := p.match(left, collected)
-			outcome := outcomeStruct{matched, l, c, len(*l)}
-			if matched {
-				outcomes = append(outcomes, outcome)
-			}
-		}
-		if len(outcomes) > 0 {
-			minLen := outcomes[0].length
-			minIndex := 0
-			for i, v := range outcomes {
-				if v.length < minLen {
-					minIndex = i
-				}
-			}
-			return outcomes[minIndex].matched, outcomes[minIndex].left, outcomes[minIndex].collected
-		}
-		return false, left, collected
-	} else if p.t&patternLeaf != 0 {
-		pos, match := p.singleMatch(left)
-		var increment interface{}
-		if match == nil {
-			return false, left, collected
-		}
-		leftAlt := make(patternList, len((*left)[:pos]), len((*left)[:pos])+len((*left)[pos+1:]))
-		copy(leftAlt, (*left)[:pos])
-		leftAlt = append(leftAlt, (*left)[pos+1:]...)
-		sameName := patternList{}
-		for _, a := range *collected {
-			if a.name == p.name {
-				sameName = append(sameName, a)
-			}
-		}
-
-		switch p.value.(type) {
-		case int, []string:
-			switch p.value.(type) {
-			case int:
-				increment = 1
-			case []string:
-				switch match.value.(type) {
-				case string:
-					increment = []string{match.value.(string)}
-				default:
-					increment = match.value
-				}
-			}
-			if len(sameName) == 0 {
-				match.value = increment
-				collectedMatch := make(patternList, len(*collected), len(*collected)+1)
-				copy(collectedMatch, *collected)
-				collectedMatch = append(collectedMatch, match)
-				return true, &leftAlt, &collectedMatch
-			}
-			switch sameName[0].value.(type) {
-			case int:
-				sameName[0].value = sameName[0].value.(int) + increment.(int)
-			case []string:
-				sameName[0].value = append(sameName[0].value.([]string), increment.([]string)...)
-			}
-			return true, &leftAlt, collected
-		}
-		collectedMatch := make(patternList, len(*collected), len(*collected)+1)
-		copy(collectedMatch, *collected)
-		collectedMatch = append(collectedMatch, match)
-		return true, &leftAlt, &collectedMatch
-	}
-	panic("unmatched type")
-}
-
-func (p *pattern) singleMatch(left *patternList) (int, *pattern) {
-	if p.t&patternArgument != 0 {
-		for n, pat := range *left {
-			if pat.t&patternArgument != 0 {
-				return n, newArgument(p.name, pat.value)
-			}
-		}
-		return -1, nil
-	} else if p.t&patternCommand != 0 {
-		for n, pat := range *left {
-			if pat.t&patternArgument != 0 {
-				if pat.value == p.name {
-					return n, newCommand(p.name, true)
-				}
-				break
-			}
-		}
-		return -1, nil
-	} else if p.t&patternOption != 0 {
-		for n, pat := range *left {
-			if p.name == pat.name {
-				return n, pat
-			}
-		}
-		return -1, nil
-	}
-	panic("unmatched type")
-}
-
-func (p *pattern) String() string {
-	if p.t&patternOption != 0 {
-		return fmt.Sprintf("%s(%s, %s, %d, %+v)", p.t, p.short, p.long, p.argcount, p.value)
-	} else if p.t&patternLeaf != 0 {
-		return fmt.Sprintf("%s(%s, %+v)", p.t, p.name, p.value)
-	} else if p.t&patternBranch != 0 {
-		result := ""
-		for i, child := range p.children {
-			if i > 0 {
-				result += ", "
-			}
-			result += child.String()
-		}
-		return fmt.Sprintf("%s(%s)", p.t, result)
-	}
-	panic("unmatched type")
-}
-
-func (p *pattern) transform() *pattern {
-	/*
-		Expand pattern into an (almost) equivalent one, but with single Either.
-
-		Example: ((-a | -b) (-c | -d)) => (-a -c | -a -d | -b -c | -b -d)
-		Quirks: [-a] => (-a), (-a...) => (-a -a)
-	*/
-	result := []patternList{}
-	groups := []patternList{patternList{p}}
-	parents := patternRequired +
-		patternOptionAL +
-		patternOptionSSHORTCUT +
-		patternEither +
-		patternOneOrMore
-	for len(groups) > 0 {
-		children := groups[0]
-		groups = groups[1:]
-		var child *pattern
-		for _, c := range children {
-			if c.t&parents != 0 {
-				child = c
-				break
-			}
-		}
-		if child != nil {
-			children.remove(child)
-			if child.t&patternEither != 0 {
-				for _, c := range child.children {
-					r := patternList{}
-					r = append(r, c)
-					r = append(r, children...)
-					groups = append(groups, r)
-				}
-			} else if child.t&patternOneOrMore != 0 {
-				r := patternList{}
-				r = append(r, child.children.double()...)
-				r = append(r, children...)
-				groups = append(groups, r)
-			} else {
-				r := patternList{}
-				r = append(r, child.children...)
-				r = append(r, children...)
-				groups = append(groups, r)
-			}
-		} else {
-			result = append(result, children)
-		}
-	}
-	either := patternList{}
-	for _, e := range result {
-		either = append(either, newRequired(e...))
-	}
-	return newEither(either...)
-}
-
-func (p *pattern) eq(other *pattern) bool {
-	return reflect.DeepEqual(p, other)
-}
-
-func (pl patternList) unique() patternList {
-	table := make(map[string]bool)
-	result := patternList{}
-	for _, v := range pl {
-		if !table[v.String()] {
-			table[v.String()] = true
-			result = append(result, v)
-		}
-	}
-	return result
-}
-
-func (pl patternList) index(p *pattern) (int, error) {
-	for i, c := range pl {
-		if c.eq(p) {
-			return i, nil
-		}
-	}
-	return -1, newError("%s not in list", p)
-}
-
-func (pl patternList) count(p *pattern) int {
-	count := 0
-	for _, c := range pl {
-		if c.eq(p) {
-			count++
-		}
-	}
-	return count
-}
-
-func (pl patternList) diff(l patternList) patternList {
-	lAlt := make(patternList, len(l))
-	copy(lAlt, l)
-	result := make(patternList, 0, len(pl))
-	for _, v := range pl {
-		if v != nil {
-			match := false
-			for i, w := range lAlt {
-				if w.eq(v) {
-					match = true
-					lAlt[i] = nil
-					break
-				}
-			}
-			if match == false {
-				result = append(result, v)
-			}
-		}
-	}
-	return result
-}
-
-func (pl patternList) double() patternList {
-	l := len(pl)
-	result := make(patternList, l*2)
-	copy(result, pl)
-	copy(result[l:2*l], pl)
-	return result
-}
-
-func (pl *patternList) remove(p *pattern) {
-	(*pl) = pl.diff(patternList{p})
-}
-
-func (pl patternList) dictionary() map[string]interface{} {
-	dict := make(map[string]interface{})
-	for _, a := range pl {
-		dict[a.name] = a.value
-	}
-	return dict
-}
-
-func stringPartition(s, sep string) (string, string, string) {
-	sepPos := strings.Index(s, sep)
-	if sepPos == -1 { // no seperator found
-		return s, "", ""
-	}
-	split := strings.SplitN(s, sep, 2)
-	return split[0], sep, split[1]
-}
-
-// returns true if all cased characters in the string are uppercase
-// and there are there is at least one cased charcter
-func isStringUppercase(s string) bool {
-	if strings.ToUpper(s) != s {
-		return false
-	}
-	for _, c := range []rune(s) {
-		if unicode.IsUpper(c) {
-			return true
-		}
-	}
-	return false
-}
diff --git a/vendor/github.com/docopt/docopt-go/test_golang.docopt b/vendor/github.com/docopt/docopt-go/test_golang.docopt
deleted file mode 100644
index 323fd67..0000000
--- a/vendor/github.com/docopt/docopt-go/test_golang.docopt
+++ /dev/null
@@ -1,9 +0,0 @@
-r"""usage: prog [NAME_-2]..."""
-$ prog 10 20
-{"NAME_-2": ["10", "20"]}
-
-$ prog 10
-{"NAME_-2": ["10"]}
-
-$ prog
-{"NAME_-2": []}
diff --git a/vendor/github.com/docopt/docopt-go/testcases.docopt b/vendor/github.com/docopt/docopt-go/testcases.docopt
deleted file mode 100644
index efe9a07..0000000
--- a/vendor/github.com/docopt/docopt-go/testcases.docopt
+++ /dev/null
@@ -1,957 +0,0 @@
-r"""Usage: prog
-
-"""
-$ prog
-{}
-
-$ prog --xxx
-"user-error"
-
-
-r"""Usage: prog [options]
-
-Options: -a  All.
-
-"""
-$ prog
-{"-a": false}
-
-$ prog -a
-{"-a": true}
-
-$ prog -x
-"user-error"
-
-
-r"""Usage: prog [options]
-
-Options: --all  All.
-
-"""
-$ prog
-{"--all": false}
-
-$ prog --all
-{"--all": true}
-
-$ prog --xxx
-"user-error"
-
-
-r"""Usage: prog [options]
-
-Options: -v, --verbose  Verbose.
-
-"""
-$ prog --verbose
-{"--verbose": true}
-
-$ prog --ver
-{"--verbose": true}
-
-$ prog -v
-{"--verbose": true}
-
-
-r"""Usage: prog [options]
-
-Options: -p PATH
-
-"""
-$ prog -p home/
-{"-p": "home/"}
-
-$ prog -phome/
-{"-p": "home/"}
-
-$ prog -p
-"user-error"
-
-
-r"""Usage: prog [options]
-
-Options: --path <path>
-
-"""
-$ prog --path home/
-{"--path": "home/"}
-
-$ prog --path=home/
-{"--path": "home/"}
-
-$ prog --pa home/
-{"--path": "home/"}
-
-$ prog --pa=home/
-{"--path": "home/"}
-
-$ prog --path
-"user-error"
-
-
-r"""Usage: prog [options]
-
-Options: -p PATH, --path=<path>  Path to files.
-
-"""
-$ prog -proot
-{"--path": "root"}
-
-
-r"""Usage: prog [options]
-
-Options:    -p --path PATH  Path to files.
-
-"""
-$ prog -p root
-{"--path": "root"}
-
-$ prog --path root
-{"--path": "root"}
-
-
-r"""Usage: prog [options]
-
-Options:
- -p PATH  Path to files [default: ./]
-
-"""
-$ prog
-{"-p": "./"}
-
-$ prog -phome
-{"-p": "home"}
-
-
-r"""UsAgE: prog [options]
-
-OpTiOnS: --path=<files>  Path to files
-                [dEfAuLt: /root]
-
-"""
-$ prog
-{"--path": "/root"}
-
-$ prog --path=home
-{"--path": "home"}
-
-
-r"""usage: prog [options]
-
-options:
-    -a        Add
-    -r        Remote
-    -m <msg>  Message
-
-"""
-$ prog -a -r -m Hello
-{"-a": true,
- "-r": true,
- "-m": "Hello"}
-
-$ prog -armyourass
-{"-a": true,
- "-r": true,
- "-m": "yourass"}
-
-$ prog -a -r
-{"-a": true,
- "-r": true,
- "-m": null}
-
-
-r"""Usage: prog [options]
-
-Options: --version
-         --verbose
-
-"""
-$ prog --version
-{"--version": true,
- "--verbose": false}
-
-$ prog --verbose
-{"--version": false,
- "--verbose": true}
-
-$ prog --ver
-"user-error"
-
-$ prog --verb
-{"--version": false,
- "--verbose": true}
-
-
-r"""usage: prog [-a -r -m <msg>]
-
-options:
- -a        Add
- -r        Remote
- -m <msg>  Message
-
-"""
-$ prog -armyourass
-{"-a": true,
- "-r": true,
- "-m": "yourass"}
-
-
-r"""usage: prog [-armmsg]
-
-options: -a        Add
-         -r        Remote
-         -m <msg>  Message
-
-"""
-$ prog -a -r -m Hello
-{"-a": true,
- "-r": true,
- "-m": "Hello"}
-
-
-r"""usage: prog -a -b
-
-options:
- -a
- -b
-
-"""
-$ prog -a -b
-{"-a": true, "-b": true}
-
-$ prog -b -a
-{"-a": true, "-b": true}
-
-$ prog -a
-"user-error"
-
-$ prog
-"user-error"
-
-
-r"""usage: prog (-a -b)
-
-options: -a
-         -b
-
-"""
-$ prog -a -b
-{"-a": true, "-b": true}
-
-$ prog -b -a
-{"-a": true, "-b": true}
-
-$ prog -a
-"user-error"
-
-$ prog
-"user-error"
-
-
-r"""usage: prog [-a] -b
-
-options: -a
- -b
-
-"""
-$ prog -a -b
-{"-a": true, "-b": true}
-
-$ prog -b -a
-{"-a": true, "-b": true}
-
-$ prog -a
-"user-error"
-
-$ prog -b
-{"-a": false, "-b": true}
-
-$ prog
-"user-error"
-
-
-r"""usage: prog [(-a -b)]
-
-options: -a
-         -b
-
-"""
-$ prog -a -b
-{"-a": true, "-b": true}
-
-$ prog -b -a
-{"-a": true, "-b": true}
-
-$ prog -a
-"user-error"
-
-$ prog -b
-"user-error"
-
-$ prog
-{"-a": false, "-b": false}
-
-
-r"""usage: prog (-a|-b)
-
-options: -a
-         -b
-
-"""
-$ prog -a -b
-"user-error"
-
-$ prog
-"user-error"
-
-$ prog -a
-{"-a": true, "-b": false}
-
-$ prog -b
-{"-a": false, "-b": true}
-
-
-r"""usage: prog [ -a | -b ]
-
-options: -a
-         -b
-
-"""
-$ prog -a -b
-"user-error"
-
-$ prog
-{"-a": false, "-b": false}
-
-$ prog -a
-{"-a": true, "-b": false}
-
-$ prog -b
-{"-a": false, "-b": true}
-
-
-r"""usage: prog <arg>"""
-$ prog 10
-{"<arg>": "10"}
-
-$ prog 10 20
-"user-error"
-
-$ prog
-"user-error"
-
-
-r"""usage: prog [<arg>]"""
-$ prog 10
-{"<arg>": "10"}
-
-$ prog 10 20
-"user-error"
-
-$ prog
-{"<arg>": null}
-
-
-r"""usage: prog <kind> <name> <type>"""
-$ prog 10 20 40
-{"<kind>": "10", "<name>": "20", "<type>": "40"}
-
-$ prog 10 20
-"user-error"
-
-$ prog
-"user-error"
-
-
-r"""usage: prog <kind> [<name> <type>]"""
-$ prog 10 20 40
-{"<kind>": "10", "<name>": "20", "<type>": "40"}
-
-$ prog 10 20
-{"<kind>": "10", "<name>": "20", "<type>": null}
-
-$ prog
-"user-error"
-
-
-r"""usage: prog [<kind> | <name> <type>]"""
-$ prog 10 20 40
-"user-error"
-
-$ prog 20 40
-{"<kind>": null, "<name>": "20", "<type>": "40"}
-
-$ prog
-{"<kind>": null, "<name>": null, "<type>": null}
-
-
-r"""usage: prog (<kind> --all | <name>)
-
-options:
- --all
-
-"""
-$ prog 10 --all
-{"<kind>": "10", "--all": true, "<name>": null}
-
-$ prog 10
-{"<kind>": null, "--all": false, "<name>": "10"}
-
-$ prog
-"user-error"
-
-
-r"""usage: prog [<name> <name>]"""
-$ prog 10 20
-{"<name>": ["10", "20"]}
-
-$ prog 10
-{"<name>": ["10"]}
-
-$ prog
-{"<name>": []}
-
-
-r"""usage: prog [(<name> <name>)]"""
-$ prog 10 20
-{"<name>": ["10", "20"]}
-
-$ prog 10
-"user-error"
-
-$ prog
-{"<name>": []}
-
-
-r"""usage: prog NAME..."""
-$ prog 10 20
-{"NAME": ["10", "20"]}
-
-$ prog 10
-{"NAME": ["10"]}
-
-$ prog
-"user-error"
-
-
-r"""usage: prog [NAME]..."""
-$ prog 10 20
-{"NAME": ["10", "20"]}
-
-$ prog 10
-{"NAME": ["10"]}
-
-$ prog
-{"NAME": []}
-
-
-r"""usage: prog [NAME...]"""
-$ prog 10 20
-{"NAME": ["10", "20"]}
-
-$ prog 10
-{"NAME": ["10"]}
-
-$ prog
-{"NAME": []}
-
-
-r"""usage: prog [NAME [NAME ...]]"""
-$ prog 10 20
-{"NAME": ["10", "20"]}
-
-$ prog 10
-{"NAME": ["10"]}
-
-$ prog
-{"NAME": []}
-
-
-r"""usage: prog (NAME | --foo NAME)
-
-options: --foo
-
-"""
-$ prog 10
-{"NAME": "10", "--foo": false}
-
-$ prog --foo 10
-{"NAME": "10", "--foo": true}
-
-$ prog --foo=10
-"user-error"
-
-
-r"""usage: prog (NAME | --foo) [--bar | NAME]
-
-options: --foo
-options: --bar
-
-"""
-$ prog 10
-{"NAME": ["10"], "--foo": false, "--bar": false}
-
-$ prog 10 20
-{"NAME": ["10", "20"], "--foo": false, "--bar": false}
-
-$ prog --foo --bar
-{"NAME": [], "--foo": true, "--bar": true}
-
-
-r"""Naval Fate.
-
-Usage:
-  prog ship new <name>...
-  prog ship [<name>] move <x> <y> [--speed=<kn>]
-  prog ship shoot <x> <y>
-  prog mine (set|remove) <x> <y> [--moored|--drifting]
-  prog -h | --help
-  prog --version
-
-Options:
-  -h --help     Show this screen.
-  --version     Show version.
-  --speed=<kn>  Speed in knots [default: 10].
-  --moored      Mored (anchored) mine.
-  --drifting    Drifting mine.
-
-"""
-$ prog ship Guardian move 150 300 --speed=20
-{"--drifting": false,
- "--help": false,
- "--moored": false,
- "--speed": "20",
- "--version": false,
- "<name>": ["Guardian"],
- "<x>": "150",
- "<y>": "300",
- "mine": false,
- "move": true,
- "new": false,
- "remove": false,
- "set": false,
- "ship": true,
- "shoot": false}
-
-
-r"""usage: prog --hello"""
-$ prog --hello
-{"--hello": true}
-
-
-r"""usage: prog [--hello=<world>]"""
-$ prog
-{"--hello": null}
-
-$ prog --hello wrld
-{"--hello": "wrld"}
-
-
-r"""usage: prog [-o]"""
-$ prog
-{"-o": false}
-
-$ prog -o
-{"-o": true}
-
-
-r"""usage: prog [-opr]"""
-$ prog -op
-{"-o": true, "-p": true, "-r": false}
-
-
-r"""usage: prog --aabb | --aa"""
-$ prog --aa
-{"--aabb": false, "--aa": true}
-
-$ prog --a
-"user-error"  # not a unique prefix
-
-#
-# Counting number of flags
-#
-
-r"""Usage: prog -v"""
-$ prog -v
-{"-v": true}
-
-
-r"""Usage: prog [-v -v]"""
-$ prog
-{"-v": 0}
-
-$ prog -v
-{"-v": 1}
-
-$ prog -vv
-{"-v": 2}
-
-
-r"""Usage: prog -v ..."""
-$ prog
-"user-error"
-
-$ prog -v
-{"-v": 1}
-
-$ prog -vv
-{"-v": 2}
-
-$ prog -vvvvvv
-{"-v": 6}
-
-
-r"""Usage: prog [-v | -vv | -vvv]
-
-This one is probably most readable user-friednly variant.
-
-"""
-$ prog
-{"-v": 0}
-
-$ prog -v
-{"-v": 1}
-
-$ prog -vv
-{"-v": 2}
-
-$ prog -vvvv
-"user-error"
-
-
-r"""usage: prog [--ver --ver]"""
-$ prog --ver --ver
-{"--ver": 2}
-
-
-#
-# Counting commands
-#
-
-r"""usage: prog [go]"""
-$ prog go
-{"go": true}
-
-
-r"""usage: prog [go go]"""
-$ prog
-{"go": 0}
-
-$ prog go
-{"go": 1}
-
-$ prog go go
-{"go": 2}
-
-$ prog go go go
-"user-error"
-
-r"""usage: prog go..."""
-$ prog go go go go go
-{"go": 5}
-
-#
-# [options] does not include options from usage-pattern
-#
-r"""usage: prog [options] [-a]
-
-options: -a
-         -b
-"""
-$ prog -a
-{"-a": true, "-b": false}
-
-$ prog -aa
-"user-error"
-
-#
-# Test [options] shourtcut
-#
-
-r"""Usage: prog [options] A
-Options:
-    -q  Be quiet
-    -v  Be verbose.
-
-"""
-$ prog arg
-{"A": "arg", "-v": false, "-q": false}
-
-$ prog -v arg
-{"A": "arg", "-v": true, "-q": false}
-
-$ prog -q arg
-{"A": "arg", "-v": false, "-q": true}
-
-#
-# Test single dash
-#
-
-r"""usage: prog [-]"""
-
-$ prog -
-{"-": true}
-
-$ prog
-{"-": false}
-
-#
-# If argument is repeated, its value should always be a list
-#
-
-r"""usage: prog [NAME [NAME ...]]"""
-
-$ prog a b
-{"NAME": ["a", "b"]}
-
-$ prog
-{"NAME": []}
-
-#
-# Option's argument defaults to null/None
-#
-
-r"""usage: prog [options]
-options:
- -a        Add
- -m <msg>  Message
-
-"""
-$ prog -a
-{"-m": null, "-a": true}
-
-#
-# Test options without description
-#
-
-r"""usage: prog --hello"""
-$ prog --hello
-{"--hello": true}
-
-r"""usage: prog [--hello=<world>]"""
-$ prog
-{"--hello": null}
-
-$ prog --hello wrld
-{"--hello": "wrld"}
-
-r"""usage: prog [-o]"""
-$ prog
-{"-o": false}
-
-$ prog -o
-{"-o": true}
-
-r"""usage: prog [-opr]"""
-$ prog -op
-{"-o": true, "-p": true, "-r": false}
-
-r"""usage: git [-v | --verbose]"""
-$ prog -v
-{"-v": true, "--verbose": false}
-
-r"""usage: git remote [-v | --verbose]"""
-$ prog remote -v
-{"remote": true, "-v": true, "--verbose": false}
-
-#
-# Test empty usage pattern
-#
-
-r"""usage: prog"""
-$ prog
-{}
-
-r"""usage: prog
-           prog <a> <b>
-"""
-$ prog 1 2
-{"<a>": "1", "<b>": "2"}
-
-$ prog
-{"<a>": null, "<b>": null}
-
-r"""usage: prog <a> <b>
-           prog
-"""
-$ prog
-{"<a>": null, "<b>": null}
-
-#
-# Option's argument should not capture default value from usage pattern
-#
-
-r"""usage: prog [--file=<f>]"""
-$ prog
-{"--file": null}
-
-r"""usage: prog [--file=<f>]
-
-options: --file <a>
-
-"""
-$ prog
-{"--file": null}
-
-r"""Usage: prog [-a <host:port>]
-
-Options: -a, --address <host:port>  TCP address [default: localhost:6283].
-
-"""
-$ prog
-{"--address": "localhost:6283"}
-
-#
-# If option with argument could be repeated,
-# its arguments should be accumulated into a list
-#
-
-r"""usage: prog --long=<arg> ..."""
-
-$ prog --long one
-{"--long": ["one"]}
-
-$ prog --long one --long two
-{"--long": ["one", "two"]}
-
-#
-# Test multiple elements repeated at once
-#
-
-r"""usage: prog (go <direction> --speed=<km/h>)..."""
-$ prog  go left --speed=5  go right --speed=9
-{"go": 2, "<direction>": ["left", "right"], "--speed": ["5", "9"]}
-
-#
-# Required options should work with option shortcut
-#
-
-r"""usage: prog [options] -a
-
-options: -a
-
-"""
-$ prog -a
-{"-a": true}
-
-#
-# If option could be repeated its defaults should be split into a list
-#
-
-r"""usage: prog [-o <o>]...
-
-options: -o <o>  [default: x]
-
-"""
-$ prog -o this -o that
-{"-o": ["this", "that"]}
-
-$ prog
-{"-o": ["x"]}
-
-r"""usage: prog [-o <o>]...
-
-options: -o <o>  [default: x y]
-
-"""
-$ prog -o this
-{"-o": ["this"]}
-
-$ prog
-{"-o": ["x", "y"]}
-
-#
-# Test stacked option's argument
-#
-
-r"""usage: prog -pPATH
-
-options: -p PATH
-
-"""
-$ prog -pHOME
-{"-p": "HOME"}
-
-#
-# Issue 56: Repeated mutually exclusive args give nested lists sometimes
-#
-
-r"""Usage: foo (--xx=x|--yy=y)..."""
-$ prog --xx=1 --yy=2
-{"--xx": ["1"], "--yy": ["2"]}
-
-#
-# POSIXly correct tokenization
-#
-
-r"""usage: prog [<input file>]"""
-$ prog f.txt
-{"<input file>": "f.txt"}
-
-r"""usage: prog [--input=<file name>]..."""
-$ prog --input a.txt --input=b.txt
-{"--input": ["a.txt", "b.txt"]}
-
-#
-# Issue 85: `[options]` shourtcut with multiple subcommands
-#
-
-r"""usage: prog good [options]
-           prog fail [options]
-
-options: --loglevel=N
-
-"""
-$ prog fail --loglevel 5
-{"--loglevel": "5", "fail": true, "good": false}
-
-#
-# Usage-section syntax
-#
-
-r"""usage:prog --foo"""
-$ prog --foo
-{"--foo": true}
-
-r"""PROGRAM USAGE: prog --foo"""
-$ prog --foo
-{"--foo": true}
-
-r"""Usage: prog --foo
-           prog --bar
-NOT PART OF SECTION"""
-$ prog --foo
-{"--foo": true, "--bar": false}
-
-r"""Usage:
- prog --foo
- prog --bar
-
-NOT PART OF SECTION"""
-$ prog --foo
-{"--foo": true, "--bar": false}
-
-r"""Usage:
- prog --foo
- prog --bar
-NOT PART OF SECTION"""
-$ prog --foo
-{"--foo": true, "--bar": false}
-
-#
-# Options-section syntax
-#
-
-r"""Usage: prog [options]
-
-global options: --foo
-local options: --baz
-               --bar
-other options:
- --egg
- --spam
--not-an-option-
-
-"""
-$ prog --baz --egg
-{"--foo": false, "--baz": true, "--bar": false, "--egg": true, "--spam": false}
diff --git a/vendor/github.com/go-ini/ini/.gitignore b/vendor/github.com/go-ini/ini/.gitignore
deleted file mode 100644
index 7adca94..0000000
--- a/vendor/github.com/go-ini/ini/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-testdata/conf_out.ini
-ini.sublime-project
-ini.sublime-workspace
-testdata/conf_reflect.ini
diff --git a/vendor/github.com/go-ini/ini/LICENSE b/vendor/github.com/go-ini/ini/LICENSE
deleted file mode 100644
index 37ec93a..0000000
--- a/vendor/github.com/go-ini/ini/LICENSE
+++ /dev/null
@@ -1,191 +0,0 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-"License" shall mean the terms and conditions for use, reproduction, and
-distribution as defined by Sections 1 through 9 of this document.
-
-"Licensor" shall mean the copyright owner or entity authorized by the copyright
-owner that is granting the License.
-
-"Legal Entity" shall mean the union of the acting entity and all other entities
-that control, are controlled by, or are under common control with that entity.
-For the purposes of this definition, "control" means (i) the power, direct or
-indirect, to cause the direction or management of such entity, whether by
-contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
-outstanding shares, or (iii) beneficial ownership of such entity.
-
-"You" (or "Your") shall mean an individual or Legal Entity exercising
-permissions granted by this License.
-
-"Source" form shall mean the preferred form for making modifications, including
-but not limited to software source code, documentation source, and configuration
-files.
-
-"Object" form shall mean any form resulting from mechanical transformation or
-translation of a Source form, including but not limited to compiled object code,
-generated documentation, and conversions to other media types.
-
-"Work" shall mean the work of authorship, whether in Source or Object form, made
-available under the License, as indicated by a copyright notice that is included
-in or attached to the work (an example is provided in the Appendix below).
-
-"Derivative Works" shall mean any work, whether in Source or Object form, that
-is based on (or derived from) the Work and for which the editorial revisions,
-annotations, elaborations, or other modifications represent, as a whole, an
-original work of authorship. For the purposes of this License, Derivative Works
-shall not include works that remain separable from, or merely link (or bind by
-name) to the interfaces of, the Work and Derivative Works thereof.
-
-"Contribution" shall mean any work of authorship, including the original version
-of the Work and any modifications or additions to that Work or Derivative Works
-thereof, that is intentionally submitted to Licensor for inclusion in the Work
-by the copyright owner or by an individual or Legal Entity authorized to submit
-on behalf of the copyright owner. For the purposes of this definition,
-"submitted" means any form of electronic, verbal, or written communication sent
-to the Licensor or its representatives, including but not limited to
-communication on electronic mailing lists, source code control systems, and
-issue tracking systems that are managed by, or on behalf of, the Licensor for
-the purpose of discussing and improving the Work, but excluding communication
-that is conspicuously marked or otherwise designated in writing by the copyright
-owner as "Not a Contribution."
-
-"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
-of whom a Contribution has been received by Licensor and subsequently
-incorporated within the Work.
-
-2. Grant of Copyright License.
-
-Subject to the terms and conditions of this License, each Contributor hereby
-grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
-irrevocable copyright license to reproduce, prepare Derivative Works of,
-publicly display, publicly perform, sublicense, and distribute the Work and such
-Derivative Works in Source or Object form.
-
-3. Grant of Patent License.
-
-Subject to the terms and conditions of this License, each Contributor hereby
-grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
-irrevocable (except as stated in this section) patent license to make, have
-made, use, offer to sell, sell, import, and otherwise transfer the Work, where
-such license applies only to those patent claims licensable by such Contributor
-that are necessarily infringed by their Contribution(s) alone or by combination
-of their Contribution(s) with the Work to which such Contribution(s) was
-submitted. If You institute patent litigation against any entity (including a
-cross-claim or counterclaim in a lawsuit) alleging that the Work or a
-Contribution incorporated within the Work constitutes direct or contributory
-patent infringement, then any patent licenses granted to You under this License
-for that Work shall terminate as of the date such litigation is filed.
-
-4. Redistribution.
-
-You may reproduce and distribute copies of the Work or Derivative Works thereof
-in any medium, with or without modifications, and in Source or Object form,
-provided that You meet the following conditions:
-
-You must give any other recipients of the Work or Derivative Works a copy of
-this License; and
-You must cause any modified files to carry prominent notices stating that You
-changed the files; and
-You must retain, in the Source form of any Derivative Works that You distribute,
-all copyright, patent, trademark, and attribution notices from the Source form
-of the Work, excluding those notices that do not pertain to any part of the
-Derivative Works; and
-If the Work includes a "NOTICE" text file as part of its distribution, then any
-Derivative Works that You distribute must include a readable copy of the
-attribution notices contained within such NOTICE file, excluding those notices
-that do not pertain to any part of the Derivative Works, in at least one of the
-following places: within a NOTICE text file distributed as part of the
-Derivative Works; within the Source form or documentation, if provided along
-with the Derivative Works; or, within a display generated by the Derivative
-Works, if and wherever such third-party notices normally appear. The contents of
-the NOTICE file are for informational purposes only and do not modify the
-License. You may add Your own attribution notices within Derivative Works that
-You distribute, alongside or as an addendum to the NOTICE text from the Work,
-provided that such additional attribution notices cannot be construed as
-modifying the License.
-You may add Your own copyright statement to Your modifications and may provide
-additional or different license terms and conditions for use, reproduction, or
-distribution of Your modifications, or for any such Derivative Works as a whole,
-provided Your use, reproduction, and distribution of the Work otherwise complies
-with the conditions stated in this License.
-
-5. Submission of Contributions.
-
-Unless You explicitly state otherwise, any Contribution intentionally submitted
-for inclusion in the Work by You to the Licensor shall be under the terms and
-conditions of this License, without any additional terms or conditions.
-Notwithstanding the above, nothing herein shall supersede or modify the terms of
-any separate license agreement you may have executed with Licensor regarding
-such Contributions.
-
-6. Trademarks.
-
-This License does not grant permission to use the trade names, trademarks,
-service marks, or product names of the Licensor, except as required for
-reasonable and customary use in describing the origin of the Work and
-reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty.
-
-Unless required by applicable law or agreed to in writing, Licensor provides the
-Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
-including, without limitation, any warranties or conditions of TITLE,
-NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
-solely responsible for determining the appropriateness of using or
-redistributing the Work and assume any risks associated with Your exercise of
-permissions under this License.
-
-8. Limitation of Liability.
-
-In no event and under no legal theory, whether in tort (including negligence),
-contract, or otherwise, unless required by applicable law (such as deliberate
-and grossly negligent acts) or agreed to in writing, shall any Contributor be
-liable to You for damages, including any direct, indirect, special, incidental,
-or consequential damages of any character arising as a result of this License or
-out of the use or inability to use the Work (including but not limited to
-damages for loss of goodwill, work stoppage, computer failure or malfunction, or
-any and all other commercial damages or losses), even if such Contributor has
-been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability.
-
-While redistributing the Work or Derivative Works thereof, You may choose to
-offer, and charge a fee for, acceptance of support, warranty, indemnity, or
-other liability obligations and/or rights consistent with this License. However,
-in accepting such obligations, You may act only on Your own behalf and on Your
-sole responsibility, not on behalf of any other Contributor, and only if You
-agree to indemnify, defend, and hold each Contributor harmless for any liability
-incurred by, or claims asserted against, such Contributor by reason of your
-accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work
-
-To apply the Apache License to your work, attach the following boilerplate
-notice, with the fields enclosed by brackets "[]" replaced with your own
-identifying information. (Don't include the brackets!) The text should be
-enclosed in the appropriate comment syntax for the file format. We also
-recommend that a file or class name and description of purpose be included on
-the same "printed page" as the copyright notice for easier identification within
-third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/vendor/github.com/go-ini/ini/Makefile b/vendor/github.com/go-ini/ini/Makefile
deleted file mode 100644
index ac034e5..0000000
--- a/vendor/github.com/go-ini/ini/Makefile
+++ /dev/null
@@ -1,12 +0,0 @@
-.PHONY: build test bench vet
-
-build: vet bench
-
-test:
-	go test -v -cover -race
-
-bench:
-	go test -v -cover -race -test.bench=. -test.benchmem
-
-vet:
-	go vet
diff --git a/vendor/github.com/go-ini/ini/README.md b/vendor/github.com/go-ini/ini/README.md
deleted file mode 100644
index a87cca2..0000000
--- a/vendor/github.com/go-ini/ini/README.md
+++ /dev/null
@@ -1,632 +0,0 @@
-ini [![Build Status](https://drone.io/github.com/go-ini/ini/status.png)](https://drone.io/github.com/go-ini/ini/latest) [![](http://gocover.io/_badge/github.com/go-ini/ini)](http://gocover.io/github.com/go-ini/ini)
-===
-
-![](https://avatars0.githubusercontent.com/u/10216035?v=3&s=200)
-
-Package ini provides INI file read and write functionality in Go.
-
-[简体中文](README_ZH.md)
-
-## Feature
-
-- Load multiple data sources(`[]byte` or file) with overwrites.
-- Read with recursion values.
-- Read with parent-child sections.
-- Read with auto-increment key names.
-- Read with multiple-line values.
-- Read with tons of helper methods.
-- Read and convert values to Go types.
-- Read and **WRITE** comments of sections and keys.
-- Manipulate sections, keys and comments with ease.
-- Keep sections and keys in order as you parse and save.
-
-## Installation
-
-To use a tagged revision:
-
-	go get gopkg.in/ini.v1
-
-To use with latest changes:
-
-	go get github.com/go-ini/ini
-
-Please add `-u` flag to update in the future.
-
-### Testing
-
-If you want to test on your machine, please apply `-t` flag:
-
-	go get -t gopkg.in/ini.v1
-
-Please add `-u` flag to update in the future.
-
-## Getting Started
-
-### Loading from data sources
-
-A **Data Source** is either raw data in type `[]byte` or a file name with type `string` and you can load **as many as** data sources you want. Passing other types will simply return an error.
-
-```go
-cfg, err := ini.Load([]byte("raw data"), "filename")
-```
-
-Or start with an empty object:
-
-```go
-cfg := ini.Empty()
-```
-
-When you cannot decide how many data sources to load at the beginning, you still able to **Append()** them later.
-
-```go
-err := cfg.Append("other file", []byte("other raw data"))
-```
-
-If you have a list of files with possibilities that some of them may not available at the time, and you don't know exactly which ones, you can use `LooseLoad` to ignore nonexistent files without returning error.
-
-```go
-cfg, err := ini.LooseLoad("filename", "filename_404")
-```
-
-The cool thing is, whenever the file is available to load while you're calling `Reload` method, it will be counted as usual.
-
-### Working with sections
-
-To get a section, you would need to:
-
-```go
-section, err := cfg.GetSection("section name")
-```
-
-For a shortcut for default section, just give an empty string as name:
-
-```go
-section, err := cfg.GetSection("")
-```
-
-When you're pretty sure the section exists, following code could make your life easier:
-
-```go
-section := cfg.Section("")
-```
-
-What happens when the section somehow does not exist? Don't panic, it automatically creates and returns a new section to you.
-
-To create a new section:
-
-```go
-err := cfg.NewSection("new section")
-```
-
-To get a list of sections or section names:
-
-```go
-sections := cfg.Sections()
-names := cfg.SectionStrings()
-```
-
-### Working with keys
-
-To get a key under a section:
-
-```go
-key, err := cfg.Section("").GetKey("key name")
-```
-
-Same rule applies to key operations:
-
-```go
-key := cfg.Section("").Key("key name")
-```
-
-To check if a key exists:
-
-```go
-yes := cfg.Section("").HasKey("key name")
-```
-
-To create a new key:
-
-```go
-err := cfg.Section("").NewKey("name", "value")
-```
-
-To get a list of keys or key names:
-
-```go
-keys := cfg.Section("").Keys()
-names := cfg.Section("").KeyStrings()
-```
-
-To get a clone hash of keys and corresponding values:
-
-```go
-hash := cfg.GetSection("").KeysHash()
-```
-
-### Working with values
-
-To get a string value:
-
-```go
-val := cfg.Section("").Key("key name").String()
-```
-
-To validate key value on the fly:
-
-```go
-val := cfg.Section("").Key("key name").Validate(func(in string) string {
-	if len(in) == 0 {
-		return "default"
-	}
-	return in
-})
-```
-
-If you do not want any auto-transformation (such as recursive read) for the values, you can get raw value directly (this way you get much better performance):
-
-```go
-val := cfg.Section("").Key("key name").Value()
-```
-
-To check if raw value exists:
-
-```go
-yes := cfg.Section("").HasValue("test value")
-```
-
-To get value with types:
-
-```go
-// For boolean values:
-// true when value is: 1, t, T, TRUE, true, True, YES, yes, Yes, y, ON, on, On
-// false when value is: 0, f, F, FALSE, false, False, NO, no, No, n, OFF, off, Off
-v, err = cfg.Section("").Key("BOOL").Bool()
-v, err = cfg.Section("").Key("FLOAT64").Float64()
-v, err = cfg.Section("").Key("INT").Int()
-v, err = cfg.Section("").Key("INT64").Int64()
-v, err = cfg.Section("").Key("UINT").Uint()
-v, err = cfg.Section("").Key("UINT64").Uint64()
-v, err = cfg.Section("").Key("TIME").TimeFormat(time.RFC3339)
-v, err = cfg.Section("").Key("TIME").Time() // RFC3339
-
-v = cfg.Section("").Key("BOOL").MustBool()
-v = cfg.Section("").Key("FLOAT64").MustFloat64()
-v = cfg.Section("").Key("INT").MustInt()
-v = cfg.Section("").Key("INT64").MustInt64()
-v = cfg.Section("").Key("UINT").MustUint()
-v = cfg.Section("").Key("UINT64").MustUint64()
-v = cfg.Section("").Key("TIME").MustTimeFormat(time.RFC3339)
-v = cfg.Section("").Key("TIME").MustTime() // RFC3339
-
-// Methods start with Must also accept one argument for default value
-// when key not found or fail to parse value to given type.
-// Except method MustString, which you have to pass a default value.
-
-v = cfg.Section("").Key("String").MustString("default")
-v = cfg.Section("").Key("BOOL").MustBool(true)
-v = cfg.Section("").Key("FLOAT64").MustFloat64(1.25)
-v = cfg.Section("").Key("INT").MustInt(10)
-v = cfg.Section("").Key("INT64").MustInt64(99)
-v = cfg.Section("").Key("UINT").MustUint(3)
-v = cfg.Section("").Key("UINT64").MustUint64(6)
-v = cfg.Section("").Key("TIME").MustTimeFormat(time.RFC3339, time.Now())
-v = cfg.Section("").Key("TIME").MustTime(time.Now()) // RFC3339
-```
-
-What if my value is three-line long?
-
-```ini
-[advance]
-ADDRESS = """404 road,
-NotFound, State, 5000
-Earth"""
-```
-
-Not a problem!
-
-```go
-cfg.Section("advance").Key("ADDRESS").String()
-
-/* --- start ---
-404 road,
-NotFound, State, 5000
-Earth
-------  end  --- */
-```
-
-That's cool, how about continuation lines?
-
-```ini
-[advance]
-two_lines = how about \
-	continuation lines?
-lots_of_lines = 1 \
-	2 \
-	3 \
-	4
-```
-
-Piece of cake!
-
-```go
-cfg.Section("advance").Key("two_lines").String() // how about continuation lines?
-cfg.Section("advance").Key("lots_of_lines").String() // 1 2 3 4
-```
-
-Note that single quotes around values will be stripped:
-
-```ini
-foo = "some value" // foo: some value
-bar = 'some value' // bar: some value
-```
-
-That's all? Hmm, no.
-
-#### Helper methods of working with values
-
-To get value with given candidates:
-
-```go
-v = cfg.Section("").Key("STRING").In("default", []string{"str", "arr", "types"})
-v = cfg.Section("").Key("FLOAT64").InFloat64(1.1, []float64{1.25, 2.5, 3.75})
-v = cfg.Section("").Key("INT").InInt(5, []int{10, 20, 30})
-v = cfg.Section("").Key("INT64").InInt64(10, []int64{10, 20, 30})
-v = cfg.Section("").Key("UINT").InUint(4, []int{3, 6, 9})
-v = cfg.Section("").Key("UINT64").InUint64(8, []int64{3, 6, 9})
-v = cfg.Section("").Key("TIME").InTimeFormat(time.RFC3339, time.Now(), []time.Time{time1, time2, time3})
-v = cfg.Section("").Key("TIME").InTime(time.Now(), []time.Time{time1, time2, time3}) // RFC3339
-```
-
-Default value will be presented if value of key is not in candidates you given, and default value does not need be one of candidates.
-
-To validate value in a given range:
-
-```go
-vals = cfg.Section("").Key("FLOAT64").RangeFloat64(0.0, 1.1, 2.2)
-vals = cfg.Section("").Key("INT").RangeInt(0, 10, 20)
-vals = cfg.Section("").Key("INT64").RangeInt64(0, 10, 20)
-vals = cfg.Section("").Key("UINT").RangeUint(0, 3, 9)
-vals = cfg.Section("").Key("UINT64").RangeUint64(0, 3, 9)
-vals = cfg.Section("").Key("TIME").RangeTimeFormat(time.RFC3339, time.Now(), minTime, maxTime)
-vals = cfg.Section("").Key("TIME").RangeTime(time.Now(), minTime, maxTime) // RFC3339
-```
-
-##### Auto-split values into a slice
-
-To use zero value of type for invalid inputs:
-
-```go
-// Input: 1.1, 2.2, 3.3, 4.4 -> [1.1 2.2 3.3 4.4]
-// Input: how, 2.2, are, you -> [0.0 2.2 0.0 0.0]
-vals = cfg.Section("").Key("STRINGS").Strings(",")
-vals = cfg.Section("").Key("FLOAT64S").Float64s(",")
-vals = cfg.Section("").Key("INTS").Ints(",")
-vals = cfg.Section("").Key("INT64S").Int64s(",")
-vals = cfg.Section("").Key("UINTS").Uints(",")
-vals = cfg.Section("").Key("UINT64S").Uint64s(",")
-vals = cfg.Section("").Key("TIMES").Times(",")
-```
-
-To exclude invalid values out of result slice:
-
-```go
-// Input: 1.1, 2.2, 3.3, 4.4 -> [1.1 2.2 3.3 4.4]
-// Input: how, 2.2, are, you -> [2.2]
-vals = cfg.Section("").Key("FLOAT64S").ValidFloat64s(",")
-vals = cfg.Section("").Key("INTS").ValidInts(",")
-vals = cfg.Section("").Key("INT64S").ValidInt64s(",")
-vals = cfg.Section("").Key("UINTS").ValidUints(",")
-vals = cfg.Section("").Key("UINT64S").ValidUint64s(",")
-vals = cfg.Section("").Key("TIMES").ValidTimes(",")
-```
-
-Or to return nothing but error when have invalid inputs:
-
-```go
-// Input: 1.1, 2.2, 3.3, 4.4 -> [1.1 2.2 3.3 4.4]
-// Input: how, 2.2, are, you -> error
-vals = cfg.Section("").Key("FLOAT64S").StrictFloat64s(",")
-vals = cfg.Section("").Key("INTS").StrictInts(",")
-vals = cfg.Section("").Key("INT64S").StrictInt64s(",")
-vals = cfg.Section("").Key("UINTS").StrictUints(",")
-vals = cfg.Section("").Key("UINT64S").StrictUint64s(",")
-vals = cfg.Section("").Key("TIMES").StrictTimes(",")
-```
-
-### Save your configuration
-
-Finally, it's time to save your configuration to somewhere.
-
-A typical way to save configuration is writing it to a file:
-
-```go
-// ...
-err = cfg.SaveTo("my.ini")
-err = cfg.SaveToIndent("my.ini", "\t")
-```
-
-Another way to save is writing to a `io.Writer` interface:
-
-```go
-// ...
-cfg.WriteTo(writer)
-cfg.WriteToIndent(writer, "\t")
-```
-
-## Advanced Usage
-
-### Recursive Values
-
-For all value of keys, there is a special syntax `%(<name>)s`, where `<name>` is the key name in same section or default section, and `%(<name>)s` will be replaced by corresponding value(empty string if key not found). You can use this syntax at most 99 level of recursions.
-
-```ini
-NAME = ini
-
-[author]
-NAME = Unknwon
-GITHUB = https://github.com/%(NAME)s
-
-[package]
-FULL_NAME = github.com/go-ini/%(NAME)s
-```
-
-```go
-cfg.Section("author").Key("GITHUB").String()		// https://github.com/Unknwon
-cfg.Section("package").Key("FULL_NAME").String()	// github.com/go-ini/ini
-```
-
-### Parent-child Sections
-
-You can use `.` in section name to indicate parent-child relationship between two or more sections. If the key not found in the child section, library will try again on its parent section until there is no parent section.
-
-```ini
-NAME = ini
-VERSION = v1
-IMPORT_PATH = gopkg.in/%(NAME)s.%(VERSION)s
-
-[package]
-CLONE_URL = https://%(IMPORT_PATH)s
-
-[package.sub]
-```
-
-```go
-cfg.Section("package.sub").Key("CLONE_URL").String()	// https://gopkg.in/ini.v1
-```
-
-### Auto-increment Key Names
-
-If key name is `-` in data source, then it would be seen as special syntax for auto-increment key name start from 1, and every section is independent on counter.
-
-```ini
-[features]
--: Support read/write comments of keys and sections
--: Support auto-increment of key names
--: Support load multiple files to overwrite key values
-```
-
-```go
-cfg.Section("features").KeyStrings()	// []{"#1", "#2", "#3"}
-```
-
-### Map To Struct
-
-Want more objective way to play with INI? Cool.
-
-```ini
-Name = Unknwon
-age = 21
-Male = true
-Born = 1993-01-01T20:17:05Z
-
-[Note]
-Content = Hi is a good man!
-Cities = HangZhou, Boston
-```
-
-```go
-type Note struct {
-	Content string
-	Cities  []string
-}
-
-type Person struct {
-	Name string
-	Age  int `ini:"age"`
-	Male bool
-	Born time.Time
-	Note
-	Created time.Time `ini:"-"`
-}
-
-func main() {
-	cfg, err := ini.Load("path/to/ini")
-	// ...
-	p := new(Person)
-	err = cfg.MapTo(p)
-	// ...
-
-	// Things can be simpler.
-	err = ini.MapTo(p, "path/to/ini")
-	// ...
-
-	// Just map a section? Fine.
-	n := new(Note)
-	err = cfg.Section("Note").MapTo(n)
-	// ...
-}
-```
-
-Can I have default value for field? Absolutely.
-
-Assign it before you map to struct. It will keep the value as it is if the key is not presented or got wrong type.
-
-```go
-// ...
-p := &Person{
-	Name: "Joe",
-}
-// ...
-```
-
-It's really cool, but what's the point if you can't give me my file back from struct?
-
-### Reflect From Struct
-
-Why not?
-
-```go
-type Embeded struct {
-	Dates  []time.Time `delim:"|"`
-	Places []string
-	None   []int
-}
-
-type Author struct {
-	Name      string `ini:"NAME"`
-	Male      bool
-	Age       int
-	GPA       float64
-	NeverMind string `ini:"-"`
-	*Embeded
-}
-
-func main() {
-	a := &Author{"Unknwon", true, 21, 2.8, "",
-		&Embeded{
-			[]time.Time{time.Now(), time.Now()},
-			[]string{"HangZhou", "Boston"},
-			[]int{},
-		}}
-	cfg := ini.Empty()
-	err = ini.ReflectFrom(cfg, a)
-	// ...
-}
-```
-
-So, what do I get?
-
-```ini
-NAME = Unknwon
-Male = true
-Age = 21
-GPA = 2.8
-
-[Embeded]
-Dates = 2015-08-07T22:14:22+08:00|2015-08-07T22:14:22+08:00
-Places = HangZhou,Boston
-None =
-```
-
-#### Name Mapper
-
-To save your time and make your code cleaner, this library supports [`NameMapper`](https://gowalker.org/gopkg.in/ini.v1#NameMapper) between struct field and actual section and key name.
-
-There are 2 built-in name mappers:
-
-- `AllCapsUnderscore`: it converts to format `ALL_CAPS_UNDERSCORE` then match section or key.
-- `TitleUnderscore`: it converts to format `title_underscore` then match section or key.
-
-To use them:
-
-```go
-type Info struct {
-	PackageName string
-}
-
-func main() {
-	err = ini.MapToWithMapper(&Info{}, ini.TitleUnderscore, []byte("package_name=ini"))
-	// ...
-
-	cfg, err := ini.Load([]byte("PACKAGE_NAME=ini"))
-	// ...
-	info := new(Info)
-	cfg.NameMapper = ini.AllCapsUnderscore
-	err = cfg.MapTo(info)
-	// ...
-}
-```
-
-Same rules of name mapper apply to `ini.ReflectFromWithMapper` function.
-
-#### Other Notes On Map/Reflect
-
-Any embedded struct is treated as a section by default, and there is no automatic parent-child relations in map/reflect feature:
-
-```go
-type Child struct {
-	Age string
-}
-
-type Parent struct {
-	Name string
-	Child
-}
-
-type Config struct {
-	City string
-	Parent
-}
-```
-
-Example configuration:
-
-```ini
-City = Boston
-
-[Parent]
-Name = Unknwon
-
-[Child]
-Age = 21
-```
-
-What if, yes, I'm paranoid, I want embedded struct to be in the same section. Well, all roads lead to Rome.
-
-```go
-type Child struct {
-	Age string
-}
-
-type Parent struct {
-	Name string
-	Child `ini:"Parent"`
-}
-
-type Config struct {
-	City string
-	Parent
-}
-```
-
-Example configuration:
-
-```ini
-City = Boston
-
-[Parent]
-Name = Unknwon
-Age = 21
-```
-
-## Getting Help
-
-- [API Documentation](https://gowalker.org/gopkg.in/ini.v1)
-- [File An Issue](https://github.com/go-ini/ini/issues/new)
-
-## FAQs
-
-### What does `BlockMode` field do?
-
-By default, library lets you read and write values so we need a locker to make sure your data is safe. But in cases that you are very sure about only reading data through the library, you can set `cfg.BlockMode = false` to speed up read operations about **50-70%** faster.
-
-### Why another INI library?
-
-Many people are using my another INI library [goconfig](https://github.com/Unknwon/goconfig), so the reason for this one is I would like to make more Go style code. Also when you set `cfg.BlockMode = false`, this one is about **10-30%** faster.
-
-To make those changes I have to confirm API broken, so it's safer to keep it in another place and start using `gopkg.in` to version my package at this time.(PS: shorter import path)
-
-## License
-
-This project is under Apache v2 License. See the [LICENSE](LICENSE) file for the full license text.
diff --git a/vendor/github.com/go-ini/ini/README_ZH.md b/vendor/github.com/go-ini/ini/README_ZH.md
deleted file mode 100644
index 75c1005..0000000
--- a/vendor/github.com/go-ini/ini/README_ZH.md
+++ /dev/null
@@ -1,619 +0,0 @@
-本包提供了 Go 语言中读写 INI 文件的功能。
-
-## 功能特性
-
-- 支持覆盖加载多个数据源（`[]byte` 或文件）
-- 支持递归读取键值
-- 支持读取父子分区
-- 支持读取自增键名
-- 支持读取多行的键值
-- 支持大量辅助方法
-- 支持在读取时直接转换为 Go 语言类型
-- 支持读取和 **写入** 分区和键的注释
-- 轻松操作分区、键值和注释
-- 在保存文件时分区和键值会保持原有的顺序
-
-## 下载安装
-
-使用一个特定版本：
-
-    go get gopkg.in/ini.v1
-
-使用最新版：
-
-	go get github.com/go-ini/ini
-
-如需更新请添加 `-u` 选项。
-
-### 测试安装
-
-如果您想要在自己的机器上运行测试，请使用 `-t` 标记：
-
-	go get -t gopkg.in/ini.v1
-
-如需更新请添加 `-u` 选项。
-
-## 开始使用
-
-### 从数据源加载
-
-一个 **数据源** 可以是 `[]byte` 类型的原始数据，或 `string` 类型的文件路径。您可以加载 **任意多个** 数据源。如果您传递其它类型的数据源，则会直接返回错误。
-
-```go
-cfg, err := ini.Load([]byte("raw data"), "filename")
-```
-
-或者从一个空白的文件开始：
-
-```go
-cfg := ini.Empty()
-```
-
-当您在一开始无法决定需要加载哪些数据源时，仍可以使用 **Append()** 在需要的时候加载它们。
-
-```go
-err := cfg.Append("other file", []byte("other raw data"))
-```
-
-当您想要加载一系列文件，但是不能够确定其中哪些文件是不存在的，可以通过调用函数 `LooseLoad` 来忽略它们（`Load` 会因为文件不存在而返回错误）：
-
-```go
-cfg, err := ini.LooseLoad("filename", "filename_404")
-```
-
-更牛逼的是，当那些之前不存在的文件在重新调用 `Reload` 方法的时候突然出现了，那么它们会被正常加载。
-
-### 操作分区（Section）
-
-获取指定分区：
-
-```go
-section, err := cfg.GetSection("section name")
-```
-
-如果您想要获取默认分区，则可以用空字符串代替分区名：
-
-```go
-section, err := cfg.GetSection("")
-```
-
-当您非常确定某个分区是存在的，可以使用以下简便方法：
-
-```go
-section := cfg.Section("")
-```
-
-如果不小心判断错了，要获取的分区其实是不存在的，那会发生什么呢？没事的，它会自动创建并返回一个对应的分区对象给您。
-
-创建一个分区：
-
-```go
-err := cfg.NewSection("new section")
-```
-
-获取所有分区对象或名称：
-
-```go
-sections := cfg.Sections()
-names := cfg.SectionStrings()
-```
-
-### 操作键（Key）
-
-获取某个分区下的键：
-
-```go
-key, err := cfg.Section("").GetKey("key name")
-```
-
-和分区一样，您也可以直接获取键而忽略错误处理：
-
-```go
-key := cfg.Section("").Key("key name")
-```
-
-判断某个键是否存在：
-
-```go
-yes := cfg.Section("").HasKey("key name")
-```
-
-创建一个新的键：
-
-```go
-err := cfg.Section("").NewKey("name", "value")
-```
-
-获取分区下的所有键或键名：
-
-```go
-keys := cfg.Section("").Keys()
-names := cfg.Section("").KeyStrings()
-```
-
-获取分区下的所有键值对的克隆：
-
-```go
-hash := cfg.GetSection("").KeysHash()
-```
-
-### 操作键值（Value）
-
-获取一个类型为字符串（string）的值：
-
-```go
-val := cfg.Section("").Key("key name").String()
-```
-
-获取值的同时通过自定义函数进行处理验证：
-
-```go
-val := cfg.Section("").Key("key name").Validate(func(in string) string {
-	if len(in) == 0 {
-		return "default"
-	}
-	return in
-})
-```
-
-如果您不需要任何对值的自动转变功能（例如递归读取），可以直接获取原值（这种方式性能最佳）：
-
-```go
-val := cfg.Section("").Key("key name").Value()
-```
-
-判断某个原值是否存在：
-
-```go
-yes := cfg.Section("").HasValue("test value")
-```
-
-获取其它类型的值：
-
-```go
-// 布尔值的规则：
-// true 当值为：1, t, T, TRUE, true, True, YES, yes, Yes, y, ON, on, On
-// false 当值为：0, f, F, FALSE, false, False, NO, no, No, n, OFF, off, Off
-v, err = cfg.Section("").Key("BOOL").Bool()
-v, err = cfg.Section("").Key("FLOAT64").Float64()
-v, err = cfg.Section("").Key("INT").Int()
-v, err = cfg.Section("").Key("INT64").Int64()
-v, err = cfg.Section("").Key("UINT").Uint()
-v, err = cfg.Section("").Key("UINT64").Uint64()
-v, err = cfg.Section("").Key("TIME").TimeFormat(time.RFC3339)
-v, err = cfg.Section("").Key("TIME").Time() // RFC3339
-
-v = cfg.Section("").Key("BOOL").MustBool()
-v = cfg.Section("").Key("FLOAT64").MustFloat64()
-v = cfg.Section("").Key("INT").MustInt()
-v = cfg.Section("").Key("INT64").MustInt64()
-v = cfg.Section("").Key("UINT").MustUint()
-v = cfg.Section("").Key("UINT64").MustUint64()
-v = cfg.Section("").Key("TIME").MustTimeFormat(time.RFC3339)
-v = cfg.Section("").Key("TIME").MustTime() // RFC3339
-
-// 由 Must 开头的方法名允许接收一个相同类型的参数来作为默认值，
-// 当键不存在或者转换失败时，则会直接返回该默认值。
-// 但是，MustString 方法必须传递一个默认值。
-
-v = cfg.Seciont("").Key("String").MustString("default")
-v = cfg.Section("").Key("BOOL").MustBool(true)
-v = cfg.Section("").Key("FLOAT64").MustFloat64(1.25)
-v = cfg.Section("").Key("INT").MustInt(10)
-v = cfg.Section("").Key("INT64").MustInt64(99)
-v = cfg.Section("").Key("UINT").MustUint(3)
-v = cfg.Section("").Key("UINT64").MustUint64(6)
-v = cfg.Section("").Key("TIME").MustTimeFormat(time.RFC3339, time.Now())
-v = cfg.Section("").Key("TIME").MustTime(time.Now()) // RFC3339
-```
-
-如果我的值有好多行怎么办？
-
-```ini
-[advance]
-ADDRESS = """404 road,
-NotFound, State, 5000
-Earth"""
-```
-
-嗯哼？小 case！
-
-```go
-cfg.Section("advance").Key("ADDRESS").String()
-
-/* --- start ---
-404 road,
-NotFound, State, 5000
-Earth
-------  end  --- */
-```
-
-赞爆了！那要是我属于一行的内容写不下想要写到第二行怎么办？
-
-```ini
-[advance]
-two_lines = how about \
-	continuation lines?
-lots_of_lines = 1 \
-	2 \
-	3 \
-	4
-```
-
-简直是小菜一碟！
-
-```go
-cfg.Section("advance").Key("two_lines").String() // how about continuation lines?
-cfg.Section("advance").Key("lots_of_lines").String() // 1 2 3 4
-```
-
-需要注意的是，值两侧的单引号会被自动剔除：
-
-```ini
-foo = "some value" // foo: some value
-bar = 'some value' // bar: some value
-```
-
-这就是全部了？哈哈，当然不是。
-
-#### 操作键值的辅助方法
-
-获取键值时设定候选值：
-
-```go
-v = cfg.Section("").Key("STRING").In("default", []string{"str", "arr", "types"})
-v = cfg.Section("").Key("FLOAT64").InFloat64(1.1, []float64{1.25, 2.5, 3.75})
-v = cfg.Section("").Key("INT").InInt(5, []int{10, 20, 30})
-v = cfg.Section("").Key("INT64").InInt64(10, []int64{10, 20, 30})
-v = cfg.Section("").Key("UINT").InUint(4, []int{3, 6, 9})
-v = cfg.Section("").Key("UINT64").InUint64(8, []int64{3, 6, 9})
-v = cfg.Section("").Key("TIME").InTimeFormat(time.RFC3339, time.Now(), []time.Time{time1, time2, time3})
-v = cfg.Section("").Key("TIME").InTime(time.Now(), []time.Time{time1, time2, time3}) // RFC3339
-```
-
-如果获取到的值不是候选值的任意一个，则会返回默认值，而默认值不需要是候选值中的一员。
-
-验证获取的值是否在指定范围内：
-
-```go
-vals = cfg.Section("").Key("FLOAT64").RangeFloat64(0.0, 1.1, 2.2)
-vals = cfg.Section("").Key("INT").RangeInt(0, 10, 20)
-vals = cfg.Section("").Key("INT64").RangeInt64(0, 10, 20)
-vals = cfg.Section("").Key("UINT").RangeUint(0, 3, 9)
-vals = cfg.Section("").Key("UINT64").RangeUint64(0, 3, 9)
-vals = cfg.Section("").Key("TIME").RangeTimeFormat(time.RFC3339, time.Now(), minTime, maxTime)
-vals = cfg.Section("").Key("TIME").RangeTime(time.Now(), minTime, maxTime) // RFC3339
-```
-
-##### 自动分割键值到切片（slice）
-
-当存在无效输入时，使用零值代替：
-
-```go
-// Input: 1.1, 2.2, 3.3, 4.4 -> [1.1 2.2 3.3 4.4]
-// Input: how, 2.2, are, you -> [0.0 2.2 0.0 0.0]
-vals = cfg.Section("").Key("STRINGS").Strings(",")
-vals = cfg.Section("").Key("FLOAT64S").Float64s(",")
-vals = cfg.Section("").Key("INTS").Ints(",")
-vals = cfg.Section("").Key("INT64S").Int64s(",")
-vals = cfg.Section("").Key("UINTS").Uints(",")
-vals = cfg.Section("").Key("UINT64S").Uint64s(",")
-vals = cfg.Section("").Key("TIMES").Times(",")
-```
-
-从结果切片中剔除无效输入：
-
-```go
-// Input: 1.1, 2.2, 3.3, 4.4 -> [1.1 2.2 3.3 4.4]
-// Input: how, 2.2, are, you -> [2.2]
-vals = cfg.Section("").Key("FLOAT64S").ValidFloat64s(",")
-vals = cfg.Section("").Key("INTS").ValidInts(",")
-vals = cfg.Section("").Key("INT64S").ValidInt64s(",")
-vals = cfg.Section("").Key("UINTS").ValidUints(",")
-vals = cfg.Section("").Key("UINT64S").ValidUint64s(",")
-vals = cfg.Section("").Key("TIMES").ValidTimes(",")
-```
-
-当存在无效输入时，直接返回错误：
-
-```go
-// Input: 1.1, 2.2, 3.3, 4.4 -> [1.1 2.2 3.3 4.4]
-// Input: how, 2.2, are, you -> error
-vals = cfg.Section("").Key("FLOAT64S").StrictFloat64s(",")
-vals = cfg.Section("").Key("INTS").StrictInts(",")
-vals = cfg.Section("").Key("INT64S").StrictInt64s(",")
-vals = cfg.Section("").Key("UINTS").StrictUints(",")
-vals = cfg.Section("").Key("UINT64S").StrictUint64s(",")
-vals = cfg.Section("").Key("TIMES").StrictTimes(",")
-```
-
-### 保存配置
-
-终于到了这个时刻，是时候保存一下配置了。
-
-比较原始的做法是输出配置到某个文件：
-
-```go
-// ...
-err = cfg.SaveTo("my.ini")
-err = cfg.SaveToIndent("my.ini", "\t")
-```
-
-另一个比较高级的做法是写入到任何实现 `io.Writer` 接口的对象中：
-
-```go
-// ...
-cfg.WriteTo(writer)
-cfg.WriteToIndent(writer, "\t")
-```
-
-### 高级用法
-
-#### 递归读取键值
-
-在获取所有键值的过程中，特殊语法 `%(<name>)s` 会被应用，其中 `<name>` 可以是相同分区或者默认分区下的键名。字符串 `%(<name>)s` 会被相应的键值所替代，如果指定的键不存在，则会用空字符串替代。您可以最多使用 99 层的递归嵌套。
-
-```ini
-NAME = ini
-
-[author]
-NAME = Unknwon
-GITHUB = https://github.com/%(NAME)s
-
-[package]
-FULL_NAME = github.com/go-ini/%(NAME)s
-```
-
-```go
-cfg.Section("author").Key("GITHUB").String()		// https://github.com/Unknwon
-cfg.Section("package").Key("FULL_NAME").String()	// github.com/go-ini/ini
-```
-
-#### 读取父子分区
-
-您可以在分区名称中使用 `.` 来表示两个或多个分区之间的父子关系。如果某个键在子分区中不存在，则会去它的父分区中再次寻找，直到没有父分区为止。
-
-```ini
-NAME = ini
-VERSION = v1
-IMPORT_PATH = gopkg.in/%(NAME)s.%(VERSION)s
-
-[package]
-CLONE_URL = https://%(IMPORT_PATH)s
-
-[package.sub]
-```
-
-```go
-cfg.Section("package.sub").Key("CLONE_URL").String()	// https://gopkg.in/ini.v1
-```
-
-#### 读取自增键名
-
-如果数据源中的键名为 `-`，则认为该键使用了自增键名的特殊语法。计数器从 1 开始，并且分区之间是相互独立的。
-
-```ini
-[features]
--: Support read/write comments of keys and sections
--: Support auto-increment of key names
--: Support load multiple files to overwrite key values
-```
-
-```go
-cfg.Section("features").KeyStrings()	// []{"#1", "#2", "#3"}
-```
-
-### 映射到结构
-
-想要使用更加面向对象的方式玩转 INI 吗？好主意。
-
-```ini
-Name = Unknwon
-age = 21
-Male = true
-Born = 1993-01-01T20:17:05Z
-
-[Note]
-Content = Hi is a good man!
-Cities = HangZhou, Boston
-```
-
-```go
-type Note struct {
-	Content string
-	Cities  []string
-}
-
-type Person struct {
-	Name string
-	Age  int `ini:"age"`
-	Male bool
-	Born time.Time
-	Note
-	Created time.Time `ini:"-"`
-}
-
-func main() {
-	cfg, err := ini.Load("path/to/ini")
-	// ...
-	p := new(Person)
-	err = cfg.MapTo(p)
-	// ...
-
-	// 一切竟可以如此的简单。
-	err = ini.MapTo(p, "path/to/ini")
-	// ...
-
-	// 嗯哼？只需要映射一个分区吗？
-	n := new(Note)
-	err = cfg.Section("Note").MapTo(n)
-	// ...
-}
-```
-
-结构的字段怎么设置默认值呢？很简单，只要在映射之前对指定字段进行赋值就可以了。如果键未找到或者类型错误，该值不会发生改变。
-
-```go
-// ...
-p := &Person{
-	Name: "Joe",
-}
-// ...
-```
-
-这样玩 INI 真的好酷啊！然而，如果不能还给我原来的配置文件，有什么卵用？
-
-### 从结构反射
-
-可是，我有说不能吗？
-
-```go
-type Embeded struct {
-	Dates  []time.Time `delim:"|"`
-	Places []string
-	None   []int
-}
-
-type Author struct {
-	Name      string `ini:"NAME"`
-	Male      bool
-	Age       int
-	GPA       float64
-	NeverMind string `ini:"-"`
-	*Embeded
-}
-
-func main() {
-	a := &Author{"Unknwon", true, 21, 2.8, "",
-		&Embeded{
-			[]time.Time{time.Now(), time.Now()},
-			[]string{"HangZhou", "Boston"},
-			[]int{},
-		}}
-	cfg := ini.Empty()
-	err = ini.ReflectFrom(cfg, a)
-	// ...
-}
-```
-
-瞧瞧，奇迹发生了。
-
-```ini
-NAME = Unknwon
-Male = true
-Age = 21
-GPA = 2.8
-
-[Embeded]
-Dates = 2015-08-07T22:14:22+08:00|2015-08-07T22:14:22+08:00
-Places = HangZhou,Boston
-None =
-```
-
-#### 名称映射器（Name Mapper）
-
-为了节省您的时间并简化代码，本库支持类型为 [`NameMapper`](https://gowalker.org/gopkg.in/ini.v1#NameMapper) 的名称映射器，该映射器负责结构字段名与分区名和键名之间的映射。
-
-目前有 2 款内置的映射器：
-
-- `AllCapsUnderscore`：该映射器将字段名转换至格式 `ALL_CAPS_UNDERSCORE` 后再去匹配分区名和键名。
-- `TitleUnderscore`：该映射器将字段名转换至格式 `title_underscore` 后再去匹配分区名和键名。
-
-使用方法：
-
-```go
-type Info struct{
-	PackageName string
-}
-
-func main() {
-	err = ini.MapToWithMapper(&Info{}, ini.TitleUnderscore, []byte("package_name=ini"))
-	// ...
-
-	cfg, err := ini.Load([]byte("PACKAGE_NAME=ini"))
-	// ...
-	info := new(Info)
-	cfg.NameMapper = ini.AllCapsUnderscore
-	err = cfg.MapTo(info)
-	// ...
-}
-```
-
-使用函数 `ini.ReflectFromWithMapper` 时也可应用相同的规则。
-
-#### 映射/反射的其它说明
-
-任何嵌入的结构都会被默认认作一个不同的分区，并且不会自动产生所谓的父子分区关联：
-
-```go
-type Child struct {
-	Age string
-}
-
-type Parent struct {
-	Name string
-	Child
-}
-
-type Config struct {
-	City string
-	Parent
-}
-```
-
-示例配置文件：
-
-```ini
-City = Boston
-
-[Parent]
-Name = Unknwon
-
-[Child]
-Age = 21
-```
-
-很好，但是，我就是要嵌入结构也在同一个分区。好吧，你爹是李刚！
-
-```go
-type Child struct {
-	Age string
-}
-
-type Parent struct {
-	Name string
-	Child `ini:"Parent"`
-}
-
-type Config struct {
-	City string
-	Parent
-}
-```
-
-示例配置文件：
-
-```ini
-City = Boston
-
-[Parent]
-Name = Unknwon
-Age = 21
-```
-
-## 获取帮助
-
-- [API 文档](https://gowalker.org/gopkg.in/ini.v1)
-- [创建工单](https://github.com/go-ini/ini/issues/new)
-
-## 常见问题
-
-### 字段 `BlockMode` 是什么？
-
-默认情况下，本库会在您进行读写操作时采用锁机制来确保数据时间。但在某些情况下，您非常确定只进行读操作。此时，您可以通过设置 `cfg.BlockMode = false` 来将读操作提升大约 **50-70%** 的性能。
-
-### 为什么要写另一个 INI 解析库？
-
-许多人都在使用我的 [goconfig](https://github.com/Unknwon/goconfig) 来完成对 INI 文件的操作，但我希望使用更加 Go 风格的代码。并且当您设置 `cfg.BlockMode = false` 时，会有大约 **10-30%** 的性能提升。
-
-为了做出这些改变，我必须对 API 进行破坏，所以新开一个仓库是最安全的做法。除此之外，本库直接使用 `gopkg.in` 来进行版本化发布。（其实真相是导入路径更短了）
diff --git a/vendor/github.com/go-ini/ini/ini.go b/vendor/github.com/go-ini/ini/ini.go
deleted file mode 100644
index f186148..0000000
--- a/vendor/github.com/go-ini/ini/ini.go
+++ /dev/null
@@ -1,465 +0,0 @@
-// Copyright 2014 Unknwon
-//
-// Licensed under the Apache License, Version 2.0 (the "License"): you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-// License for the specific language governing permissions and limitations
-// under the License.
-
-// Package ini provides INI file read and write functionality in Go.
-package ini
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"regexp"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-)
-
-const (
-	// Name for default section. You can use this constant or the string literal.
-	// In most of cases, an empty string is all you need to access the section.
-	DEFAULT_SECTION = "DEFAULT"
-
-	// Maximum allowed depth when recursively substituing variable names.
-	_DEPTH_VALUES = 99
-	_VERSION      = "1.11.0"
-)
-
-// Version returns current package version literal.
-func Version() string {
-	return _VERSION
-}
-
-var (
-	// Delimiter to determine or compose a new line.
-	// This variable will be changed to "\r\n" automatically on Windows
-	// at package init time.
-	LineBreak = "\n"
-
-	// Variable regexp pattern: %(variable)s
-	varPattern = regexp.MustCompile(`%\(([^\)]+)\)s`)
-
-	// Indicate whether to align "=" sign with spaces to produce pretty output
-	// or reduce all possible spaces for compact format.
-	PrettyFormat = true
-
-	// Explicitly write DEFAULT section header
-	DefaultHeader = false
-)
-
-func init() {
-	if runtime.GOOS == "windows" {
-		LineBreak = "\r\n"
-	}
-}
-
-func inSlice(str string, s []string) bool {
-	for _, v := range s {
-		if str == v {
-			return true
-		}
-	}
-	return false
-}
-
-// dataSource is an interface that returns object which can be read and closed.
-type dataSource interface {
-	ReadCloser() (io.ReadCloser, error)
-}
-
-// sourceFile represents an object that contains content on the local file system.
-type sourceFile struct {
-	name string
-}
-
-func (s sourceFile) ReadCloser() (_ io.ReadCloser, err error) {
-	return os.Open(s.name)
-}
-
-type bytesReadCloser struct {
-	reader io.Reader
-}
-
-func (rc *bytesReadCloser) Read(p []byte) (n int, err error) {
-	return rc.reader.Read(p)
-}
-
-func (rc *bytesReadCloser) Close() error {
-	return nil
-}
-
-// sourceData represents an object that contains content in memory.
-type sourceData struct {
-	data []byte
-}
-
-func (s *sourceData) ReadCloser() (io.ReadCloser, error) {
-	return &bytesReadCloser{bytes.NewReader(s.data)}, nil
-}
-
-// File represents a combination of a or more INI file(s) in memory.
-type File struct {
-	// Should make things safe, but sometimes doesn't matter.
-	BlockMode bool
-	// Make sure data is safe in multiple goroutines.
-	lock sync.RWMutex
-
-	// Allow combination of multiple data sources.
-	dataSources []dataSource
-	// Actual data is stored here.
-	sections map[string]*Section
-
-	// To keep data in order.
-	sectionList []string
-
-	// Whether the parser should ignore nonexistent files or return error.
-	looseMode bool
-
-	NameMapper
-}
-
-// newFile initializes File object with given data sources.
-func newFile(dataSources []dataSource, looseMode bool) *File {
-	return &File{
-		BlockMode:   true,
-		dataSources: dataSources,
-		sections:    make(map[string]*Section),
-		sectionList: make([]string, 0, 10),
-		looseMode:   looseMode,
-	}
-}
-
-func parseDataSource(source interface{}) (dataSource, error) {
-	switch s := source.(type) {
-	case string:
-		return sourceFile{s}, nil
-	case []byte:
-		return &sourceData{s}, nil
-	default:
-		return nil, fmt.Errorf("error parsing data source: unknown type '%s'", s)
-	}
-}
-
-func loadSources(looseMode bool, source interface{}, others ...interface{}) (_ *File, err error) {
-	sources := make([]dataSource, len(others)+1)
-	sources[0], err = parseDataSource(source)
-	if err != nil {
-		return nil, err
-	}
-	for i := range others {
-		sources[i+1], err = parseDataSource(others[i])
-		if err != nil {
-			return nil, err
-		}
-	}
-	f := newFile(sources, looseMode)
-	if err = f.Reload(); err != nil {
-		return nil, err
-	}
-	return f, nil
-}
-
-// Load loads and parses from INI data sources.
-// Arguments can be mixed of file name with string type, or raw data in []byte.
-// It will return error if list contains nonexistent files.
-func Load(source interface{}, others ...interface{}) (*File, error) {
-	return loadSources(false, source, others...)
-}
-
-// LooseLoad has exactly same functionality as Load function
-// except it ignores nonexistent files instead of returning error.
-func LooseLoad(source interface{}, others ...interface{}) (*File, error) {
-	return loadSources(true, source, others...)
-}
-
-// Empty returns an empty file object.
-func Empty() *File {
-	// Ignore error here, we sure our data is good.
-	f, _ := Load([]byte(""))
-	return f
-}
-
-// NewSection creates a new section.
-func (f *File) NewSection(name string) (*Section, error) {
-	if len(name) == 0 {
-		return nil, errors.New("error creating new section: empty section name")
-	}
-
-	if f.BlockMode {
-		f.lock.Lock()
-		defer f.lock.Unlock()
-	}
-
-	if inSlice(name, f.sectionList) {
-		return f.sections[name], nil
-	}
-
-	f.sectionList = append(f.sectionList, name)
-	f.sections[name] = newSection(f, name)
-	return f.sections[name], nil
-}
-
-// NewSections creates a list of sections.
-func (f *File) NewSections(names ...string) (err error) {
-	for _, name := range names {
-		if _, err = f.NewSection(name); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// GetSection returns section by given name.
-func (f *File) GetSection(name string) (*Section, error) {
-	if len(name) == 0 {
-		name = DEFAULT_SECTION
-	}
-
-	if f.BlockMode {
-		f.lock.RLock()
-		defer f.lock.RUnlock()
-	}
-
-	sec := f.sections[name]
-	if sec == nil {
-		return nil, fmt.Errorf("section '%s' does not exist", name)
-	}
-	return sec, nil
-}
-
-// Section assumes named section exists and returns a zero-value when not.
-func (f *File) Section(name string) *Section {
-	sec, err := f.GetSection(name)
-	if err != nil {
-		// Note: It's OK here because the only possible error is empty section name,
-		// but if it's empty, this piece of code won't be executed.
-		sec, _ = f.NewSection(name)
-		return sec
-	}
-	return sec
-}
-
-// Section returns list of Section.
-func (f *File) Sections() []*Section {
-	sections := make([]*Section, len(f.sectionList))
-	for i := range f.sectionList {
-		sections[i] = f.Section(f.sectionList[i])
-	}
-	return sections
-}
-
-// SectionStrings returns list of section names.
-func (f *File) SectionStrings() []string {
-	list := make([]string, len(f.sectionList))
-	copy(list, f.sectionList)
-	return list
-}
-
-// DeleteSection deletes a section.
-func (f *File) DeleteSection(name string) {
-	if f.BlockMode {
-		f.lock.Lock()
-		defer f.lock.Unlock()
-	}
-
-	if len(name) == 0 {
-		name = DEFAULT_SECTION
-	}
-
-	for i, s := range f.sectionList {
-		if s == name {
-			f.sectionList = append(f.sectionList[:i], f.sectionList[i+1:]...)
-			delete(f.sections, name)
-			return
-		}
-	}
-}
-
-func (f *File) reload(s dataSource) error {
-	r, err := s.ReadCloser()
-	if err != nil {
-		return err
-	}
-	defer r.Close()
-
-	return f.parse(r)
-}
-
-// Reload reloads and parses all data sources.
-func (f *File) Reload() (err error) {
-	for _, s := range f.dataSources {
-		if err = f.reload(s); err != nil {
-			// In loose mode, we create an empty default section for nonexistent files.
-			if os.IsNotExist(err) && f.looseMode {
-				f.parse(bytes.NewBuffer(nil))
-				continue
-			}
-			return err
-		}
-	}
-	return nil
-}
-
-// Append appends one or more data sources and reloads automatically.
-func (f *File) Append(source interface{}, others ...interface{}) error {
-	ds, err := parseDataSource(source)
-	if err != nil {
-		return err
-	}
-	f.dataSources = append(f.dataSources, ds)
-	for _, s := range others {
-		ds, err = parseDataSource(s)
-		if err != nil {
-			return err
-		}
-		f.dataSources = append(f.dataSources, ds)
-	}
-	return f.Reload()
-}
-
-// WriteToIndent writes content into io.Writer with given indention.
-// If PrettyFormat has been set to be true,
-// it will align "=" sign with spaces under each section.
-func (f *File) WriteToIndent(w io.Writer, indent string) (n int64, err error) {
-	equalSign := "="
-	if PrettyFormat {
-		equalSign = " = "
-	}
-
-	// Use buffer to make sure target is safe until finish encoding.
-	buf := bytes.NewBuffer(nil)
-	for i, sname := range f.sectionList {
-		sec := f.Section(sname)
-		if len(sec.Comment) > 0 {
-			if sec.Comment[0] != '#' && sec.Comment[0] != ';' {
-				sec.Comment = "; " + sec.Comment
-			}
-			if _, err = buf.WriteString(sec.Comment + LineBreak); err != nil {
-				return 0, err
-			}
-		}
-
-		if i > 0 || DefaultHeader {
-			if _, err = buf.WriteString("[" + sname + "]" + LineBreak); err != nil {
-				return 0, err
-			}
-		} else {
-			// Write nothing if default section is empty
-			if len(sec.keyList) == 0 {
-				continue
-			}
-		}
-
-		// Count and generate alignment length and buffer spaces
-		alignLength := 0
-		if PrettyFormat {
-			for i := 0; i < len(sec.keyList); i++ {
-				if len(sec.keyList[i]) > alignLength {
-					alignLength = len(sec.keyList[i])
-				}
-			}
-		}
-		alignSpaces := bytes.Repeat([]byte(" "), alignLength)
-
-		for _, kname := range sec.keyList {
-			key := sec.Key(kname)
-			if len(key.Comment) > 0 {
-				if len(indent) > 0 && sname != DEFAULT_SECTION {
-					buf.WriteString(indent)
-				}
-				if key.Comment[0] != '#' && key.Comment[0] != ';' {
-					key.Comment = "; " + key.Comment
-				}
-				if _, err = buf.WriteString(key.Comment + LineBreak); err != nil {
-					return 0, err
-				}
-			}
-
-			if len(indent) > 0 && sname != DEFAULT_SECTION {
-				buf.WriteString(indent)
-			}
-
-			switch {
-			case key.isAutoIncr:
-				kname = "-"
-			case strings.ContainsAny(kname, "\"=:"):
-				kname = "`" + kname + "`"
-			case strings.Contains(kname, "`"):
-				kname = `"""` + kname + `"""`
-			}
-			if _, err = buf.WriteString(kname); err != nil {
-				return 0, err
-			}
-
-			// Write out alignment spaces before "=" sign
-			if PrettyFormat {
-				buf.Write(alignSpaces[:alignLength-len(kname)])
-			}
-
-			val := key.value
-			// In case key value contains "\n", "`", "\"", "#" or ";"
-			if strings.ContainsAny(val, "\n`") {
-				val = `"""` + val + `"""`
-			} else if strings.ContainsAny(val, "#;") {
-				val = "`" + val + "`"
-			}
-			if _, err = buf.WriteString(equalSign + val + LineBreak); err != nil {
-				return 0, err
-			}
-		}
-
-		// Put a line between sections
-		if _, err = buf.WriteString(LineBreak); err != nil {
-			return 0, err
-		}
-	}
-
-	return buf.WriteTo(w)
-}
-
-// WriteTo writes file content into io.Writer.
-func (f *File) WriteTo(w io.Writer) (int64, error) {
-	return f.WriteToIndent(w, "")
-}
-
-// SaveToIndent writes content to file system with given value indention.
-func (f *File) SaveToIndent(filename, indent string) error {
-	// Note: Because we are truncating with os.Create,
-	// 	so it's safer to save to a temporary file location and rename afte done.
-	tmpPath := filename + "." + strconv.Itoa(time.Now().Nanosecond()) + ".tmp"
-	defer os.Remove(tmpPath)
-
-	fw, err := os.Create(tmpPath)
-	if err != nil {
-		return err
-	}
-
-	if _, err = f.WriteToIndent(fw, indent); err != nil {
-		fw.Close()
-		return err
-	}
-	fw.Close()
-
-	// Remove old file and rename the new one.
-	os.Remove(filename)
-	return os.Rename(tmpPath, filename)
-}
-
-// SaveTo writes content to file system.
-func (f *File) SaveTo(filename string) error {
-	return f.SaveToIndent(filename, "")
-}
diff --git a/vendor/github.com/go-ini/ini/key.go b/vendor/github.com/go-ini/ini/key.go
deleted file mode 100644
index 7cbccd3..0000000
--- a/vendor/github.com/go-ini/ini/key.go
+++ /dev/null
@@ -1,616 +0,0 @@
-// Copyright 2014 Unknwon
-//
-// Licensed under the Apache License, Version 2.0 (the "License"): you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-// License for the specific language governing permissions and limitations
-// under the License.
-
-package ini
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Key represents a key under a section.
-type Key struct {
-	s          *Section
-	Comment    string
-	name       string
-	value      string
-	isAutoIncr bool
-}
-
-// Name returns name of key.
-func (k *Key) Name() string {
-	return k.name
-}
-
-// Value returns raw value of key for performance purpose.
-func (k *Key) Value() string {
-	return k.value
-}
-
-// String returns string representation of value.
-func (k *Key) String() string {
-	val := k.value
-	if strings.Index(val, "%") == -1 {
-		return val
-	}
-
-	for i := 0; i < _DEPTH_VALUES; i++ {
-		vr := varPattern.FindString(val)
-		if len(vr) == 0 {
-			break
-		}
-
-		// Take off leading '%(' and trailing ')s'.
-		noption := strings.TrimLeft(vr, "%(")
-		noption = strings.TrimRight(noption, ")s")
-
-		// Search in the same section.
-		nk, err := k.s.GetKey(noption)
-		if err != nil {
-			// Search again in default section.
-			nk, _ = k.s.f.Section("").GetKey(noption)
-		}
-
-		// Substitute by new value and take off leading '%(' and trailing ')s'.
-		val = strings.Replace(val, vr, nk.value, -1)
-	}
-	return val
-}
-
-// Validate accepts a validate function which can
-// return modifed result as key value.
-func (k *Key) Validate(fn func(string) string) string {
-	return fn(k.String())
-}
-
-// parseBool returns the boolean value represented by the string.
-//
-// It accepts 1, t, T, TRUE, true, True, YES, yes, Yes, y, ON, on, On,
-// 0, f, F, FALSE, false, False, NO, no, No, n, OFF, off, Off.
-// Any other value returns an error.
-func parseBool(str string) (value bool, err error) {
-	switch str {
-	case "1", "t", "T", "true", "TRUE", "True", "YES", "yes", "Yes", "y", "ON", "on", "On":
-		return true, nil
-	case "0", "f", "F", "false", "FALSE", "False", "NO", "no", "No", "n", "OFF", "off", "Off":
-		return false, nil
-	}
-	return false, fmt.Errorf("parsing \"%s\": invalid syntax", str)
-}
-
-// Bool returns bool type value.
-func (k *Key) Bool() (bool, error) {
-	return parseBool(k.String())
-}
-
-// Float64 returns float64 type value.
-func (k *Key) Float64() (float64, error) {
-	return strconv.ParseFloat(k.String(), 64)
-}
-
-// Int returns int type value.
-func (k *Key) Int() (int, error) {
-	return strconv.Atoi(k.String())
-}
-
-// Int64 returns int64 type value.
-func (k *Key) Int64() (int64, error) {
-	return strconv.ParseInt(k.String(), 10, 64)
-}
-
-// Uint returns uint type valued.
-func (k *Key) Uint() (uint, error) {
-	u, e := strconv.ParseUint(k.String(), 10, 64)
-	return uint(u), e
-}
-
-// Uint64 returns uint64 type value.
-func (k *Key) Uint64() (uint64, error) {
-	return strconv.ParseUint(k.String(), 10, 64)
-}
-
-// Duration returns time.Duration type value.
-func (k *Key) Duration() (time.Duration, error) {
-	return time.ParseDuration(k.String())
-}
-
-// TimeFormat parses with given format and returns time.Time type value.
-func (k *Key) TimeFormat(format string) (time.Time, error) {
-	return time.Parse(format, k.String())
-}
-
-// Time parses with RFC3339 format and returns time.Time type value.
-func (k *Key) Time() (time.Time, error) {
-	return k.TimeFormat(time.RFC3339)
-}
-
-// MustString returns default value if key value is empty.
-func (k *Key) MustString(defaultVal string) string {
-	val := k.String()
-	if len(val) == 0 {
-		return defaultVal
-	}
-	return val
-}
-
-// MustBool always returns value without error,
-// it returns false if error occurs.
-func (k *Key) MustBool(defaultVal ...bool) bool {
-	val, err := k.Bool()
-	if len(defaultVal) > 0 && err != nil {
-		return defaultVal[0]
-	}
-	return val
-}
-
-// MustFloat64 always returns value without error,
-// it returns 0.0 if error occurs.
-func (k *Key) MustFloat64(defaultVal ...float64) float64 {
-	val, err := k.Float64()
-	if len(defaultVal) > 0 && err != nil {
-		return defaultVal[0]
-	}
-	return val
-}
-
-// MustInt always returns value without error,
-// it returns 0 if error occurs.
-func (k *Key) MustInt(defaultVal ...int) int {
-	val, err := k.Int()
-	if len(defaultVal) > 0 && err != nil {
-		return defaultVal[0]
-	}
-	return val
-}
-
-// MustInt64 always returns value without error,
-// it returns 0 if error occurs.
-func (k *Key) MustInt64(defaultVal ...int64) int64 {
-	val, err := k.Int64()
-	if len(defaultVal) > 0 && err != nil {
-		return defaultVal[0]
-	}
-	return val
-}
-
-// MustUint always returns value without error,
-// it returns 0 if error occurs.
-func (k *Key) MustUint(defaultVal ...uint) uint {
-	val, err := k.Uint()
-	if len(defaultVal) > 0 && err != nil {
-		return defaultVal[0]
-	}
-	return val
-}
-
-// MustUint64 always returns value without error,
-// it returns 0 if error occurs.
-func (k *Key) MustUint64(defaultVal ...uint64) uint64 {
-	val, err := k.Uint64()
-	if len(defaultVal) > 0 && err != nil {
-		return defaultVal[0]
-	}
-	return val
-}
-
-// MustDuration always returns value without error,
-// it returns zero value if error occurs.
-func (k *Key) MustDuration(defaultVal ...time.Duration) time.Duration {
-	val, err := k.Duration()
-	if len(defaultVal) > 0 && err != nil {
-		return defaultVal[0]
-	}
-	return val
-}
-
-// MustTimeFormat always parses with given format and returns value without error,
-// it returns zero value if error occurs.
-func (k *Key) MustTimeFormat(format string, defaultVal ...time.Time) time.Time {
-	val, err := k.TimeFormat(format)
-	if len(defaultVal) > 0 && err != nil {
-		return defaultVal[0]
-	}
-	return val
-}
-
-// MustTime always parses with RFC3339 format and returns value without error,
-// it returns zero value if error occurs.
-func (k *Key) MustTime(defaultVal ...time.Time) time.Time {
-	return k.MustTimeFormat(time.RFC3339, defaultVal...)
-}
-
-// In always returns value without error,
-// it returns default value if error occurs or doesn't fit into candidates.
-func (k *Key) In(defaultVal string, candidates []string) string {
-	val := k.String()
-	for _, cand := range candidates {
-		if val == cand {
-			return val
-		}
-	}
-	return defaultVal
-}
-
-// InFloat64 always returns value without error,
-// it returns default value if error occurs or doesn't fit into candidates.
-func (k *Key) InFloat64(defaultVal float64, candidates []float64) float64 {
-	val := k.MustFloat64()
-	for _, cand := range candidates {
-		if val == cand {
-			return val
-		}
-	}
-	return defaultVal
-}
-
-// InInt always returns value without error,
-// it returns default value if error occurs or doesn't fit into candidates.
-func (k *Key) InInt(defaultVal int, candidates []int) int {
-	val := k.MustInt()
-	for _, cand := range candidates {
-		if val == cand {
-			return val
-		}
-	}
-	return defaultVal
-}
-
-// InInt64 always returns value without error,
-// it returns default value if error occurs or doesn't fit into candidates.
-func (k *Key) InInt64(defaultVal int64, candidates []int64) int64 {
-	val := k.MustInt64()
-	for _, cand := range candidates {
-		if val == cand {
-			return val
-		}
-	}
-	return defaultVal
-}
-
-// InUint always returns value without error,
-// it returns default value if error occurs or doesn't fit into candidates.
-func (k *Key) InUint(defaultVal uint, candidates []uint) uint {
-	val := k.MustUint()
-	for _, cand := range candidates {
-		if val == cand {
-			return val
-		}
-	}
-	return defaultVal
-}
-
-// InUint64 always returns value without error,
-// it returns default value if error occurs or doesn't fit into candidates.
-func (k *Key) InUint64(defaultVal uint64, candidates []uint64) uint64 {
-	val := k.MustUint64()
-	for _, cand := range candidates {
-		if val == cand {
-			return val
-		}
-	}
-	return defaultVal
-}
-
-// InTimeFormat always parses with given format and returns value without error,
-// it returns default value if error occurs or doesn't fit into candidates.
-func (k *Key) InTimeFormat(format string, defaultVal time.Time, candidates []time.Time) time.Time {
-	val := k.MustTimeFormat(format)
-	for _, cand := range candidates {
-		if val == cand {
-			return val
-		}
-	}
-	return defaultVal
-}
-
-// InTime always parses with RFC3339 format and returns value without error,
-// it returns default value if error occurs or doesn't fit into candidates.
-func (k *Key) InTime(defaultVal time.Time, candidates []time.Time) time.Time {
-	return k.InTimeFormat(time.RFC3339, defaultVal, candidates)
-}
-
-// RangeFloat64 checks if value is in given range inclusively,
-// and returns default value if it's not.
-func (k *Key) RangeFloat64(defaultVal, min, max float64) float64 {
-	val := k.MustFloat64()
-	if val < min || val > max {
-		return defaultVal
-	}
-	return val
-}
-
-// RangeInt checks if value is in given range inclusively,
-// and returns default value if it's not.
-func (k *Key) RangeInt(defaultVal, min, max int) int {
-	val := k.MustInt()
-	if val < min || val > max {
-		return defaultVal
-	}
-	return val
-}
-
-// RangeInt64 checks if value is in given range inclusively,
-// and returns default value if it's not.
-func (k *Key) RangeInt64(defaultVal, min, max int64) int64 {
-	val := k.MustInt64()
-	if val < min || val > max {
-		return defaultVal
-	}
-	return val
-}
-
-// RangeTimeFormat checks if value with given format is in given range inclusively,
-// and returns default value if it's not.
-func (k *Key) RangeTimeFormat(format string, defaultVal, min, max time.Time) time.Time {
-	val := k.MustTimeFormat(format)
-	if val.Unix() < min.Unix() || val.Unix() > max.Unix() {
-		return defaultVal
-	}
-	return val
-}
-
-// RangeTime checks if value with RFC3339 format is in given range inclusively,
-// and returns default value if it's not.
-func (k *Key) RangeTime(defaultVal, min, max time.Time) time.Time {
-	return k.RangeTimeFormat(time.RFC3339, defaultVal, min, max)
-}
-
-// Strings returns list of string divided by given delimiter.
-func (k *Key) Strings(delim string) []string {
-	str := k.String()
-	if len(str) == 0 {
-		return []string{}
-	}
-
-	vals := strings.Split(str, delim)
-	for i := range vals {
-		vals[i] = strings.TrimSpace(vals[i])
-	}
-	return vals
-}
-
-// Float64s returns list of float64 divided by given delimiter. Any invalid input will be treated as zero value.
-func (k *Key) Float64s(delim string) []float64 {
-	vals, _ := k.getFloat64s(delim, true, false)
-	return vals
-}
-
-// Ints returns list of int divided by given delimiter. Any invalid input will be treated as zero value.
-func (k *Key) Ints(delim string) []int {
-	vals, _ := k.getInts(delim, true, false)
-	return vals
-}
-
-// Int64s returns list of int64 divided by given delimiter. Any invalid input will be treated as zero value.
-func (k *Key) Int64s(delim string) []int64 {
-	vals, _ := k.getInt64s(delim, true, false)
-	return vals
-}
-
-// Uints returns list of uint divided by given delimiter. Any invalid input will be treated as zero value.
-func (k *Key) Uints(delim string) []uint {
-	vals, _ := k.getUints(delim, true, false)
-	return vals
-}
-
-// Uint64s returns list of uint64 divided by given delimiter. Any invalid input will be treated as zero value.
-func (k *Key) Uint64s(delim string) []uint64 {
-	vals, _ := k.getUint64s(delim, true, false)
-	return vals
-}
-
-// TimesFormat parses with given format and returns list of time.Time divided by given delimiter.
-// Any invalid input will be treated as zero value (0001-01-01 00:00:00 +0000 UTC).
-func (k *Key) TimesFormat(format, delim string) []time.Time {
-	vals, _ := k.getTimesFormat(format, delim, true, false)
-	return vals
-}
-
-// Times parses with RFC3339 format and returns list of time.Time divided by given delimiter.
-// Any invalid input will be treated as zero value (0001-01-01 00:00:00 +0000 UTC).
-func (k *Key) Times(delim string) []time.Time {
-	return k.TimesFormat(time.RFC3339, delim)
-}
-
-// ValidFloat64s returns list of float64 divided by given delimiter. If some value is not float, then
-// it will not be included to result list.
-func (k *Key) ValidFloat64s(delim string) []float64 {
-	vals, _ := k.getFloat64s(delim, false, false)
-	return vals
-}
-
-// ValidInts returns list of int divided by given delimiter. If some value is not integer, then it will
-// not be included to result list.
-func (k *Key) ValidInts(delim string) []int {
-	vals, _ := k.getInts(delim, false, false)
-	return vals
-}
-
-// ValidInt64s returns list of int64 divided by given delimiter. If some value is not 64-bit integer,
-// then it will not be included to result list.
-func (k *Key) ValidInt64s(delim string) []int64 {
-	vals, _ := k.getInt64s(delim, false, false)
-	return vals
-}
-
-// ValidUints returns list of uint divided by given delimiter. If some value is not unsigned integer,
-// then it will not be included to result list.
-func (k *Key) ValidUints(delim string) []uint {
-	vals, _ := k.getUints(delim, false, false)
-	return vals
-}
-
-// ValidUint64s returns list of uint64 divided by given delimiter. If some value is not 64-bit unsigned
-// integer, then it will not be included to result list.
-func (k *Key) ValidUint64s(delim string) []uint64 {
-	vals, _ := k.getUint64s(delim, false, false)
-	return vals
-}
-
-// ValidTimesFormat parses with given format and returns list of time.Time divided by given delimiter.
-func (k *Key) ValidTimesFormat(format, delim string) []time.Time {
-	vals, _ := k.getTimesFormat(format, delim, false, false)
-	return vals
-}
-
-// ValidTimes parses with RFC3339 format and returns list of time.Time divided by given delimiter.
-func (k *Key) ValidTimes(delim string) []time.Time {
-	return k.ValidTimesFormat(time.RFC3339, delim)
-}
-
-// StrictFloat64s returns list of float64 divided by given delimiter or error on first invalid input.
-func (k *Key) StrictFloat64s(delim string) ([]float64, error) {
-	return k.getFloat64s(delim, false, true)
-}
-
-// StrictInts returns list of int divided by given delimiter or error on first invalid input.
-func (k *Key) StrictInts(delim string) ([]int, error) {
-	return k.getInts(delim, false, true)
-}
-
-// StrictInt64s returns list of int64 divided by given delimiter or error on first invalid input.
-func (k *Key) StrictInt64s(delim string) ([]int64, error) {
-	return k.getInt64s(delim, false, true)
-}
-
-// StrictUints returns list of uint divided by given delimiter or error on first invalid input.
-func (k *Key) StrictUints(delim string) ([]uint, error) {
-	return k.getUints(delim, false, true)
-}
-
-// StrictUint64s returns list of uint64 divided by given delimiter or error on first invalid input.
-func (k *Key) StrictUint64s(delim string) ([]uint64, error) {
-	return k.getUint64s(delim, false, true)
-}
-
-// StrictTimesFormat parses with given format and returns list of time.Time divided by given delimiter
-// or error on first invalid input.
-func (k *Key) StrictTimesFormat(format, delim string) ([]time.Time, error) {
-	return k.getTimesFormat(format, delim, false, true)
-}
-
-// StrictTimes parses with RFC3339 format and returns list of time.Time divided by given delimiter
-// or error on first invalid input.
-func (k *Key) StrictTimes(delim string) ([]time.Time, error) {
-	return k.StrictTimesFormat(time.RFC3339, delim)
-}
-
-// getFloat64s returns list of float64 divided by given delimiter.
-func (k *Key) getFloat64s(delim string, addInvalid, returnOnInvalid bool) ([]float64, error) {
-	strs := k.Strings(delim)
-	vals := make([]float64, 0, len(strs))
-	for _, str := range strs {
-		val, err := strconv.ParseFloat(str, 64)
-		if err != nil && returnOnInvalid {
-			return nil, err
-		}
-		if err == nil || addInvalid {
-			vals = append(vals, val)
-		}
-	}
-	return vals, nil
-}
-
-// getInts returns list of int divided by given delimiter.
-func (k *Key) getInts(delim string, addInvalid, returnOnInvalid bool) ([]int, error) {
-	strs := k.Strings(delim)
-	vals := make([]int, 0, len(strs))
-	for _, str := range strs {
-		val, err := strconv.Atoi(str)
-		if err != nil && returnOnInvalid {
-			return nil, err
-		}
-		if err == nil || addInvalid {
-			vals = append(vals, val)
-		}
-	}
-	return vals, nil
-}
-
-// getInt64s returns list of int64 divided by given delimiter.
-func (k *Key) getInt64s(delim string, addInvalid, returnOnInvalid bool) ([]int64, error) {
-	strs := k.Strings(delim)
-	vals := make([]int64, 0, len(strs))
-	for _, str := range strs {
-		val, err := strconv.ParseInt(str, 10, 64)
-		if err != nil && returnOnInvalid {
-			return nil, err
-		}
-		if err == nil || addInvalid {
-			vals = append(vals, val)
-		}
-	}
-	return vals, nil
-}
-
-// getUints returns list of uint divided by given delimiter.
-func (k *Key) getUints(delim string, addInvalid, returnOnInvalid bool) ([]uint, error) {
-	strs := k.Strings(delim)
-	vals := make([]uint, 0, len(strs))
-	for _, str := range strs {
-		val, err := strconv.ParseUint(str, 10, 0)
-		if err != nil && returnOnInvalid {
-			return nil, err
-		}
-		if err == nil || addInvalid {
-			vals = append(vals, uint(val))
-		}
-	}
-	return vals, nil
-}
-
-// getUint64s returns list of uint64 divided by given delimiter.
-func (k *Key) getUint64s(delim string, addInvalid, returnOnInvalid bool) ([]uint64, error) {
-	strs := k.Strings(delim)
-	vals := make([]uint64, 0, len(strs))
-	for _, str := range strs {
-		val, err := strconv.ParseUint(str, 10, 64)
-		if err != nil && returnOnInvalid {
-			return nil, err
-		}
-		if err == nil || addInvalid {
-			vals = append(vals, val)
-		}
-	}
-	return vals, nil
-}
-
-// getTimesFormat parses with given format and returns list of time.Time divided by given delimiter.
-func (k *Key) getTimesFormat(format, delim string, addInvalid, returnOnInvalid bool) ([]time.Time, error) {
-	strs := k.Strings(delim)
-	vals := make([]time.Time, 0, len(strs))
-	for _, str := range strs {
-		val, err := time.Parse(format, str)
-		if err != nil && returnOnInvalid {
-			return nil, err
-		}
-		if err == nil || addInvalid {
-			vals = append(vals, val)
-		}
-	}
-	return vals, nil
-}
-
-// SetValue changes key value.
-func (k *Key) SetValue(v string) {
-	if k.s.f.BlockMode {
-		k.s.f.lock.Lock()
-		defer k.s.f.lock.Unlock()
-	}
-
-	k.value = v
-	k.s.keysHash[k.name] = v
-}
diff --git a/vendor/github.com/go-ini/ini/parser.go b/vendor/github.com/go-ini/ini/parser.go
deleted file mode 100644
index 1c1bf91..0000000
--- a/vendor/github.com/go-ini/ini/parser.go
+++ /dev/null
@@ -1,312 +0,0 @@
-// Copyright 2015 Unknwon
-//
-// Licensed under the Apache License, Version 2.0 (the "License"): you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-// License for the specific language governing permissions and limitations
-// under the License.
-
-package ini
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-	"unicode"
-)
-
-type tokenType int
-
-const (
-	_TOKEN_INVALID tokenType = iota
-	_TOKEN_COMMENT
-	_TOKEN_SECTION
-	_TOKEN_KEY
-)
-
-type parser struct {
-	buf     *bufio.Reader
-	isEOF   bool
-	count   int
-	comment *bytes.Buffer
-}
-
-func newParser(r io.Reader) *parser {
-	return &parser{
-		buf:     bufio.NewReader(r),
-		count:   1,
-		comment: &bytes.Buffer{},
-	}
-}
-
-// BOM handles header of BOM-UTF8 format.
-// http://en.wikipedia.org/wiki/Byte_order_mark#Representations_of_byte_order_marks_by_encoding
-func (p *parser) BOM() error {
-	mask, err := p.buf.Peek(3)
-	if err != nil && err != io.EOF {
-		return err
-	} else if len(mask) < 3 {
-		return nil
-	} else if mask[0] == 239 && mask[1] == 187 && mask[2] == 191 {
-		p.buf.Read(mask)
-	}
-	return nil
-}
-
-func (p *parser) readUntil(delim byte) ([]byte, error) {
-	data, err := p.buf.ReadBytes(delim)
-	if err != nil {
-		if err == io.EOF {
-			p.isEOF = true
-		} else {
-			return nil, err
-		}
-	}
-	return data, nil
-}
-
-func cleanComment(in []byte) ([]byte, bool) {
-	i := bytes.IndexAny(in, "#;")
-	if i == -1 {
-		return nil, false
-	}
-	return in[i:], true
-}
-
-func readKeyName(in []byte) (string, int, error) {
-	line := string(in)
-
-	// Check if key name surrounded by quotes.
-	var keyQuote string
-	if line[0] == '"' {
-		if len(line) > 6 && string(line[0:3]) == `"""` {
-			keyQuote = `"""`
-		} else {
-			keyQuote = `"`
-		}
-	} else if line[0] == '`' {
-		keyQuote = "`"
-	}
-
-	// Get out key name
-	endIdx := -1
-	if len(keyQuote) > 0 {
-		startIdx := len(keyQuote)
-		// FIXME: fail case -> """"""name"""=value
-		pos := strings.Index(line[startIdx:], keyQuote)
-		if pos == -1 {
-			return "", -1, fmt.Errorf("missing closing key quote: %s", line)
-		}
-		pos += startIdx
-
-		// Find key-value delimiter
-		i := strings.IndexAny(line[pos+startIdx:], "=:")
-		if i < 0 {
-			return "", -1, fmt.Errorf("key-value delimiter not found: %s", line)
-		}
-		endIdx = pos + i
-		return strings.TrimSpace(line[startIdx:pos]), endIdx + startIdx + 1, nil
-	}
-
-	endIdx = strings.IndexAny(line, "=:")
-	if endIdx < 0 {
-		return "", -1, fmt.Errorf("key-value delimiter not found: %s", line)
-	}
-	return strings.TrimSpace(line[0:endIdx]), endIdx + 1, nil
-}
-
-func (p *parser) readMultilines(line, val, valQuote string) (string, error) {
-	for {
-		data, err := p.readUntil('\n')
-		if err != nil {
-			return "", err
-		}
-		next := string(data)
-
-		pos := strings.LastIndex(next, valQuote)
-		if pos > -1 {
-			val += next[:pos]
-
-			comment, has := cleanComment([]byte(next[pos:]))
-			if has {
-				p.comment.Write(bytes.TrimSpace(comment))
-			}
-			break
-		}
-		val += next
-		if p.isEOF {
-			return "", fmt.Errorf("missing closing key quote from '%s' to '%s'", line, next)
-		}
-	}
-	return val, nil
-}
-
-func (p *parser) readContinuationLines(val string) (string, error) {
-	for {
-		data, err := p.readUntil('\n')
-		if err != nil {
-			return "", err
-		}
-		next := strings.TrimSpace(string(data))
-
-		if len(next) == 0 {
-			break
-		}
-		val += next
-		if val[len(val)-1] != '\\' {
-			break
-		}
-		val = val[:len(val)-1]
-	}
-	return val, nil
-}
-
-// hasSurroundedQuote check if and only if the first and last characters
-// are quotes \" or \'.
-// It returns false if any other parts also contain same kind of quotes.
-func hasSurroundedQuote(in string, quote byte) bool {
-	return len(in) > 2 && in[0] == quote && in[len(in)-1] == quote &&
-		strings.IndexByte(in[1:], quote) == len(in)-2
-}
-
-func (p *parser) readValue(in []byte) (string, error) {
-	line := strings.TrimLeftFunc(string(in), unicode.IsSpace)
-	if len(line) == 0 {
-		return "", nil
-	}
-
-	var valQuote string
-	if len(line) > 3 && string(line[0:3]) == `"""` {
-		valQuote = `"""`
-	} else if line[0] == '`' {
-		valQuote = "`"
-	}
-
-	if len(valQuote) > 0 {
-		startIdx := len(valQuote)
-		pos := strings.LastIndex(line[startIdx:], valQuote)
-		// Check for multi-line value
-		if pos == -1 {
-			return p.readMultilines(line, line[startIdx:], valQuote)
-		}
-
-		return line[startIdx : pos+startIdx], nil
-	}
-
-	// Won't be able to reach here if value only contains whitespace.
-	line = strings.TrimSpace(line)
-
-	// Check continuation lines
-	if line[len(line)-1] == '\\' {
-		return p.readContinuationLines(line[:len(line)-1])
-	}
-
-	i := strings.IndexAny(line, "#;")
-	if i > -1 {
-		p.comment.WriteString(line[i:])
-		line = strings.TrimSpace(line[:i])
-	}
-
-	// Trim single quotes
-	if hasSurroundedQuote(line, '\'') ||
-		hasSurroundedQuote(line, '"') {
-		line = line[1 : len(line)-1]
-	}
-	return line, nil
-}
-
-// parse parses data through an io.Reader.
-func (f *File) parse(reader io.Reader) (err error) {
-	p := newParser(reader)
-	if err = p.BOM(); err != nil {
-		return fmt.Errorf("BOM: %v", err)
-	}
-
-	// Ignore error because default section name is never empty string.
-	section, _ := f.NewSection(DEFAULT_SECTION)
-
-	var line []byte
-	for !p.isEOF {
-		line, err = p.readUntil('\n')
-		if err != nil {
-			return err
-		}
-
-		line = bytes.TrimLeftFunc(line, unicode.IsSpace)
-		if len(line) == 0 {
-			continue
-		}
-
-		// Comments
-		if line[0] == '#' || line[0] == ';' {
-			// Note: we do not care ending line break,
-			// it is needed for adding second line,
-			// so just clean it once at the end when set to value.
-			p.comment.Write(line)
-			continue
-		}
-
-		// Section
-		if line[0] == '[' {
-			// Read to the next ']' (TODO: support quoted strings)
-			closeIdx := bytes.IndexByte(line, ']')
-			if closeIdx == -1 {
-				return fmt.Errorf("unclosed section: %s", line)
-			}
-
-			section, err = f.NewSection(string(line[1:closeIdx]))
-			if err != nil {
-				return err
-			}
-
-			comment, has := cleanComment(line[closeIdx+1:])
-			if has {
-				p.comment.Write(comment)
-			}
-
-			section.Comment = strings.TrimSpace(p.comment.String())
-
-			// Reset aotu-counter and comments
-			p.comment.Reset()
-			p.count = 1
-			continue
-		}
-
-		kname, offset, err := readKeyName(line)
-		if err != nil {
-			return err
-		}
-
-		// Auto increment.
-		isAutoIncr := false
-		if kname == "-" {
-			isAutoIncr = true
-			kname = "#" + strconv.Itoa(p.count)
-			p.count++
-		}
-
-		key, err := section.NewKey(kname, "")
-		if err != nil {
-			return err
-		}
-		key.isAutoIncr = isAutoIncr
-
-		value, err := p.readValue(line[offset:])
-		if err != nil {
-			return err
-		}
-		key.SetValue(value)
-		key.Comment = strings.TrimSpace(p.comment.String())
-		p.comment.Reset()
-	}
-	return nil
-}
diff --git a/vendor/github.com/go-ini/ini/section.go b/vendor/github.com/go-ini/ini/section.go
deleted file mode 100644
index ed8cbdb..0000000
--- a/vendor/github.com/go-ini/ini/section.go
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright 2014 Unknwon
-//
-// Licensed under the Apache License, Version 2.0 (the "License"): you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-// License for the specific language governing permissions and limitations
-// under the License.
-
-package ini
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-)
-
-// Section represents a config section.
-type Section struct {
-	f        *File
-	Comment  string
-	name     string
-	keys     map[string]*Key
-	keyList  []string
-	keysHash map[string]string
-}
-
-func newSection(f *File, name string) *Section {
-	return &Section{f, "", name, make(map[string]*Key), make([]string, 0, 10), make(map[string]string)}
-}
-
-// Name returns name of Section.
-func (s *Section) Name() string {
-	return s.name
-}
-
-// NewKey creates a new key to given section.
-func (s *Section) NewKey(name, val string) (*Key, error) {
-	if len(name) == 0 {
-		return nil, errors.New("error creating new key: empty key name")
-	}
-
-	if s.f.BlockMode {
-		s.f.lock.Lock()
-		defer s.f.lock.Unlock()
-	}
-
-	if inSlice(name, s.keyList) {
-		s.keys[name].value = val
-		return s.keys[name], nil
-	}
-
-	s.keyList = append(s.keyList, name)
-	s.keys[name] = &Key{s, "", name, val, false}
-	s.keysHash[name] = val
-	return s.keys[name], nil
-}
-
-// GetKey returns key in section by given name.
-func (s *Section) GetKey(name string) (*Key, error) {
-	// FIXME: change to section level lock?
-	if s.f.BlockMode {
-		s.f.lock.RLock()
-	}
-	key := s.keys[name]
-	if s.f.BlockMode {
-		s.f.lock.RUnlock()
-	}
-
-	if key == nil {
-		// Check if it is a child-section.
-		sname := s.name
-		for {
-			if i := strings.LastIndex(sname, "."); i > -1 {
-				sname = sname[:i]
-				sec, err := s.f.GetSection(sname)
-				if err != nil {
-					continue
-				}
-				return sec.GetKey(name)
-			} else {
-				break
-			}
-		}
-		return nil, fmt.Errorf("error when getting key of section '%s': key '%s' not exists", s.name, name)
-	}
-	return key, nil
-}
-
-// HasKey returns true if section contains a key with given name.
-func (s *Section) HasKey(name string) bool {
-	key, _ := s.GetKey(name)
-	return key != nil
-}
-
-// Haskey is a backwards-compatible name for HasKey.
-func (s *Section) Haskey(name string) bool {
-	return s.HasKey(name)
-}
-
-// HasValue returns true if section contains given raw value.
-func (s *Section) HasValue(value string) bool {
-	if s.f.BlockMode {
-		s.f.lock.RLock()
-		defer s.f.lock.RUnlock()
-	}
-
-	for _, k := range s.keys {
-		if value == k.value {
-			return true
-		}
-	}
-	return false
-}
-
-// Key assumes named Key exists in section and returns a zero-value when not.
-func (s *Section) Key(name string) *Key {
-	key, err := s.GetKey(name)
-	if err != nil {
-		// It's OK here because the only possible error is empty key name,
-		// but if it's empty, this piece of code won't be executed.
-		key, _ = s.NewKey(name, "")
-		return key
-	}
-	return key
-}
-
-// Keys returns list of keys of section.
-func (s *Section) Keys() []*Key {
-	keys := make([]*Key, len(s.keyList))
-	for i := range s.keyList {
-		keys[i] = s.Key(s.keyList[i])
-	}
-	return keys
-}
-
-// KeyStrings returns list of key names of section.
-func (s *Section) KeyStrings() []string {
-	list := make([]string, len(s.keyList))
-	copy(list, s.keyList)
-	return list
-}
-
-// KeysHash returns keys hash consisting of names and values.
-func (s *Section) KeysHash() map[string]string {
-	if s.f.BlockMode {
-		s.f.lock.RLock()
-		defer s.f.lock.RUnlock()
-	}
-
-	hash := map[string]string{}
-	for key, value := range s.keysHash {
-		hash[key] = value
-	}
-	return hash
-}
-
-// DeleteKey deletes a key from section.
-func (s *Section) DeleteKey(name string) {
-	if s.f.BlockMode {
-		s.f.lock.Lock()
-		defer s.f.lock.Unlock()
-	}
-
-	for i, k := range s.keyList {
-		if k == name {
-			s.keyList = append(s.keyList[:i], s.keyList[i+1:]...)
-			delete(s.keys, name)
-			return
-		}
-	}
-}
diff --git a/vendor/github.com/go-ini/ini/struct.go b/vendor/github.com/go-ini/ini/struct.go
deleted file mode 100644
index 3fb92c3..0000000
--- a/vendor/github.com/go-ini/ini/struct.go
+++ /dev/null
@@ -1,351 +0,0 @@
-// Copyright 2014 Unknwon
-//
-// Licensed under the Apache License, Version 2.0 (the "License"): you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-// License for the specific language governing permissions and limitations
-// under the License.
-
-package ini
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"reflect"
-	"time"
-	"unicode"
-)
-
-// NameMapper represents a ini tag name mapper.
-type NameMapper func(string) string
-
-// Built-in name getters.
-var (
-	// AllCapsUnderscore converts to format ALL_CAPS_UNDERSCORE.
-	AllCapsUnderscore NameMapper = func(raw string) string {
-		newstr := make([]rune, 0, len(raw))
-		for i, chr := range raw {
-			if isUpper := 'A' <= chr && chr <= 'Z'; isUpper {
-				if i > 0 {
-					newstr = append(newstr, '_')
-				}
-			}
-			newstr = append(newstr, unicode.ToUpper(chr))
-		}
-		return string(newstr)
-	}
-	// TitleUnderscore converts to format title_underscore.
-	TitleUnderscore NameMapper = func(raw string) string {
-		newstr := make([]rune, 0, len(raw))
-		for i, chr := range raw {
-			if isUpper := 'A' <= chr && chr <= 'Z'; isUpper {
-				if i > 0 {
-					newstr = append(newstr, '_')
-				}
-				chr -= ('A' - 'a')
-			}
-			newstr = append(newstr, chr)
-		}
-		return string(newstr)
-	}
-)
-
-func (s *Section) parseFieldName(raw, actual string) string {
-	if len(actual) > 0 {
-		return actual
-	}
-	if s.f.NameMapper != nil {
-		return s.f.NameMapper(raw)
-	}
-	return raw
-}
-
-func parseDelim(actual string) string {
-	if len(actual) > 0 {
-		return actual
-	}
-	return ","
-}
-
-var reflectTime = reflect.TypeOf(time.Now()).Kind()
-
-// setWithProperType sets proper value to field based on its type,
-// but it does not return error for failing parsing,
-// because we want to use default value that is already assigned to strcut.
-func setWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string) error {
-	switch t.Kind() {
-	case reflect.String:
-		if len(key.String()) == 0 {
-			return nil
-		}
-		field.SetString(key.String())
-	case reflect.Bool:
-		boolVal, err := key.Bool()
-		if err != nil {
-			return nil
-		}
-		field.SetBool(boolVal)
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		durationVal, err := key.Duration()
-		// Skip zero value
-		if err == nil && int(durationVal) > 0 {
-			field.Set(reflect.ValueOf(durationVal))
-			return nil
-		}
-
-		intVal, err := key.Int64()
-		if err != nil || intVal == 0 {
-			return nil
-		}
-		field.SetInt(intVal)
-	//	byte is an alias for uint8, so supporting uint8 breaks support for byte
-	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		durationVal, err := key.Duration()
-		if err == nil {
-			field.Set(reflect.ValueOf(durationVal))
-			return nil
-		}
-
-		uintVal, err := key.Uint64()
-		if err != nil {
-			return nil
-		}
-		field.SetUint(uintVal)
-
-	case reflect.Float64:
-		floatVal, err := key.Float64()
-		if err != nil {
-			return nil
-		}
-		field.SetFloat(floatVal)
-	case reflectTime:
-		timeVal, err := key.Time()
-		if err != nil {
-			return nil
-		}
-		field.Set(reflect.ValueOf(timeVal))
-	case reflect.Slice:
-		vals := key.Strings(delim)
-		numVals := len(vals)
-		if numVals == 0 {
-			return nil
-		}
-
-		sliceOf := field.Type().Elem().Kind()
-
-		var times []time.Time
-		if sliceOf == reflectTime {
-			times = key.Times(delim)
-		}
-
-		slice := reflect.MakeSlice(field.Type(), numVals, numVals)
-		for i := 0; i < numVals; i++ {
-			switch sliceOf {
-			case reflectTime:
-				slice.Index(i).Set(reflect.ValueOf(times[i]))
-			default:
-				slice.Index(i).Set(reflect.ValueOf(vals[i]))
-			}
-		}
-		field.Set(slice)
-	default:
-		return fmt.Errorf("unsupported type '%s'", t)
-	}
-	return nil
-}
-
-func (s *Section) mapTo(val reflect.Value) error {
-	if val.Kind() == reflect.Ptr {
-		val = val.Elem()
-	}
-	typ := val.Type()
-
-	for i := 0; i < typ.NumField(); i++ {
-		field := val.Field(i)
-		tpField := typ.Field(i)
-
-		tag := tpField.Tag.Get("ini")
-		if tag == "-" {
-			continue
-		}
-
-		fieldName := s.parseFieldName(tpField.Name, tag)
-		if len(fieldName) == 0 || !field.CanSet() {
-			continue
-		}
-
-		isAnonymous := tpField.Type.Kind() == reflect.Ptr && tpField.Anonymous
-		isStruct := tpField.Type.Kind() == reflect.Struct
-		if isAnonymous {
-			field.Set(reflect.New(tpField.Type.Elem()))
-		}
-
-		if isAnonymous || isStruct {
-			if sec, err := s.f.GetSection(fieldName); err == nil {
-				if err = sec.mapTo(field); err != nil {
-					return fmt.Errorf("error mapping field(%s): %v", fieldName, err)
-				}
-				continue
-			}
-		}
-
-		if key, err := s.GetKey(fieldName); err == nil {
-			if err = setWithProperType(tpField.Type, key, field, parseDelim(tpField.Tag.Get("delim"))); err != nil {
-				return fmt.Errorf("error mapping field(%s): %v", fieldName, err)
-			}
-		}
-	}
-	return nil
-}
-
-// MapTo maps section to given struct.
-func (s *Section) MapTo(v interface{}) error {
-	typ := reflect.TypeOf(v)
-	val := reflect.ValueOf(v)
-	if typ.Kind() == reflect.Ptr {
-		typ = typ.Elem()
-		val = val.Elem()
-	} else {
-		return errors.New("cannot map to non-pointer struct")
-	}
-
-	return s.mapTo(val)
-}
-
-// MapTo maps file to given struct.
-func (f *File) MapTo(v interface{}) error {
-	return f.Section("").MapTo(v)
-}
-
-// MapTo maps data sources to given struct with name mapper.
-func MapToWithMapper(v interface{}, mapper NameMapper, source interface{}, others ...interface{}) error {
-	cfg, err := Load(source, others...)
-	if err != nil {
-		return err
-	}
-	cfg.NameMapper = mapper
-	return cfg.MapTo(v)
-}
-
-// MapTo maps data sources to given struct.
-func MapTo(v, source interface{}, others ...interface{}) error {
-	return MapToWithMapper(v, nil, source, others...)
-}
-
-// reflectWithProperType does the opposite thing with setWithProperType.
-func reflectWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string) error {
-	switch t.Kind() {
-	case reflect.String:
-		key.SetValue(field.String())
-	case reflect.Bool,
-		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
-		reflect.Float64,
-		reflectTime:
-		key.SetValue(fmt.Sprint(field))
-	case reflect.Slice:
-		vals := field.Slice(0, field.Len())
-		if field.Len() == 0 {
-			return nil
-		}
-
-		var buf bytes.Buffer
-		isTime := fmt.Sprint(field.Type()) == "[]time.Time"
-		for i := 0; i < field.Len(); i++ {
-			if isTime {
-				buf.WriteString(vals.Index(i).Interface().(time.Time).Format(time.RFC3339))
-			} else {
-				buf.WriteString(fmt.Sprint(vals.Index(i)))
-			}
-			buf.WriteString(delim)
-		}
-		key.SetValue(buf.String()[:buf.Len()-1])
-	default:
-		return fmt.Errorf("unsupported type '%s'", t)
-	}
-	return nil
-}
-
-func (s *Section) reflectFrom(val reflect.Value) error {
-	if val.Kind() == reflect.Ptr {
-		val = val.Elem()
-	}
-	typ := val.Type()
-
-	for i := 0; i < typ.NumField(); i++ {
-		field := val.Field(i)
-		tpField := typ.Field(i)
-
-		tag := tpField.Tag.Get("ini")
-		if tag == "-" {
-			continue
-		}
-
-		fieldName := s.parseFieldName(tpField.Name, tag)
-		if len(fieldName) == 0 || !field.CanSet() {
-			continue
-		}
-
-		if (tpField.Type.Kind() == reflect.Ptr && tpField.Anonymous) ||
-			(tpField.Type.Kind() == reflect.Struct) {
-			// Note: The only error here is section doesn't exist.
-			sec, err := s.f.GetSection(fieldName)
-			if err != nil {
-				// Note: fieldName can never be empty here, ignore error.
-				sec, _ = s.f.NewSection(fieldName)
-			}
-			if err = sec.reflectFrom(field); err != nil {
-				return fmt.Errorf("error reflecting field(%s): %v", fieldName, err)
-			}
-			continue
-		}
-
-		// Note: Same reason as secion.
-		key, err := s.GetKey(fieldName)
-		if err != nil {
-			key, _ = s.NewKey(fieldName, "")
-		}
-		if err = reflectWithProperType(tpField.Type, key, field, parseDelim(tpField.Tag.Get("delim"))); err != nil {
-			return fmt.Errorf("error reflecting field(%s): %v", fieldName, err)
-		}
-
-	}
-	return nil
-}
-
-// ReflectFrom reflects secion from given struct.
-func (s *Section) ReflectFrom(v interface{}) error {
-	typ := reflect.TypeOf(v)
-	val := reflect.ValueOf(v)
-	if typ.Kind() == reflect.Ptr {
-		typ = typ.Elem()
-		val = val.Elem()
-	} else {
-		return errors.New("cannot reflect from non-pointer struct")
-	}
-
-	return s.reflectFrom(val)
-}
-
-// ReflectFrom reflects file from given struct.
-func (f *File) ReflectFrom(v interface{}) error {
-	return f.Section("").ReflectFrom(v)
-}
-
-// ReflectFrom reflects data sources from given struct with name mapper.
-func ReflectFromWithMapper(cfg *File, v interface{}, mapper NameMapper) error {
-	cfg.NameMapper = mapper
-	return cfg.ReflectFrom(v)
-}
-
-// ReflectFrom reflects data sources from given struct.
-func ReflectFrom(cfg *File, v interface{}) error {
-	return ReflectFromWithMapper(cfg, v, nil)
-}
diff --git a/vendor/github.com/olekukonko/tablewriter/.travis.yml b/vendor/github.com/olekukonko/tablewriter/.travis.yml
deleted file mode 100644
index 354b7f8..0000000
--- a/vendor/github.com/olekukonko/tablewriter/.travis.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-language: go
-
-go:
-  - 1.1
-  - 1.2
-  - 1.3
-  - 1.4
-  - tip
diff --git a/vendor/github.com/olekukonko/tablewriter/LICENCE.md b/vendor/github.com/olekukonko/tablewriter/LICENCE.md
deleted file mode 100644
index 1fd8484..0000000
--- a/vendor/github.com/olekukonko/tablewriter/LICENCE.md
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (C) 2014 by Oleku Konko
-
-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.
\ No newline at end of file
diff --git a/vendor/github.com/olekukonko/tablewriter/README.md b/vendor/github.com/olekukonko/tablewriter/README.md
deleted file mode 100644
index 4ee4435..0000000
--- a/vendor/github.com/olekukonko/tablewriter/README.md
+++ /dev/null
@@ -1,141 +0,0 @@
-ASCII Table Writer
-=========
-
-[![Build Status](https://travis-ci.org/olekukonko/tablewriter.png?branch=master)](https://travis-ci.org/olekukonko/tablewriter) [![Total views](https://sourcegraph.com/api/repos/github.com/olekukonko/tablewriter/counters/views.png)](https://sourcegraph.com/github.com/olekukonko/tablewriter)
-
-Generate ASCII table on the fly ...  Installation is simple as
-
-    go get  github.com/olekukonko/tablewriter
-
-
-#### Features
-- Automatic Padding
-- Support Multiple Lines
-- Supports Alignment
-- Support Custom Separators
-- Automatic Alignment of numbers & percentage
-- Write directly to http , file etc via `io.Writer`
-- Read directly from CSV file
-- Optional row line via `SetRowLine`
-- Normalise table header
-- Make CSV Headers optional
-- Enable or disable table border
-- Set custom footer support
-
-
-#### Example   1 - Basic
-```go
-data := [][]string{
-    []string{"A", "The Good", "500"},
-    []string{"B", "The Very very Bad Man", "288"},
-    []string{"C", "The Ugly", "120"},
-    []string{"D", "The Gopher", "800"},
-}
-
-table := tablewriter.NewWriter(os.Stdout)
-table.SetHeader([]string{"Name", "Sign", "Rating"})
-
-for _, v := range data {
-    table.Append(v)
-}
-table.Render() // Send output
-```
-
-##### Output  1
-```
-+------+-----------------------+--------+
-| NAME |         SIGN          | RATING |
-+------+-----------------------+--------+
-|  A   |       The Good        |    500 |
-|  B   | The Very very Bad Man |    288 |
-|  C   |       The Ugly        |    120 |
-|  D   |      The Gopher       |    800 |
-+------+-----------------------+--------+
-```
-
-#### Example 2 - Without Border / Footer / Bulk Append
-```go
-data := [][]string{
-    []string{"1/1/2014", "Domain name", "2233", "$10.98"},
-    []string{"1/1/2014", "January Hosting", "2233", "$54.95"},
-    []string{"1/4/2014", "February Hosting", "2233", "$51.00"},
-    []string{"1/4/2014", "February Extra Bandwidth", "2233", "$30.00"},
-}
-
-table := tablewriter.NewWriter(os.Stdout)
-table.SetHeader([]string{"Date", "Description", "CV2", "Amount"})
-table.SetFooter([]string{"", "", "Total", "$146.93"}) // Add Footer
-table.SetBorder(false)                                // Set Border to false
-table.AppendBulk(data)                                // Add Bulk Data
-table.Render()
-```
-
-##### Output 2
-```
-
-    DATE   |       DESCRIPTION        |  CV2  | AMOUNT
-+----------+--------------------------+-------+---------+
-  1/1/2014 | Domain name              |  2233 | $10.98
-  1/1/2014 | January Hosting          |  2233 | $54.95
-  1/4/2014 | February Hosting         |  2233 | $51.00
-  1/4/2014 | February Extra Bandwidth |  2233 | $30.00
-+----------+--------------------------+-------+---------+
-                                        TOTAL | $146 93
-                                      +-------+---------+
-
-```
-
-
-#### Example 3 - CSV
-```go
-table, _ := tablewriter.NewCSV(os.Stdout, "test_info.csv", true)
-table.SetAlignment(tablewriter.ALIGN_LEFT)   // Set Alignment
-table.Render()
-```
-
-##### Output 3
-```
-+----------+--------------+------+-----+---------+----------------+
-|  FIELD   |     TYPE     | NULL | KEY | DEFAULT |     EXTRA      |
-+----------+--------------+------+-----+---------+----------------+
-| user_id  | smallint(5)  | NO   | PRI | NULL    | auto_increment |
-| username | varchar(10)  | NO   |     | NULL    |                |
-| password | varchar(100) | NO   |     | NULL    |                |
-+----------+--------------+------+-----+---------+----------------+
-```
-
-#### Example 4  - Custom Separator
-```go
-table, _ := tablewriter.NewCSV(os.Stdout, "test.csv", true)
-table.SetRowLine(true)         // Enable row line
-
-// Change table lines
-table.SetCenterSeparator("*")
-table.SetColumnSeparator("‡")
-table.SetRowSeparator("-")
-
-table.SetAlignment(tablewriter.ALIGN_LEFT)
-table.Render()
-```
-
-##### Output 4
-```
-*------------*-----------*---------*
-╪ FIRST NAME ╪ LAST NAME ╪   SSN   ╪
-*------------*-----------*---------*
-╪ John       ╪ Barry     ╪ 123456  ╪
-*------------*-----------*---------*
-╪ Kathy      ╪ Smith     ╪ 687987  ╪
-*------------*-----------*---------*
-╪ Bob        ╪ McCornick ╪ 3979870 ╪
-*------------*-----------*---------*
-```
-
-#### TODO
-- ~~Import Directly from CSV~~  - `done`
-- ~~Support for `SetFooter`~~  - `done`
-- ~~Support for `SetBorder`~~  - `done`
-- ~~Support table with uneven rows~~ - `done`
-- Support custom alignment
-- General Improvement & Optimisation
-- `NewHTML` Parse table from HTML
diff --git a/vendor/github.com/olekukonko/tablewriter/csv.go b/vendor/github.com/olekukonko/tablewriter/csv.go
deleted file mode 100644
index 9887830..0000000
--- a/vendor/github.com/olekukonko/tablewriter/csv.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2014 Oleku Konko All rights reserved.
-// Use of this source code is governed by a MIT
-// license that can be found in the LICENSE file.
-
-// This module is a Table Writer  API for the Go Programming Language.
-// The protocols were written in pure Go and works on windows and unix systems
-
-package tablewriter
-
-import (
-	"encoding/csv"
-	"io"
-	"os"
-)
-
-// Start A new table by importing from a CSV file
-// Takes io.Writer and csv File name
-func NewCSV(writer io.Writer, fileName string, hasHeader bool) (*Table, error) {
-	file, err := os.Open(fileName)
-	if err != nil {
-		return &Table{}, err
-	}
-	defer file.Close()
-	csvReader := csv.NewReader(file)
-	t, err := NewCSVReader(writer, csvReader, hasHeader)
-	return t, err
-}
-
-//  Start a New Table Writer with csv.Reader
-// This enables customisation such as reader.Comma = ';'
-// See http://golang.org/src/pkg/encoding/csv/reader.go?s=3213:3671#L94
-func NewCSVReader(writer io.Writer, csvReader *csv.Reader, hasHeader bool) (*Table, error) {
-	t := NewWriter(writer)
-	if hasHeader {
-		// Read the first row
-		headers, err := csvReader.Read()
-		if err != nil {
-			return &Table{}, err
-		}
-		t.SetHeader(headers)
-	}
-	for {
-		record, err := csvReader.Read()
-		if err == io.EOF {
-			break
-		} else if err != nil {
-			return &Table{}, err
-		}
-		t.Append(record)
-	}
-	return t, nil
-}
diff --git a/vendor/github.com/olekukonko/tablewriter/table.go b/vendor/github.com/olekukonko/tablewriter/table.go
deleted file mode 100644
index 4835e31..0000000
--- a/vendor/github.com/olekukonko/tablewriter/table.go
+++ /dev/null
@@ -1,472 +0,0 @@
-// Copyright 2014 Oleku Konko All rights reserved.
-// Use of this source code is governed by a MIT
-// license that can be found in the LICENSE file.
-
-// This module is a Table Writer  API for the Go Programming Language.
-// The protocols were written in pure Go and works on windows and unix systems
-
-// Create & Generate text based table
-package tablewriter
-
-import (
-	"fmt"
-	"io"
-	"regexp"
-	"strings"
-)
-
-const (
-	MAX_ROW_WIDTH = 30
-)
-
-const (
-	CENTRE = "+"
-	ROW    = "-"
-	COLUMN = "|"
-	SPACE  = " "
-)
-
-const (
-	ALIGN_DEFAULT = iota
-	ALIGN_CENTRE
-	ALIGN_RIGHT
-	ALIGN_LEFT
-)
-
-var (
-	decimal = regexp.MustCompile(`^[0-9]+(.[0-9]+?)$`)
-	percent = regexp.MustCompile(`^[0-9]+(.[0-9]+?)%$`)
-)
-
-type Table struct {
-	out      io.Writer
-	rows     [][]string
-	lines    [][][]string
-	cs       map[int]int
-	rs       map[int]int
-	headers  []string
-	footers  []string
-	autoFmt  bool
-	autoWrap bool
-	mW       int
-	pCenter  string
-	pRow     string
-	pColumn  string
-	tColumn  int
-	tRow     int
-	align    int
-	rowLine  bool
-	border   bool
-	colSize  int
-}
-
-// Start New Table
-// Take io.Writer Directly
-func NewWriter(writer io.Writer) *Table {
-	t := &Table{
-		out:      writer,
-		rows:     [][]string{},
-		lines:    [][][]string{},
-		cs:       make(map[int]int),
-		rs:       make(map[int]int),
-		headers:  []string{},
-		footers:  []string{},
-		autoFmt:  true,
-		autoWrap: true,
-		mW:       MAX_ROW_WIDTH,
-		pCenter:  CENTRE,
-		pRow:     ROW,
-		pColumn:  COLUMN,
-		tColumn:  -1,
-		tRow:     -1,
-		align:    ALIGN_DEFAULT,
-		rowLine:  false,
-		border:   true,
-		colSize:  -1}
-	return t
-}
-
-// Render table output
-func (t Table) Render() {
-	if t.border {
-		t.printLine(true)
-	}
-	t.printHeading()
-	t.printRows()
-
-	if !t.rowLine && t.border {
-		t.printLine(true)
-	}
-	t.printFooter()
-
-}
-
-// Set table header
-func (t *Table) SetHeader(keys []string) {
-	t.colSize = len(keys)
-	for i, v := range keys {
-		t.parseDimension(v, i, -1)
-		t.headers = append(t.headers, v)
-	}
-}
-
-// Set table Footer
-func (t *Table) SetFooter(keys []string) {
-	//t.colSize = len(keys)
-	for i, v := range keys {
-		t.parseDimension(v, i, -1)
-		t.footers = append(t.footers, v)
-	}
-}
-
-// Turn header autoformatting on/off. Default is on (true).
-func (t *Table) SetAutoFormatHeaders(auto bool) {
-	t.autoFmt = auto
-}
-
-// Turn automatic multiline text adjustment on/off. Default is on (true).
-func (t *Table) SetAutoWrapText(auto bool) {
-	t.autoWrap = auto
-}
-
-// Set the Default column width
-func (t *Table) SetColWidth(width int) {
-	t.mW = width
-}
-
-// Set the Column Separator
-func (t *Table) SetColumnSeparator(sep string) {
-	t.pColumn = sep
-}
-
-// Set the Row Separator
-func (t *Table) SetRowSeparator(sep string) {
-	t.pRow = sep
-}
-
-// Set the center Separator
-func (t *Table) SetCenterSeparator(sep string) {
-	t.pCenter = sep
-}
-
-// Set Table Alignment
-func (t *Table) SetAlignment(align int) {
-	t.align = align
-}
-
-// Set Row Line
-// This would enable / disable a line on each row of the table
-func (t *Table) SetRowLine(line bool) {
-	t.rowLine = line
-}
-
-// Set Table Border
-// This would enable / disable line around the table
-func (t *Table) SetBorder(border bool) {
-	t.border = border
-}
-
-// Append row to table
-func (t *Table) Append(row []string) error {
-	rowSize := len(t.headers)
-	if rowSize > t.colSize {
-		t.colSize = rowSize
-	}
-
-	n := len(t.lines)
-	line := [][]string{}
-	for i, v := range row {
-
-		// Detect string  width
-		// Detect String height
-		// Break strings into words
-		out := t.parseDimension(v, i, n)
-
-		// Append broken words
-		line = append(line, out)
-	}
-	t.lines = append(t.lines, line)
-	return nil
-}
-
-// Allow Support for Bulk Append
-// Eliminates repeated for loops
-func (t *Table) AppendBulk(rows [][]string) (err error) {
-	for _, row := range rows {
-		err = t.Append(row)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Print line based on row width
-func (t Table) printLine(nl bool) {
-	fmt.Fprint(t.out, t.pCenter)
-	for i := 0; i < len(t.cs); i++ {
-		v := t.cs[i]
-		fmt.Fprintf(t.out, "%s%s%s%s",
-			t.pRow,
-			strings.Repeat(string(t.pRow), v),
-			t.pRow,
-			t.pCenter)
-	}
-	if nl {
-		fmt.Fprintln(t.out)
-	}
-}
-
-// Print heading information
-func (t Table) printHeading() {
-	// Check if headers is available
-	if len(t.headers) < 1 {
-		return
-	}
-
-	// Check if border is set
-	// Replace with space if not set
-	fmt.Fprint(t.out, ConditionString(t.border, t.pColumn, SPACE))
-
-	// Identify last column
-	end := len(t.cs) - 1
-
-	// Print Heading column
-	for i := 0; i <= end; i++ {
-		v := t.cs[i]
-		h := t.headers[i]
-		if t.autoFmt {
-			h = Title(h)
-		}
-		pad := ConditionString((i == end && !t.border), SPACE, t.pColumn)
-		fmt.Fprintf(t.out, " %s %s",
-			Pad(h, SPACE, v),
-			pad)
-	}
-	// Next line
-	fmt.Fprintln(t.out)
-	t.printLine(true)
-}
-
-// Print heading information
-func (t Table) printFooter() {
-	// Check if headers is available
-	if len(t.footers) < 1 {
-		return
-	}
-
-	// Only print line if border is not set
-	if !t.border {
-		t.printLine(true)
-	}
-	// Check if border is set
-	// Replace with space if not set
-	fmt.Fprint(t.out, ConditionString(t.border, t.pColumn, SPACE))
-
-	// Identify last column
-	end := len(t.cs) - 1
-
-	// Print Heading column
-	for i := 0; i <= end; i++ {
-		v := t.cs[i]
-		f := t.footers[i]
-		if t.autoFmt {
-			f = Title(f)
-		}
-		pad := ConditionString((i == end && !t.border), SPACE, t.pColumn)
-
-		if len(t.footers[i]) == 0 {
-			pad = SPACE
-		}
-		fmt.Fprintf(t.out, " %s %s",
-			Pad(f, SPACE, v),
-			pad)
-	}
-	// Next line
-	fmt.Fprintln(t.out)
-	//t.printLine(true)
-
-	hasPrinted := false
-
-	for i := 0; i <= end; i++ {
-		v := t.cs[i]
-		pad := t.pRow
-		center := t.pCenter
-		length := len(t.footers[i])
-
-		if length > 0 {
-			hasPrinted = true
-		}
-
-		// Set center to be space if length is 0
-		if length == 0 && !t.border {
-			center = SPACE
-		}
-
-		// Print first junction
-		if i == 0 {
-			fmt.Fprint(t.out, center)
-		}
-
-		// Pad With space of length is 0
-		if length == 0 {
-			pad = SPACE
-		}
-		// Ignore left space of it has printed before
-		if hasPrinted || t.border {
-			pad = t.pRow
-			center = t.pCenter
-		}
-
-		// Change Center start position
-		if center == SPACE {
-			if i < end && len(t.footers[i+1]) != 0 {
-				center = t.pCenter
-			}
-		}
-
-		// Print the footer
-		fmt.Fprintf(t.out, "%s%s%s%s",
-			pad,
-			strings.Repeat(string(pad), v),
-			pad,
-			center)
-
-	}
-
-	fmt.Fprintln(t.out)
-
-}
-
-func (t Table) printRows() {
-	for i, lines := range t.lines {
-		t.printRow(lines, i)
-	}
-
-}
-
-// Print Row Information
-// Adjust column alignment based on type
-
-func (t Table) printRow(columns [][]string, colKey int) {
-	// Get Maximum Height
-	max := t.rs[colKey]
-	total := len(columns)
-
-	// TODO Fix uneven col size
-	// if total < t.colSize {
-	//	for n := t.colSize - total; n < t.colSize ; n++ {
-	//		columns = append(columns, []string{SPACE})
-	//		t.cs[n] = t.mW
-	//	}
-	//}
-
-	// Pad Each Height
-	// pads := []int{}
-	pads := []int{}
-
-	for i, line := range columns {
-		length := len(line)
-		pad := max - length
-		pads = append(pads, pad)
-		for n := 0; n < pad; n++ {
-			columns[i] = append(columns[i], "  ")
-		}
-	}
-	//fmt.Println(max, "\n")
-	for x := 0; x < max; x++ {
-		for y := 0; y < total; y++ {
-
-			// Check if border is set
-			fmt.Fprint(t.out, ConditionString((!t.border && y == 0), SPACE, t.pColumn))
-
-			fmt.Fprintf(t.out, SPACE)
-			str := columns[y][x]
-
-			// This would print alignment
-			// Default alignment  would use multiple configuration
-			switch t.align {
-			case ALIGN_CENTRE: //
-				fmt.Fprintf(t.out, "%s", Pad(str, SPACE, t.cs[y]))
-			case ALIGN_RIGHT:
-				fmt.Fprintf(t.out, "%s", PadLeft(str, SPACE, t.cs[y]))
-			case ALIGN_LEFT:
-				fmt.Fprintf(t.out, "%s", PadRight(str, SPACE, t.cs[y]))
-			default:
-				if decimal.MatchString(strings.TrimSpace(str)) || percent.MatchString(strings.TrimSpace(str)) {
-					fmt.Fprintf(t.out, "%s", PadLeft(str, SPACE, t.cs[y]))
-				} else {
-					fmt.Fprintf(t.out, "%s", PadRight(str, SPACE, t.cs[y]))
-
-					// TODO Custom alignment per column
-					//if max == 1 || pads[y] > 0 {
-					//	fmt.Fprintf(t.out, "%s", Pad(str, SPACE, t.cs[y]))
-					//} else {
-					//	fmt.Fprintf(t.out, "%s", PadRight(str, SPACE, t.cs[y]))
-					//}
-
-				}
-			}
-			fmt.Fprintf(t.out, SPACE)
-		}
-		// Check if border is set
-		// Replace with space if not set
-		fmt.Fprint(t.out, ConditionString(t.border, t.pColumn, SPACE))
-		fmt.Fprintln(t.out)
-	}
-
-	if t.rowLine {
-		t.printLine(true)
-	}
-
-}
-
-func (t *Table) parseDimension(str string, colKey, rowKey int) []string {
-	var (
-		raw []string
-		max int
-	)
-	w := DisplayWidth(str)
-	// Calculate Width
-	// Check if with is grater than maximum width
-	if w > t.mW {
-		w = t.mW
-	}
-
-	// Check if width exists
-	v, ok := t.cs[colKey]
-	if !ok || v < w || v == 0 {
-		t.cs[colKey] = w
-	}
-
-	if rowKey == -1 {
-		return raw
-	}
-	// Calculate Height
-	if t.autoWrap {
-		raw, _ = WrapString(str, t.cs[colKey])
-	} else {
-		raw = getLines(str)
-	}
-
-	for _, line := range raw {
-		if w := DisplayWidth(line); w > max {
-			max = w
-		}
-	}
-
-	// Make sure the with is the same length as maximum word
-	// Important for cases where the width is smaller than maxu word
-	if max > t.cs[colKey] {
-		t.cs[colKey] = max
-	}
-
-	h := len(raw)
-	v, ok = t.rs[rowKey]
-
-	if !ok || v < h || v == 0 {
-		t.rs[rowKey] = h
-	}
-	//fmt.Printf("Raw %+v %d\n", raw, len(raw))
-	return raw
-}
diff --git a/vendor/github.com/olekukonko/tablewriter/test.csv b/vendor/github.com/olekukonko/tablewriter/test.csv
deleted file mode 100644
index 1609327..0000000
--- a/vendor/github.com/olekukonko/tablewriter/test.csv
+++ /dev/null
@@ -1,4 +0,0 @@
-first_name,last_name,ssn
-John,Barry,123456
-Kathy,Smith,687987
-Bob,McCornick,3979870
\ No newline at end of file
diff --git a/vendor/github.com/olekukonko/tablewriter/test_info.csv b/vendor/github.com/olekukonko/tablewriter/test_info.csv
deleted file mode 100644
index e4c40e9..0000000
--- a/vendor/github.com/olekukonko/tablewriter/test_info.csv
+++ /dev/null
@@ -1,4 +0,0 @@
-Field,Type,Null,Key,Default,Extra
-user_id,smallint(5),NO,PRI,NULL,auto_increment
-username,varchar(10),NO,,NULL, 
-password,varchar(100),NO,,NULL, 
\ No newline at end of file
diff --git a/vendor/github.com/olekukonko/tablewriter/util.go b/vendor/github.com/olekukonko/tablewriter/util.go
deleted file mode 100644
index e006ac6..0000000
--- a/vendor/github.com/olekukonko/tablewriter/util.go
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2014 Oleku Konko All rights reserved.
-// Use of this source code is governed by a MIT
-// license that can be found in the LICENSE file.
-
-// This module is a Table Writer  API for the Go Programming Language.
-// The protocols were written in pure Go and works on windows and unix systems
-
-package tablewriter
-
-import (
-	"math"
-	"regexp"
-	"strings"
-	"unicode/utf8"
-)
-
-var (
-	ansi = regexp.MustCompile("\033\\[(?:[0-9]{1,3}(?:;[0-9]{1,3})*)?[m|K]")
-)
-
-func DisplayWidth(str string) int {
-	return utf8.RuneCountInString(ansi.ReplaceAllLiteralString(str, ""))
-}
-
-// Simple Condition for string
-// Returns value based on condition
-func ConditionString(cond bool, valid, inValid string) string {
-	if cond {
-		return valid
-	}
-	return inValid
-}
-
-// Format Table Header
-// Replace _ , . and spaces
-func Title(name string) string {
-	name = strings.Replace(name, "_", " ", -1)
-	name = strings.Replace(name, ".", " ", -1)
-	name = strings.TrimSpace(name)
-	return strings.ToUpper(name)
-}
-
-// Pad String
-// Attempts to play string in the center
-func Pad(s, pad string, width int) string {
-	gap := width - DisplayWidth(s)
-	if gap > 0 {
-		gapLeft := int(math.Ceil(float64(gap / 2)))
-		gapRight := gap - gapLeft
-		return strings.Repeat(string(pad), gapLeft) + s + strings.Repeat(string(pad), gapRight)
-	}
-	return s
-}
-
-// Pad String Right position
-// This would pace string at the left side fo the screen
-func PadRight(s, pad string, width int) string {
-	gap := width - DisplayWidth(s)
-	if gap > 0 {
-		return s + strings.Repeat(string(pad), gap)
-	}
-	return s
-}
-
-// Pad String Left position
-// This would pace string at the right side fo the screen
-func PadLeft(s, pad string, width int) string {
-	gap := width - DisplayWidth(s)
-	if gap > 0 {
-		return strings.Repeat(string(pad), gap) + s
-	}
-	return s
-}
diff --git a/vendor/github.com/olekukonko/tablewriter/wrap.go b/vendor/github.com/olekukonko/tablewriter/wrap.go
deleted file mode 100644
index f3747d9..0000000
--- a/vendor/github.com/olekukonko/tablewriter/wrap.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright 2014 Oleku Konko All rights reserved.
-// Use of this source code is governed by a MIT
-// license that can be found in the LICENSE file.
-
-// This module is a Table Writer  API for the Go Programming Language.
-// The protocols were written in pure Go and works on windows and unix systems
-
-package tablewriter
-
-import (
-	"math"
-	"strings"
-	"unicode/utf8"
-)
-
-var (
-	nl = "\n"
-	sp = " "
-)
-
-const defaultPenalty = 1e5
-
-// Wrap wraps s into a paragraph of lines of length lim, with minimal
-// raggedness.
-func WrapString(s string, lim int) ([]string, int) {
-	words := strings.Split(strings.Replace(strings.TrimSpace(s), nl, sp, -1), sp)
-	var lines []string
-	max := 0
-	for _, v := range words {
-		max = len(v)
-		if max > lim {
-			lim = max
-		}
-	}
-	for _, line := range WrapWords(words, 1, lim, defaultPenalty) {
-		lines = append(lines, strings.Join(line, sp))
-	}
-	return lines, lim
-}
-
-// WrapWords is the low-level line-breaking algorithm, useful if you need more
-// control over the details of the text wrapping process. For most uses,
-// WrapString will be sufficient and more convenient.
-//
-// WrapWords splits a list of words into lines with minimal "raggedness",
-// treating each rune as one unit, accounting for spc units between adjacent
-// words on each line, and attempting to limit lines to lim units. Raggedness
-// is the total error over all lines, where error is the square of the
-// difference of the length of the line and lim. Too-long lines (which only
-// happen when a single word is longer than lim units) have pen penalty units
-// added to the error.
-func WrapWords(words []string, spc, lim, pen int) [][]string {
-	n := len(words)
-
-	length := make([][]int, n)
-	for i := 0; i < n; i++ {
-		length[i] = make([]int, n)
-		length[i][i] = utf8.RuneCountInString(words[i])
-		for j := i + 1; j < n; j++ {
-			length[i][j] = length[i][j-1] + spc + utf8.RuneCountInString(words[j])
-		}
-	}
-	nbrk := make([]int, n)
-	cost := make([]int, n)
-	for i := range cost {
-		cost[i] = math.MaxInt32
-	}
-	for i := n - 1; i >= 0; i-- {
-		if length[i][n-1] <= lim {
-			cost[i] = 0
-			nbrk[i] = n
-		} else {
-			for j := i + 1; j < n; j++ {
-				d := lim - length[i][j-1]
-				c := d*d + cost[j]
-				if length[i][j-1] > lim {
-					c += pen // too-long lines get a worse penalty
-				}
-				if c < cost[i] {
-					cost[i] = c
-					nbrk[i] = j
-				}
-			}
-		}
-	}
-	var lines [][]string
-	i := 0
-	for i < n {
-		lines = append(lines, words[i:nbrk[i]])
-		i = nbrk[i]
-	}
-	return lines
-}
-
-// getLines decomposes a multiline string into a slice of strings.
-func getLines(s string) []string {
-	var lines []string
-
-	for _, line := range strings.Split(strings.TrimSpace(s), nl) {
-		lines = append(lines, line)
-	}
-	return lines
-}
diff --git a/vendor/github.com/pmezard/go-difflib/LICENSE b/vendor/github.com/pmezard/go-difflib/LICENSE
deleted file mode 100644
index c67dad6..0000000
--- a/vendor/github.com/pmezard/go-difflib/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2013, Patrick Mezard
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-    The names of its contributors may not be used to endorse or promote
-products derived from this software without specific prior written
-permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/pmezard/go-difflib/difflib/difflib.go b/vendor/github.com/pmezard/go-difflib/difflib/difflib.go
deleted file mode 100644
index 003e99f..0000000
--- a/vendor/github.com/pmezard/go-difflib/difflib/difflib.go
+++ /dev/null
@@ -1,772 +0,0 @@
-// Package difflib is a partial port of Python difflib module.
-//
-// It provides tools to compare sequences of strings and generate textual diffs.
-//
-// The following class and functions have been ported:
-//
-// - SequenceMatcher
-//
-// - unified_diff
-//
-// - context_diff
-//
-// Getting unified diffs was the main goal of the port. Keep in mind this code
-// is mostly suitable to output text differences in a human friendly way, there
-// are no guarantees generated diffs are consumable by patch(1).
-package difflib
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"strings"
-)
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-func max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}
-
-func calculateRatio(matches, length int) float64 {
-	if length > 0 {
-		return 2.0 * float64(matches) / float64(length)
-	}
-	return 1.0
-}
-
-type Match struct {
-	A    int
-	B    int
-	Size int
-}
-
-type OpCode struct {
-	Tag byte
-	I1  int
-	I2  int
-	J1  int
-	J2  int
-}
-
-// SequenceMatcher compares sequence of strings. The basic
-// algorithm predates, and is a little fancier than, an algorithm
-// published in the late 1980's by Ratcliff and Obershelp under the
-// hyperbolic name "gestalt pattern matching".  The basic idea is to find
-// the longest contiguous matching subsequence that contains no "junk"
-// elements (R-O doesn't address junk).  The same idea is then applied
-// recursively to the pieces of the sequences to the left and to the right
-// of the matching subsequence.  This does not yield minimal edit
-// sequences, but does tend to yield matches that "look right" to people.
-//
-// SequenceMatcher tries to compute a "human-friendly diff" between two
-// sequences.  Unlike e.g. UNIX(tm) diff, the fundamental notion is the
-// longest *contiguous* & junk-free matching subsequence.  That's what
-// catches peoples' eyes.  The Windows(tm) windiff has another interesting
-// notion, pairing up elements that appear uniquely in each sequence.
-// That, and the method here, appear to yield more intuitive difference
-// reports than does diff.  This method appears to be the least vulnerable
-// to synching up on blocks of "junk lines", though (like blank lines in
-// ordinary text files, or maybe "<P>" lines in HTML files).  That may be
-// because this is the only method of the 3 that has a *concept* of
-// "junk" <wink>.
-//
-// Timing:  Basic R-O is cubic time worst case and quadratic time expected
-// case.  SequenceMatcher is quadratic time for the worst case and has
-// expected-case behavior dependent in a complicated way on how many
-// elements the sequences have in common; best case time is linear.
-type SequenceMatcher struct {
-	a              []string
-	b              []string
-	b2j            map[string][]int
-	IsJunk         func(string) bool
-	autoJunk       bool
-	bJunk          map[string]struct{}
-	matchingBlocks []Match
-	fullBCount     map[string]int
-	bPopular       map[string]struct{}
-	opCodes        []OpCode
-}
-
-func NewMatcher(a, b []string) *SequenceMatcher {
-	m := SequenceMatcher{autoJunk: true}
-	m.SetSeqs(a, b)
-	return &m
-}
-
-func NewMatcherWithJunk(a, b []string, autoJunk bool,
-	isJunk func(string) bool) *SequenceMatcher {
-
-	m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
-	m.SetSeqs(a, b)
-	return &m
-}
-
-// Set two sequences to be compared.
-func (m *SequenceMatcher) SetSeqs(a, b []string) {
-	m.SetSeq1(a)
-	m.SetSeq2(b)
-}
-
-// Set the first sequence to be compared. The second sequence to be compared is
-// not changed.
-//
-// SequenceMatcher computes and caches detailed information about the second
-// sequence, so if you want to compare one sequence S against many sequences,
-// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
-// sequences.
-//
-// See also SetSeqs() and SetSeq2().
-func (m *SequenceMatcher) SetSeq1(a []string) {
-	if &a == &m.a {
-		return
-	}
-	m.a = a
-	m.matchingBlocks = nil
-	m.opCodes = nil
-}
-
-// Set the second sequence to be compared. The first sequence to be compared is
-// not changed.
-func (m *SequenceMatcher) SetSeq2(b []string) {
-	if &b == &m.b {
-		return
-	}
-	m.b = b
-	m.matchingBlocks = nil
-	m.opCodes = nil
-	m.fullBCount = nil
-	m.chainB()
-}
-
-func (m *SequenceMatcher) chainB() {
-	// Populate line -> index mapping
-	b2j := map[string][]int{}
-	for i, s := range m.b {
-		indices := b2j[s]
-		indices = append(indices, i)
-		b2j[s] = indices
-	}
-
-	// Purge junk elements
-	m.bJunk = map[string]struct{}{}
-	if m.IsJunk != nil {
-		junk := m.bJunk
-		for s, _ := range b2j {
-			if m.IsJunk(s) {
-				junk[s] = struct{}{}
-			}
-		}
-		for s, _ := range junk {
-			delete(b2j, s)
-		}
-	}
-
-	// Purge remaining popular elements
-	popular := map[string]struct{}{}
-	n := len(m.b)
-	if m.autoJunk && n >= 200 {
-		ntest := n/100 + 1
-		for s, indices := range b2j {
-			if len(indices) > ntest {
-				popular[s] = struct{}{}
-			}
-		}
-		for s, _ := range popular {
-			delete(b2j, s)
-		}
-	}
-	m.bPopular = popular
-	m.b2j = b2j
-}
-
-func (m *SequenceMatcher) isBJunk(s string) bool {
-	_, ok := m.bJunk[s]
-	return ok
-}
-
-// Find longest matching block in a[alo:ahi] and b[blo:bhi].
-//
-// If IsJunk is not defined:
-//
-// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
-//     alo <= i <= i+k <= ahi
-//     blo <= j <= j+k <= bhi
-// and for all (i',j',k') meeting those conditions,
-//     k >= k'
-//     i <= i'
-//     and if i == i', j <= j'
-//
-// In other words, of all maximal matching blocks, return one that
-// starts earliest in a, and of all those maximal matching blocks that
-// start earliest in a, return the one that starts earliest in b.
-//
-// If IsJunk is defined, first the longest matching block is
-// determined as above, but with the additional restriction that no
-// junk element appears in the block.  Then that block is extended as
-// far as possible by matching (only) junk elements on both sides.  So
-// the resulting block never matches on junk except as identical junk
-// happens to be adjacent to an "interesting" match.
-//
-// If no blocks match, return (alo, blo, 0).
-func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {
-	// CAUTION:  stripping common prefix or suffix would be incorrect.
-	// E.g.,
-	//    ab
-	//    acab
-	// Longest matching block is "ab", but if common prefix is
-	// stripped, it's "a" (tied with "b").  UNIX(tm) diff does so
-	// strip, so ends up claiming that ab is changed to acab by
-	// inserting "ca" in the middle.  That's minimal but unintuitive:
-	// "it's obvious" that someone inserted "ac" at the front.
-	// Windiff ends up at the same place as diff, but by pairing up
-	// the unique 'b's and then matching the first two 'a's.
-	besti, bestj, bestsize := alo, blo, 0
-
-	// find longest junk-free match
-	// during an iteration of the loop, j2len[j] = length of longest
-	// junk-free match ending with a[i-1] and b[j]
-	j2len := map[int]int{}
-	for i := alo; i != ahi; i++ {
-		// look at all instances of a[i] in b; note that because
-		// b2j has no junk keys, the loop is skipped if a[i] is junk
-		newj2len := map[int]int{}
-		for _, j := range m.b2j[m.a[i]] {
-			// a[i] matches b[j]
-			if j < blo {
-				continue
-			}
-			if j >= bhi {
-				break
-			}
-			k := j2len[j-1] + 1
-			newj2len[j] = k
-			if k > bestsize {
-				besti, bestj, bestsize = i-k+1, j-k+1, k
-			}
-		}
-		j2len = newj2len
-	}
-
-	// Extend the best by non-junk elements on each end.  In particular,
-	// "popular" non-junk elements aren't in b2j, which greatly speeds
-	// the inner loop above, but also means "the best" match so far
-	// doesn't contain any junk *or* popular non-junk elements.
-	for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&
-		m.a[besti-1] == m.b[bestj-1] {
-		besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
-	}
-	for besti+bestsize < ahi && bestj+bestsize < bhi &&
-		!m.isBJunk(m.b[bestj+bestsize]) &&
-		m.a[besti+bestsize] == m.b[bestj+bestsize] {
-		bestsize += 1
-	}
-
-	// Now that we have a wholly interesting match (albeit possibly
-	// empty!), we may as well suck up the matching junk on each
-	// side of it too.  Can't think of a good reason not to, and it
-	// saves post-processing the (possibly considerable) expense of
-	// figuring out what to do with it.  In the case of an empty
-	// interesting match, this is clearly the right thing to do,
-	// because no other kind of match is possible in the regions.
-	for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&
-		m.a[besti-1] == m.b[bestj-1] {
-		besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
-	}
-	for besti+bestsize < ahi && bestj+bestsize < bhi &&
-		m.isBJunk(m.b[bestj+bestsize]) &&
-		m.a[besti+bestsize] == m.b[bestj+bestsize] {
-		bestsize += 1
-	}
-
-	return Match{A: besti, B: bestj, Size: bestsize}
-}
-
-// Return list of triples describing matching subsequences.
-//
-// Each triple is of the form (i, j, n), and means that
-// a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in
-// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
-// adjacent triples in the list, and the second is not the last triple in the
-// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
-// adjacent equal blocks.
-//
-// The last triple is a dummy, (len(a), len(b), 0), and is the only
-// triple with n==0.
-func (m *SequenceMatcher) GetMatchingBlocks() []Match {
-	if m.matchingBlocks != nil {
-		return m.matchingBlocks
-	}
-
-	var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match
-	matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {
-		match := m.findLongestMatch(alo, ahi, blo, bhi)
-		i, j, k := match.A, match.B, match.Size
-		if match.Size > 0 {
-			if alo < i && blo < j {
-				matched = matchBlocks(alo, i, blo, j, matched)
-			}
-			matched = append(matched, match)
-			if i+k < ahi && j+k < bhi {
-				matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
-			}
-		}
-		return matched
-	}
-	matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)
-
-	// It's possible that we have adjacent equal blocks in the
-	// matching_blocks list now.
-	nonAdjacent := []Match{}
-	i1, j1, k1 := 0, 0, 0
-	for _, b := range matched {
-		// Is this block adjacent to i1, j1, k1?
-		i2, j2, k2 := b.A, b.B, b.Size
-		if i1+k1 == i2 && j1+k1 == j2 {
-			// Yes, so collapse them -- this just increases the length of
-			// the first block by the length of the second, and the first
-			// block so lengthened remains the block to compare against.
-			k1 += k2
-		} else {
-			// Not adjacent.  Remember the first block (k1==0 means it's
-			// the dummy we started with), and make the second block the
-			// new block to compare against.
-			if k1 > 0 {
-				nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
-			}
-			i1, j1, k1 = i2, j2, k2
-		}
-	}
-	if k1 > 0 {
-		nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
-	}
-
-	nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})
-	m.matchingBlocks = nonAdjacent
-	return m.matchingBlocks
-}
-
-// Return list of 5-tuples describing how to turn a into b.
-//
-// Each tuple is of the form (tag, i1, i2, j1, j2).  The first tuple
-// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
-// tuple preceding it, and likewise for j1 == the previous j2.
-//
-// The tags are characters, with these meanings:
-//
-// 'r' (replace):  a[i1:i2] should be replaced by b[j1:j2]
-//
-// 'd' (delete):   a[i1:i2] should be deleted, j1==j2 in this case.
-//
-// 'i' (insert):   b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
-//
-// 'e' (equal):    a[i1:i2] == b[j1:j2]
-func (m *SequenceMatcher) GetOpCodes() []OpCode {
-	if m.opCodes != nil {
-		return m.opCodes
-	}
-	i, j := 0, 0
-	matching := m.GetMatchingBlocks()
-	opCodes := make([]OpCode, 0, len(matching))
-	for _, m := range matching {
-		//  invariant:  we've pumped out correct diffs to change
-		//  a[:i] into b[:j], and the next matching block is
-		//  a[ai:ai+size] == b[bj:bj+size]. So we need to pump
-		//  out a diff to change a[i:ai] into b[j:bj], pump out
-		//  the matching block, and move (i,j) beyond the match
-		ai, bj, size := m.A, m.B, m.Size
-		tag := byte(0)
-		if i < ai && j < bj {
-			tag = 'r'
-		} else if i < ai {
-			tag = 'd'
-		} else if j < bj {
-			tag = 'i'
-		}
-		if tag > 0 {
-			opCodes = append(opCodes, OpCode{tag, i, ai, j, bj})
-		}
-		i, j = ai+size, bj+size
-		// the list of matching blocks is terminated by a
-		// sentinel with size 0
-		if size > 0 {
-			opCodes = append(opCodes, OpCode{'e', ai, i, bj, j})
-		}
-	}
-	m.opCodes = opCodes
-	return m.opCodes
-}
-
-// Isolate change clusters by eliminating ranges with no changes.
-//
-// Return a generator of groups with up to n lines of context.
-// Each group is in the same format as returned by GetOpCodes().
-func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
-	if n < 0 {
-		n = 3
-	}
-	codes := m.GetOpCodes()
-	if len(codes) == 0 {
-		codes = []OpCode{OpCode{'e', 0, 1, 0, 1}}
-	}
-	// Fixup leading and trailing groups if they show no changes.
-	if codes[0].Tag == 'e' {
-		c := codes[0]
-		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-		codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}
-	}
-	if codes[len(codes)-1].Tag == 'e' {
-		c := codes[len(codes)-1]
-		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-		codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}
-	}
-	nn := n + n
-	groups := [][]OpCode{}
-	group := []OpCode{}
-	for _, c := range codes {
-		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-		// End the current group and start a new one whenever
-		// there is a large range with no changes.
-		if c.Tag == 'e' && i2-i1 > nn {
-			group = append(group, OpCode{c.Tag, i1, min(i2, i1+n),
-				j1, min(j2, j1+n)})
-			groups = append(groups, group)
-			group = []OpCode{}
-			i1, j1 = max(i1, i2-n), max(j1, j2-n)
-		}
-		group = append(group, OpCode{c.Tag, i1, i2, j1, j2})
-	}
-	if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {
-		groups = append(groups, group)
-	}
-	return groups
-}
-
-// Return a measure of the sequences' similarity (float in [0,1]).
-//
-// Where T is the total number of elements in both sequences, and
-// M is the number of matches, this is 2.0*M / T.
-// Note that this is 1 if the sequences are identical, and 0 if
-// they have nothing in common.
-//
-// .Ratio() is expensive to compute if you haven't already computed
-// .GetMatchingBlocks() or .GetOpCodes(), in which case you may
-// want to try .QuickRatio() or .RealQuickRation() first to get an
-// upper bound.
-func (m *SequenceMatcher) Ratio() float64 {
-	matches := 0
-	for _, m := range m.GetMatchingBlocks() {
-		matches += m.Size
-	}
-	return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() relatively quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute.
-func (m *SequenceMatcher) QuickRatio() float64 {
-	// viewing a and b as multisets, set matches to the cardinality
-	// of their intersection; this counts the number of matches
-	// without regard to order, so is clearly an upper bound
-	if m.fullBCount == nil {
-		m.fullBCount = map[string]int{}
-		for _, s := range m.b {
-			m.fullBCount[s] = m.fullBCount[s] + 1
-		}
-	}
-
-	// avail[x] is the number of times x appears in 'b' less the
-	// number of times we've seen it in 'a' so far ... kinda
-	avail := map[string]int{}
-	matches := 0
-	for _, s := range m.a {
-		n, ok := avail[s]
-		if !ok {
-			n = m.fullBCount[s]
-		}
-		avail[s] = n - 1
-		if n > 0 {
-			matches += 1
-		}
-	}
-	return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() very quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute than either .Ratio() or .QuickRatio().
-func (m *SequenceMatcher) RealQuickRatio() float64 {
-	la, lb := len(m.a), len(m.b)
-	return calculateRatio(min(la, lb), la+lb)
-}
-
-// Convert range to the "ed" format
-func formatRangeUnified(start, stop int) string {
-	// Per the diff spec at http://www.unix.org/single_unix_specification/
-	beginning := start + 1 // lines start numbering with one
-	length := stop - start
-	if length == 1 {
-		return fmt.Sprintf("%d", beginning)
-	}
-	if length == 0 {
-		beginning -= 1 // empty ranges begin at line just before the range
-	}
-	return fmt.Sprintf("%d,%d", beginning, length)
-}
-
-// Unified diff parameters
-type UnifiedDiff struct {
-	A        []string // First sequence lines
-	FromFile string   // First file name
-	FromDate string   // First file time
-	B        []string // Second sequence lines
-	ToFile   string   // Second file name
-	ToDate   string   // Second file time
-	Eol      string   // Headers end of line, defaults to LF
-	Context  int      // Number of context lines
-}
-
-// Compare two sequences of lines; generate the delta as a unified diff.
-//
-// Unified diffs are a compact way of showing line changes and a few
-// lines of context.  The number of context lines is set by 'n' which
-// defaults to three.
-//
-// By default, the diff control lines (those with ---, +++, or @@) are
-// created with a trailing newline.  This is helpful so that inputs
-// created from file.readlines() result in diffs that are suitable for
-// file.writelines() since both the inputs and outputs have trailing
-// newlines.
-//
-// For inputs that do not have trailing newlines, set the lineterm
-// argument to "" so that the output will be uniformly newline free.
-//
-// The unidiff format normally has a header for filenames and modification
-// times.  Any or all of these may be specified using strings for
-// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
-// The modification times are normally expressed in the ISO 8601 format.
-func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {
-	buf := bufio.NewWriter(writer)
-	defer buf.Flush()
-	wf := func(format string, args ...interface{}) error {
-		_, err := buf.WriteString(fmt.Sprintf(format, args...))
-		return err
-	}
-	ws := func(s string) error {
-		_, err := buf.WriteString(s)
-		return err
-	}
-
-	if len(diff.Eol) == 0 {
-		diff.Eol = "\n"
-	}
-
-	started := false
-	m := NewMatcher(diff.A, diff.B)
-	for _, g := range m.GetGroupedOpCodes(diff.Context) {
-		if !started {
-			started = true
-			fromDate := ""
-			if len(diff.FromDate) > 0 {
-				fromDate = "\t" + diff.FromDate
-			}
-			toDate := ""
-			if len(diff.ToDate) > 0 {
-				toDate = "\t" + diff.ToDate
-			}
-			if diff.FromFile != "" || diff.ToFile != "" {
-				err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol)
-				if err != nil {
-					return err
-				}
-				err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol)
-				if err != nil {
-					return err
-				}
-			}
-		}
-		first, last := g[0], g[len(g)-1]
-		range1 := formatRangeUnified(first.I1, last.I2)
-		range2 := formatRangeUnified(first.J1, last.J2)
-		if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil {
-			return err
-		}
-		for _, c := range g {
-			i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-			if c.Tag == 'e' {
-				for _, line := range diff.A[i1:i2] {
-					if err := ws(" " + line); err != nil {
-						return err
-					}
-				}
-				continue
-			}
-			if c.Tag == 'r' || c.Tag == 'd' {
-				for _, line := range diff.A[i1:i2] {
-					if err := ws("-" + line); err != nil {
-						return err
-					}
-				}
-			}
-			if c.Tag == 'r' || c.Tag == 'i' {
-				for _, line := range diff.B[j1:j2] {
-					if err := ws("+" + line); err != nil {
-						return err
-					}
-				}
-			}
-		}
-	}
-	return nil
-}
-
-// Like WriteUnifiedDiff but returns the diff a string.
-func GetUnifiedDiffString(diff UnifiedDiff) (string, error) {
-	w := &bytes.Buffer{}
-	err := WriteUnifiedDiff(w, diff)
-	return string(w.Bytes()), err
-}
-
-// Convert range to the "ed" format.
-func formatRangeContext(start, stop int) string {
-	// Per the diff spec at http://www.unix.org/single_unix_specification/
-	beginning := start + 1 // lines start numbering with one
-	length := stop - start
-	if length == 0 {
-		beginning -= 1 // empty ranges begin at line just before the range
-	}
-	if length <= 1 {
-		return fmt.Sprintf("%d", beginning)
-	}
-	return fmt.Sprintf("%d,%d", beginning, beginning+length-1)
-}
-
-type ContextDiff UnifiedDiff
-
-// Compare two sequences of lines; generate the delta as a context diff.
-//
-// Context diffs are a compact way of showing line changes and a few
-// lines of context. The number of context lines is set by diff.Context
-// which defaults to three.
-//
-// By default, the diff control lines (those with *** or ---) are
-// created with a trailing newline.
-//
-// For inputs that do not have trailing newlines, set the diff.Eol
-// argument to "" so that the output will be uniformly newline free.
-//
-// The context diff format normally has a header for filenames and
-// modification times.  Any or all of these may be specified using
-// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.
-// The modification times are normally expressed in the ISO 8601 format.
-// If not specified, the strings default to blanks.
-func WriteContextDiff(writer io.Writer, diff ContextDiff) error {
-	buf := bufio.NewWriter(writer)
-	defer buf.Flush()
-	var diffErr error
-	wf := func(format string, args ...interface{}) {
-		_, err := buf.WriteString(fmt.Sprintf(format, args...))
-		if diffErr == nil && err != nil {
-			diffErr = err
-		}
-	}
-	ws := func(s string) {
-		_, err := buf.WriteString(s)
-		if diffErr == nil && err != nil {
-			diffErr = err
-		}
-	}
-
-	if len(diff.Eol) == 0 {
-		diff.Eol = "\n"
-	}
-
-	prefix := map[byte]string{
-		'i': "+ ",
-		'd': "- ",
-		'r': "! ",
-		'e': "  ",
-	}
-
-	started := false
-	m := NewMatcher(diff.A, diff.B)
-	for _, g := range m.GetGroupedOpCodes(diff.Context) {
-		if !started {
-			started = true
-			fromDate := ""
-			if len(diff.FromDate) > 0 {
-				fromDate = "\t" + diff.FromDate
-			}
-			toDate := ""
-			if len(diff.ToDate) > 0 {
-				toDate = "\t" + diff.ToDate
-			}
-			if diff.FromFile != "" || diff.ToFile != "" {
-				wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol)
-				wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol)
-			}
-		}
-
-		first, last := g[0], g[len(g)-1]
-		ws("***************" + diff.Eol)
-
-		range1 := formatRangeContext(first.I1, last.I2)
-		wf("*** %s ****%s", range1, diff.Eol)
-		for _, c := range g {
-			if c.Tag == 'r' || c.Tag == 'd' {
-				for _, cc := range g {
-					if cc.Tag == 'i' {
-						continue
-					}
-					for _, line := range diff.A[cc.I1:cc.I2] {
-						ws(prefix[cc.Tag] + line)
-					}
-				}
-				break
-			}
-		}
-
-		range2 := formatRangeContext(first.J1, last.J2)
-		wf("--- %s ----%s", range2, diff.Eol)
-		for _, c := range g {
-			if c.Tag == 'r' || c.Tag == 'i' {
-				for _, cc := range g {
-					if cc.Tag == 'd' {
-						continue
-					}
-					for _, line := range diff.B[cc.J1:cc.J2] {
-						ws(prefix[cc.Tag] + line)
-					}
-				}
-				break
-			}
-		}
-	}
-	return diffErr
-}
-
-// Like WriteContextDiff but returns the diff a string.
-func GetContextDiffString(diff ContextDiff) (string, error) {
-	w := &bytes.Buffer{}
-	err := WriteContextDiff(w, diff)
-	return string(w.Bytes()), err
-}
-
-// Split a string on "\n" while preserving them. The output can be used
-// as input for UnifiedDiff and ContextDiff structures.
-func SplitLines(s string) []string {
-	lines := strings.SplitAfter(s, "\n")
-	lines[len(lines)-1] += "\n"
-	return lines
-}
diff --git a/vendor/github.com/stretchr/testify/LICENSE b/vendor/github.com/stretchr/testify/LICENSE
deleted file mode 100644
index 473b670..0000000
--- a/vendor/github.com/stretchr/testify/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
-
-Please consider promoting this project if you find it useful.
-
-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.
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go b/vendor/github.com/stretchr/testify/assert/assertion_forward.go
deleted file mode 100644
index e6a7960..0000000
--- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go
+++ /dev/null
@@ -1,387 +0,0 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
-*/
-
-package assert
-
-import (
-
-	http "net/http"
-	url "net/url"
-	time "time"
-)
-
-
-// Condition uses a Comparison to assert a complex condition.
-func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
-	return Condition(a.t, comp, msgAndArgs...)
-}
-
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-// 
-//    a.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
-//    a.Contains(["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
-//    a.Contains({"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
-	return Contains(a.t, s, contains, msgAndArgs...)
-}
-
-
-// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-// 
-//  a.Empty(obj)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
-	return Empty(a.t, object, msgAndArgs...)
-}
-
-
-// Equal asserts that two objects are equal.
-// 
-//    a.Equal(123, 123, "123 and 123 should be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
-	return Equal(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-// 
-//   actualObj, err := SomeFunction()
-//   if assert.Error(t, err, "An error was expected") {
-// 	   assert.Equal(t, err, expectedError)
-//   }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
-	return EqualError(a.t, theError, errString, msgAndArgs...)
-}
-
-
-// EqualValues asserts that two objects are equal or convertable to the same types
-// and equal.
-// 
-//    a.EqualValues(uint32(123), int32(123), "123 and 123 should be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
-	return EqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-// 
-//   actualObj, err := SomeFunction()
-//   if a.Error(err, "An error was expected") {
-// 	   assert.Equal(t, err, expectedError)
-//   }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool {
-	return Error(a.t, err, msgAndArgs...)
-}
-
-
-// Exactly asserts that two objects are equal is value and type.
-// 
-//    a.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
-	return Exactly(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// Fail reports a failure through
-func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
-	return Fail(a.t, failureMessage, msgAndArgs...)
-}
-
-
-// FailNow fails test
-func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool {
-	return FailNow(a.t, failureMessage, msgAndArgs...)
-}
-
-
-// False asserts that the specified value is false.
-// 
-//    a.False(myBool, "myBool should be false")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
-	return False(a.t, value, msgAndArgs...)
-}
-
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-// 
-//  a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
-	return HTTPBodyContains(a.t, handler, method, url, values, str)
-}
-
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-// 
-//  a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
-	return HTTPBodyNotContains(a.t, handler, method, url, values, str)
-}
-
-
-// HTTPError asserts that a specified handler returns an error status code.
-// 
-//  a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPError(a.t, handler, method, url, values)
-}
-
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-// 
-//  a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPRedirect(a.t, handler, method, url, values)
-}
-
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-// 
-//  a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPSuccess(a.t, handler, method, url, values)
-}
-
-
-// Implements asserts that an object is implemented by the specified interface.
-// 
-//    a.Implements((*MyInterface)(nil), new(MyObject), "MyObject")
-func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
-	return Implements(a.t, interfaceObject, object, msgAndArgs...)
-}
-
-
-// InDelta asserts that the two numerals are within delta of each other.
-// 
-// 	 a.InDelta(math.Pi, (22 / 7.0), 0.01)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
-	return InDelta(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
-	return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
-	return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-
-// InEpsilonSlice is the same as InEpsilon, except it compares two slices.
-func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
-	return InEpsilonSlice(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-
-// IsType asserts that the specified objects are of the same type.
-func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
-	return IsType(a.t, expectedType, object, msgAndArgs...)
-}
-
-
-// JSONEq asserts that two JSON strings are equivalent.
-// 
-//  a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool {
-	return JSONEq(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-// 
-//    a.Len(mySlice, 3, "The size of slice is not 3")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
-	return Len(a.t, object, length, msgAndArgs...)
-}
-
-
-// Nil asserts that the specified object is nil.
-// 
-//    a.Nil(err, "err should be nothing")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
-	return Nil(a.t, object, msgAndArgs...)
-}
-
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-// 
-//   actualObj, err := SomeFunction()
-//   if a.NoError(err) {
-// 	   assert.Equal(t, actualObj, expectedObj)
-//   }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
-	return NoError(a.t, err, msgAndArgs...)
-}
-
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-// 
-//    a.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
-//    a.NotContains(["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
-//    a.NotContains({"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
-	return NotContains(a.t, s, contains, msgAndArgs...)
-}
-
-
-// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-// 
-//  if a.NotEmpty(obj) {
-//    assert.Equal(t, "two", obj[1])
-//  }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
-	return NotEmpty(a.t, object, msgAndArgs...)
-}
-
-
-// NotEqual asserts that the specified values are NOT equal.
-// 
-//    a.NotEqual(obj1, obj2, "two objects shouldn't be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
-	return NotEqual(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// NotNil asserts that the specified object is not nil.
-// 
-//    a.NotNil(err, "err should be something")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
-	return NotNil(a.t, object, msgAndArgs...)
-}
-
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-// 
-//   a.NotPanics(func(){
-//     RemainCalm()
-//   }, "Calling RemainCalm() should NOT panic")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
-	return NotPanics(a.t, f, msgAndArgs...)
-}
-
-
-// NotRegexp asserts that a specified regexp does not match a string.
-// 
-//  a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
-//  a.NotRegexp("^start", "it's not starting")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
-	return NotRegexp(a.t, rx, str, msgAndArgs...)
-}
-
-
-// NotZero asserts that i is not the zero value for its type and returns the truth.
-func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool {
-	return NotZero(a.t, i, msgAndArgs...)
-}
-
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-// 
-//   a.Panics(func(){
-//     GoCrazy()
-//   }, "Calling GoCrazy() should panic")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
-	return Panics(a.t, f, msgAndArgs...)
-}
-
-
-// Regexp asserts that a specified regexp matches a string.
-// 
-//  a.Regexp(regexp.MustCompile("start"), "it's starting")
-//  a.Regexp("start...$", "it's not starting")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
-	return Regexp(a.t, rx, str, msgAndArgs...)
-}
-
-
-// True asserts that the specified value is true.
-// 
-//    a.True(myBool, "myBool should be true")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
-	return True(a.t, value, msgAndArgs...)
-}
-
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-// 
-//   a.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
-	return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-
-// Zero asserts that i is the zero value for its type and returns the truth.
-func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool {
-	return Zero(a.t, i, msgAndArgs...)
-}
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl b/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl
deleted file mode 100644
index 99f9acf..0000000
--- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl
+++ /dev/null
@@ -1,4 +0,0 @@
-{{.CommentWithoutT "a"}}
-func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool {
-	return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
-}
diff --git a/vendor/github.com/stretchr/testify/assert/assertions.go b/vendor/github.com/stretchr/testify/assert/assertions.go
deleted file mode 100644
index 348d5f1..0000000
--- a/vendor/github.com/stretchr/testify/assert/assertions.go
+++ /dev/null
@@ -1,1007 +0,0 @@
-package assert
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"math"
-	"reflect"
-	"regexp"
-	"runtime"
-	"strings"
-	"time"
-	"unicode"
-	"unicode/utf8"
-
-	"github.com/davecgh/go-spew/spew"
-	"github.com/pmezard/go-difflib/difflib"
-)
-
-// TestingT is an interface wrapper around *testing.T
-type TestingT interface {
-	Errorf(format string, args ...interface{})
-}
-
-// Comparison a custom function that returns true on success and false on failure
-type Comparison func() (success bool)
-
-/*
-	Helper functions
-*/
-
-// ObjectsAreEqual determines if two objects are considered equal.
-//
-// This function does no assertion of any kind.
-func ObjectsAreEqual(expected, actual interface{}) bool {
-
-	if expected == nil || actual == nil {
-		return expected == actual
-	}
-
-	return reflect.DeepEqual(expected, actual)
-
-}
-
-// ObjectsAreEqualValues gets whether two objects are equal, or if their
-// values are equal.
-func ObjectsAreEqualValues(expected, actual interface{}) bool {
-	if ObjectsAreEqual(expected, actual) {
-		return true
-	}
-
-	actualType := reflect.TypeOf(actual)
-	if actualType == nil {
-		return false
-	}
-	expectedValue := reflect.ValueOf(expected)
-	if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) {
-		// Attempt comparison after type conversion
-		return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual)
-	}
-
-	return false
-}
-
-/* CallerInfo is necessary because the assert functions use the testing object
-internally, causing it to print the file:line of the assert method, rather than where
-the problem actually occured in calling code.*/
-
-// CallerInfo returns an array of strings containing the file and line number
-// of each stack frame leading from the current test to the assert call that
-// failed.
-func CallerInfo() []string {
-
-	pc := uintptr(0)
-	file := ""
-	line := 0
-	ok := false
-	name := ""
-
-	callers := []string{}
-	for i := 0; ; i++ {
-		pc, file, line, ok = runtime.Caller(i)
-		if !ok {
-			return nil
-		}
-
-		// This is a huge edge case, but it will panic if this is the case, see #180
-		if file == "<autogenerated>" {
-			break
-		}
-
-		parts := strings.Split(file, "/")
-		dir := parts[len(parts)-2]
-		file = parts[len(parts)-1]
-		if (dir != "assert" && dir != "mock" && dir != "require") || file == "mock_test.go" {
-			callers = append(callers, fmt.Sprintf("%s:%d", file, line))
-		}
-
-		f := runtime.FuncForPC(pc)
-		if f == nil {
-			break
-		}
-		name = f.Name()
-		// Drop the package
-		segments := strings.Split(name, ".")
-		name = segments[len(segments)-1]
-		if isTest(name, "Test") ||
-			isTest(name, "Benchmark") ||
-			isTest(name, "Example") {
-			break
-		}
-	}
-
-	return callers
-}
-
-// Stolen from the `go test` tool.
-// isTest tells whether name looks like a test (or benchmark, according to prefix).
-// It is a Test (say) if there is a character after Test that is not a lower-case letter.
-// We don't want TesticularCancer.
-func isTest(name, prefix string) bool {
-	if !strings.HasPrefix(name, prefix) {
-		return false
-	}
-	if len(name) == len(prefix) { // "Test" is ok
-		return true
-	}
-	rune, _ := utf8.DecodeRuneInString(name[len(prefix):])
-	return !unicode.IsLower(rune)
-}
-
-// getWhitespaceString returns a string that is long enough to overwrite the default
-// output from the go testing framework.
-func getWhitespaceString() string {
-
-	_, file, line, ok := runtime.Caller(1)
-	if !ok {
-		return ""
-	}
-	parts := strings.Split(file, "/")
-	file = parts[len(parts)-1]
-
-	return strings.Repeat(" ", len(fmt.Sprintf("%s:%d:      ", file, line)))
-
-}
-
-func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
-	if len(msgAndArgs) == 0 || msgAndArgs == nil {
-		return ""
-	}
-	if len(msgAndArgs) == 1 {
-		return msgAndArgs[0].(string)
-	}
-	if len(msgAndArgs) > 1 {
-		return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
-	}
-	return ""
-}
-
-// Indents all lines of the message by appending a number of tabs to each line, in an output format compatible with Go's
-// test printing (see inner comment for specifics)
-func indentMessageLines(message string, tabs int) string {
-	outBuf := new(bytes.Buffer)
-
-	for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {
-		if i != 0 {
-			outBuf.WriteRune('\n')
-		}
-		for ii := 0; ii < tabs; ii++ {
-			outBuf.WriteRune('\t')
-			// Bizarrely, all lines except the first need one fewer tabs prepended, so deliberately advance the counter
-			// by 1 prematurely.
-			if ii == 0 && i > 0 {
-				ii++
-			}
-		}
-		outBuf.WriteString(scanner.Text())
-	}
-
-	return outBuf.String()
-}
-
-type failNower interface {
-	FailNow()
-}
-
-// FailNow fails test
-func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
-	Fail(t, failureMessage, msgAndArgs...)
-
-	// We cannot extend TestingT with FailNow() and
-	// maintain backwards compatibility, so we fallback
-	// to panicking when FailNow is not available in
-	// TestingT.
-	// See issue #263
-
-	if t, ok := t.(failNower); ok {
-		t.FailNow()
-	} else {
-		panic("test failed and t is missing `FailNow()`")
-	}
-	return false
-}
-
-// Fail reports a failure through
-func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
-
-	message := messageFromMsgAndArgs(msgAndArgs...)
-
-	errorTrace := strings.Join(CallerInfo(), "\n\r\t\t\t")
-	if len(message) > 0 {
-		t.Errorf("\r%s\r\tError Trace:\t%s\n"+
-			"\r\tError:%s\n"+
-			"\r\tMessages:\t%s\n\r",
-			getWhitespaceString(),
-			errorTrace,
-			indentMessageLines(failureMessage, 2),
-			message)
-	} else {
-		t.Errorf("\r%s\r\tError Trace:\t%s\n"+
-			"\r\tError:%s\n\r",
-			getWhitespaceString(),
-			errorTrace,
-			indentMessageLines(failureMessage, 2))
-	}
-
-	return false
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-//    assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject")
-func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
-
-	interfaceType := reflect.TypeOf(interfaceObject).Elem()
-
-	if !reflect.TypeOf(object).Implements(interfaceType) {
-		return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...)
-	}
-
-	return true
-
-}
-
-// IsType asserts that the specified objects are of the same type.
-func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
-
-	if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) {
-		return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...)
-	}
-
-	return true
-}
-
-// Equal asserts that two objects are equal.
-//
-//    assert.Equal(t, 123, 123, "123 and 123 should be equal")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
-
-	if !ObjectsAreEqual(expected, actual) {
-		diff := diff(expected, actual)
-		return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+
-			"        != %#v (actual)%s", expected, actual, diff), msgAndArgs...)
-	}
-
-	return true
-
-}
-
-// EqualValues asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-//    assert.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
-
-	if !ObjectsAreEqualValues(expected, actual) {
-		return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+
-			"        != %#v (actual)", expected, actual), msgAndArgs...)
-	}
-
-	return true
-
-}
-
-// Exactly asserts that two objects are equal is value and type.
-//
-//    assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
-
-	aType := reflect.TypeOf(expected)
-	bType := reflect.TypeOf(actual)
-
-	if aType != bType {
-		return Fail(t, fmt.Sprintf("Types expected to match exactly\n\r\t%v != %v", aType, bType), msgAndArgs...)
-	}
-
-	return Equal(t, expected, actual, msgAndArgs...)
-
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-//    assert.NotNil(t, err, "err should be something")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
-	if !isNil(object) {
-		return true
-	}
-	return Fail(t, "Expected value not to be nil.", msgAndArgs...)
-}
-
-// isNil checks if a specified object is nil or not, without Failing.
-func isNil(object interface{}) bool {
-	if object == nil {
-		return true
-	}
-
-	value := reflect.ValueOf(object)
-	kind := value.Kind()
-	if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
-		return true
-	}
-
-	return false
-}
-
-// Nil asserts that the specified object is nil.
-//
-//    assert.Nil(t, err, "err should be nothing")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
-	if isNil(object) {
-		return true
-	}
-	return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...)
-}
-
-var numericZeros = []interface{}{
-	int(0),
-	int8(0),
-	int16(0),
-	int32(0),
-	int64(0),
-	uint(0),
-	uint8(0),
-	uint16(0),
-	uint32(0),
-	uint64(0),
-	float32(0),
-	float64(0),
-}
-
-// isEmpty gets whether the specified object is considered empty or not.
-func isEmpty(object interface{}) bool {
-
-	if object == nil {
-		return true
-	} else if object == "" {
-		return true
-	} else if object == false {
-		return true
-	}
-
-	for _, v := range numericZeros {
-		if object == v {
-			return true
-		}
-	}
-
-	objValue := reflect.ValueOf(object)
-
-	switch objValue.Kind() {
-	case reflect.Map:
-		fallthrough
-	case reflect.Slice, reflect.Chan:
-		{
-			return (objValue.Len() == 0)
-		}
-	case reflect.Struct:
-		switch object.(type) {
-		case time.Time:
-			return object.(time.Time).IsZero()
-		}
-	case reflect.Ptr:
-		{
-			if objValue.IsNil() {
-				return true
-			}
-			switch object.(type) {
-			case *time.Time:
-				return object.(*time.Time).IsZero()
-			default:
-				return false
-			}
-		}
-	}
-	return false
-}
-
-// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-//  assert.Empty(t, obj)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
-
-	pass := isEmpty(object)
-	if !pass {
-		Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...)
-	}
-
-	return pass
-
-}
-
-// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-//  if assert.NotEmpty(t, obj) {
-//    assert.Equal(t, "two", obj[1])
-//  }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
-
-	pass := !isEmpty(object)
-	if !pass {
-		Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...)
-	}
-
-	return pass
-
-}
-
-// getLen try to get length of object.
-// return (false, 0) if impossible.
-func getLen(x interface{}) (ok bool, length int) {
-	v := reflect.ValueOf(x)
-	defer func() {
-		if e := recover(); e != nil {
-			ok = false
-		}
-	}()
-	return true, v.Len()
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-//    assert.Len(t, mySlice, 3, "The size of slice is not 3")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool {
-	ok, l := getLen(object)
-	if !ok {
-		return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...)
-	}
-
-	if l != length {
-		return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
-	}
-	return true
-}
-
-// True asserts that the specified value is true.
-//
-//    assert.True(t, myBool, "myBool should be true")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func True(t TestingT, value bool, msgAndArgs ...interface{}) bool {
-
-	if value != true {
-		return Fail(t, "Should be true", msgAndArgs...)
-	}
-
-	return true
-
-}
-
-// False asserts that the specified value is false.
-//
-//    assert.False(t, myBool, "myBool should be false")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
-
-	if value != false {
-		return Fail(t, "Should be false", msgAndArgs...)
-	}
-
-	return true
-
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-//    assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
-
-	if ObjectsAreEqual(expected, actual) {
-		return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...)
-	}
-
-	return true
-
-}
-
-// containsElement try loop over the list check if the list includes the element.
-// return (false, false) if impossible.
-// return (true, false) if element was not found.
-// return (true, true) if element was found.
-func includeElement(list interface{}, element interface{}) (ok, found bool) {
-
-	listValue := reflect.ValueOf(list)
-	elementValue := reflect.ValueOf(element)
-	defer func() {
-		if e := recover(); e != nil {
-			ok = false
-			found = false
-		}
-	}()
-
-	if reflect.TypeOf(list).Kind() == reflect.String {
-		return true, strings.Contains(listValue.String(), elementValue.String())
-	}
-
-	if reflect.TypeOf(list).Kind() == reflect.Map {
-		mapKeys := listValue.MapKeys()
-		for i := 0; i < len(mapKeys); i++ {
-			if ObjectsAreEqual(mapKeys[i].Interface(), element) {
-				return true, true
-			}
-		}
-		return true, false
-	}
-
-	for i := 0; i < listValue.Len(); i++ {
-		if ObjectsAreEqual(listValue.Index(i).Interface(), element) {
-			return true, true
-		}
-	}
-	return true, false
-
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-//    assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")
-//    assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
-//    assert.Contains(t, {"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
-
-	ok, found := includeElement(s, contains)
-	if !ok {
-		return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
-	}
-	if !found {
-		return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", s, contains), msgAndArgs...)
-	}
-
-	return true
-
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-//    assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
-//    assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
-//    assert.NotContains(t, {"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
-
-	ok, found := includeElement(s, contains)
-	if !ok {
-		return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
-	}
-	if found {
-		return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...)
-	}
-
-	return true
-
-}
-
-// Condition uses a Comparison to assert a complex condition.
-func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool {
-	result := comp()
-	if !result {
-		Fail(t, "Condition failed!", msgAndArgs...)
-	}
-	return result
-}
-
-// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics
-// methods, and represents a simple func that takes no arguments, and returns nothing.
-type PanicTestFunc func()
-
-// didPanic returns true if the function passed to it panics. Otherwise, it returns false.
-func didPanic(f PanicTestFunc) (bool, interface{}) {
-
-	didPanic := false
-	var message interface{}
-	func() {
-
-		defer func() {
-			if message = recover(); message != nil {
-				didPanic = true
-			}
-		}()
-
-		// call the target function
-		f()
-
-	}()
-
-	return didPanic, message
-
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-//   assert.Panics(t, func(){
-//     GoCrazy()
-//   }, "Calling GoCrazy() should panic")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
-
-	if funcDidPanic, panicValue := didPanic(f); !funcDidPanic {
-		return Fail(t, fmt.Sprintf("func %#v should panic\n\r\tPanic value:\t%v", f, panicValue), msgAndArgs...)
-	}
-
-	return true
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-//   assert.NotPanics(t, func(){
-//     RemainCalm()
-//   }, "Calling RemainCalm() should NOT panic")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
-
-	if funcDidPanic, panicValue := didPanic(f); funcDidPanic {
-		return Fail(t, fmt.Sprintf("func %#v should not panic\n\r\tPanic value:\t%v", f, panicValue), msgAndArgs...)
-	}
-
-	return true
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-//   assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
-
-	dt := expected.Sub(actual)
-	if dt < -delta || dt > delta {
-		return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
-	}
-
-	return true
-}
-
-func toFloat(x interface{}) (float64, bool) {
-	var xf float64
-	xok := true
-
-	switch xn := x.(type) {
-	case uint8:
-		xf = float64(xn)
-	case uint16:
-		xf = float64(xn)
-	case uint32:
-		xf = float64(xn)
-	case uint64:
-		xf = float64(xn)
-	case int:
-		xf = float64(xn)
-	case int8:
-		xf = float64(xn)
-	case int16:
-		xf = float64(xn)
-	case int32:
-		xf = float64(xn)
-	case int64:
-		xf = float64(xn)
-	case float32:
-		xf = float64(xn)
-	case float64:
-		xf = float64(xn)
-	default:
-		xok = false
-	}
-
-	return xf, xok
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// 	 assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
-
-	af, aok := toFloat(expected)
-	bf, bok := toFloat(actual)
-
-	if !aok || !bok {
-		return Fail(t, fmt.Sprintf("Parameters must be numerical"), msgAndArgs...)
-	}
-
-	if math.IsNaN(af) {
-		return Fail(t, fmt.Sprintf("Actual must not be NaN"), msgAndArgs...)
-	}
-
-	if math.IsNaN(bf) {
-		return Fail(t, fmt.Sprintf("Expected %v with delta %v, but was NaN", expected, delta), msgAndArgs...)
-	}
-
-	dt := af - bf
-	if dt < -delta || dt > delta {
-		return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
-	}
-
-	return true
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
-	if expected == nil || actual == nil ||
-		reflect.TypeOf(actual).Kind() != reflect.Slice ||
-		reflect.TypeOf(expected).Kind() != reflect.Slice {
-		return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...)
-	}
-
-	actualSlice := reflect.ValueOf(actual)
-	expectedSlice := reflect.ValueOf(expected)
-
-	for i := 0; i < actualSlice.Len(); i++ {
-		result := InDelta(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta)
-		if !result {
-			return result
-		}
-	}
-
-	return true
-}
-
-func calcRelativeError(expected, actual interface{}) (float64, error) {
-	af, aok := toFloat(expected)
-	if !aok {
-		return 0, fmt.Errorf("expected value %q cannot be converted to float", expected)
-	}
-	if af == 0 {
-		return 0, fmt.Errorf("expected value must have a value other than zero to calculate the relative error")
-	}
-	bf, bok := toFloat(actual)
-	if !bok {
-		return 0, fmt.Errorf("expected value %q cannot be converted to float", actual)
-	}
-
-	return math.Abs(af-bf) / math.Abs(af), nil
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-//
-// Returns whether the assertion was successful (true) or not (false).
-func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
-	actualEpsilon, err := calcRelativeError(expected, actual)
-	if err != nil {
-		return Fail(t, err.Error(), msgAndArgs...)
-	}
-	if actualEpsilon > epsilon {
-		return Fail(t, fmt.Sprintf("Relative error is too high: %#v (expected)\n"+
-			"        < %#v (actual)", actualEpsilon, epsilon), msgAndArgs...)
-	}
-
-	return true
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
-	if expected == nil || actual == nil ||
-		reflect.TypeOf(actual).Kind() != reflect.Slice ||
-		reflect.TypeOf(expected).Kind() != reflect.Slice {
-		return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...)
-	}
-
-	actualSlice := reflect.ValueOf(actual)
-	expectedSlice := reflect.ValueOf(expected)
-
-	for i := 0; i < actualSlice.Len(); i++ {
-		result := InEpsilon(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), epsilon)
-		if !result {
-			return result
-		}
-	}
-
-	return true
-}
-
-/*
-	Errors
-*/
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-//   actualObj, err := SomeFunction()
-//   if assert.NoError(t, err) {
-//	   assert.Equal(t, actualObj, expectedObj)
-//   }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
-	if err != nil {
-		return Fail(t, fmt.Sprintf("Received unexpected error %q", err), msgAndArgs...)
-	}
-
-	return true
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-//   actualObj, err := SomeFunction()
-//   if assert.Error(t, err, "An error was expected") {
-//	   assert.Equal(t, err, expectedError)
-//   }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
-
-	message := messageFromMsgAndArgs(msgAndArgs...)
-	if err == nil {
-		return Fail(t, "An error is expected but got nil. %s", message)
-	}
-
-	return true
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-//   actualObj, err := SomeFunction()
-//   if assert.Error(t, err, "An error was expected") {
-//	   assert.Equal(t, err, expectedError)
-//   }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool {
-
-	message := messageFromMsgAndArgs(msgAndArgs...)
-	if !NotNil(t, theError, "An error is expected but got nil. %s", message) {
-		return false
-	}
-	s := "An error with value \"%s\" is expected but got \"%s\". %s"
-	return Equal(t, errString, theError.Error(),
-		s, errString, theError.Error(), message)
-}
-
-// matchRegexp return true if a specified regexp matches a string.
-func matchRegexp(rx interface{}, str interface{}) bool {
-
-	var r *regexp.Regexp
-	if rr, ok := rx.(*regexp.Regexp); ok {
-		r = rr
-	} else {
-		r = regexp.MustCompile(fmt.Sprint(rx))
-	}
-
-	return (r.FindStringIndex(fmt.Sprint(str)) != nil)
-
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-//  assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
-//  assert.Regexp(t, "start...$", "it's not starting")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
-
-	match := matchRegexp(rx, str)
-
-	if !match {
-		Fail(t, fmt.Sprintf("Expect \"%v\" to match \"%v\"", str, rx), msgAndArgs...)
-	}
-
-	return match
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-//  assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
-//  assert.NotRegexp(t, "^start", "it's not starting")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
-	match := matchRegexp(rx, str)
-
-	if match {
-		Fail(t, fmt.Sprintf("Expect \"%v\" to NOT match \"%v\"", str, rx), msgAndArgs...)
-	}
-
-	return !match
-
-}
-
-// Zero asserts that i is the zero value for its type and returns the truth.
-func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool {
-	if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) {
-		return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...)
-	}
-	return true
-}
-
-// NotZero asserts that i is not the zero value for its type and returns the truth.
-func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool {
-	if i == nil || reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) {
-		return Fail(t, fmt.Sprintf("Should not be zero, but was %v", i), msgAndArgs...)
-	}
-	return true
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-//  assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool {
-	var expectedJSONAsInterface, actualJSONAsInterface interface{}
-
-	if err := json.Unmarshal([]byte(expected), &expectedJSONAsInterface); err != nil {
-		return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid json.\nJSON parsing error: '%s'", expected, err.Error()), msgAndArgs...)
-	}
-
-	if err := json.Unmarshal([]byte(actual), &actualJSONAsInterface); err != nil {
-		return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid json.\nJSON parsing error: '%s'", actual, err.Error()), msgAndArgs...)
-	}
-
-	return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...)
-}
-
-func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) {
-	t := reflect.TypeOf(v)
-	k := t.Kind()
-
-	if k == reflect.Ptr {
-		t = t.Elem()
-		k = t.Kind()
-	}
-	return t, k
-}
-
-// diff returns a diff of both values as long as both are of the same type and
-// are a struct, map, slice or array. Otherwise it returns an empty string.
-func diff(expected interface{}, actual interface{}) string {
-	if expected == nil || actual == nil {
-		return ""
-	}
-
-	et, ek := typeAndKind(expected)
-	at, _ := typeAndKind(actual)
-
-	if et != at {
-		return ""
-	}
-
-	if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array {
-		return ""
-	}
-
-	spew.Config.SortKeys = true
-	e := spew.Sdump(expected)
-	a := spew.Sdump(actual)
-
-	diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
-		A:        difflib.SplitLines(e),
-		B:        difflib.SplitLines(a),
-		FromFile: "Expected",
-		FromDate: "",
-		ToFile:   "Actual",
-		ToDate:   "",
-		Context:  1,
-	})
-
-	return "\n\nDiff:\n" + diff
-}
diff --git a/vendor/github.com/stretchr/testify/assert/doc.go b/vendor/github.com/stretchr/testify/assert/doc.go
deleted file mode 100644
index c9dccc4..0000000
--- a/vendor/github.com/stretchr/testify/assert/doc.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
-//
-// Example Usage
-//
-// The following is a complete example using assert in a standard test function:
-//    import (
-//      "testing"
-//      "github.com/stretchr/testify/assert"
-//    )
-//
-//    func TestSomething(t *testing.T) {
-//
-//      var a string = "Hello"
-//      var b string = "Hello"
-//
-//      assert.Equal(t, a, b, "The two words should be the same.")
-//
-//    }
-//
-// if you assert many times, use the format below:
-//
-//    import (
-//      "testing"
-//      "github.com/stretchr/testify/assert"
-//    )
-//
-//    func TestSomething(t *testing.T) {
-//      assert := assert.New(t)
-//
-//      var a string = "Hello"
-//      var b string = "Hello"
-//
-//      assert.Equal(a, b, "The two words should be the same.")
-//    }
-//
-// Assertions
-//
-// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
-// All assertion functions take, as the first argument, the `*testing.T` object provided by the
-// testing framework. This allows the assertion funcs to write the failings and other details to
-// the correct place.
-//
-// Every assertion function also takes an optional string message as the final argument,
-// allowing custom error messages to be appended to the message the assertion method outputs.
-package assert
diff --git a/vendor/github.com/stretchr/testify/assert/errors.go b/vendor/github.com/stretchr/testify/assert/errors.go
deleted file mode 100644
index ac9dc9d..0000000
--- a/vendor/github.com/stretchr/testify/assert/errors.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package assert
-
-import (
-	"errors"
-)
-
-// AnError is an error instance useful for testing.  If the code does not care
-// about error specifics, and only needs to return the error for example, this
-// error should be used to make the test code more readable.
-var AnError = errors.New("assert.AnError general error for testing")
diff --git a/vendor/github.com/stretchr/testify/assert/forward_assertions.go b/vendor/github.com/stretchr/testify/assert/forward_assertions.go
deleted file mode 100644
index b867e95..0000000
--- a/vendor/github.com/stretchr/testify/assert/forward_assertions.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package assert
-
-// Assertions provides assertion methods around the
-// TestingT interface.
-type Assertions struct {
-	t TestingT
-}
-
-// New makes a new Assertions object for the specified TestingT.
-func New(t TestingT) *Assertions {
-	return &Assertions{
-		t: t,
-	}
-}
-
-//go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_forward.go.tmpl
diff --git a/vendor/github.com/stretchr/testify/assert/http_assertions.go b/vendor/github.com/stretchr/testify/assert/http_assertions.go
deleted file mode 100644
index e1b9442..0000000
--- a/vendor/github.com/stretchr/testify/assert/http_assertions.go
+++ /dev/null
@@ -1,106 +0,0 @@
-package assert
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-)
-
-// httpCode is a helper that returns HTTP code of the response. It returns -1
-// if building a new request fails.
-func httpCode(handler http.HandlerFunc, method, url string, values url.Values) int {
-	w := httptest.NewRecorder()
-	req, err := http.NewRequest(method, url+"?"+values.Encode(), nil)
-	if err != nil {
-		return -1
-	}
-	handler(w, req)
-	return w.Code
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-//  assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool {
-	code := httpCode(handler, method, url, values)
-	if code == -1 {
-		return false
-	}
-	return code >= http.StatusOK && code <= http.StatusPartialContent
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-//  assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool {
-	code := httpCode(handler, method, url, values)
-	if code == -1 {
-		return false
-	}
-	return code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-//  assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool {
-	code := httpCode(handler, method, url, values)
-	if code == -1 {
-		return false
-	}
-	return code >= http.StatusBadRequest
-}
-
-// HTTPBody is a helper that returns HTTP body of the response. It returns
-// empty string if building a new request fails.
-func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string {
-	w := httptest.NewRecorder()
-	req, err := http.NewRequest(method, url+"?"+values.Encode(), nil)
-	if err != nil {
-		return ""
-	}
-	handler(w, req)
-	return w.Body.String()
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-//  assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}) bool {
-	body := HTTPBody(handler, method, url, values)
-
-	contains := strings.Contains(body, fmt.Sprint(str))
-	if !contains {
-		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
-	}
-
-	return contains
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-//  assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}) bool {
-	body := HTTPBody(handler, method, url, values)
-
-	contains := strings.Contains(body, fmt.Sprint(str))
-	if contains {
-		Fail(t, "Expected response body for %s to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)
-	}
-
-	return !contains
-}
diff --git a/vendor/github.com/stretchr/testify/require/doc.go b/vendor/github.com/stretchr/testify/require/doc.go
deleted file mode 100644
index 169de39..0000000
--- a/vendor/github.com/stretchr/testify/require/doc.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Package require implements the same assertions as the `assert` package but
-// stops test execution when a test fails.
-//
-// Example Usage
-//
-// The following is a complete example using require in a standard test function:
-//    import (
-//      "testing"
-//      "github.com/stretchr/testify/require"
-//    )
-//
-//    func TestSomething(t *testing.T) {
-//
-//      var a string = "Hello"
-//      var b string = "Hello"
-//
-//      require.Equal(t, a, b, "The two words should be the same.")
-//
-//    }
-//
-// Assertions
-//
-// The `require` package have same global functions as in the `assert` package,
-// but instead of returning a boolean result they call `t.FailNow()`.
-//
-// Every assertion function also takes an optional string message as the final argument,
-// allowing custom error messages to be appended to the message the assertion method outputs.
-package require
diff --git a/vendor/github.com/stretchr/testify/require/forward_requirements.go b/vendor/github.com/stretchr/testify/require/forward_requirements.go
deleted file mode 100644
index d3c2ab9..0000000
--- a/vendor/github.com/stretchr/testify/require/forward_requirements.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package require
-
-// Assertions provides assertion methods around the
-// TestingT interface.
-type Assertions struct {
-	t TestingT
-}
-
-// New makes a new Assertions object for the specified TestingT.
-func New(t TestingT) *Assertions {
-	return &Assertions{
-		t: t,
-	}
-}
-
-//go:generate go run ../_codegen/main.go -output-package=require -template=require_forward.go.tmpl
diff --git a/vendor/github.com/stretchr/testify/require/require.go b/vendor/github.com/stretchr/testify/require/require.go
deleted file mode 100644
index 1bcfcb0..0000000
--- a/vendor/github.com/stretchr/testify/require/require.go
+++ /dev/null
@@ -1,464 +0,0 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
-*/
-
-package require
-
-import (
-
-	assert "github.com/stretchr/testify/assert"
-	http "net/http"
-	url "net/url"
-	time "time"
-)
-
-
-// Condition uses a Comparison to assert a complex condition.
-func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{}) {
-  if !assert.Condition(t, comp, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-// 
-//    assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")
-//    assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
-//    assert.Contains(t, {"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
-  if !assert.Contains(t, s, contains, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-// 
-//  assert.Empty(t, obj)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
-  if !assert.Empty(t, object, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Equal asserts that two objects are equal.
-// 
-//    assert.Equal(t, 123, 123, "123 and 123 should be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
-  if !assert.Equal(t, expected, actual, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-// 
-//   actualObj, err := SomeFunction()
-//   if assert.Error(t, err, "An error was expected") {
-// 	   assert.Equal(t, err, expectedError)
-//   }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) {
-  if !assert.EqualError(t, theError, errString, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// EqualValues asserts that two objects are equal or convertable to the same types
-// and equal.
-// 
-//    assert.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
-  if !assert.EqualValues(t, expected, actual, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-// 
-//   actualObj, err := SomeFunction()
-//   if assert.Error(t, err, "An error was expected") {
-// 	   assert.Equal(t, err, expectedError)
-//   }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func Error(t TestingT, err error, msgAndArgs ...interface{}) {
-  if !assert.Error(t, err, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Exactly asserts that two objects are equal is value and type.
-// 
-//    assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
-  if !assert.Exactly(t, expected, actual, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Fail reports a failure through
-func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
-  if !assert.Fail(t, failureMessage, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// FailNow fails test
-func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
-  if !assert.FailNow(t, failureMessage, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// False asserts that the specified value is false.
-// 
-//    assert.False(t, myBool, "myBool should be false")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func False(t TestingT, value bool, msgAndArgs ...interface{}) {
-  if !assert.False(t, value, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-// 
-//  assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) {
-  if !assert.HTTPBodyContains(t, handler, method, url, values, str) {
-    t.FailNow()
-  }
-}
-
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-// 
-//  assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) {
-  if !assert.HTTPBodyNotContains(t, handler, method, url, values, str) {
-    t.FailNow()
-  }
-}
-
-
-// HTTPError asserts that a specified handler returns an error status code.
-// 
-//  assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) {
-  if !assert.HTTPError(t, handler, method, url, values) {
-    t.FailNow()
-  }
-}
-
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-// 
-//  assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) {
-  if !assert.HTTPRedirect(t, handler, method, url, values) {
-    t.FailNow()
-  }
-}
-
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-// 
-//  assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) {
-  if !assert.HTTPSuccess(t, handler, method, url, values) {
-    t.FailNow()
-  }
-}
-
-
-// Implements asserts that an object is implemented by the specified interface.
-// 
-//    assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject")
-func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
-  if !assert.Implements(t, interfaceObject, object, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// InDelta asserts that the two numerals are within delta of each other.
-// 
-// 	 assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
-  if !assert.InDelta(t, expected, actual, delta, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
-  if !assert.InDeltaSlice(t, expected, actual, delta, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
-  if !assert.InEpsilon(t, expected, actual, epsilon, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// InEpsilonSlice is the same as InEpsilon, except it compares two slices.
-func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
-  if !assert.InEpsilonSlice(t, expected, actual, delta, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// IsType asserts that the specified objects are of the same type.
-func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
-  if !assert.IsType(t, expectedType, object, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// JSONEq asserts that two JSON strings are equivalent.
-// 
-//  assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) {
-  if !assert.JSONEq(t, expected, actual, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-// 
-//    assert.Len(t, mySlice, 3, "The size of slice is not 3")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) {
-  if !assert.Len(t, object, length, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Nil asserts that the specified object is nil.
-// 
-//    assert.Nil(t, err, "err should be nothing")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
-  if !assert.Nil(t, object, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-// 
-//   actualObj, err := SomeFunction()
-//   if assert.NoError(t, err) {
-// 	   assert.Equal(t, actualObj, expectedObj)
-//   }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
-  if !assert.NoError(t, err, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-// 
-//    assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
-//    assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
-//    assert.NotContains(t, {"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
-  if !assert.NotContains(t, s, contains, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-// 
-//  if assert.NotEmpty(t, obj) {
-//    assert.Equal(t, "two", obj[1])
-//  }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
-  if !assert.NotEmpty(t, object, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// NotEqual asserts that the specified values are NOT equal.
-// 
-//    assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
-  if !assert.NotEqual(t, expected, actual, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// NotNil asserts that the specified object is not nil.
-// 
-//    assert.NotNil(t, err, "err should be something")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
-  if !assert.NotNil(t, object, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-// 
-//   assert.NotPanics(t, func(){
-//     RemainCalm()
-//   }, "Calling RemainCalm() should NOT panic")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
-  if !assert.NotPanics(t, f, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// NotRegexp asserts that a specified regexp does not match a string.
-// 
-//  assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
-//  assert.NotRegexp(t, "^start", "it's not starting")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
-  if !assert.NotRegexp(t, rx, str, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// NotZero asserts that i is not the zero value for its type and returns the truth.
-func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
-  if !assert.NotZero(t, i, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-// 
-//   assert.Panics(t, func(){
-//     GoCrazy()
-//   }, "Calling GoCrazy() should panic")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
-  if !assert.Panics(t, f, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Regexp asserts that a specified regexp matches a string.
-// 
-//  assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
-//  assert.Regexp(t, "start...$", "it's not starting")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
-  if !assert.Regexp(t, rx, str, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// True asserts that the specified value is true.
-// 
-//    assert.True(t, myBool, "myBool should be true")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func True(t TestingT, value bool, msgAndArgs ...interface{}) {
-  if !assert.True(t, value, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-// 
-//   assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
-  if !assert.WithinDuration(t, expected, actual, delta, msgAndArgs...) {
-    t.FailNow()
-  }
-}
-
-
-// Zero asserts that i is the zero value for its type and returns the truth.
-func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
-  if !assert.Zero(t, i, msgAndArgs...) {
-    t.FailNow()
-  }
-}
diff --git a/vendor/github.com/stretchr/testify/require/require.go.tmpl b/vendor/github.com/stretchr/testify/require/require.go.tmpl
deleted file mode 100644
index ab1b1e9..0000000
--- a/vendor/github.com/stretchr/testify/require/require.go.tmpl
+++ /dev/null
@@ -1,6 +0,0 @@
-{{.Comment}}
-func {{.DocInfo.Name}}(t TestingT, {{.Params}}) {
-  if !assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) {
-    t.FailNow()
-  }
-}
diff --git a/vendor/github.com/stretchr/testify/require/require_forward.go b/vendor/github.com/stretchr/testify/require/require_forward.go
deleted file mode 100644
index 58324f1..0000000
--- a/vendor/github.com/stretchr/testify/require/require_forward.go
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
-*/
-
-package require
-
-import (
-
-	assert "github.com/stretchr/testify/assert"
-	http "net/http"
-	url "net/url"
-	time "time"
-)
-
-
-// Condition uses a Comparison to assert a complex condition.
-func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) {
-	Condition(a.t, comp, msgAndArgs...)
-}
-
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-// 
-//    a.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
-//    a.Contains(["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
-//    a.Contains({"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
-	Contains(a.t, s, contains, msgAndArgs...)
-}
-
-
-// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-// 
-//  a.Empty(obj)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) {
-	Empty(a.t, object, msgAndArgs...)
-}
-
-
-// Equal asserts that two objects are equal.
-// 
-//    a.Equal(123, 123, "123 and 123 should be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
-	Equal(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-// 
-//   actualObj, err := SomeFunction()
-//   if assert.Error(t, err, "An error was expected") {
-// 	   assert.Equal(t, err, expectedError)
-//   }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) {
-	EqualError(a.t, theError, errString, msgAndArgs...)
-}
-
-
-// EqualValues asserts that two objects are equal or convertable to the same types
-// and equal.
-// 
-//    a.EqualValues(uint32(123), int32(123), "123 and 123 should be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
-	EqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-// 
-//   actualObj, err := SomeFunction()
-//   if a.Error(err, "An error was expected") {
-// 	   assert.Equal(t, err, expectedError)
-//   }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Error(err error, msgAndArgs ...interface{}) {
-	Error(a.t, err, msgAndArgs...)
-}
-
-
-// Exactly asserts that two objects are equal is value and type.
-// 
-//    a.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
-	Exactly(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// Fail reports a failure through
-func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) {
-	Fail(a.t, failureMessage, msgAndArgs...)
-}
-
-
-// FailNow fails test
-func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) {
-	FailNow(a.t, failureMessage, msgAndArgs...)
-}
-
-
-// False asserts that the specified value is false.
-// 
-//    a.False(myBool, "myBool should be false")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) False(value bool, msgAndArgs ...interface{}) {
-	False(a.t, value, msgAndArgs...)
-}
-
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-// 
-//  a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) {
-	HTTPBodyContains(a.t, handler, method, url, values, str)
-}
-
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-// 
-//  a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) {
-	HTTPBodyNotContains(a.t, handler, method, url, values, str)
-}
-
-
-// HTTPError asserts that a specified handler returns an error status code.
-// 
-//  a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) {
-	HTTPError(a.t, handler, method, url, values)
-}
-
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-// 
-//  a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) {
-	HTTPRedirect(a.t, handler, method, url, values)
-}
-
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-// 
-//  a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) {
-	HTTPSuccess(a.t, handler, method, url, values)
-}
-
-
-// Implements asserts that an object is implemented by the specified interface.
-// 
-//    a.Implements((*MyInterface)(nil), new(MyObject), "MyObject")
-func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
-	Implements(a.t, interfaceObject, object, msgAndArgs...)
-}
-
-
-// InDelta asserts that the two numerals are within delta of each other.
-// 
-// 	 a.InDelta(math.Pi, (22 / 7.0), 0.01)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
-	InDelta(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
-	InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
-	InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-
-// InEpsilonSlice is the same as InEpsilon, except it compares two slices.
-func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
-	InEpsilonSlice(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-
-// IsType asserts that the specified objects are of the same type.
-func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
-	IsType(a.t, expectedType, object, msgAndArgs...)
-}
-
-
-// JSONEq asserts that two JSON strings are equivalent.
-// 
-//  a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) {
-	JSONEq(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-// 
-//    a.Len(mySlice, 3, "The size of slice is not 3")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) {
-	Len(a.t, object, length, msgAndArgs...)
-}
-
-
-// Nil asserts that the specified object is nil.
-// 
-//    a.Nil(err, "err should be nothing")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) {
-	Nil(a.t, object, msgAndArgs...)
-}
-
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-// 
-//   actualObj, err := SomeFunction()
-//   if a.NoError(err) {
-// 	   assert.Equal(t, actualObj, expectedObj)
-//   }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
-	NoError(a.t, err, msgAndArgs...)
-}
-
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-// 
-//    a.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
-//    a.NotContains(["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
-//    a.NotContains({"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
-	NotContains(a.t, s, contains, msgAndArgs...)
-}
-
-
-// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-// 
-//  if a.NotEmpty(obj) {
-//    assert.Equal(t, "two", obj[1])
-//  }
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
-	NotEmpty(a.t, object, msgAndArgs...)
-}
-
-
-// NotEqual asserts that the specified values are NOT equal.
-// 
-//    a.NotEqual(obj1, obj2, "two objects shouldn't be equal")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
-	NotEqual(a.t, expected, actual, msgAndArgs...)
-}
-
-
-// NotNil asserts that the specified object is not nil.
-// 
-//    a.NotNil(err, "err should be something")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) {
-	NotNil(a.t, object, msgAndArgs...)
-}
-
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-// 
-//   a.NotPanics(func(){
-//     RemainCalm()
-//   }, "Calling RemainCalm() should NOT panic")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
-	NotPanics(a.t, f, msgAndArgs...)
-}
-
-
-// NotRegexp asserts that a specified regexp does not match a string.
-// 
-//  a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
-//  a.NotRegexp("^start", "it's not starting")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
-	NotRegexp(a.t, rx, str, msgAndArgs...)
-}
-
-
-// NotZero asserts that i is not the zero value for its type and returns the truth.
-func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) {
-	NotZero(a.t, i, msgAndArgs...)
-}
-
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-// 
-//   a.Panics(func(){
-//     GoCrazy()
-//   }, "Calling GoCrazy() should panic")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
-	Panics(a.t, f, msgAndArgs...)
-}
-
-
-// Regexp asserts that a specified regexp matches a string.
-// 
-//  a.Regexp(regexp.MustCompile("start"), "it's starting")
-//  a.Regexp("start...$", "it's not starting")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
-	Regexp(a.t, rx, str, msgAndArgs...)
-}
-
-
-// True asserts that the specified value is true.
-// 
-//    a.True(myBool, "myBool should be true")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) True(value bool, msgAndArgs ...interface{}) {
-	True(a.t, value, msgAndArgs...)
-}
-
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-// 
-//   a.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
-// 
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
-	WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-
-// Zero asserts that i is the zero value for its type and returns the truth.
-func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) {
-	Zero(a.t, i, msgAndArgs...)
-}
diff --git a/vendor/github.com/stretchr/testify/require/require_forward.go.tmpl b/vendor/github.com/stretchr/testify/require/require_forward.go.tmpl
deleted file mode 100644
index b93569e..0000000
--- a/vendor/github.com/stretchr/testify/require/require_forward.go.tmpl
+++ /dev/null
@@ -1,4 +0,0 @@
-{{.CommentWithoutT "a"}}
-func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) {
-	{{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
-}
diff --git a/vendor/github.com/stretchr/testify/require/requirements.go b/vendor/github.com/stretchr/testify/require/requirements.go
deleted file mode 100644
index 4114756..0000000
--- a/vendor/github.com/stretchr/testify/require/requirements.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package require
-
-// TestingT is an interface wrapper around *testing.T
-type TestingT interface {
-	Errorf(format string, args ...interface{})
-	FailNow()
-}
-
-//go:generate go run ../_codegen/main.go -output-package=require -template=require.go.tmpl
diff --git a/vendor/modules.txt b/vendor/modules.txt
deleted file mode 100644
index 0b5276a..0000000
--- a/vendor/modules.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-# github.com/davecgh/go-spew v1.1.1
-## explicit
-github.com/davecgh/go-spew/spew
-# github.com/docopt/docopt-go v0.0.0-20141128170934-854c423c8108
-## explicit
-github.com/docopt/docopt-go
-# github.com/go-ini/ini v1.11.0
-## explicit
-github.com/go-ini/ini
-# github.com/olekukonko/tablewriter v0.0.0-20150822215231-b9346ac189c5
-## explicit
-github.com/olekukonko/tablewriter
-# github.com/pmezard/go-difflib v1.0.0
-## explicit
-github.com/pmezard/go-difflib/difflib
-# github.com/smartystreets/goconvey v1.7.2
-## explicit; go 1.16
-# github.com/stretchr/testify v1.1.4-0.20160615092844-d77da356e56a
-## explicit
-github.com/stretchr/testify/assert
-github.com/stretchr/testify/require