Merge pull request #3671 from karalabe/1.5.9-stable

params: 1.5.9 stable

.dockerignore

@@ -0,0 +1,3 @@
+.git
+build/_workspace
+build/_bin

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.github/CONTRIBUTING.md

@@ -0,0 +1,16 @@
+## Can I have feature X
+
+Before you do a feature request please check and make sure that it isn't possible
+through some other means. The JavaScript enabled console is a powerful feature
+in the right hands. Please check our [Bitchin' tricks](https://github.com/ethereum/go-ethereum/wiki/bitchin-tricks) wiki page for more info
+and help.
+
+## Contributing
+
+If you'd like to contribute to go-ethereum please fork, fix, commit and
+send a pull request. Commits which do not comply with the coding standards
+are ignored (use gofmt!).
+
+See [Developers' Guide](https://github.com/ethereum/go-ethereum/wiki/Developers'-Guide)
+for more details on configuring your environment, testing, and
+dependency management.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,20 @@
+#### System information
+
+Geth version: `geth version`
+OS & Version: Windows/Linux/OSX
+Commit hash : (if `develop`)
+
+#### Expected behaviour
+
+
+#### Actual behaviour
+
+
+#### Steps to reproduce the behaviour
+
+
+#### Backtrace
+
+````
+[backtrace]
+````

.gitignore

@@ -13,8 +13,7 @@
 .ethtest
 */**/*tx_database*
 */**/*dapps*
-Godeps/_workspace/pkg
-Godeps/_workspace/bin
+build/_vendor/pkg
 
 #*
 .#*
@@ -23,15 +22,11 @@ Godeps/_workspace/bin
 .project
 .settings
 
-deploy/osx/Mist.app
-deploy/osx/Mist\ Installer.dmg
-cmd/mist/assets/ext/ethereum.js/
-
 # used by the Makefile
 /build/_workspace/
 /build/bin/
+/geth*.zip
 
 # travis
 profile.tmp
 profile.cov
-

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "cmd/mist/assets/ext/ethereum.js"]
-	path = cmd/mist/assets/ext/ethereum.js
-	url = https://github.com/ethereum/web3.js

.mailmap

@@ -17,6 +17,7 @@ Taylor Gerring <taylor.gerring@gmail.com> <taylor.gerring@ethereum.org>
 Bas van Kervel <bas@ethdev.com>
 Bas van Kervel <bas@ethdev.com> <basvankervel@ziggo.nl>
 Bas van Kervel <bas@ethdev.com> <basvankervel@gmail.com>
+Bas van Kervel <bas@ethdev.com> <bas-vk@users.noreply.github.com>
 
 Sven Ehlert <sven@ethdev.com>
 
@@ -59,3 +60,33 @@ Jason Carver <jacarver@linkedin.com> <ut96caarrs@snkmail.com>
 
 Joseph Chow <ethereum@outlook.com>
 Joseph Chow <ethereum@outlook.com> ethers <TODO>
+
+Enrique Fynn <enriquefynn@gmail.com>
+
+Vincent G <caktux@gmail.com>
+
+RJ Catalano <rj@erisindustries.com>
+
+Nchinda Nchinda <nchinda2@gmail.com>
+
+Aron Fischer <homotopycolimit@users.noreply.github.com>
+
+Vlad Gluhovsky <gluk256@users.noreply.github.com>
+
+Ville Sundell <github@solarius.fi>
+
+Elliot Shepherd <elliot@identitii.com>
+
+Yohann Léon <sybiload@gmail.com>
+
+Gregg Dourgarian <greggd@tempworks.com>
+
+Casey Detrio <cdetrio@gmail.com>
+
+Jens Agerberg <github@agerberg.me>
+
+Nick Johnson <arachnid@notdot.net>
+
+Henning Diedrich <hd@eonblast.com>
+Henning Diedrich <hd@eonblast.com> Drake Burroughs <wildfyre@hotmail.com>
+

.travis.yml

@@ -1,32 +1,126 @@
 language: go
-go:
-  - 1.4.2
-before_install:
-  - sudo apt-get update -qq
-  - sudo apt-get install -yqq libgmp3-dev
+go_import_path: github.com/ethereum/go-ethereum
+sudo: false
+matrix:
+  include:
+    - os: linux
+      dist: trusty
+      go: 1.5.4
+      env:
+        - GO15VENDOREXPERIMENT=1
+    - os: linux
+      dist: trusty
+      go: 1.6.2
+    - os: linux
+      dist: trusty
+      go: 1.7.4
+    - os: osx
+      go: 1.7.4
+
+    # This builder does the Ubuntu PPA and Linux Azure uploads
+    - os: linux
+      dist: trusty
+      sudo: required
+      go: 1.7.4
+      env:
+        - ubuntu-ppa
+        - azure-linux
+      addons:
+        apt:
+          packages:
+            - devscripts
+            - debhelper
+            - dput
+            - gcc-multilib
+      script:
+        # Build for the primary platforms that Trusty can manage
+        - go run build/ci.go debsrc -signer "Go Ethereum Linux Builder <geth-ci@ethereum.org>" -upload ppa:ethereum/ethereum
+        - go run build/ci.go install
+        - go run build/ci.go archive -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go install -arch 386
+        - go run build/ci.go archive -arch 386 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+
+        # Switch over GCC to cross compilation (breaks 386, hence why do it here only)
+        - sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-arm-linux-gnueabihf libc6-dev-armhf-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross
+        - sudo ln -s /usr/include/asm-generic /usr/include/asm
+
+        - GOARM=5 CC=arm-linux-gnueabi-gcc go run build/ci.go install -arch arm
+        - GOARM=5 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - GOARM=6 CC=arm-linux-gnueabi-gcc go run build/ci.go install -arch arm
+        - GOARM=6 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - GOARM=7 CC=arm-linux-gnueabihf-gcc go run build/ci.go install -arch arm
+        - GOARM=7 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - CC=aarch64-linux-gnu-gcc go run build/ci.go install -arch arm64
+        - go run build/ci.go archive -arch arm64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+
+    # This builder does the Android Maven and Azure uploads
+    - os: linux
+      dist: precise # Needed for the android tools
+      addons:
+        apt:
+          packages:
+            - oracle-java8-installer
+            - oracle-java8-set-default
+      language: android
+      android:
+        components:
+          - platform-tools
+          - tools
+          - android-15
+          - android-19
+          - android-24
+      env:
+        - azure-android
+        - maven-android
+      before_install:
+        - curl https://storage.googleapis.com/golang/go1.8rc3.linux-amd64.tar.gz | tar -xz
+        - export PATH=`pwd`/go/bin:$PATH
+        - export GOROOT=`pwd`/go
+        - export GOPATH=$HOME/go # Drop post Go 1.8
+      script:
+        # Build the Android archive and upload it to Maven Central and Azure
+        - curl https://dl.google.com/android/repository/android-ndk-r13b-linux-x86_64.zip -o android-ndk-r13b.zip
+        - unzip -q android-ndk-r13b.zip && rm android-ndk-r13b.zip
+        - mv android-ndk-r13b $HOME
+        - export ANDROID_NDK=$HOME/android-ndk-r13b
+
+        - mkdir -p $GOPATH/src/github.com/ethereum
+        - ln -s `pwd` $GOPATH/src/github.com/ethereum
+        - go run build/ci.go aar -signer ANDROID_SIGNING_KEY -deploy https://oss.sonatype.org -upload gethstore/builds
+
+    # This builder does the OSX Azure, iOS CocoaPods and iOS Azure uploads
+    - os: osx
+      go: 1.7.4
+      env:
+        - azure-osx
+        - azure-ios
+        - cocoapods-ios
+      script:
+        - go run build/ci.go install
+        - go run build/ci.go archive -type tar -signer OSX_SIGNING_KEY -upload gethstore/builds
+
+        # Build the iOS framework and upload it to CocoaPods and Azure
+        - gem uninstall cocoapods -a
+        - gem install cocoapods --pre
+
+        - mv ~/.cocoapods/repos/master ~/.cocoapods/repos/master.bak
+        - sed -i '.bak' 's/repo.join/!repo.join/g' $(dirname `gem which cocoapods`)/cocoapods/sources_manager.rb
+        - if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then git clone --depth=1 https://github.com/CocoaPods/Specs.git ~/.cocoapods/repos/master && pod setup --verbose; fi
+
+        - xctool -version
+        - xcrun simctl list
+
+        - go run build/ci.go xcode -signer IOS_SIGNING_KEY -deploy trunk -upload gethstore/builds
+
 install:
-  # - go get code.google.com/p/go.tools/cmd/goimports
-  # - go get github.com/golang/lint/golint
-  # - go get golang.org/x/tools/cmd/vet 
-  - go get golang.org/x/tools/cmd/cover github.com/mattn/goveralls
-before_script:
-  # - gofmt -l -w .
-  # - goimports -l -w .
-  # - golint .
-  # - go vet ./...
-  # - go test -race ./...
+  - go get golang.org/x/tools/cmd/cover
 script:
-  - make travis-test-with-coverage
-after_success:
-  - if [ "$COVERALLS_TOKEN" ]; then goveralls -coverprofile=profile.cov -service=travis-ci -repotoken $COVERALLS_TOKEN; fi
-env:
-  global:
-    - secure: "U2U1AmkU4NJBgKR/uUAebQY87cNL0+1JHjnLOmmXwxYYyj5ralWb1aSuSH3qSXiT93qLBmtaUkuv9fberHVqrbAeVlztVdUsKAq7JMQH+M99iFkC9UiRMqHmtjWJ0ok4COD1sRYixxi21wb/JrMe3M1iL4QJVS61iltjHhVdM64="
+  - go run build/ci.go install
+  - go run build/ci.go test -coverage -vet -misspell
 
 notifications:
   webhooks:
     urls:
       - https://webhooks.gitter.im/e/e09ccdce1048c5e03445
-    on_success: change 
+    on_success: change
     on_failure: always
-    on_start: false 

AUTHORS

@@ -1,24 +1,63 @@
 # This is the official list of go-ethereum authors for copyright purposes.
 
+Ales Katona <ales@coinbase.com>
 Alex Leverington <alex@ethdev.com>
 Alexandre Van de Sande <alex.vandesande@ethdev.com>
+Aron Fischer <homotopycolimit@users.noreply.github.com>
 Bas van Kervel <bas@ethdev.com>
+Benjamin Brent <benjamin@benjaminbrent.com>
+Casey Detrio <cdetrio@gmail.com>
+Christoph Jentzsch <jentzsch.software@gmail.com>
 Daniel A. Nagy <nagy.da@gmail.com>
+Elliot Shepherd <elliot@identitii.com>
+Enrique Fynn <enriquefynn@gmail.com>
 Ethan Buchman <ethan@coinculture.info>
 Fabian Vogelsteller <fabian@frozeman.de>
+Fabio Berger <fabioberger1991@gmail.com>
 Felix Lange <fjl@twurst.com>
+Gregg Dourgarian <greggd@tempworks.com>
 Gustav Simonsson <gustav.simonsson@gmail.com>
+Hao Bryan Cheng <haobcheng@gmail.com>
+Henning Diedrich <hd@eonblast.com>
+Isidoro Ghezzi <isidoro.ghezzi@icloud.com>
 Jae Kwon <jkwon.work@gmail.com>
 Jason Carver <jacarver@linkedin.com>
+Jeff R. Allen <jra@nella.org>
 Jeffrey Wilcke <jeffrey@ethereum.org>
+Jens Agerberg <github@agerberg.me>
+Jonathan Brown <jbrown@bluedroplet.com>
 Joseph Chow <ethereum@outlook.com>
+Justin Clark-Casey <justincc@justincc.org>
+Kenji Siu <kenji@isuntv.com>
 Kobi Gurkan <kobigurk@gmail.com>
+Lefteris Karapetsas <lefteris@refu.co>
+Leif Jurvetson <leijurv@gmail.com>
 Maran Hidskes <maran.hidskes@gmail.com>
 Marek Kotewicz <marek.kotewicz@gmail.com>
+Martin Holst Swende <martin@swende.se>
+Matthew Di Ferrante <mattdf@users.noreply.github.com>
 Matthew Wampler-Doty <matthew.wampler.doty@gmail.com>
+Nchinda Nchinda <nchinda2@gmail.com>
 Nick Dodson <silentcicero@outlook.com>
+Nick Johnson <arachnid@notdot.net>
+Paulo L F Casaretto <pcasaretto@gmail.com>
+Peter Pratscher <pratscher@gmail.com>
 Péter Szilágyi <peterke@gmail.com>
+RJ Catalano <rj@erisindustries.com>
+Ramesh Nair <ram@hiddentao.com>
+Ricardo Catalinas Jiménez <r@untroubled.be>
+Rémy Roy <remyroy@remyroy.com>
+Stein Dekker <dekker.stein@gmail.com>
+Steven Roose <stevenroose@gmail.com>
 Taylor Gerring <taylor.gerring@gmail.com>
+Thomas Bocek <tom@tomp2p.net>
+Tosh Camille <tochecamille@gmail.com>
 Viktor Trón <viktor.tron@gmail.com>
+Ville Sundell <github@solarius.fi>
+Vincent G <caktux@gmail.com>
 Vitalik Buterin <v@buterin.com>
+Vlad Gluhovsky <gluk256@users.noreply.github.com>
+Yohann Léon <sybiload@gmail.com>
+Yoichi Hirai <i@yoichihirai.com>
 Zsolt Felföldi <zsfelfoldi@gmail.com>
+ΞTHΞЯSPHΞЯΞ <{viktor.tron,nagydani,zsfelfoldi}@gmail.com>

Dockerfile

@@ -0,0 +1,14 @@
+FROM alpine:3.5
+
+ADD . /go-ethereum
+RUN \
+  apk add --update git go make gcc musl-dev linux-headers && \
+  (cd go-ethereum && make geth)                           && \
+  cp go-ethereum/build/bin/geth /geth                     && \
+  apk del git go make gcc musl-dev linux-headers          && \
+  rm -rf /go-ethereum && rm -rf /var/cache/apk/*
+
+EXPOSE 8545
+EXPOSE 30303
+
+ENTRYPOINT ["/geth"]

Godeps/Godeps.json

@@ -1,135 +0,0 @@
-{
-	"ImportPath": "github.com/ethereum/go-ethereum",
-	"GoVersion": "go1.4",
-	"Packages": [
-		"./..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "code.google.com/p/go-uuid/uuid",
-			"Comment": "null-12",
-			"Rev": "7dda39b2e7d5e265014674c5af696ba4186679e9"
-		},
-		{
-			"ImportPath": "github.com/codegangsta/cli",
-			"Comment": "1.2.0-95-g9b2bd2b",
-			"Rev": "9b2bd2b3489748d4d0a204fa4eb2ee9e89e0ebc6"
-		},
-		{
-			"ImportPath": "github.com/davecgh/go-spew/spew",
-			"Rev": "3e6e67c4dcea3ac2f25fd4731abc0e1deaf36216"
-		},
-		{
-			"ImportPath": "github.com/ethereum/ethash",
-			"Comment": "v23.1-227-g8f6ccaa",
-			"Rev": "8f6ccaaef9b418553807a73a95cb5f49cd3ea39f"
-		},
-		{
-			"ImportPath": "github.com/gizak/termui",
-			"Rev": "bab8dce01c193d82bc04888a0a9a7814d505f532"
-		},
-		{
-			"ImportPath": "github.com/howeyc/fsnotify",
-			"Comment": "v0.9.0-11-g6b1ef89",
-			"Rev": "6b1ef893dc11e0447abda6da20a5203481878dda"
-		},
-		{
-			"ImportPath": "github.com/huin/goupnp",
-			"Rev": "5cff77a69fb22f5f1774c4451ea2aab63d4d2f20"
-		},
-		{
-			"ImportPath": "github.com/jackpal/go-nat-pmp",
-			"Rev": "a45aa3d54aef73b504e15eb71bea0e5565b5e6e1"
-		},
-		{
-			"ImportPath": "github.com/kardianos/osext",
-			"Rev": "ccfcd0245381f0c94c68f50626665eed3c6b726a"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-colorable",
-			"Rev": "043ae16291351db8465272edf465c9f388161627"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-isatty",
-			"Rev": "fdbe02a1b44e75977b2690062b83cf507d70c013"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-runewidth",
-			"Comment": "travisish-33-g5890272",
-			"Rev": "5890272cd41c5103531cd7b79e428d99c9e97f76"
-		},
-		{
-			"ImportPath": "github.com/nsf/termbox-go",
-			"Rev": "675ffd907b7401b8a709a5ef2249978af5616bb2"
-		},
-		{
-			"ImportPath": "github.com/peterh/liner",
-			"Rev": "29f6a646557d83e2b6e9ba05c45fbea9c006dbe8"
-		},
-		{
-			"ImportPath": "github.com/rakyll/globalconf",
-			"Rev": "415abc325023f1a00cd2d9fa512e0e71745791a2"
-		},
-		{
-			"ImportPath": "github.com/rakyll/goini",
-			"Rev": "907cca0f578a5316fb864ec6992dc3d9730ec58c"
-		},
-		{
-			"ImportPath": "github.com/rcrowley/go-metrics",
-			"Rev": "a5cfc242a56ba7fa70b785f678d6214837bf93b9"
-		},
-		{
-			"ImportPath": "github.com/robertkrimen/otto",
-			"Rev": "dea31a3d392779af358ec41f77a07fcc7e9d04ba"
-		},
-		{
-			"ImportPath": "github.com/rs/cors",
-			"Rev": "6e0c3cb65fc0fdb064c743d176a620e3ca446dfb"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
-			"Rev": "4875955338b0a434238a31165cb87255ab6e9e4a"
-		},
-		{
-			"ImportPath": "github.com/syndtr/gosnappy/snappy",
-			"Rev": "156a073208e131d7d2e212cb749feae7c339e846"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/pbkdf2",
-			"Rev": "4ed45ec682102c643324fae5dff8dab085b6c300"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/ripemd160",
-			"Rev": "4ed45ec682102c643324fae5dff8dab085b6c300"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/scrypt",
-			"Rev": "4ed45ec682102c643324fae5dff8dab085b6c300"
-		},
-		{
-			"ImportPath": "golang.org/x/net/html",
-			"Rev": "e0403b4e005737430c05a57aac078479844f919c"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding",
-			"Rev": "c93e7c9fff19fb9139b5ab04ce041833add0134e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/transform",
-			"Rev": "c93e7c9fff19fb9139b5ab04ce041833add0134e"
-		},
-		{
-			"ImportPath": "gopkg.in/check.v1",
-			"Rev": "64131543e7896d5bcc6bd5a76287eb75ea96c673"
-		},
-		{
-			"ImportPath": "gopkg.in/fatih/set.v0",
-			"Comment": "v0.1.0-3-g27c4092",
-			"Rev": "27c40922c40b43fe04554d8223a402af3ea333f3"
-		},
-		{
-			"ImportPath": "gopkg.in/karalabe/cookiejar.v2/collections/prque",
-			"Rev": "0b2e270613f5d7ba262a5749b9e32270131497a2"
-		}
-	]
-}

Godeps/Readme

@@ -1,5 +0,0 @@
-This directory tree is generated automatically by godep.
-
-Please do not edit.
-
-See https://github.com/tools/godep for more information.

Godeps/_workspace/.gitignore

@@ -1,2 +0,0 @@
-/pkg
-/bin

Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/uuid_test.go

@@ -1,390 +0,0 @@
-// Copyright 2011 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-	"time"
-)
-
-type test struct {
-	in      string
-	version Version
-	variant Variant
-	isuuid  bool
-}
-
-var tests = []test{
-	{"f47ac10b-58cc-0372-8567-0e02b2c3d479", 0, RFC4122, true},
-	{"f47ac10b-58cc-1372-8567-0e02b2c3d479", 1, RFC4122, true},
-	{"f47ac10b-58cc-2372-8567-0e02b2c3d479", 2, RFC4122, true},
-	{"f47ac10b-58cc-3372-8567-0e02b2c3d479", 3, RFC4122, true},
-	{"f47ac10b-58cc-4372-8567-0e02b2c3d479", 4, RFC4122, true},
-	{"f47ac10b-58cc-5372-8567-0e02b2c3d479", 5, RFC4122, true},
-	{"f47ac10b-58cc-6372-8567-0e02b2c3d479", 6, RFC4122, true},
-	{"f47ac10b-58cc-7372-8567-0e02b2c3d479", 7, RFC4122, true},
-	{"f47ac10b-58cc-8372-8567-0e02b2c3d479", 8, RFC4122, true},
-	{"f47ac10b-58cc-9372-8567-0e02b2c3d479", 9, RFC4122, true},
-	{"f47ac10b-58cc-a372-8567-0e02b2c3d479", 10, RFC4122, true},
-	{"f47ac10b-58cc-b372-8567-0e02b2c3d479", 11, RFC4122, true},
-	{"f47ac10b-58cc-c372-8567-0e02b2c3d479", 12, RFC4122, true},
-	{"f47ac10b-58cc-d372-8567-0e02b2c3d479", 13, RFC4122, true},
-	{"f47ac10b-58cc-e372-8567-0e02b2c3d479", 14, RFC4122, true},
-	{"f47ac10b-58cc-f372-8567-0e02b2c3d479", 15, RFC4122, true},
-
-	{"urn:uuid:f47ac10b-58cc-4372-0567-0e02b2c3d479", 4, Reserved, true},
-	{"URN:UUID:f47ac10b-58cc-4372-0567-0e02b2c3d479", 4, Reserved, true},
-	{"f47ac10b-58cc-4372-0567-0e02b2c3d479", 4, Reserved, true},
-	{"f47ac10b-58cc-4372-1567-0e02b2c3d479", 4, Reserved, true},
-	{"f47ac10b-58cc-4372-2567-0e02b2c3d479", 4, Reserved, true},
-	{"f47ac10b-58cc-4372-3567-0e02b2c3d479", 4, Reserved, true},
-	{"f47ac10b-58cc-4372-4567-0e02b2c3d479", 4, Reserved, true},
-	{"f47ac10b-58cc-4372-5567-0e02b2c3d479", 4, Reserved, true},
-	{"f47ac10b-58cc-4372-6567-0e02b2c3d479", 4, Reserved, true},
-	{"f47ac10b-58cc-4372-7567-0e02b2c3d479", 4, Reserved, true},
-	{"f47ac10b-58cc-4372-8567-0e02b2c3d479", 4, RFC4122, true},
-	{"f47ac10b-58cc-4372-9567-0e02b2c3d479", 4, RFC4122, true},
-	{"f47ac10b-58cc-4372-a567-0e02b2c3d479", 4, RFC4122, true},
-	{"f47ac10b-58cc-4372-b567-0e02b2c3d479", 4, RFC4122, true},
-	{"f47ac10b-58cc-4372-c567-0e02b2c3d479", 4, Microsoft, true},
-	{"f47ac10b-58cc-4372-d567-0e02b2c3d479", 4, Microsoft, true},
-	{"f47ac10b-58cc-4372-e567-0e02b2c3d479", 4, Future, true},
-	{"f47ac10b-58cc-4372-f567-0e02b2c3d479", 4, Future, true},
-
-	{"f47ac10b158cc-5372-a567-0e02b2c3d479", 0, Invalid, false},
-	{"f47ac10b-58cc25372-a567-0e02b2c3d479", 0, Invalid, false},
-	{"f47ac10b-58cc-53723a567-0e02b2c3d479", 0, Invalid, false},
-	{"f47ac10b-58cc-5372-a56740e02b2c3d479", 0, Invalid, false},
-	{"f47ac10b-58cc-5372-a567-0e02-2c3d479", 0, Invalid, false},
-	{"g47ac10b-58cc-4372-a567-0e02b2c3d479", 0, Invalid, false},
-}
-
-var constants = []struct {
-	c    interface{}
-	name string
-}{
-	{Person, "Person"},
-	{Group, "Group"},
-	{Org, "Org"},
-	{Invalid, "Invalid"},
-	{RFC4122, "RFC4122"},
-	{Reserved, "Reserved"},
-	{Microsoft, "Microsoft"},
-	{Future, "Future"},
-	{Domain(17), "Domain17"},
-	{Variant(42), "BadVariant42"},
-}
-
-func testTest(t *testing.T, in string, tt test) {
-	uuid := Parse(in)
-	if ok := (uuid != nil); ok != tt.isuuid {
-		t.Errorf("Parse(%s) got %v expected %v\b", in, ok, tt.isuuid)
-	}
-	if uuid == nil {
-		return
-	}
-
-	if v := uuid.Variant(); v != tt.variant {
-		t.Errorf("Variant(%s) got %d expected %d\b", in, v, tt.variant)
-	}
-	if v, _ := uuid.Version(); v != tt.version {
-		t.Errorf("Version(%s) got %d expected %d\b", in, v, tt.version)
-	}
-}
-
-func TestUUID(t *testing.T) {
-	for _, tt := range tests {
-		testTest(t, tt.in, tt)
-		testTest(t, strings.ToUpper(tt.in), tt)
-	}
-}
-
-func TestConstants(t *testing.T) {
-	for x, tt := range constants {
-		v, ok := tt.c.(fmt.Stringer)
-		if !ok {
-			t.Errorf("%x: %v: not a stringer", x, v)
-		} else if s := v.String(); s != tt.name {
-			v, _ := tt.c.(int)
-			t.Errorf("%x: Constant %T:%d gives %q, expected %q\n", x, tt.c, v, s, tt.name)
-		}
-	}
-}
-
-func TestRandomUUID(t *testing.T) {
-	m := make(map[string]bool)
-	for x := 1; x < 32; x++ {
-		uuid := NewRandom()
-		s := uuid.String()
-		if m[s] {
-			t.Errorf("NewRandom returned duplicated UUID %s\n", s)
-		}
-		m[s] = true
-		if v, _ := uuid.Version(); v != 4 {
-			t.Errorf("Random UUID of version %s\n", v)
-		}
-		if uuid.Variant() != RFC4122 {
-			t.Errorf("Random UUID is variant %d\n", uuid.Variant())
-		}
-	}
-}
-
-func TestNew(t *testing.T) {
-	m := make(map[string]bool)
-	for x := 1; x < 32; x++ {
-		s := New()
-		if m[s] {
-			t.Errorf("New returned duplicated UUID %s\n", s)
-		}
-		m[s] = true
-		uuid := Parse(s)
-		if uuid == nil {
-			t.Errorf("New returned %q which does not decode\n", s)
-			continue
-		}
-		if v, _ := uuid.Version(); v != 4 {
-			t.Errorf("Random UUID of version %s\n", v)
-		}
-		if uuid.Variant() != RFC4122 {
-			t.Errorf("Random UUID is variant %d\n", uuid.Variant())
-		}
-	}
-}
-
-func clockSeq(t *testing.T, uuid UUID) int {
-	seq, ok := uuid.ClockSequence()
-	if !ok {
-		t.Fatalf("%s: invalid clock sequence\n", uuid)
-	}
-	return seq
-}
-
-func TestClockSeq(t *testing.T) {
-	// Fake time.Now for this test to return a monotonically advancing time; restore it at end.
-	defer func(orig func() time.Time) { timeNow = orig }(timeNow)
-	monTime := time.Now()
-	timeNow = func() time.Time {
-		monTime = monTime.Add(1 * time.Second)
-		return monTime
-	}
-
-	SetClockSequence(-1)
-	uuid1 := NewUUID()
-	uuid2 := NewUUID()
-
-	if clockSeq(t, uuid1) != clockSeq(t, uuid2) {
-		t.Errorf("clock sequence %d != %d\n", clockSeq(t, uuid1), clockSeq(t, uuid2))
-	}
-
-	SetClockSequence(-1)
-	uuid2 = NewUUID()
-
-	// Just on the very off chance we generated the same sequence
-	// two times we try again.
-	if clockSeq(t, uuid1) == clockSeq(t, uuid2) {
-		SetClockSequence(-1)
-		uuid2 = NewUUID()
-	}
-	if clockSeq(t, uuid1) == clockSeq(t, uuid2) {
-		t.Errorf("Duplicate clock sequence %d\n", clockSeq(t, uuid1))
-	}
-
-	SetClockSequence(0x1234)
-	uuid1 = NewUUID()
-	if seq := clockSeq(t, uuid1); seq != 0x1234 {
-		t.Errorf("%s: expected seq 0x1234 got 0x%04x\n", uuid1, seq)
-	}
-}
-
-func TestCoding(t *testing.T) {
-	text := "7d444840-9dc0-11d1-b245-5ffdce74fad2"
-	urn := "urn:uuid:7d444840-9dc0-11d1-b245-5ffdce74fad2"
-	data := UUID{
-		0x7d, 0x44, 0x48, 0x40,
-		0x9d, 0xc0,
-		0x11, 0xd1,
-		0xb2, 0x45,
-		0x5f, 0xfd, 0xce, 0x74, 0xfa, 0xd2,
-	}
-	if v := data.String(); v != text {
-		t.Errorf("%x: encoded to %s, expected %s\n", data, v, text)
-	}
-	if v := data.URN(); v != urn {
-		t.Errorf("%x: urn is %s, expected %s\n", data, v, urn)
-	}
-
-	uuid := Parse(text)
-	if !Equal(uuid, data) {
-		t.Errorf("%s: decoded to %s, expected %s\n", text, uuid, data)
-	}
-}
-
-func TestVersion1(t *testing.T) {
-	uuid1 := NewUUID()
-	uuid2 := NewUUID()
-
-	if Equal(uuid1, uuid2) {
-		t.Errorf("%s:duplicate uuid\n", uuid1)
-	}
-	if v, _ := uuid1.Version(); v != 1 {
-		t.Errorf("%s: version %s expected 1\n", uuid1, v)
-	}
-	if v, _ := uuid2.Version(); v != 1 {
-		t.Errorf("%s: version %s expected 1\n", uuid2, v)
-	}
-	n1 := uuid1.NodeID()
-	n2 := uuid2.NodeID()
-	if !bytes.Equal(n1, n2) {
-		t.Errorf("Different nodes %x != %x\n", n1, n2)
-	}
-	t1, ok := uuid1.Time()
-	if !ok {
-		t.Errorf("%s: invalid time\n", uuid1)
-	}
-	t2, ok := uuid2.Time()
-	if !ok {
-		t.Errorf("%s: invalid time\n", uuid2)
-	}
-	q1, ok := uuid1.ClockSequence()
-	if !ok {
-		t.Errorf("%s: invalid clock sequence\n", uuid1)
-	}
-	q2, ok := uuid2.ClockSequence()
-	if !ok {
-		t.Errorf("%s: invalid clock sequence", uuid2)
-	}
-
-	switch {
-	case t1 == t2 && q1 == q2:
-		t.Errorf("time stopped\n")
-	case t1 > t2 && q1 == q2:
-		t.Errorf("time reversed\n")
-	case t1 < t2 && q1 != q2:
-		t.Errorf("clock sequence chaned unexpectedly\n")
-	}
-}
-
-func TestNodeAndTime(t *testing.T) {
-	// Time is February 5, 1998 12:30:23.136364800 AM GMT
-
-	uuid := Parse("7d444840-9dc0-11d1-b245-5ffdce74fad2")
-	node := []byte{0x5f, 0xfd, 0xce, 0x74, 0xfa, 0xd2}
-
-	ts, ok := uuid.Time()
-	if ok {
-		c := time.Unix(ts.UnixTime())
-		want := time.Date(1998, 2, 5, 0, 30, 23, 136364800, time.UTC)
-		if !c.Equal(want) {
-			t.Errorf("Got time %v, want %v", c, want)
-		}
-	} else {
-		t.Errorf("%s: bad time\n", uuid)
-	}
-	if !bytes.Equal(node, uuid.NodeID()) {
-		t.Errorf("Expected node %v got %v\n", node, uuid.NodeID())
-	}
-}
-
-func TestMD5(t *testing.T) {
-	uuid := NewMD5(NameSpace_DNS, []byte("python.org")).String()
-	want := "6fa459ea-ee8a-3ca4-894e-db77e160355e"
-	if uuid != want {
-		t.Errorf("MD5: got %q expected %q\n", uuid, want)
-	}
-}
-
-func TestSHA1(t *testing.T) {
-	uuid := NewSHA1(NameSpace_DNS, []byte("python.org")).String()
-	want := "886313e1-3b8a-5372-9b90-0c9aee199e5d"
-	if uuid != want {
-		t.Errorf("SHA1: got %q expected %q\n", uuid, want)
-	}
-}
-
-func TestNodeID(t *testing.T) {
-	nid := []byte{1, 2, 3, 4, 5, 6}
-	SetNodeInterface("")
-	s := NodeInterface()
-	if s == "" || s == "user" {
-		t.Errorf("NodeInterface %q after SetInteface\n", s)
-	}
-	node1 := NodeID()
-	if node1 == nil {
-		t.Errorf("NodeID nil after SetNodeInterface\n", s)
-	}
-	SetNodeID(nid)
-	s = NodeInterface()
-	if s != "user" {
-		t.Errorf("Expected NodeInterface %q got %q\n", "user", s)
-	}
-	node2 := NodeID()
-	if node2 == nil {
-		t.Errorf("NodeID nil after SetNodeID\n", s)
-	}
-	if bytes.Equal(node1, node2) {
-		t.Errorf("NodeID not changed after SetNodeID\n", s)
-	} else if !bytes.Equal(nid, node2) {
-		t.Errorf("NodeID is %x, expected %x\n", node2, nid)
-	}
-}
-
-func testDCE(t *testing.T, name string, uuid UUID, domain Domain, id uint32) {
-	if uuid == nil {
-		t.Errorf("%s failed\n", name)
-		return
-	}
-	if v, _ := uuid.Version(); v != 2 {
-		t.Errorf("%s: %s: expected version 2, got %s\n", name, uuid, v)
-		return
-	}
-	if v, ok := uuid.Domain(); !ok || v != domain {
-		if !ok {
-			t.Errorf("%s: %d: Domain failed\n", name, uuid)
-		} else {
-			t.Errorf("%s: %s: expected domain %d, got %d\n", name, uuid, domain, v)
-		}
-	}
-	if v, ok := uuid.Id(); !ok || v != id {
-		if !ok {
-			t.Errorf("%s: %d: Id failed\n", name, uuid)
-		} else {
-			t.Errorf("%s: %s: expected id %d, got %d\n", name, uuid, id, v)
-		}
-	}
-}
-
-func TestDCE(t *testing.T) {
-	testDCE(t, "NewDCESecurity", NewDCESecurity(42, 12345678), 42, 12345678)
-	testDCE(t, "NewDCEPerson", NewDCEPerson(), Person, uint32(os.Getuid()))
-	testDCE(t, "NewDCEGroup", NewDCEGroup(), Group, uint32(os.Getgid()))
-}
-
-type badRand struct{}
-
-func (r badRand) Read(buf []byte) (int, error) {
-	for i, _ := range buf {
-		buf[i] = byte(i)
-	}
-	return len(buf), nil
-}
-
-func TestBadRand(t *testing.T) {
-	SetRand(badRand{})
-	uuid1 := New()
-	uuid2 := New()
-	if uuid1 != uuid2 {
-		t.Errorf("execpted duplicates, got %q and %q\n", uuid1, uuid2)
-	}
-	SetRand(nil)
-	uuid1 = New()
-	uuid2 = New()
-	if uuid1 == uuid2 {
-		t.Errorf("unexecpted duplicates, got %q\n", uuid1)
-	}
-}

Godeps/_workspace/src/github.com/codegangsta/cli/.travis.yml

@@ -1,6 +0,0 @@
-language: go
-go: 1.1
-
-script:
-- go vet ./...
-- go test -v ./...

Godeps/_workspace/src/github.com/codegangsta/cli/README.md

@@ -1,298 +0,0 @@
-[![Build Status](https://travis-ci.org/codegangsta/cli.png?branch=master)](https://travis-ci.org/codegangsta/cli)
-
-# cli.go
-cli.go is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
-
-You can view the API docs here:
-http://godoc.org/github.com/codegangsta/cli
-
-## Overview
-Command line apps are usually so tiny that there is absolutely no reason why your code should *not* be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.
-
-**This is where cli.go comes into play.** cli.go makes command line programming fun, organized, and expressive!
-
-## Installation
-Make sure you have a working Go environment (go 1.1 is *required*). [See the install instructions](http://golang.org/doc/install.html).
-
-To install `cli.go`, simply run:
-```
-$ go get github.com/codegangsta/cli
-```
-
-Make sure your `PATH` includes to the `$GOPATH/bin` directory so your commands can be easily used:
-```
-export PATH=$PATH:$GOPATH/bin
-```
-
-## Getting Started
-One of the philosophies behind cli.go is that an API should be playful and full of discovery. So a cli.go app can be as little as one line of code in `main()`. 
-
-``` go
-package main
-
-import (
-  "os"
-  "github.com/codegangsta/cli"
-)
-
-func main() {
-  cli.NewApp().Run(os.Args)
-}
-```
-
-This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:
-
-``` go
-package main
-
-import (
-  "os"
-  "github.com/codegangsta/cli"
-)
-
-func main() {
-  app := cli.NewApp()
-  app.Name = "boom"
-  app.Usage = "make an explosive entrance"
-  app.Action = func(c *cli.Context) {
-    println("boom! I say!")
-  }
-  
-  app.Run(os.Args)
-}
-```
-
-Running this already gives you a ton of functionality, plus support for things like subcommands and flags, which are covered below.
-
-## Example
-
-Being a programmer can be a lonely job. Thankfully by the power of automation that is not the case! Let's create a greeter app to fend off our demons of loneliness!
-
-Start by creating a directory named `greet`, and within it, add a file, `greet.go` with the following code in it:
-
-``` go
-package main
-
-import (
-  "os"
-  "github.com/codegangsta/cli"
-)
-
-func main() {
-  app := cli.NewApp()
-  app.Name = "greet"
-  app.Usage = "fight the loneliness!"
-  app.Action = func(c *cli.Context) {
-    println("Hello friend!")
-  }
-
-  app.Run(os.Args)
-}
-```
-
-Install our command to the `$GOPATH/bin` directory:
-
-```
-$ go install
-```
-
-Finally run our new command:
-
-```
-$ greet
-Hello friend!
-```
-
-cli.go also generates some bitchass help text:
-```
-$ greet help
-NAME:
-    greet - fight the loneliness!
-
-USAGE:
-    greet [global options] command [command options] [arguments...]
-
-VERSION:
-    0.0.0
-
-COMMANDS:
-    help, h  Shows a list of commands or help for one command
-
-GLOBAL OPTIONS
-    --version	Shows version information
-```
-
-### Arguments
-You can lookup arguments by calling the `Args` function on `cli.Context`.
-
-``` go
-...
-app.Action = func(c *cli.Context) {
-  println("Hello", c.Args()[0])
-}
-...
-```
-
-### Flags
-Setting and querying flags is simple.
-``` go
-...
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang",
-    Value: "english",
-    Usage: "language for the greeting",
-  },
-}
-app.Action = func(c *cli.Context) {
-  name := "someone"
-  if len(c.Args()) > 0 {
-    name = c.Args()[0]
-  }
-  if c.String("lang") == "spanish" {
-    println("Hola", name)
-  } else {
-    println("Hello", name)
-  }
-}
-...
-```
-
-#### Alternate Names
-
-You can set alternate (or short) names for flags by providing a comma-delimited list for the `Name`. e.g.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-  },
-}
-```
-
-That flag can then be set with `--lang spanish` or `-l spanish`. Note that giving two different forms of the same flag in the same command invocation is an error.
-
-#### Values from the Environment
-
-You can also have the default value set from the environment via `EnvVar`.  e.g.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-    EnvVar: "APP_LANG",
-  },
-}
-```
-
-The `EnvVar` may also be given as a comma-delimited "cascade", where the first environment variable that resolves is used as the default.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-    EnvVar: "LEGACY_COMPAT_LANG,APP_LANG,LANG",
-  },
-}
-```
-
-### Subcommands
-
-Subcommands can be defined for a more git-like command line app.
-```go
-...
-app.Commands = []cli.Command{
-  {
-    Name:      "add",
-    Aliases:     []string{"a"},
-    Usage:     "add a task to the list",
-    Action: func(c *cli.Context) {
-      println("added task: ", c.Args().First())
-    },
-  },
-  {
-    Name:      "complete",
-    Aliases:     []string{"c"},
-    Usage:     "complete a task on the list",
-    Action: func(c *cli.Context) {
-      println("completed task: ", c.Args().First())
-    },
-  },
-  {
-    Name:      "template",
-    Aliases:     []string{"r"},
-    Usage:     "options for task templates",
-    Subcommands: []cli.Command{
-      {
-        Name:  "add",
-        Usage: "add a new template",
-        Action: func(c *cli.Context) {
-            println("new task template: ", c.Args().First())
-        },
-      },
-      {
-        Name:  "remove",
-        Usage: "remove an existing template",
-        Action: func(c *cli.Context) {
-          println("removed task template: ", c.Args().First())
-        },
-      },
-    },
-  },
-}
-...
-```
-
-### Bash Completion
-
-You can enable completion commands by setting the `EnableBashCompletion`
-flag on the `App` object.  By default, this setting will only auto-complete to
-show an app's subcommands, but you can write your own completion methods for
-the App or its subcommands.
-```go
-...
-var tasks = []string{"cook", "clean", "laundry", "eat", "sleep", "code"}
-app := cli.NewApp()
-app.EnableBashCompletion = true
-app.Commands = []cli.Command{
-  {
-    Name:  "complete",
-    Aliases: []string{"c"},
-    Usage: "complete a task on the list",
-    Action: func(c *cli.Context) {
-       println("completed task: ", c.Args().First())
-    },
-    BashComplete: func(c *cli.Context) {
-      // This will complete if no args are passed
-      if len(c.Args()) > 0 {
-        return
-      }
-      for _, t := range tasks {
-        fmt.Println(t)
-      }
-    },
-  }
-}
-...
-```
-
-#### To Enable
-
-Source the `autocomplete/bash_autocomplete` file in your `.bashrc` file while
-setting the `PROG` variable to the name of your program:
-
-`PROG=myprogram source /.../cli/autocomplete/bash_autocomplete`
-
-
-## Contribution Guidelines
-Feel free to put up a pull request to fix a bug or maybe add a feature. I will give it a code review and make sure that it does not break backwards compatibility. If I or any other collaborators agree that it is in line with the vision of the project, we will work with you to get the code into a mergeable state and merge it into the master branch.
-
-If you have contributed something significant to the project, I will most likely add you as a collaborator. As a collaborator you are given the ability to merge others pull requests. It is very important that new code does not break existing code, so be careful about what code you do choose to merge. If you have any questions feel free to link @codegangsta to the issue in question and we can review it together.
-
-If you feel like you have contributed to the project but have not yet been added as a collaborator, I probably forgot to add you. Hit @codegangsta up over email and we will get it figured out.

Godeps/_workspace/src/github.com/codegangsta/cli/app.go

@@ -1,321 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"strings"
-	"text/tabwriter"
-	"text/template"
-	"time"
-)
-
-// App is the main structure of a cli application. It is recomended that
-// and app be created with the cli.NewApp() function
-type App struct {
-	// The name of the program. Defaults to os.Args[0]
-	Name string
-	// Description of the program.
-	Usage string
-	// Version of the program
-	Version string
-	// List of commands to execute
-	Commands []Command
-	// List of flags to parse
-	Flags []Flag
-	// Boolean to enable bash completion commands
-	EnableBashCompletion bool
-	// Boolean to hide built-in help command
-	HideHelp bool
-	// Boolean to hide built-in version flag
-	HideVersion bool
-	// An action to execute when the bash-completion flag is set
-	BashComplete func(context *Context)
-	// An action to execute before any subcommands are run, but after the context is ready
-	// If a non-nil error is returned, no subcommands are run
-	Before func(context *Context) error
-	// An action to execute after any subcommands are run, but after the subcommand has finished
-	// It is run even if Action() panics
-	After func(context *Context) error
-	// The action to execute when no subcommands are specified
-	Action func(context *Context)
-	// Execute this function if the proper command cannot be found
-	CommandNotFound func(context *Context, command string)
-	// Compilation date
-	Compiled time.Time
-	// List of all authors who contributed
-	Authors []Author
-	// Name of Author (Note: Use App.Authors, this is deprecated)
-	Author string
-	// Email of Author (Note: Use App.Authors, this is deprecated)
-	Email string
-	// Writer writer to write output to
-	Writer io.Writer
-}
-
-// Tries to find out when this binary was compiled.
-// Returns the current time if it fails to find it.
-func compileTime() time.Time {
-	info, err := os.Stat(os.Args[0])
-	if err != nil {
-		return time.Now()
-	}
-	return info.ModTime()
-}
-
-// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
-func NewApp() *App {
-	return &App{
-		Name:         os.Args[0],
-		Usage:        "A new cli application",
-		Version:      "0.0.0",
-		BashComplete: DefaultAppComplete,
-		Action:       helpCommand.Action,
-		Compiled:     compileTime(),
-		Writer:       os.Stdout,
-	}
-}
-
-// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
-func (a *App) Run(arguments []string) (err error) {
-	if a.Author != "" || a.Email != "" {
-		a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email})
-	}
-
-	if HelpPrinter == nil {
-		defer func() {
-			HelpPrinter = nil
-		}()
-
-		HelpPrinter = func(templ string, data interface{}) {
-			funcMap := template.FuncMap{
-				"join": strings.Join,
-			}
-
-			w := tabwriter.NewWriter(a.Writer, 0, 8, 1, '\t', 0)
-			t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
-			err := t.Execute(w, data)
-			if err != nil {
-				panic(err)
-			}
-			w.Flush()
-		}
-	}
-
-	// append help to commands
-	if a.Command(helpCommand.Name) == nil && !a.HideHelp {
-		a.Commands = append(a.Commands, helpCommand)
-		if (HelpFlag != BoolFlag{}) {
-			a.appendFlag(HelpFlag)
-		}
-	}
-
-	//append version/help flags
-	if a.EnableBashCompletion {
-		a.appendFlag(BashCompletionFlag)
-	}
-
-	if !a.HideVersion {
-		a.appendFlag(VersionFlag)
-	}
-
-	// parse flags
-	set := flagSet(a.Name, a.Flags)
-	set.SetOutput(ioutil.Discard)
-	err = set.Parse(arguments[1:])
-	nerr := normalizeFlags(a.Flags, set)
-	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
-		context := NewContext(a, set, set)
-		ShowAppHelp(context)
-		fmt.Fprintln(a.Writer)
-		return nerr
-	}
-	context := NewContext(a, set, set)
-
-	if err != nil {
-		fmt.Fprintf(a.Writer, "Incorrect Usage.\n\n")
-		ShowAppHelp(context)
-		fmt.Fprintln(a.Writer)
-		return err
-	}
-
-	if checkCompletions(context) {
-		return nil
-	}
-
-	if checkHelp(context) {
-		return nil
-	}
-
-	if checkVersion(context) {
-		return nil
-	}
-
-	if a.After != nil {
-		defer func() {
-			// err is always nil here.
-			// There is a check to see if it is non-nil
-			// just few lines before.
-			err = a.After(context)
-		}()
-	}
-
-	if a.Before != nil {
-		err := a.Before(context)
-		if err != nil {
-			return err
-		}
-	}
-
-	args := context.Args()
-	if args.Present() {
-		name := args.First()
-		c := a.Command(name)
-		if c != nil {
-			return c.Run(context)
-		}
-	}
-
-	// Run default Action
-	a.Action(context)
-	return nil
-}
-
-// Another entry point to the cli app, takes care of passing arguments and error handling
-func (a *App) RunAndExitOnError() {
-	if err := a.Run(os.Args); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
-func (a *App) RunAsSubcommand(ctx *Context) (err error) {
-	// append help to commands
-	if len(a.Commands) > 0 {
-		if a.Command(helpCommand.Name) == nil && !a.HideHelp {
-			a.Commands = append(a.Commands, helpCommand)
-			if (HelpFlag != BoolFlag{}) {
-				a.appendFlag(HelpFlag)
-			}
-		}
-	}
-
-	// append flags
-	if a.EnableBashCompletion {
-		a.appendFlag(BashCompletionFlag)
-	}
-
-	// parse flags
-	set := flagSet(a.Name, a.Flags)
-	set.SetOutput(ioutil.Discard)
-	err = set.Parse(ctx.Args().Tail())
-	nerr := normalizeFlags(a.Flags, set)
-	context := NewContext(a, set, ctx.globalSet)
-
-	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
-		if len(a.Commands) > 0 {
-			ShowSubcommandHelp(context)
-		} else {
-			ShowCommandHelp(ctx, context.Args().First())
-		}
-		fmt.Fprintln(a.Writer)
-		return nerr
-	}
-
-	if err != nil {
-		fmt.Fprintf(a.Writer, "Incorrect Usage.\n\n")
-		ShowSubcommandHelp(context)
-		return err
-	}
-
-	if checkCompletions(context) {
-		return nil
-	}
-
-	if len(a.Commands) > 0 {
-		if checkSubcommandHelp(context) {
-			return nil
-		}
-	} else {
-		if checkCommandHelp(ctx, context.Args().First()) {
-			return nil
-		}
-	}
-
-	if a.After != nil {
-		defer func() {
-			// err is always nil here.
-			// There is a check to see if it is non-nil
-			// just few lines before.
-			err = a.After(context)
-		}()
-	}
-
-	if a.Before != nil {
-		err := a.Before(context)
-		if err != nil {
-			return err
-		}
-	}
-
-	args := context.Args()
-	if args.Present() {
-		name := args.First()
-		c := a.Command(name)
-		if c != nil {
-			return c.Run(context)
-		}
-	}
-
-	// Run default Action
-	a.Action(context)
-
-	return nil
-}
-
-// Returns the named command on App. Returns nil if the command does not exist
-func (a *App) Command(name string) *Command {
-	for _, c := range a.Commands {
-		if c.HasName(name) {
-			return &c
-		}
-	}
-
-	return nil
-}
-
-func (a *App) hasFlag(flag Flag) bool {
-	for _, f := range a.Flags {
-		if flag == f {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (a *App) appendFlag(flag Flag) {
-	if !a.hasFlag(flag) {
-		a.Flags = append(a.Flags, flag)
-	}
-}
-
-// Author represents someone who has contributed to a cli project.
-type Author struct {
-	Name  string // The Authors name
-	Email string // The Authors email
-}
-
-// String makes Author comply to the Stringer interface, to allow an easy print in the templating process
-func (a Author) String() string {
-	e := ""
-	if a.Email != "" {
-		e = "<" + a.Email + "> "
-	}
-
-	return fmt.Sprintf("%v %v", a.Name, e)
-}

Godeps/_workspace/src/github.com/codegangsta/cli/app_test.go

@@ -1,622 +0,0 @@
-package cli_test
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"testing"
-
-	"github.com/codegangsta/cli"
-)
-
-func ExampleApp() {
-	// set args for examples sake
-	os.Args = []string{"greet", "--name", "Jeremy"}
-
-	app := cli.NewApp()
-	app.Name = "greet"
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
-	}
-	app.Action = func(c *cli.Context) {
-		fmt.Printf("Hello %v\n", c.String("name"))
-	}
-	app.Author = "Harrison"
-	app.Email = "harrison@lolwut.com"
-	app.Authors = []cli.Author{cli.Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}}
-	app.Run(os.Args)
-	// Output:
-	// Hello Jeremy
-}
-
-func ExampleAppSubcommand() {
-	// set args for examples sake
-	os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}
-	app := cli.NewApp()
-	app.Name = "say"
-	app.Commands = []cli.Command{
-		{
-			Name:        "hello",
-			Aliases:     []string{"hi"},
-			Usage:       "use it to see a description",
-			Description: "This is how we describe hello the function",
-			Subcommands: []cli.Command{
-				{
-					Name:        "english",
-					Aliases:     []string{"en"},
-					Usage:       "sends a greeting in english",
-					Description: "greets someone in english",
-					Flags: []cli.Flag{
-						cli.StringFlag{
-							Name:  "name",
-							Value: "Bob",
-							Usage: "Name of the person to greet",
-						},
-					},
-					Action: func(c *cli.Context) {
-						fmt.Println("Hello,", c.String("name"))
-					},
-				},
-			},
-		},
-	}
-
-	app.Run(os.Args)
-	// Output:
-	// Hello, Jeremy
-}
-
-func ExampleAppHelp() {
-	// set args for examples sake
-	os.Args = []string{"greet", "h", "describeit"}
-
-	app := cli.NewApp()
-	app.Name = "greet"
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
-	}
-	app.Commands = []cli.Command{
-		{
-			Name:        "describeit",
-			Aliases:     []string{"d"},
-			Usage:       "use it to see a description",
-			Description: "This is how we describe describeit the function",
-			Action: func(c *cli.Context) {
-				fmt.Printf("i like to describe things")
-			},
-		},
-	}
-	app.Run(os.Args)
-	// Output:
-	// NAME:
-	//    describeit - use it to see a description
-	//
-	// USAGE:
-	//    command describeit [arguments...]
-	//
-	// DESCRIPTION:
-	//    This is how we describe describeit the function
-}
-
-func ExampleAppBashComplete() {
-	// set args for examples sake
-	os.Args = []string{"greet", "--generate-bash-completion"}
-
-	app := cli.NewApp()
-	app.Name = "greet"
-	app.EnableBashCompletion = true
-	app.Commands = []cli.Command{
-		{
-			Name:        "describeit",
-			Aliases:     []string{"d"},
-			Usage:       "use it to see a description",
-			Description: "This is how we describe describeit the function",
-			Action: func(c *cli.Context) {
-				fmt.Printf("i like to describe things")
-			},
-		}, {
-			Name:        "next",
-			Usage:       "next example",
-			Description: "more stuff to see when generating bash completion",
-			Action: func(c *cli.Context) {
-				fmt.Printf("the next example")
-			},
-		},
-	}
-
-	app.Run(os.Args)
-	// Output:
-	// describeit
-	// d
-	// next
-	// help
-	// h
-}
-
-func TestApp_Run(t *testing.T) {
-	s := ""
-
-	app := cli.NewApp()
-	app.Action = func(c *cli.Context) {
-		s = s + c.Args().First()
-	}
-
-	err := app.Run([]string{"command", "foo"})
-	expect(t, err, nil)
-	err = app.Run([]string{"command", "bar"})
-	expect(t, err, nil)
-	expect(t, s, "foobar")
-}
-
-var commandAppTests = []struct {
-	name     string
-	expected bool
-}{
-	{"foobar", true},
-	{"batbaz", true},
-	{"b", true},
-	{"f", true},
-	{"bat", false},
-	{"nothing", false},
-}
-
-func TestApp_Command(t *testing.T) {
-	app := cli.NewApp()
-	fooCommand := cli.Command{Name: "foobar", Aliases: []string{"f"}}
-	batCommand := cli.Command{Name: "batbaz", Aliases: []string{"b"}}
-	app.Commands = []cli.Command{
-		fooCommand,
-		batCommand,
-	}
-
-	for _, test := range commandAppTests {
-		expect(t, app.Command(test.name) != nil, test.expected)
-	}
-}
-
-func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
-	var parsedOption, firstArg string
-
-	app := cli.NewApp()
-	command := cli.Command{
-		Name: "cmd",
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
-		},
-		Action: func(c *cli.Context) {
-			parsedOption = c.String("option")
-			firstArg = c.Args().First()
-		},
-	}
-	app.Commands = []cli.Command{command}
-
-	app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
-
-	expect(t, parsedOption, "my-option")
-	expect(t, firstArg, "my-arg")
-}
-
-func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
-	var context *cli.Context
-
-	a := cli.NewApp()
-	a.Commands = []cli.Command{
-		{
-			Name: "foo",
-			Action: func(c *cli.Context) {
-				context = c
-			},
-			Flags: []cli.Flag{
-				cli.StringFlag{
-					Name:  "lang",
-					Value: "english",
-					Usage: "language for the greeting",
-				},
-			},
-			Before: func(_ *cli.Context) error { return nil },
-		},
-	}
-	a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
-
-	expect(t, context.Args().Get(0), "abcd")
-	expect(t, context.String("lang"), "spanish")
-}
-
-func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
-	var parsedOption string
-	var args []string
-
-	app := cli.NewApp()
-	command := cli.Command{
-		Name: "cmd",
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
-		},
-		Action: func(c *cli.Context) {
-			parsedOption = c.String("option")
-			args = c.Args()
-		},
-	}
-	app.Commands = []cli.Command{command}
-
-	app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"})
-
-	expect(t, parsedOption, "my-option")
-	expect(t, args[0], "my-arg")
-	expect(t, args[1], "--")
-	expect(t, args[2], "--notARealFlag")
-}
-
-func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
-	var args []string
-
-	app := cli.NewApp()
-	command := cli.Command{
-		Name: "cmd",
-		Action: func(c *cli.Context) {
-			args = c.Args()
-		},
-	}
-	app.Commands = []cli.Command{command}
-
-	app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"})
-
-	expect(t, args[0], "my-arg")
-	expect(t, args[1], "--")
-	expect(t, args[2], "notAFlagAtAll")
-}
-
-func TestApp_Float64Flag(t *testing.T) {
-	var meters float64
-
-	app := cli.NewApp()
-	app.Flags = []cli.Flag{
-		cli.Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
-	}
-	app.Action = func(c *cli.Context) {
-		meters = c.Float64("height")
-	}
-
-	app.Run([]string{"", "--height", "1.93"})
-	expect(t, meters, 1.93)
-}
-
-func TestApp_ParseSliceFlags(t *testing.T) {
-	var parsedOption, firstArg string
-	var parsedIntSlice []int
-	var parsedStringSlice []string
-
-	app := cli.NewApp()
-	command := cli.Command{
-		Name: "cmd",
-		Flags: []cli.Flag{
-			cli.IntSliceFlag{Name: "p", Value: &cli.IntSlice{}, Usage: "set one or more ip addr"},
-			cli.StringSliceFlag{Name: "ip", Value: &cli.StringSlice{}, Usage: "set one or more ports to open"},
-		},
-		Action: func(c *cli.Context) {
-			parsedIntSlice = c.IntSlice("p")
-			parsedStringSlice = c.StringSlice("ip")
-			parsedOption = c.String("option")
-			firstArg = c.Args().First()
-		},
-	}
-	app.Commands = []cli.Command{command}
-
-	app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"})
-
-	IntsEquals := func(a, b []int) bool {
-		if len(a) != len(b) {
-			return false
-		}
-		for i, v := range a {
-			if v != b[i] {
-				return false
-			}
-		}
-		return true
-	}
-
-	StrsEquals := func(a, b []string) bool {
-		if len(a) != len(b) {
-			return false
-		}
-		for i, v := range a {
-			if v != b[i] {
-				return false
-			}
-		}
-		return true
-	}
-	var expectedIntSlice = []int{22, 80}
-	var expectedStringSlice = []string{"8.8.8.8", "8.8.4.4"}
-
-	if !IntsEquals(parsedIntSlice, expectedIntSlice) {
-		t.Errorf("%v does not match %v", parsedIntSlice, expectedIntSlice)
-	}
-
-	if !StrsEquals(parsedStringSlice, expectedStringSlice) {
-		t.Errorf("%v does not match %v", parsedStringSlice, expectedStringSlice)
-	}
-}
-
-func TestApp_DefaultStdout(t *testing.T) {
-	app := cli.NewApp()
-
-	if app.Writer != os.Stdout {
-		t.Error("Default output writer not set.")
-	}
-}
-
-type mockWriter struct {
-	written []byte
-}
-
-func (fw *mockWriter) Write(p []byte) (n int, err error) {
-	if fw.written == nil {
-		fw.written = p
-	} else {
-		fw.written = append(fw.written, p...)
-	}
-
-	return len(p), nil
-}
-
-func (fw *mockWriter) GetWritten() (b []byte) {
-	return fw.written
-}
-
-func TestApp_SetStdout(t *testing.T) {
-	w := &mockWriter{}
-
-	app := cli.NewApp()
-	app.Name = "test"
-	app.Writer = w
-
-	err := app.Run([]string{"help"})
-
-	if err != nil {
-		t.Fatalf("Run error: %s", err)
-	}
-
-	if len(w.written) == 0 {
-		t.Error("App did not write output to desired writer.")
-	}
-}
-
-func TestApp_BeforeFunc(t *testing.T) {
-	beforeRun, subcommandRun := false, false
-	beforeError := fmt.Errorf("fail")
-	var err error
-
-	app := cli.NewApp()
-
-	app.Before = func(c *cli.Context) error {
-		beforeRun = true
-		s := c.String("opt")
-		if s == "fail" {
-			return beforeError
-		}
-
-		return nil
-	}
-
-	app.Commands = []cli.Command{
-		cli.Command{
-			Name: "sub",
-			Action: func(c *cli.Context) {
-				subcommandRun = true
-			},
-		},
-	}
-
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "opt"},
-	}
-
-	// run with the Before() func succeeding
-	err = app.Run([]string{"command", "--opt", "succeed", "sub"})
-
-	if err != nil {
-		t.Fatalf("Run error: %s", err)
-	}
-
-	if beforeRun == false {
-		t.Errorf("Before() not executed when expected")
-	}
-
-	if subcommandRun == false {
-		t.Errorf("Subcommand not executed when expected")
-	}
-
-	// reset
-	beforeRun, subcommandRun = false, false
-
-	// run with the Before() func failing
-	err = app.Run([]string{"command", "--opt", "fail", "sub"})
-
-	// should be the same error produced by the Before func
-	if err != beforeError {
-		t.Errorf("Run error expected, but not received")
-	}
-
-	if beforeRun == false {
-		t.Errorf("Before() not executed when expected")
-	}
-
-	if subcommandRun == true {
-		t.Errorf("Subcommand executed when NOT expected")
-	}
-
-}
-
-func TestApp_AfterFunc(t *testing.T) {
-	afterRun, subcommandRun := false, false
-	afterError := fmt.Errorf("fail")
-	var err error
-
-	app := cli.NewApp()
-
-	app.After = func(c *cli.Context) error {
-		afterRun = true
-		s := c.String("opt")
-		if s == "fail" {
-			return afterError
-		}
-
-		return nil
-	}
-
-	app.Commands = []cli.Command{
-		cli.Command{
-			Name: "sub",
-			Action: func(c *cli.Context) {
-				subcommandRun = true
-			},
-		},
-	}
-
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "opt"},
-	}
-
-	// run with the After() func succeeding
-	err = app.Run([]string{"command", "--opt", "succeed", "sub"})
-
-	if err != nil {
-		t.Fatalf("Run error: %s", err)
-	}
-
-	if afterRun == false {
-		t.Errorf("After() not executed when expected")
-	}
-
-	if subcommandRun == false {
-		t.Errorf("Subcommand not executed when expected")
-	}
-
-	// reset
-	afterRun, subcommandRun = false, false
-
-	// run with the Before() func failing
-	err = app.Run([]string{"command", "--opt", "fail", "sub"})
-
-	// should be the same error produced by the Before func
-	if err != afterError {
-		t.Errorf("Run error expected, but not received")
-	}
-
-	if afterRun == false {
-		t.Errorf("After() not executed when expected")
-	}
-
-	if subcommandRun == false {
-		t.Errorf("Subcommand not executed when expected")
-	}
-}
-
-func TestAppNoHelpFlag(t *testing.T) {
-	oldFlag := cli.HelpFlag
-	defer func() {
-		cli.HelpFlag = oldFlag
-	}()
-
-	cli.HelpFlag = cli.BoolFlag{}
-
-	app := cli.NewApp()
-	err := app.Run([]string{"test", "-h"})
-
-	if err != flag.ErrHelp {
-		t.Errorf("expected error about missing help flag, but got: %s (%T)", err, err)
-	}
-}
-
-func TestAppHelpPrinter(t *testing.T) {
-	oldPrinter := cli.HelpPrinter
-	defer func() {
-		cli.HelpPrinter = oldPrinter
-	}()
-
-	var wasCalled = false
-	cli.HelpPrinter = func(template string, data interface{}) {
-		wasCalled = true
-	}
-
-	app := cli.NewApp()
-	app.Run([]string{"-h"})
-
-	if wasCalled == false {
-		t.Errorf("Help printer expected to be called, but was not")
-	}
-}
-
-func TestAppVersionPrinter(t *testing.T) {
-	oldPrinter := cli.VersionPrinter
-	defer func() {
-		cli.VersionPrinter = oldPrinter
-	}()
-
-	var wasCalled = false
-	cli.VersionPrinter = func(c *cli.Context) {
-		wasCalled = true
-	}
-
-	app := cli.NewApp()
-	ctx := cli.NewContext(app, nil, nil)
-	cli.ShowVersion(ctx)
-
-	if wasCalled == false {
-		t.Errorf("Version printer expected to be called, but was not")
-	}
-}
-
-func TestAppCommandNotFound(t *testing.T) {
-	beforeRun, subcommandRun := false, false
-	app := cli.NewApp()
-
-	app.CommandNotFound = func(c *cli.Context, command string) {
-		beforeRun = true
-	}
-
-	app.Commands = []cli.Command{
-		cli.Command{
-			Name: "bar",
-			Action: func(c *cli.Context) {
-				subcommandRun = true
-			},
-		},
-	}
-
-	app.Run([]string{"command", "foo"})
-
-	expect(t, beforeRun, true)
-	expect(t, subcommandRun, false)
-}
-
-func TestGlobalFlagsInSubcommands(t *testing.T) {
-	subcommandRun := false
-	app := cli.NewApp()
-
-	app.Flags = []cli.Flag{
-		cli.BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
-	}
-
-	app.Commands = []cli.Command{
-		cli.Command{
-			Name: "foo",
-			Subcommands: []cli.Command{
-				{
-					Name: "bar",
-					Action: func(c *cli.Context) {
-						if c.GlobalBool("debug") {
-							subcommandRun = true
-						}
-					},
-				},
-			},
-		},
-	}
-
-	app.Run([]string{"command", "-d", "foo", "bar"})
-
-	expect(t, subcommandRun, true)
-}

Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete

@@ -1,13 +0,0 @@
-#! /bin/bash
-
-_cli_bash_autocomplete() {
-     local cur prev opts base
-     COMPREPLY=()
-     cur="${COMP_WORDS[COMP_CWORD]}"
-     prev="${COMP_WORDS[COMP_CWORD-1]}"
-     opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
-     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
-     return 0
- }
-  
- complete -F _cli_bash_autocomplete $PROG

Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/zsh_autocomplete

@@ -1,5 +0,0 @@
-autoload -U compinit && compinit
-autoload -U bashcompinit && bashcompinit
-
-script_dir=$(dirname $0)
-source ${script_dir}/bash_autocomplete

Godeps/_workspace/src/github.com/codegangsta/cli/cli_test.go

@@ -1,100 +0,0 @@
-package cli_test
-
-import (
-	"os"
-
-	"github.com/codegangsta/cli"
-)
-
-func Example() {
-	app := cli.NewApp()
-	app.Name = "todo"
-	app.Usage = "task list on the command line"
-	app.Commands = []cli.Command{
-		{
-			Name:    "add",
-			Aliases: []string{"a"},
-			Usage:   "add a task to the list",
-			Action: func(c *cli.Context) {
-				println("added task: ", c.Args().First())
-			},
-		},
-		{
-			Name:    "complete",
-			Aliases: []string{"c"},
-			Usage:   "complete a task on the list",
-			Action: func(c *cli.Context) {
-				println("completed task: ", c.Args().First())
-			},
-		},
-	}
-
-	app.Run(os.Args)
-}
-
-func ExampleSubcommand() {
-	app := cli.NewApp()
-	app.Name = "say"
-	app.Commands = []cli.Command{
-		{
-			Name:        "hello",
-			Aliases:     []string{"hi"},
-			Usage:       "use it to see a description",
-			Description: "This is how we describe hello the function",
-			Subcommands: []cli.Command{
-				{
-					Name:        "english",
-					Aliases:     []string{"en"},
-					Usage:       "sends a greeting in english",
-					Description: "greets someone in english",
-					Flags: []cli.Flag{
-						cli.StringFlag{
-							Name:  "name",
-							Value: "Bob",
-							Usage: "Name of the person to greet",
-						},
-					},
-					Action: func(c *cli.Context) {
-						println("Hello, ", c.String("name"))
-					},
-				}, {
-					Name:    "spanish",
-					Aliases: []string{"sp"},
-					Usage:   "sends a greeting in spanish",
-					Flags: []cli.Flag{
-						cli.StringFlag{
-							Name:  "surname",
-							Value: "Jones",
-							Usage: "Surname of the person to greet",
-						},
-					},
-					Action: func(c *cli.Context) {
-						println("Hola, ", c.String("surname"))
-					},
-				}, {
-					Name:    "french",
-					Aliases: []string{"fr"},
-					Usage:   "sends a greeting in french",
-					Flags: []cli.Flag{
-						cli.StringFlag{
-							Name:  "nickname",
-							Value: "Stevie",
-							Usage: "Nickname of the person to greet",
-						},
-					},
-					Action: func(c *cli.Context) {
-						println("Bonjour, ", c.String("nickname"))
-					},
-				},
-			},
-		}, {
-			Name:  "bye",
-			Usage: "says goodbye",
-			Action: func(c *cli.Context) {
-				println("bye")
-			},
-		},
-	}
-
-	app.Run(os.Args)
-}

Godeps/_workspace/src/github.com/codegangsta/cli/command.go

@@ -1,177 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io/ioutil"
-	"strings"
-)
-
-// Command is a subcommand for a cli.App.
-type Command struct {
-	// The name of the command
-	Name string
-	// short name of the command. Typically one character (deprecated, use `Aliases`)
-	ShortName string
-	// A list of aliases for the command
-	Aliases []string
-	// A short description of the usage of this command
-	Usage string
-	// A longer explanation of how the command works
-	Description string
-	// The function to call when checking for bash command completions
-	BashComplete func(context *Context)
-	// An action to execute before any sub-subcommands are run, but after the context is ready
-	// If a non-nil error is returned, no sub-subcommands are run
-	Before func(context *Context) error
-	// An action to execute after any subcommands are run, but after the subcommand has finished
-	// It is run even if Action() panics
-	After func(context *Context) error
-	// The function to call when this command is invoked
-	Action func(context *Context)
-	// List of child commands
-	Subcommands []Command
-	// List of flags to parse
-	Flags []Flag
-	// Treat all flags as normal arguments if true
-	SkipFlagParsing bool
-	// Boolean to hide built-in help command
-	HideHelp bool
-}
-
-// Invokes the command given the context, parses ctx.Args() to generate command-specific flags
-func (c Command) Run(ctx *Context) error {
-
-	if len(c.Subcommands) > 0 || c.Before != nil || c.After != nil {
-		return c.startApp(ctx)
-	}
-
-	if !c.HideHelp && (HelpFlag != BoolFlag{}) {
-		// append help to flags
-		c.Flags = append(
-			c.Flags,
-			HelpFlag,
-		)
-	}
-
-	if ctx.App.EnableBashCompletion {
-		c.Flags = append(c.Flags, BashCompletionFlag)
-	}
-
-	set := flagSet(c.Name, c.Flags)
-	set.SetOutput(ioutil.Discard)
-
-	firstFlagIndex := -1
-	terminatorIndex := -1
-	for index, arg := range ctx.Args() {
-		if arg == "--" {
-			terminatorIndex = index
-			break
-		} else if strings.HasPrefix(arg, "-") && firstFlagIndex == -1 {
-			firstFlagIndex = index
-		}
-	}
-
-	var err error
-	if firstFlagIndex > -1 && !c.SkipFlagParsing {
-		args := ctx.Args()
-		regularArgs := make([]string, len(args[1:firstFlagIndex]))
-		copy(regularArgs, args[1:firstFlagIndex])
-
-		var flagArgs []string
-		if terminatorIndex > -1 {
-			flagArgs = args[firstFlagIndex:terminatorIndex]
-			regularArgs = append(regularArgs, args[terminatorIndex:]...)
-		} else {
-			flagArgs = args[firstFlagIndex:]
-		}
-
-		err = set.Parse(append(flagArgs, regularArgs...))
-	} else {
-		err = set.Parse(ctx.Args().Tail())
-	}
-
-	if err != nil {
-		fmt.Fprint(ctx.App.Writer, "Incorrect Usage.\n\n")
-		ShowCommandHelp(ctx, c.Name)
-		fmt.Fprintln(ctx.App.Writer)
-		return err
-	}
-
-	nerr := normalizeFlags(c.Flags, set)
-	if nerr != nil {
-		fmt.Fprintln(ctx.App.Writer, nerr)
-		fmt.Fprintln(ctx.App.Writer)
-		ShowCommandHelp(ctx, c.Name)
-		fmt.Fprintln(ctx.App.Writer)
-		return nerr
-	}
-	context := NewContext(ctx.App, set, ctx.globalSet)
-
-	if checkCommandCompletions(context, c.Name) {
-		return nil
-	}
-
-	if checkCommandHelp(context, c.Name) {
-		return nil
-	}
-	context.Command = c
-	c.Action(context)
-	return nil
-}
-
-func (c Command) Names() []string {
-	names := []string{c.Name}
-
-	if c.ShortName != "" {
-		names = append(names, c.ShortName)
-	}
-
-	return append(names, c.Aliases...)
-}
-
-// Returns true if Command.Name or Command.ShortName matches given name
-func (c Command) HasName(name string) bool {
-	for _, n := range c.Names() {
-		if n == name {
-			return true
-		}
-	}
-	return false
-}
-
-func (c Command) startApp(ctx *Context) error {
-	app := NewApp()
-
-	// set the name and usage
-	app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
-	if c.Description != "" {
-		app.Usage = c.Description
-	} else {
-		app.Usage = c.Usage
-	}
-
-	// set CommandNotFound
-	app.CommandNotFound = ctx.App.CommandNotFound
-
-	// set the flags and commands
-	app.Commands = c.Subcommands
-	app.Flags = c.Flags
-	app.HideHelp = c.HideHelp
-
-	// bash completion
-	app.EnableBashCompletion = ctx.App.EnableBashCompletion
-	if c.BashComplete != nil {
-		app.BashComplete = c.BashComplete
-	}
-
-	// set the actions
-	app.Before = c.Before
-	app.After = c.After
-	if c.Action != nil {
-		app.Action = c.Action
-	} else {
-		app.Action = helpSubcommand.Action
-	}
-
-	return app.RunAsSubcommand(ctx)
-}

Godeps/_workspace/src/github.com/codegangsta/cli/command_test.go

@@ -1,49 +0,0 @@
-package cli_test
-
-import (
-	"flag"
-	"testing"
-
-	"github.com/codegangsta/cli"
-)
-
-func TestCommandDoNotIgnoreFlags(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	test := []string{"blah", "blah", "-break"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, set)
-
-	command := cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action:      func(_ *cli.Context) {},
-	}
-	err := command.Run(c)
-
-	expect(t, err.Error(), "flag provided but not defined: -break")
-}
-
-func TestCommandIgnoreFlags(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	test := []string{"blah", "blah"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, set)
-
-	command := cli.Command{
-		Name:            "test-cmd",
-		Aliases:         []string{"tc"},
-		Usage:           "this is for testing",
-		Description:     "testing",
-		Action:          func(_ *cli.Context) {},
-		SkipFlagParsing: true,
-	}
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}

Godeps/_workspace/src/github.com/codegangsta/cli/context.go

@@ -1,344 +0,0 @@
-package cli
-
-import (
-	"errors"
-	"flag"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Context is a type that is passed through to
-// each Handler action in a cli application. Context
-// can be used to retrieve context-specific Args and
-// parsed command-line options.
-type Context struct {
-	App            *App
-	Command        Command
-	flagSet        *flag.FlagSet
-	globalSet      *flag.FlagSet
-	setFlags       map[string]bool
-	globalSetFlags map[string]bool
-}
-
-// Creates a new context. For use in when invoking an App or Command action.
-func NewContext(app *App, set *flag.FlagSet, globalSet *flag.FlagSet) *Context {
-	return &Context{App: app, flagSet: set, globalSet: globalSet}
-}
-
-// Looks up the value of a local int flag, returns 0 if no int flag exists
-func (c *Context) Int(name string) int {
-	return lookupInt(name, c.flagSet)
-}
-
-// Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists
-func (c *Context) Duration(name string) time.Duration {
-	return lookupDuration(name, c.flagSet)
-}
-
-// Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
-func (c *Context) Float64(name string) float64 {
-	return lookupFloat64(name, c.flagSet)
-}
-
-// Looks up the value of a local bool flag, returns false if no bool flag exists
-func (c *Context) Bool(name string) bool {
-	return lookupBool(name, c.flagSet)
-}
-
-// Looks up the value of a local boolT flag, returns false if no bool flag exists
-func (c *Context) BoolT(name string) bool {
-	return lookupBoolT(name, c.flagSet)
-}
-
-// Looks up the value of a local string flag, returns "" if no string flag exists
-func (c *Context) String(name string) string {
-	return lookupString(name, c.flagSet)
-}
-
-// Looks up the value of a local string slice flag, returns nil if no string slice flag exists
-func (c *Context) StringSlice(name string) []string {
-	return lookupStringSlice(name, c.flagSet)
-}
-
-// Looks up the value of a local int slice flag, returns nil if no int slice flag exists
-func (c *Context) IntSlice(name string) []int {
-	return lookupIntSlice(name, c.flagSet)
-}
-
-// Looks up the value of a local generic flag, returns nil if no generic flag exists
-func (c *Context) Generic(name string) interface{} {
-	return lookupGeneric(name, c.flagSet)
-}
-
-// Looks up the value of a global int flag, returns 0 if no int flag exists
-func (c *Context) GlobalInt(name string) int {
-	return lookupInt(name, c.globalSet)
-}
-
-// Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists
-func (c *Context) GlobalDuration(name string) time.Duration {
-	return lookupDuration(name, c.globalSet)
-}
-
-// Looks up the value of a global bool flag, returns false if no bool flag exists
-func (c *Context) GlobalBool(name string) bool {
-	return lookupBool(name, c.globalSet)
-}
-
-// Looks up the value of a global string flag, returns "" if no string flag exists
-func (c *Context) GlobalString(name string) string {
-	return lookupString(name, c.globalSet)
-}
-
-// Looks up the value of a global string slice flag, returns nil if no string slice flag exists
-func (c *Context) GlobalStringSlice(name string) []string {
-	return lookupStringSlice(name, c.globalSet)
-}
-
-// Looks up the value of a global int slice flag, returns nil if no int slice flag exists
-func (c *Context) GlobalIntSlice(name string) []int {
-	return lookupIntSlice(name, c.globalSet)
-}
-
-// Looks up the value of a global generic flag, returns nil if no generic flag exists
-func (c *Context) GlobalGeneric(name string) interface{} {
-	return lookupGeneric(name, c.globalSet)
-}
-
-// Returns the number of flags set
-func (c *Context) NumFlags() int {
-	return c.flagSet.NFlag()
-}
-
-// Determines if the flag was actually set
-func (c *Context) IsSet(name string) bool {
-	if c.setFlags == nil {
-		c.setFlags = make(map[string]bool)
-		c.flagSet.Visit(func(f *flag.Flag) {
-			c.setFlags[f.Name] = true
-		})
-	}
-	return c.setFlags[name] == true
-}
-
-// Determines if the global flag was actually set
-func (c *Context) GlobalIsSet(name string) bool {
-	if c.globalSetFlags == nil {
-		c.globalSetFlags = make(map[string]bool)
-		c.globalSet.Visit(func(f *flag.Flag) {
-			c.globalSetFlags[f.Name] = true
-		})
-	}
-	return c.globalSetFlags[name] == true
-}
-
-// Returns a slice of flag names used in this context.
-func (c *Context) FlagNames() (names []string) {
-	for _, flag := range c.Command.Flags {
-		name := strings.Split(flag.getName(), ",")[0]
-		if name == "help" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-// Returns a slice of global flag names used by the app.
-func (c *Context) GlobalFlagNames() (names []string) {
-	for _, flag := range c.App.Flags {
-		name := strings.Split(flag.getName(), ",")[0]
-		if name == "help" || name == "version" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-type Args []string
-
-// Returns the command line arguments associated with the context.
-func (c *Context) Args() Args {
-	args := Args(c.flagSet.Args())
-	return args
-}
-
-// Returns the nth argument, or else a blank string
-func (a Args) Get(n int) string {
-	if len(a) > n {
-		return a[n]
-	}
-	return ""
-}
-
-// Returns the first argument, or else a blank string
-func (a Args) First() string {
-	return a.Get(0)
-}
-
-// Return the rest of the arguments (not the first one)
-// or else an empty string slice
-func (a Args) Tail() []string {
-	if len(a) >= 2 {
-		return []string(a)[1:]
-	}
-	return []string{}
-}
-
-// Checks if there are any arguments present
-func (a Args) Present() bool {
-	return len(a) != 0
-}
-
-// Swaps arguments at the given indexes
-func (a Args) Swap(from, to int) error {
-	if from >= len(a) || to >= len(a) {
-		return errors.New("index out of range")
-	}
-	a[from], a[to] = a[to], a[from]
-	return nil
-}
-
-func lookupInt(name string, set *flag.FlagSet) int {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.Atoi(f.Value.String())
-		if err != nil {
-			return 0
-		}
-		return val
-	}
-
-	return 0
-}
-
-func lookupDuration(name string, set *flag.FlagSet) time.Duration {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := time.ParseDuration(f.Value.String())
-		if err == nil {
-			return val
-		}
-	}
-
-	return 0
-}
-
-func lookupFloat64(name string, set *flag.FlagSet) float64 {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.ParseFloat(f.Value.String(), 64)
-		if err != nil {
-			return 0
-		}
-		return val
-	}
-
-	return 0
-}
-
-func lookupString(name string, set *flag.FlagSet) string {
-	f := set.Lookup(name)
-	if f != nil {
-		return f.Value.String()
-	}
-
-	return ""
-}
-
-func lookupStringSlice(name string, set *flag.FlagSet) []string {
-	f := set.Lookup(name)
-	if f != nil {
-		return (f.Value.(*StringSlice)).Value()
-
-	}
-
-	return nil
-}
-
-func lookupIntSlice(name string, set *flag.FlagSet) []int {
-	f := set.Lookup(name)
-	if f != nil {
-		return (f.Value.(*IntSlice)).Value()
-
-	}
-
-	return nil
-}
-
-func lookupGeneric(name string, set *flag.FlagSet) interface{} {
-	f := set.Lookup(name)
-	if f != nil {
-		return f.Value
-	}
-	return nil
-}
-
-func lookupBool(name string, set *flag.FlagSet) bool {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.ParseBool(f.Value.String())
-		if err != nil {
-			return false
-		}
-		return val
-	}
-
-	return false
-}
-
-func lookupBoolT(name string, set *flag.FlagSet) bool {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.ParseBool(f.Value.String())
-		if err != nil {
-			return true
-		}
-		return val
-	}
-
-	return false
-}
-
-func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) {
-	switch ff.Value.(type) {
-	case *StringSlice:
-	default:
-		set.Set(name, ff.Value.String())
-	}
-}
-
-func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
-	visited := make(map[string]bool)
-	set.Visit(func(f *flag.Flag) {
-		visited[f.Name] = true
-	})
-	for _, f := range flags {
-		parts := strings.Split(f.getName(), ",")
-		if len(parts) == 1 {
-			continue
-		}
-		var ff *flag.Flag
-		for _, name := range parts {
-			name = strings.Trim(name, " ")
-			if visited[name] {
-				if ff != nil {
-					return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
-				}
-				ff = set.Lookup(name)
-			}
-		}
-		if ff == nil {
-			continue
-		}
-		for _, name := range parts {
-			name = strings.Trim(name, " ")
-			if !visited[name] {
-				copyFlag(name, ff, set)
-			}
-		}
-	}
-	return nil
-}

Godeps/_workspace/src/github.com/codegangsta/cli/context_test.go

@@ -1,111 +0,0 @@
-package cli_test
-
-import (
-	"flag"
-	"testing"
-	"time"
-
-	"github.com/codegangsta/cli"
-)
-
-func TestNewContext(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int("myflag", 12, "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Int("myflag", 42, "doc")
-	command := cli.Command{Name: "mycommand"}
-	c := cli.NewContext(nil, set, globalSet)
-	c.Command = command
-	expect(t, c.Int("myflag"), 12)
-	expect(t, c.GlobalInt("myflag"), 42)
-	expect(t, c.Command.Name, "mycommand")
-}
-
-func TestContext_Int(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int("myflag", 12, "doc")
-	c := cli.NewContext(nil, set, set)
-	expect(t, c.Int("myflag"), 12)
-}
-
-func TestContext_Duration(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Duration("myflag", time.Duration(12*time.Second), "doc")
-	c := cli.NewContext(nil, set, set)
-	expect(t, c.Duration("myflag"), time.Duration(12*time.Second))
-}
-
-func TestContext_String(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.String("myflag", "hello world", "doc")
-	c := cli.NewContext(nil, set, set)
-	expect(t, c.String("myflag"), "hello world")
-}
-
-func TestContext_Bool(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	c := cli.NewContext(nil, set, set)
-	expect(t, c.Bool("myflag"), false)
-}
-
-func TestContext_BoolT(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", true, "doc")
-	c := cli.NewContext(nil, set, set)
-	expect(t, c.BoolT("myflag"), true)
-}
-
-func TestContext_Args(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	c := cli.NewContext(nil, set, set)
-	set.Parse([]string{"--myflag", "bat", "baz"})
-	expect(t, len(c.Args()), 2)
-	expect(t, c.Bool("myflag"), true)
-}
-
-func TestContext_IsSet(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	set.String("otherflag", "hello world", "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Bool("myflagGlobal", true, "doc")
-	c := cli.NewContext(nil, set, globalSet)
-	set.Parse([]string{"--myflag", "bat", "baz"})
-	globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
-	expect(t, c.IsSet("myflag"), true)
-	expect(t, c.IsSet("otherflag"), false)
-	expect(t, c.IsSet("bogusflag"), false)
-	expect(t, c.IsSet("myflagGlobal"), false)
-}
-
-func TestContext_GlobalIsSet(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	set.String("otherflag", "hello world", "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Bool("myflagGlobal", true, "doc")
-	globalSet.Bool("myflagGlobalUnset", true, "doc")
-	c := cli.NewContext(nil, set, globalSet)
-	set.Parse([]string{"--myflag", "bat", "baz"})
-	globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
-	expect(t, c.GlobalIsSet("myflag"), false)
-	expect(t, c.GlobalIsSet("otherflag"), false)
-	expect(t, c.GlobalIsSet("bogusflag"), false)
-	expect(t, c.GlobalIsSet("myflagGlobal"), true)
-	expect(t, c.GlobalIsSet("myflagGlobalUnset"), false)
-	expect(t, c.GlobalIsSet("bogusGlobal"), false)
-}
-
-func TestContext_NumFlags(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	set.String("otherflag", "hello world", "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Bool("myflagGlobal", true, "doc")
-	c := cli.NewContext(nil, set, globalSet)
-	set.Parse([]string{"--myflag", "--otherflag=foo"})
-	globalSet.Parse([]string{"--myflagGlobal"})
-	expect(t, c.NumFlags(), 2)
-}

Godeps/_workspace/src/github.com/codegangsta/cli/flag.go

@@ -1,454 +0,0 @@
-package cli
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// This flag enables bash-completion for all commands and subcommands
-var BashCompletionFlag = BoolFlag{
-	Name: "generate-bash-completion",
-}
-
-// This flag prints the version for the application
-var VersionFlag = BoolFlag{
-	Name:  "version, v",
-	Usage: "print the version",
-}
-
-// This flag prints the help for all commands and subcommands
-// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
-// unless HideHelp is set to true)
-var HelpFlag = BoolFlag{
-	Name:  "help, h",
-	Usage: "show help",
-}
-
-// Flag is a common interface related to parsing flags in cli.
-// For more advanced flag parsing techniques, it is recomended that
-// this interface be implemented.
-type Flag interface {
-	fmt.Stringer
-	// Apply Flag settings to the given flag set
-	Apply(*flag.FlagSet)
-	getName() string
-}
-
-func flagSet(name string, flags []Flag) *flag.FlagSet {
-	set := flag.NewFlagSet(name, flag.ContinueOnError)
-
-	for _, f := range flags {
-		f.Apply(set)
-	}
-	return set
-}
-
-func eachName(longName string, fn func(string)) {
-	parts := strings.Split(longName, ",")
-	for _, name := range parts {
-		name = strings.Trim(name, " ")
-		fn(name)
-	}
-}
-
-// Generic is a generic parseable type identified by a specific flag
-type Generic interface {
-	Set(value string) error
-	String() string
-}
-
-// GenericFlag is the flag type for types implementing Generic
-type GenericFlag struct {
-	Name   string
-	Value  Generic
-	Usage  string
-	EnvVar string
-}
-
-// String returns the string representation of the generic flag to display the
-// help text to the user (uses the String() method of the generic flag to show
-// the value)
-func (f GenericFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s%s \"%v\"\t%v", prefixFor(f.Name), f.Name, f.Value, f.Usage))
-}
-
-// Apply takes the flagset and calls Set on the generic flag with the value
-// provided by the user for parsing by the flag
-func (f GenericFlag) Apply(set *flag.FlagSet) {
-	val := f.Value
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				val.Set(envVal)
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Var(f.Value, name, f.Usage)
-	})
-}
-
-func (f GenericFlag) getName() string {
-	return f.Name
-}
-
-type StringSlice []string
-
-func (f *StringSlice) Set(value string) error {
-	*f = append(*f, value)
-	return nil
-}
-
-func (f *StringSlice) String() string {
-	return fmt.Sprintf("%s", *f)
-}
-
-func (f *StringSlice) Value() []string {
-	return *f
-}
-
-type StringSliceFlag struct {
-	Name   string
-	Value  *StringSlice
-	Usage  string
-	EnvVar string
-}
-
-func (f StringSliceFlag) String() string {
-	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
-	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
-}
-
-func (f StringSliceFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				newVal := &StringSlice{}
-				for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
-					newVal.Set(s)
-				}
-				f.Value = newVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Var(f.Value, name, f.Usage)
-	})
-}
-
-func (f StringSliceFlag) getName() string {
-	return f.Name
-}
-
-type IntSlice []int
-
-func (f *IntSlice) Set(value string) error {
-
-	tmp, err := strconv.Atoi(value)
-	if err != nil {
-		return err
-	} else {
-		*f = append(*f, tmp)
-	}
-	return nil
-}
-
-func (f *IntSlice) String() string {
-	return fmt.Sprintf("%d", *f)
-}
-
-func (f *IntSlice) Value() []int {
-	return *f
-}
-
-type IntSliceFlag struct {
-	Name   string
-	Value  *IntSlice
-	Usage  string
-	EnvVar string
-}
-
-func (f IntSliceFlag) String() string {
-	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
-	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
-}
-
-func (f IntSliceFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				newVal := &IntSlice{}
-				for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
-					err := newVal.Set(s)
-					if err != nil {
-						fmt.Fprintf(os.Stderr, err.Error())
-					}
-				}
-				f.Value = newVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Var(f.Value, name, f.Usage)
-	})
-}
-
-func (f IntSliceFlag) getName() string {
-	return f.Name
-}
-
-type BoolFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
-}
-
-func (f BoolFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
-}
-
-func (f BoolFlag) Apply(set *flag.FlagSet) {
-	val := false
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValBool, err := strconv.ParseBool(envVal)
-				if err == nil {
-					val = envValBool
-				}
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Bool(name, val, f.Usage)
-	})
-}
-
-func (f BoolFlag) getName() string {
-	return f.Name
-}
-
-type BoolTFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
-}
-
-func (f BoolTFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
-}
-
-func (f BoolTFlag) Apply(set *flag.FlagSet) {
-	val := true
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValBool, err := strconv.ParseBool(envVal)
-				if err == nil {
-					val = envValBool
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Bool(name, val, f.Usage)
-	})
-}
-
-func (f BoolTFlag) getName() string {
-	return f.Name
-}
-
-type StringFlag struct {
-	Name   string
-	Value  string
-	Usage  string
-	EnvVar string
-}
-
-func (f StringFlag) String() string {
-	var fmtString string
-	fmtString = "%s %v\t%v"
-
-	if len(f.Value) > 0 {
-		fmtString = "%s \"%v\"\t%v"
-	} else {
-		fmtString = "%s %v\t%v"
-	}
-
-	return withEnvHint(f.EnvVar, fmt.Sprintf(fmtString, prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-func (f StringFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				f.Value = envVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.String(name, f.Value, f.Usage)
-	})
-}
-
-func (f StringFlag) getName() string {
-	return f.Name
-}
-
-type IntFlag struct {
-	Name   string
-	Value  int
-	Usage  string
-	EnvVar string
-}
-
-func (f IntFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-func (f IntFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValInt, err := strconv.ParseInt(envVal, 0, 64)
-				if err == nil {
-					f.Value = int(envValInt)
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Int(name, f.Value, f.Usage)
-	})
-}
-
-func (f IntFlag) getName() string {
-	return f.Name
-}
-
-type DurationFlag struct {
-	Name   string
-	Value  time.Duration
-	Usage  string
-	EnvVar string
-}
-
-func (f DurationFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-func (f DurationFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValDuration, err := time.ParseDuration(envVal)
-				if err == nil {
-					f.Value = envValDuration
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Duration(name, f.Value, f.Usage)
-	})
-}
-
-func (f DurationFlag) getName() string {
-	return f.Name
-}
-
-type Float64Flag struct {
-	Name   string
-	Value  float64
-	Usage  string
-	EnvVar string
-}
-
-func (f Float64Flag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-func (f Float64Flag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValFloat, err := strconv.ParseFloat(envVal, 10)
-				if err == nil {
-					f.Value = float64(envValFloat)
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Float64(name, f.Value, f.Usage)
-	})
-}
-
-func (f Float64Flag) getName() string {
-	return f.Name
-}
-
-func prefixFor(name string) (prefix string) {
-	if len(name) == 1 {
-		prefix = "-"
-	} else {
-		prefix = "--"
-	}
-
-	return
-}
-
-func prefixedNames(fullName string) (prefixed string) {
-	parts := strings.Split(fullName, ",")
-	for i, name := range parts {
-		name = strings.Trim(name, " ")
-		prefixed += prefixFor(name) + name
-		if i < len(parts)-1 {
-			prefixed += ", "
-		}
-	}
-	return
-}
-
-func withEnvHint(envVar, str string) string {
-	envText := ""
-	if envVar != "" {
-		envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
-	}
-	return str + envText
-}

Godeps/_workspace/src/github.com/codegangsta/cli/flag_test.go

@@ -1,742 +0,0 @@
-package cli_test
-
-import (
-	"fmt"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/codegangsta/cli"
-)
-
-var boolFlagTests = []struct {
-	name     string
-	expected string
-}{
-	{"help", "--help\t"},
-	{"h", "-h\t"},
-}
-
-func TestBoolFlagHelpOutput(t *testing.T) {
-
-	for _, test := range boolFlagTests {
-		flag := cli.BoolFlag{Name: test.name}
-		output := flag.String()
-
-		if output != test.expected {
-			t.Errorf("%s does not match %s", output, test.expected)
-		}
-	}
-}
-
-var stringFlagTests = []struct {
-	name     string
-	value    string
-	expected string
-}{
-	{"help", "", "--help \t"},
-	{"h", "", "-h \t"},
-	{"h", "", "-h \t"},
-	{"test", "Something", "--test \"Something\"\t"},
-}
-
-func TestStringFlagHelpOutput(t *testing.T) {
-
-	for _, test := range stringFlagTests {
-		flag := cli.StringFlag{Name: test.name, Value: test.value}
-		output := flag.String()
-
-		if output != test.expected {
-			t.Errorf("%s does not match %s", output, test.expected)
-		}
-	}
-}
-
-func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_FOO", "derp")
-	for _, test := range stringFlagTests {
-		flag := cli.StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
-		output := flag.String()
-
-		if !strings.HasSuffix(output, " [$APP_FOO]") {
-			t.Errorf("%s does not end with [$APP_FOO]", output)
-		}
-	}
-}
-
-var stringSliceFlagTests = []struct {
-	name     string
-	value    *cli.StringSlice
-	expected string
-}{
-	{"help", func() *cli.StringSlice {
-		s := &cli.StringSlice{}
-		s.Set("")
-		return s
-	}(), "--help [--help option --help option]\t"},
-	{"h", func() *cli.StringSlice {
-		s := &cli.StringSlice{}
-		s.Set("")
-		return s
-	}(), "-h [-h option -h option]\t"},
-	{"h", func() *cli.StringSlice {
-		s := &cli.StringSlice{}
-		s.Set("")
-		return s
-	}(), "-h [-h option -h option]\t"},
-	{"test", func() *cli.StringSlice {
-		s := &cli.StringSlice{}
-		s.Set("Something")
-		return s
-	}(), "--test [--test option --test option]\t"},
-}
-
-func TestStringSliceFlagHelpOutput(t *testing.T) {
-
-	for _, test := range stringSliceFlagTests {
-		flag := cli.StringSliceFlag{Name: test.name, Value: test.value}
-		output := flag.String()
-
-		if output != test.expected {
-			t.Errorf("%q does not match %q", output, test.expected)
-		}
-	}
-}
-
-func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_QWWX", "11,4")
-	for _, test := range stringSliceFlagTests {
-		flag := cli.StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
-		output := flag.String()
-
-		if !strings.HasSuffix(output, " [$APP_QWWX]") {
-			t.Errorf("%q does not end with [$APP_QWWX]", output)
-		}
-	}
-}
-
-var intFlagTests = []struct {
-	name     string
-	expected string
-}{
-	{"help", "--help \"0\"\t"},
-	{"h", "-h \"0\"\t"},
-}
-
-func TestIntFlagHelpOutput(t *testing.T) {
-
-	for _, test := range intFlagTests {
-		flag := cli.IntFlag{Name: test.name}
-		output := flag.String()
-
-		if output != test.expected {
-			t.Errorf("%s does not match %s", output, test.expected)
-		}
-	}
-}
-
-func TestIntFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_BAR", "2")
-	for _, test := range intFlagTests {
-		flag := cli.IntFlag{Name: test.name, EnvVar: "APP_BAR"}
-		output := flag.String()
-
-		if !strings.HasSuffix(output, " [$APP_BAR]") {
-			t.Errorf("%s does not end with [$APP_BAR]", output)
-		}
-	}
-}
-
-var durationFlagTests = []struct {
-	name     string
-	expected string
-}{
-	{"help", "--help \"0\"\t"},
-	{"h", "-h \"0\"\t"},
-}
-
-func TestDurationFlagHelpOutput(t *testing.T) {
-
-	for _, test := range durationFlagTests {
-		flag := cli.DurationFlag{Name: test.name}
-		output := flag.String()
-
-		if output != test.expected {
-			t.Errorf("%s does not match %s", output, test.expected)
-		}
-	}
-}
-
-func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_BAR", "2h3m6s")
-	for _, test := range durationFlagTests {
-		flag := cli.DurationFlag{Name: test.name, EnvVar: "APP_BAR"}
-		output := flag.String()
-
-		if !strings.HasSuffix(output, " [$APP_BAR]") {
-			t.Errorf("%s does not end with [$APP_BAR]", output)
-		}
-	}
-}
-
-var intSliceFlagTests = []struct {
-	name     string
-	value    *cli.IntSlice
-	expected string
-}{
-	{"help", &cli.IntSlice{}, "--help [--help option --help option]\t"},
-	{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"},
-	{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"},
-	{"test", func() *cli.IntSlice {
-		i := &cli.IntSlice{}
-		i.Set("9")
-		return i
-	}(), "--test [--test option --test option]\t"},
-}
-
-func TestIntSliceFlagHelpOutput(t *testing.T) {
-
-	for _, test := range intSliceFlagTests {
-		flag := cli.IntSliceFlag{Name: test.name, Value: test.value}
-		output := flag.String()
-
-		if output != test.expected {
-			t.Errorf("%q does not match %q", output, test.expected)
-		}
-	}
-}
-
-func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_SMURF", "42,3")
-	for _, test := range intSliceFlagTests {
-		flag := cli.IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
-		output := flag.String()
-
-		if !strings.HasSuffix(output, " [$APP_SMURF]") {
-			t.Errorf("%q does not end with [$APP_SMURF]", output)
-		}
-	}
-}
-
-var float64FlagTests = []struct {
-	name     string
-	expected string
-}{
-	{"help", "--help \"0\"\t"},
-	{"h", "-h \"0\"\t"},
-}
-
-func TestFloat64FlagHelpOutput(t *testing.T) {
-
-	for _, test := range float64FlagTests {
-		flag := cli.Float64Flag{Name: test.name}
-		output := flag.String()
-
-		if output != test.expected {
-			t.Errorf("%s does not match %s", output, test.expected)
-		}
-	}
-}
-
-func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_BAZ", "99.4")
-	for _, test := range float64FlagTests {
-		flag := cli.Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
-		output := flag.String()
-
-		if !strings.HasSuffix(output, " [$APP_BAZ]") {
-			t.Errorf("%s does not end with [$APP_BAZ]", output)
-		}
-	}
-}
-
-var genericFlagTests = []struct {
-	name     string
-	value    cli.Generic
-	expected string
-}{
-	{"test", &Parser{"abc", "def"}, "--test \"abc,def\"\ttest flag"},
-	{"t", &Parser{"abc", "def"}, "-t \"abc,def\"\ttest flag"},
-}
-
-func TestGenericFlagHelpOutput(t *testing.T) {
-
-	for _, test := range genericFlagTests {
-		flag := cli.GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"}
-		output := flag.String()
-
-		if output != test.expected {
-			t.Errorf("%q does not match %q", output, test.expected)
-		}
-	}
-}
-
-func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_ZAP", "3")
-	for _, test := range genericFlagTests {
-		flag := cli.GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
-		output := flag.String()
-
-		if !strings.HasSuffix(output, " [$APP_ZAP]") {
-			t.Errorf("%s does not end with [$APP_ZAP]", output)
-		}
-	}
-}
-
-func TestParseMultiString(t *testing.T) {
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "serve, s"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.String("serve") != "10" {
-				t.Errorf("main name not set")
-			}
-			if ctx.String("s") != "10" {
-				t.Errorf("short name not set")
-			}
-		},
-	}).Run([]string{"run", "-s", "10"})
-}
-
-func TestParseMultiStringFromEnv(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_COUNT", "20")
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.String("count") != "20" {
-				t.Errorf("main name not set")
-			}
-			if ctx.String("c") != "20" {
-				t.Errorf("short name not set")
-			}
-		},
-	}).Run([]string{"run"})
-}
-
-func TestParseMultiStringFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_COUNT", "20")
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.String("count") != "20" {
-				t.Errorf("main name not set")
-			}
-			if ctx.String("c") != "20" {
-				t.Errorf("short name not set")
-			}
-		},
-	}).Run([]string{"run"})
-}
-
-func TestParseMultiStringSlice(t *testing.T) {
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringSliceFlag{Name: "serve, s", Value: &cli.StringSlice{}},
-		},
-		Action: func(ctx *cli.Context) {
-			if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) {
-				t.Errorf("main name not set")
-			}
-			if !reflect.DeepEqual(ctx.StringSlice("s"), []string{"10", "20"}) {
-				t.Errorf("short name not set")
-			}
-		},
-	}).Run([]string{"run", "-s", "10", "-s", "20"})
-}
-
-func TestParseMultiStringSliceFromEnv(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_INTERVALS", "20,30,40")
-
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "APP_INTERVALS"},
-		},
-		Action: func(ctx *cli.Context) {
-			if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
-				t.Errorf("main name not set from env")
-			}
-			if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}).Run([]string{"run"})
-}
-
-func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_INTERVALS", "20,30,40")
-
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
-		},
-		Action: func(ctx *cli.Context) {
-			if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
-				t.Errorf("main name not set from env")
-			}
-			if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}).Run([]string{"run"})
-}
-
-func TestParseMultiInt(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.IntFlag{Name: "serve, s"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.Int("serve") != 10 {
-				t.Errorf("main name not set")
-			}
-			if ctx.Int("s") != 10 {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run", "-s", "10"})
-}
-
-func TestParseMultiIntFromEnv(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_TIMEOUT_SECONDS", "10")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.Int("timeout") != 10 {
-				t.Errorf("main name not set")
-			}
-			if ctx.Int("t") != 10 {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiIntFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_TIMEOUT_SECONDS", "10")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.Int("timeout") != 10 {
-				t.Errorf("main name not set")
-			}
-			if ctx.Int("t") != 10 {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiIntSlice(t *testing.T) {
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.IntSliceFlag{Name: "serve, s", Value: &cli.IntSlice{}},
-		},
-		Action: func(ctx *cli.Context) {
-			if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) {
-				t.Errorf("main name not set")
-			}
-			if !reflect.DeepEqual(ctx.IntSlice("s"), []int{10, 20}) {
-				t.Errorf("short name not set")
-			}
-		},
-	}).Run([]string{"run", "-s", "10", "-s", "20"})
-}
-
-func TestParseMultiIntSliceFromEnv(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_INTERVALS", "20,30,40")
-
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "APP_INTERVALS"},
-		},
-		Action: func(ctx *cli.Context) {
-			if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
-				t.Errorf("main name not set from env")
-			}
-			if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}).Run([]string{"run"})
-}
-
-func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_INTERVALS", "20,30,40")
-
-	(&cli.App{
-		Flags: []cli.Flag{
-			cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
-		},
-		Action: func(ctx *cli.Context) {
-			if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
-				t.Errorf("main name not set from env")
-			}
-			if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}).Run([]string{"run"})
-}
-
-func TestParseMultiFloat64(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.Float64Flag{Name: "serve, s"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.Float64("serve") != 10.2 {
-				t.Errorf("main name not set")
-			}
-			if ctx.Float64("s") != 10.2 {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run", "-s", "10.2"})
-}
-
-func TestParseMultiFloat64FromEnv(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.Float64("timeout") != 15.5 {
-				t.Errorf("main name not set")
-			}
-			if ctx.Float64("t") != 15.5 {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.Float64("timeout") != 15.5 {
-				t.Errorf("main name not set")
-			}
-			if ctx.Float64("t") != 15.5 {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiBool(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolFlag{Name: "serve, s"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.Bool("serve") != true {
-				t.Errorf("main name not set")
-			}
-			if ctx.Bool("s") != true {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run", "--serve"})
-}
-
-func TestParseMultiBoolFromEnv(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_DEBUG", "1")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.Bool("debug") != true {
-				t.Errorf("main name not set from env")
-			}
-			if ctx.Bool("d") != true {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiBoolFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_DEBUG", "1")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.Bool("debug") != true {
-				t.Errorf("main name not set from env")
-			}
-			if ctx.Bool("d") != true {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiBoolT(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolTFlag{Name: "serve, s"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.BoolT("serve") != true {
-				t.Errorf("main name not set")
-			}
-			if ctx.BoolT("s") != true {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run", "--serve"})
-}
-
-func TestParseMultiBoolTFromEnv(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_DEBUG", "0")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.BoolT("debug") != false {
-				t.Errorf("main name not set from env")
-			}
-			if ctx.BoolT("d") != false {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiBoolTFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_DEBUG", "0")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
-		},
-		Action: func(ctx *cli.Context) {
-			if ctx.BoolT("debug") != false {
-				t.Errorf("main name not set from env")
-			}
-			if ctx.BoolT("d") != false {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-type Parser [2]string
-
-func (p *Parser) Set(value string) error {
-	parts := strings.Split(value, ",")
-	if len(parts) != 2 {
-		return fmt.Errorf("invalid format")
-	}
-
-	(*p)[0] = parts[0]
-	(*p)[1] = parts[1]
-
-	return nil
-}
-
-func (p *Parser) String() string {
-	return fmt.Sprintf("%s,%s", p[0], p[1])
-}
-
-func TestParseGeneric(t *testing.T) {
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.GenericFlag{Name: "serve, s", Value: &Parser{}},
-		},
-		Action: func(ctx *cli.Context) {
-			if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) {
-				t.Errorf("main name not set")
-			}
-			if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"10", "20"}) {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run", "-s", "10,20"})
-}
-
-func TestParseGenericFromEnv(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_SERVE", "20,30")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
-		},
-		Action: func(ctx *cli.Context) {
-			if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) {
-				t.Errorf("main name not set from env")
-			}
-			if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"20", "30"}) {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseGenericFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_FOO", "99,2000")
-	a := cli.App{
-		Flags: []cli.Flag{
-			cli.GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"},
-		},
-		Action: func(ctx *cli.Context) {
-			if !reflect.DeepEqual(ctx.Generic("foos"), &Parser{"99", "2000"}) {
-				t.Errorf("value not set from env")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}

Godeps/_workspace/src/github.com/codegangsta/cli/help.go

@@ -1,215 +0,0 @@
-package cli
-
-import "fmt"
-
-// The text template for the Default help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var AppHelpTemplate = `NAME:
-   {{.Name}} - {{.Usage}}
-
-USAGE:
-   {{.Name}} {{if .Flags}}[global options] {{end}}command{{if .Flags}} [command options]{{end}} [arguments...]
-
-VERSION:
-   {{.Version}}
-
-AUTHOR(S): 
-   {{range .Authors}}{{ . }}
-   {{end}}
-COMMANDS:
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-   {{end}}{{if .Flags}}
-GLOBAL OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{end}}
-`
-
-// The text template for the command help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var CommandHelpTemplate = `NAME:
-   {{.Name}} - {{.Usage}}
-
-USAGE:
-   command {{.Name}}{{if .Flags}} [command options]{{end}} [arguments...]{{if .Description}}
-
-DESCRIPTION:
-   {{.Description}}{{end}}{{if .Flags}}
-
-OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{ end }}
-`
-
-// The text template for the subcommand help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var SubcommandHelpTemplate = `NAME:
-   {{.Name}} - {{.Usage}}
-
-USAGE:
-   {{.Name}} command{{if .Flags}} [command options]{{end}} [arguments...]
-
-COMMANDS:
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-   {{end}}{{if .Flags}}
-OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{end}}
-`
-
-var helpCommand = Command{
-	Name:    "help",
-	Aliases: []string{"h"},
-	Usage:   "Shows a list of commands or help for one command",
-	Action: func(c *Context) {
-		args := c.Args()
-		if args.Present() {
-			ShowCommandHelp(c, args.First())
-		} else {
-			ShowAppHelp(c)
-		}
-	},
-}
-
-var helpSubcommand = Command{
-	Name:    "help",
-	Aliases: []string{"h"},
-	Usage:   "Shows a list of commands or help for one command",
-	Action: func(c *Context) {
-		args := c.Args()
-		if args.Present() {
-			ShowCommandHelp(c, args.First())
-		} else {
-			ShowSubcommandHelp(c)
-		}
-	},
-}
-
-// Prints help for the App
-type helpPrinter func(templ string, data interface{})
-
-var HelpPrinter helpPrinter = nil
-
-// Prints version for the App
-var VersionPrinter = printVersion
-
-func ShowAppHelp(c *Context) {
-	HelpPrinter(AppHelpTemplate, c.App)
-}
-
-// Prints the list of subcommands as the default app completion method
-func DefaultAppComplete(c *Context) {
-	for _, command := range c.App.Commands {
-		for _, name := range command.Names() {
-			fmt.Fprintln(c.App.Writer, name)
-		}
-	}
-}
-
-// Prints help for the given command
-func ShowCommandHelp(c *Context, command string) {
-	// show the subcommand help for a command with subcommands
-	if command == "" {
-		HelpPrinter(SubcommandHelpTemplate, c.App)
-		return
-	}
-
-	for _, c := range c.App.Commands {
-		if c.HasName(command) {
-			HelpPrinter(CommandHelpTemplate, c)
-			return
-		}
-	}
-
-	if c.App.CommandNotFound != nil {
-		c.App.CommandNotFound(c, command)
-	} else {
-		fmt.Fprintf(c.App.Writer, "No help topic for '%v'\n", command)
-	}
-}
-
-// Prints help for the given subcommand
-func ShowSubcommandHelp(c *Context) {
-	ShowCommandHelp(c, c.Command.Name)
-}
-
-// Prints the version number of the App
-func ShowVersion(c *Context) {
-	VersionPrinter(c)
-}
-
-func printVersion(c *Context) {
-	fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
-}
-
-// Prints the lists of commands within a given context
-func ShowCompletions(c *Context) {
-	a := c.App
-	if a != nil && a.BashComplete != nil {
-		a.BashComplete(c)
-	}
-}
-
-// Prints the custom completions for a given command
-func ShowCommandCompletions(ctx *Context, command string) {
-	c := ctx.App.Command(command)
-	if c != nil && c.BashComplete != nil {
-		c.BashComplete(ctx)
-	}
-}
-
-func checkVersion(c *Context) bool {
-	if c.GlobalBool("version") {
-		ShowVersion(c)
-		return true
-	}
-
-	return false
-}
-
-func checkHelp(c *Context) bool {
-	if c.GlobalBool("h") || c.GlobalBool("help") {
-		ShowAppHelp(c)
-		return true
-	}
-
-	return false
-}
-
-func checkCommandHelp(c *Context, name string) bool {
-	if c.Bool("h") || c.Bool("help") {
-		ShowCommandHelp(c, name)
-		return true
-	}
-
-	return false
-}
-
-func checkSubcommandHelp(c *Context) bool {
-	if c.GlobalBool("h") || c.GlobalBool("help") {
-		ShowSubcommandHelp(c)
-		return true
-	}
-
-	return false
-}
-
-func checkCompletions(c *Context) bool {
-	if (c.GlobalBool(BashCompletionFlag.Name) || c.Bool(BashCompletionFlag.Name)) && c.App.EnableBashCompletion {
-		ShowCompletions(c)
-		return true
-	}
-
-	return false
-}
-
-func checkCommandCompletions(c *Context, name string) bool {
-	if c.Bool(BashCompletionFlag.Name) && c.App.EnableBashCompletion {
-		ShowCommandCompletions(c, name)
-		return true
-	}
-
-	return false
-}

Godeps/_workspace/src/github.com/codegangsta/cli/helpers_test.go

@@ -1,19 +0,0 @@
-package cli_test
-
-import (
-	"reflect"
-	"testing"
-)
-
-/* Test Helpers */
-func expect(t *testing.T, a interface{}, b interface{}) {
-	if a != b {
-		t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}
-
-func refute(t *testing.T, a interface{}, b interface{}) {
-	if a == b {
-		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common_test.go

@@ -1,298 +0,0 @@
-/*
- * Copyright (c) 2013 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_test
-
-import (
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-// custom type to test Stinger interface on non-pointer receiver.
-type stringer string
-
-// String implements the Stringer interface for testing invocation of custom
-// stringers on types with non-pointer receivers.
-func (s stringer) String() string {
-	return "stringer " + string(s)
-}
-
-// custom type to test Stinger interface on pointer receiver.
-type pstringer string
-
-// String implements the Stringer interface for testing invocation of custom
-// stringers on types with only pointer receivers.
-func (s *pstringer) String() string {
-	return "stringer " + string(*s)
-}
-
-// xref1 and xref2 are cross referencing structs for testing circular reference
-// detection.
-type xref1 struct {
-	ps2 *xref2
-}
-type xref2 struct {
-	ps1 *xref1
-}
-
-// indirCir1, indirCir2, and indirCir3 are used to generate an indirect circular
-// reference for testing detection.
-type indirCir1 struct {
-	ps2 *indirCir2
-}
-type indirCir2 struct {
-	ps3 *indirCir3
-}
-type indirCir3 struct {
-	ps1 *indirCir1
-}
-
-// embed is used to test embedded structures.
-type embed struct {
-	a string
-}
-
-// embedwrap is used to test embedded structures.
-type embedwrap struct {
-	*embed
-	e *embed
-}
-
-// panicer is used to intentionally cause a panic for testing spew properly
-// handles them
-type panicer int
-
-func (p panicer) String() string {
-	panic("test panic")
-}
-
-// customError is used to test custom error interface invocation.
-type customError int
-
-func (e customError) Error() string {
-	return fmt.Sprintf("error: %d", int(e))
-}
-
-// stringizeWants converts a slice of wanted test output into a format suitable
-// for a test error message.
-func stringizeWants(wants []string) string {
-	s := ""
-	for i, want := range wants {
-		if i > 0 {
-			s += fmt.Sprintf("want%d: %s", i+1, want)
-		} else {
-			s += "want: " + want
-		}
-	}
-	return s
-}
-
-// testFailed returns whether or not a test failed by checking if the result
-// of the test is in the slice of wanted strings.
-func testFailed(result string, wants []string) bool {
-	for _, want := range wants {
-		if result == want {
-			return false
-		}
-	}
-	return true
-}
-
-type sortableStruct struct {
-	x int
-}
-
-func (ss sortableStruct) String() string {
-	return fmt.Sprintf("ss.%d", ss.x)
-}
-
-type unsortableStruct struct {
-	x int
-}
-
-type sortTestCase struct {
-	input    []reflect.Value
-	expected []reflect.Value
-}
-
-func helpTestSortValues(tests []sortTestCase, cs *spew.ConfigState, t *testing.T) {
-	getInterfaces := func(values []reflect.Value) []interface{} {
-		interfaces := []interface{}{}
-		for _, v := range values {
-			interfaces = append(interfaces, v.Interface())
-		}
-		return interfaces
-	}
-
-	for _, test := range tests {
-		spew.SortValues(test.input, cs)
-		// reflect.DeepEqual cannot really make sense of reflect.Value,
-		// probably because of all the pointer tricks. For instance,
-		// v(2.0) != v(2.0) on a 32-bits system. Turn them into interface{}
-		// instead.
-		input := getInterfaces(test.input)
-		expected := getInterfaces(test.expected)
-		if !reflect.DeepEqual(input, expected) {
-			t.Errorf("Sort mismatch:\n %v != %v", input, expected)
-		}
-	}
-}
-
-// TestSortValues ensures the sort functionality for relect.Value based sorting
-// works as intended.
-func TestSortValues(t *testing.T) {
-	v := reflect.ValueOf
-
-	a := v("a")
-	b := v("b")
-	c := v("c")
-	embedA := v(embed{"a"})
-	embedB := v(embed{"b"})
-	embedC := v(embed{"c"})
-	tests := []sortTestCase{
-		// No values.
-		{
-			[]reflect.Value{},
-			[]reflect.Value{},
-		},
-		// Bools.
-		{
-			[]reflect.Value{v(false), v(true), v(false)},
-			[]reflect.Value{v(false), v(false), v(true)},
-		},
-		// Ints.
-		{
-			[]reflect.Value{v(2), v(1), v(3)},
-			[]reflect.Value{v(1), v(2), v(3)},
-		},
-		// Uints.
-		{
-			[]reflect.Value{v(uint8(2)), v(uint8(1)), v(uint8(3))},
-			[]reflect.Value{v(uint8(1)), v(uint8(2)), v(uint8(3))},
-		},
-		// Floats.
-		{
-			[]reflect.Value{v(2.0), v(1.0), v(3.0)},
-			[]reflect.Value{v(1.0), v(2.0), v(3.0)},
-		},
-		// Strings.
-		{
-			[]reflect.Value{b, a, c},
-			[]reflect.Value{a, b, c},
-		},
-		// Array
-		{
-			[]reflect.Value{v([3]int{3, 2, 1}), v([3]int{1, 3, 2}), v([3]int{1, 2, 3})},
-			[]reflect.Value{v([3]int{1, 2, 3}), v([3]int{1, 3, 2}), v([3]int{3, 2, 1})},
-		},
-		// Uintptrs.
-		{
-			[]reflect.Value{v(uintptr(2)), v(uintptr(1)), v(uintptr(3))},
-			[]reflect.Value{v(uintptr(1)), v(uintptr(2)), v(uintptr(3))},
-		},
-		// SortableStructs.
-		{
-			// Note: not sorted - DisableMethods is set.
-			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
-			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
-		},
-		// UnsortableStructs.
-		{
-			// Note: not sorted - SpewKeys is false.
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-		},
-		// Invalid.
-		{
-			[]reflect.Value{embedB, embedA, embedC},
-			[]reflect.Value{embedB, embedA, embedC},
-		},
-	}
-	cs := spew.ConfigState{DisableMethods: true, SpewKeys: false}
-	helpTestSortValues(tests, &cs, t)
-}
-
-// TestSortValuesWithMethods ensures the sort functionality for relect.Value
-// based sorting works as intended when using string methods.
-func TestSortValuesWithMethods(t *testing.T) {
-	v := reflect.ValueOf
-
-	a := v("a")
-	b := v("b")
-	c := v("c")
-	tests := []sortTestCase{
-		// Ints.
-		{
-			[]reflect.Value{v(2), v(1), v(3)},
-			[]reflect.Value{v(1), v(2), v(3)},
-		},
-		// Strings.
-		{
-			[]reflect.Value{b, a, c},
-			[]reflect.Value{a, b, c},
-		},
-		// SortableStructs.
-		{
-			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
-			[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
-		},
-		// UnsortableStructs.
-		{
-			// Note: not sorted - SpewKeys is false.
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-		},
-	}
-	cs := spew.ConfigState{DisableMethods: false, SpewKeys: false}
-	helpTestSortValues(tests, &cs, t)
-}
-
-// TestSortValuesWithSpew ensures the sort functionality for relect.Value
-// based sorting works as intended when using spew to stringify keys.
-func TestSortValuesWithSpew(t *testing.T) {
-	v := reflect.ValueOf
-
-	a := v("a")
-	b := v("b")
-	c := v("c")
-	tests := []sortTestCase{
-		// Ints.
-		{
-			[]reflect.Value{v(2), v(1), v(3)},
-			[]reflect.Value{v(1), v(2), v(3)},
-		},
-		// Strings.
-		{
-			[]reflect.Value{b, a, c},
-			[]reflect.Value{a, b, c},
-		},
-		// SortableStructs.
-		{
-			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
-			[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
-		},
-		// UnsortableStructs.
-		{
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-			[]reflect.Value{v(unsortableStruct{1}), v(unsortableStruct{2}), v(unsortableStruct{3})},
-		},
-	}
-	cs := spew.ConfigState{DisableMethods: true, SpewKeys: true}
-	helpTestSortValues(tests, &cs, t)
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpcgo_test.go

@@ -1,97 +0,0 @@
-// Copyright (c) 2013 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 both cgo is supported and "-tags testcgo" is added to the go test
-// command line.  This means the cgo tests are only added (and hence run) when
-// specifially requested.  This configuration is used because spew itself
-// does not require cgo to run even though it does handle certain cgo types
-// specially.  Rather than forcing all clients to require cgo and an external
-// C compiler just to run the tests, this scheme makes them optional.
-// +build cgo,testcgo
-
-package spew_test
-
-import (
-	"fmt"
-	"github.com/davecgh/go-spew/spew/testdata"
-)
-
-func addCgoDumpTests() {
-	// C char pointer.
-	v := testdata.GetCgoCharPointer()
-	nv := testdata.GetCgoNullCharPointer()
-	pv := &v
-	vcAddr := fmt.Sprintf("%p", v)
-	vAddr := fmt.Sprintf("%p", pv)
-	pvAddr := fmt.Sprintf("%p", &pv)
-	vt := "*testdata._Ctype_char"
-	vs := "116"
-	addDumpTest(v, "("+vt+")("+vcAddr+")("+vs+")\n")
-	addDumpTest(pv, "(*"+vt+")("+vAddr+"->"+vcAddr+")("+vs+")\n")
-	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+"->"+vcAddr+")("+vs+")\n")
-	addDumpTest(nv, "("+vt+")(<nil>)\n")
-
-	// C char array.
-	v2, v2l, v2c := testdata.GetCgoCharArray()
-	v2Len := fmt.Sprintf("%d", v2l)
-	v2Cap := fmt.Sprintf("%d", v2c)
-	v2t := "[6]testdata._Ctype_char"
-	v2s := "(len=" + v2Len + " cap=" + v2Cap + ") " +
-		"{\n 00000000  74 65 73 74 32 00                               " +
-		"  |test2.|\n}"
-	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
-
-	// C unsigned char array.
-	v3, v3l, v3c := testdata.GetCgoUnsignedCharArray()
-	v3Len := fmt.Sprintf("%d", v3l)
-	v3Cap := fmt.Sprintf("%d", v3c)
-	v3t := "[6]testdata._Ctype_unsignedchar"
-	v3s := "(len=" + v3Len + " cap=" + v3Cap + ") " +
-		"{\n 00000000  74 65 73 74 33 00                               " +
-		"  |test3.|\n}"
-	addDumpTest(v3, "("+v3t+") "+v3s+"\n")
-
-	// C signed char array.
-	v4, v4l, v4c := testdata.GetCgoSignedCharArray()
-	v4Len := fmt.Sprintf("%d", v4l)
-	v4Cap := fmt.Sprintf("%d", v4c)
-	v4t := "[6]testdata._Ctype_schar"
-	v4t2 := "testdata._Ctype_schar"
-	v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
-		"{\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 101,\n (" + v4t2 +
-		") 115,\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 52,\n (" + v4t2 +
-		") 0\n}"
-	addDumpTest(v4, "("+v4t+") "+v4s+"\n")
-
-	// C uint8_t array.
-	v5, v5l, v5c := testdata.GetCgoUint8tArray()
-	v5Len := fmt.Sprintf("%d", v5l)
-	v5Cap := fmt.Sprintf("%d", v5c)
-	v5t := "[6]testdata._Ctype_uint8_t"
-	v5s := "(len=" + v5Len + " cap=" + v5Cap + ") " +
-		"{\n 00000000  74 65 73 74 35 00                               " +
-		"  |test5.|\n}"
-	addDumpTest(v5, "("+v5t+") "+v5s+"\n")
-
-	// C typedefed unsigned char array.
-	v6, v6l, v6c := testdata.GetCgoTypdefedUnsignedCharArray()
-	v6Len := fmt.Sprintf("%d", v6l)
-	v6Cap := fmt.Sprintf("%d", v6c)
-	v6t := "[6]testdata._Ctype_custom_uchar_t"
-	v6s := "(len=" + v6Len + " cap=" + v6Cap + ") " +
-		"{\n 00000000  74 65 73 74 36 00                               " +
-		"  |test6.|\n}"
-	addDumpTest(v6, "("+v6t+") "+v6s+"\n")
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpnocgo_test.go

@@ -1,26 +0,0 @@
-// Copyright (c) 2013 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 either cgo is not supported or "-tags testcgo" is not added to the go
-// test command line.  This file intentionally does not setup any cgo tests in
-// this scenario.
-// +build !cgo !testcgo
-
-package spew_test
-
-func addCgoDumpTests() {
-	// Don't add any tests for cgo since this file is only compiled when
-	// there should not be any cgo tests.
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/example_test.go

@@ -1,230 +0,0 @@
-/*
- * Copyright (c) 2013 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_test
-
-import (
-	"fmt"
-	"github.com/davecgh/go-spew/spew"
-)
-
-type Flag int
-
-const (
-	flagOne Flag = iota
-	flagTwo
-)
-
-var flagStrings = map[Flag]string{
-	flagOne: "flagOne",
-	flagTwo: "flagTwo",
-}
-
-func (f Flag) String() string {
-	if s, ok := flagStrings[f]; ok {
-		return s
-	}
-	return fmt.Sprintf("Unknown flag (%d)", int(f))
-}
-
-type Bar struct {
-	flag Flag
-	data uintptr
-}
-
-type Foo struct {
-	unexportedField Bar
-	ExportedField   map[interface{}]interface{}
-}
-
-// This example demonstrates how to use Dump to dump variables to stdout.
-func ExampleDump() {
-	// The following package level declarations are assumed for this example:
-	/*
-		type Flag int
-
-		const (
-			flagOne Flag = iota
-			flagTwo
-		)
-
-		var flagStrings = map[Flag]string{
-			flagOne: "flagOne",
-			flagTwo: "flagTwo",
-		}
-
-		func (f Flag) String() string {
-			if s, ok := flagStrings[f]; ok {
-				return s
-			}
-			return fmt.Sprintf("Unknown flag (%d)", int(f))
-		}
-
-		type Bar struct {
-			flag Flag
-			data uintptr
-		}
-
-		type Foo struct {
-			unexportedField Bar
-			ExportedField   map[interface{}]interface{}
-		}
-	*/
-
-	// Setup some sample data structures for the example.
-	bar := Bar{Flag(flagTwo), uintptr(0)}
-	s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
-	f := Flag(5)
-	b := []byte{
-		0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
-		0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
-		0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
-		0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
-		0x31, 0x32,
-	}
-
-	// Dump!
-	spew.Dump(s1, f, b)
-
-	// Output:
-	// (spew_test.Foo) {
-	//  unexportedField: (spew_test.Bar) {
-	//   flag: (spew_test.Flag) flagTwo,
-	//   data: (uintptr) <nil>
-	//  },
-	//  ExportedField: (map[interface {}]interface {}) (len=1) {
-	//   (string) (len=3) "one": (bool) true
-	//  }
-	// }
-	// (spew_test.Flag) Unknown flag (5)
-	// ([]uint8) (len=34 cap=34) {
-	//  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|
-	// }
-	//
-}
-
-// This example demonstrates how to use Printf to display a variable with a
-// format string and inline formatting.
-func ExamplePrintf() {
-	// Create a double pointer to a uint 8.
-	ui8 := uint8(5)
-	pui8 := &ui8
-	ppui8 := &pui8
-
-	// Create a circular data type.
-	type circular struct {
-		ui8 uint8
-		c   *circular
-	}
-	c := circular{ui8: 1}
-	c.c = &c
-
-	// Print!
-	spew.Printf("ppui8: %v\n", ppui8)
-	spew.Printf("circular: %v\n", c)
-
-	// Output:
-	// ppui8: <**>5
-	// circular: {1 <*>{1 <*><shown>}}
-}
-
-// This example demonstrates how to use a ConfigState.
-func ExampleConfigState() {
-	// Modify the indent level of the ConfigState only.  The global
-	// configuration is not modified.
-	scs := spew.ConfigState{Indent: "\t"}
-
-	// Output using the ConfigState instance.
-	v := map[string]int{"one": 1}
-	scs.Printf("v: %v\n", v)
-	scs.Dump(v)
-
-	// Output:
-	// v: map[one:1]
-	// (map[string]int) (len=1) {
-	// 	(string) (len=3) "one": (int) 1
-	// }
-}
-
-// This example demonstrates how to use ConfigState.Dump to dump variables to
-// stdout
-func ExampleConfigState_Dump() {
-	// See the top-level Dump example for details on the types used in this
-	// example.
-
-	// Create two ConfigState instances with different indentation.
-	scs := spew.ConfigState{Indent: "\t"}
-	scs2 := spew.ConfigState{Indent: " "}
-
-	// Setup some sample data structures for the example.
-	bar := Bar{Flag(flagTwo), uintptr(0)}
-	s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
-
-	// Dump using the ConfigState instances.
-	scs.Dump(s1)
-	scs2.Dump(s1)
-
-	// Output:
-	// (spew_test.Foo) {
-	// 	unexportedField: (spew_test.Bar) {
-	// 		flag: (spew_test.Flag) flagTwo,
-	// 		data: (uintptr) <nil>
-	// 	},
-	// 	ExportedField: (map[interface {}]interface {}) (len=1) {
-	//		(string) (len=3) "one": (bool) true
-	// 	}
-	// }
-	// (spew_test.Foo) {
-	//  unexportedField: (spew_test.Bar) {
-	//   flag: (spew_test.Flag) flagTwo,
-	//   data: (uintptr) <nil>
-	//  },
-	//  ExportedField: (map[interface {}]interface {}) (len=1) {
-	//   (string) (len=3) "one": (bool) true
-	//  }
-	// }
-	//
-}
-
-// This example demonstrates how to use ConfigState.Printf to display a variable
-// with a format string and inline formatting.
-func ExampleConfigState_Printf() {
-	// See the top-level Dump example for details on the types used in this
-	// example.
-
-	// Create two ConfigState instances and modify the method handling of the
-	// first ConfigState only.
-	scs := spew.NewDefaultConfig()
-	scs2 := spew.NewDefaultConfig()
-	scs.DisableMethods = true
-
-	// Alternatively
-	// scs := spew.ConfigState{Indent: " ", DisableMethods: true}
-	// scs2 := spew.ConfigState{Indent: " "}
-
-	// This is of type Flag which implements a Stringer and has raw value 1.
-	f := flagTwo
-
-	// Dump using the ConfigState instances.
-	scs.Printf("f: %v\n", f)
-	scs2.Printf("f: %v\n", f)
-
-	// Output:
-	// f: 1
-	// f: flagTwo
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/internal_test.go

@@ -1,156 +0,0 @@
-/*
- * Copyright (c) 2013 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.
- */
-
-/*
-This test file is part of the spew package rather than than the spew_test
-package because it needs access to internals to properly test certain cases
-which are not possible via the public interface since they should never happen.
-*/
-
-package spew
-
-import (
-	"bytes"
-	"reflect"
-	"testing"
-	"unsafe"
-)
-
-// dummyFmtState implements a fake fmt.State to use for testing invalid
-// reflect.Value handling.  This is necessary because the fmt package catches
-// invalid values before invoking the formatter on them.
-type dummyFmtState struct {
-	bytes.Buffer
-}
-
-func (dfs *dummyFmtState) Flag(f int) bool {
-	if f == int('+') {
-		return true
-	}
-	return false
-}
-
-func (dfs *dummyFmtState) Precision() (int, bool) {
-	return 0, false
-}
-
-func (dfs *dummyFmtState) Width() (int, bool) {
-	return 0, false
-}
-
-// TestInvalidReflectValue ensures the dump and formatter code handles an
-// invalid reflect value properly.  This needs access to internal state since it
-// should never happen in real code and therefore can't be tested via the public
-// API.
-func TestInvalidReflectValue(t *testing.T) {
-	i := 1
-
-	// Dump invalid reflect value.
-	v := new(reflect.Value)
-	buf := new(bytes.Buffer)
-	d := dumpState{w: buf, cs: &Config}
-	d.dump(*v)
-	s := buf.String()
-	want := "<invalid>"
-	if s != want {
-		t.Errorf("InvalidReflectValue #%d\n got: %s want: %s", i, s, want)
-	}
-	i++
-
-	// Formatter invalid reflect value.
-	buf2 := new(dummyFmtState)
-	f := formatState{value: *v, cs: &Config, fs: buf2}
-	f.format(*v)
-	s = buf2.String()
-	want = "<invalid>"
-	if s != want {
-		t.Errorf("InvalidReflectValue #%d got: %s want: %s", i, s, want)
-	}
-}
-
-// changeKind uses unsafe to intentionally change the kind of a reflect.Value to
-// the maximum kind value which does not exist.  This is needed to test the
-// fallback code which punts to the standard fmt library for new types that
-// might get added to the language.
-func changeKind(v *reflect.Value, readOnly bool) {
-	rvf := (*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + offsetFlag))
-	*rvf = *rvf | ((1<<flagKindWidth - 1) << flagKindShift)
-	if readOnly {
-		*rvf |= flagRO
-	} else {
-		*rvf &= ^uintptr(flagRO)
-	}
-}
-
-// TestAddedReflectValue tests functionaly of the dump and formatter code which
-// falls back to the standard fmt library for new types that might get added to
-// the language.
-func TestAddedReflectValue(t *testing.T) {
-	i := 1
-
-	// Dump using a reflect.Value that is exported.
-	v := reflect.ValueOf(int8(5))
-	changeKind(&v, false)
-	buf := new(bytes.Buffer)
-	d := dumpState{w: buf, cs: &Config}
-	d.dump(v)
-	s := buf.String()
-	want := "(int8) 5"
-	if s != want {
-		t.Errorf("TestAddedReflectValue #%d\n got: %s want: %s", i, s, want)
-	}
-	i++
-
-	// Dump using a reflect.Value that is not exported.
-	changeKind(&v, true)
-	buf.Reset()
-	d.dump(v)
-	s = buf.String()
-	want = "(int8) <int8 Value>"
-	if s != want {
-		t.Errorf("TestAddedReflectValue #%d\n got: %s want: %s", i, s, want)
-	}
-	i++
-
-	// Formatter using a reflect.Value that is exported.
-	changeKind(&v, false)
-	buf2 := new(dummyFmtState)
-	f := formatState{value: v, cs: &Config, fs: buf2}
-	f.format(v)
-	s = buf2.String()
-	want = "5"
-	if s != want {
-		t.Errorf("TestAddedReflectValue #%d got: %s want: %s", i, s, want)
-	}
-	i++
-
-	// Formatter using a reflect.Value that is not exported.
-	changeKind(&v, true)
-	buf2.Reset()
-	f = formatState{value: v, cs: &Config, fs: buf2}
-	f.format(v)
-	s = buf2.String()
-	want = "<int8 Value>"
-	if s != want {
-		t.Errorf("TestAddedReflectValue #%d got: %s want: %s", i, s, want)
-	}
-}
-
-// SortValues makes the internal sortValues function available to the test
-// package.
-func SortValues(values []reflect.Value, cs *ConfigState) {
-	sortValues(values, cs)
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew_test.go

@@ -1,308 +0,0 @@
-/*
- * Copyright (c) 2013 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_test
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/davecgh/go-spew/spew"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-// spewFunc is used to identify which public function of the spew package or
-// ConfigState a test applies to.
-type spewFunc int
-
-const (
-	fCSFdump spewFunc = iota
-	fCSFprint
-	fCSFprintf
-	fCSFprintln
-	fCSPrint
-	fCSPrintln
-	fCSSdump
-	fCSSprint
-	fCSSprintf
-	fCSSprintln
-	fCSErrorf
-	fCSNewFormatter
-	fErrorf
-	fFprint
-	fFprintln
-	fPrint
-	fPrintln
-	fSdump
-	fSprint
-	fSprintf
-	fSprintln
-)
-
-// Map of spewFunc values to names for pretty printing.
-var spewFuncStrings = map[spewFunc]string{
-	fCSFdump:        "ConfigState.Fdump",
-	fCSFprint:       "ConfigState.Fprint",
-	fCSFprintf:      "ConfigState.Fprintf",
-	fCSFprintln:     "ConfigState.Fprintln",
-	fCSSdump:        "ConfigState.Sdump",
-	fCSPrint:        "ConfigState.Print",
-	fCSPrintln:      "ConfigState.Println",
-	fCSSprint:       "ConfigState.Sprint",
-	fCSSprintf:      "ConfigState.Sprintf",
-	fCSSprintln:     "ConfigState.Sprintln",
-	fCSErrorf:       "ConfigState.Errorf",
-	fCSNewFormatter: "ConfigState.NewFormatter",
-	fErrorf:         "spew.Errorf",
-	fFprint:         "spew.Fprint",
-	fFprintln:       "spew.Fprintln",
-	fPrint:          "spew.Print",
-	fPrintln:        "spew.Println",
-	fSdump:          "spew.Sdump",
-	fSprint:         "spew.Sprint",
-	fSprintf:        "spew.Sprintf",
-	fSprintln:       "spew.Sprintln",
-}
-
-func (f spewFunc) String() string {
-	if s, ok := spewFuncStrings[f]; ok {
-		return s
-	}
-	return fmt.Sprintf("Unknown spewFunc (%d)", int(f))
-}
-
-// spewTest is used to describe a test to be performed against the public
-// functions of the spew package or ConfigState.
-type spewTest struct {
-	cs     *spew.ConfigState
-	f      spewFunc
-	format string
-	in     interface{}
-	want   string
-}
-
-// spewTests houses the tests to be performed against the public functions of
-// the spew package and ConfigState.
-//
-// These tests are only intended to ensure the public functions are exercised
-// and are intentionally not exhaustive of types.  The exhaustive type
-// tests are handled in the dump and format tests.
-var spewTests []spewTest
-
-// redirStdout is a helper function to return the standard output from f as a
-// byte slice.
-func redirStdout(f func()) ([]byte, error) {
-	tempFile, err := ioutil.TempFile("", "ss-test")
-	if err != nil {
-		return nil, err
-	}
-	fileName := tempFile.Name()
-	defer os.Remove(fileName) // Ignore error
-
-	origStdout := os.Stdout
-	os.Stdout = tempFile
-	f()
-	os.Stdout = origStdout
-	tempFile.Close()
-
-	return ioutil.ReadFile(fileName)
-}
-
-func initSpewTests() {
-	// Config states with various settings.
-	scsDefault := spew.NewDefaultConfig()
-	scsNoMethods := &spew.ConfigState{Indent: " ", DisableMethods: true}
-	scsNoPmethods := &spew.ConfigState{Indent: " ", DisablePointerMethods: true}
-	scsMaxDepth := &spew.ConfigState{Indent: " ", MaxDepth: 1}
-	scsContinue := &spew.ConfigState{Indent: " ", ContinueOnMethod: true}
-
-	// Variables for tests on types which implement Stringer interface with and
-	// without a pointer receiver.
-	ts := stringer("test")
-	tps := pstringer("test")
-
-	// depthTester is used to test max depth handling for structs, array, slices
-	// and maps.
-	type depthTester struct {
-		ic    indirCir1
-		arr   [1]string
-		slice []string
-		m     map[string]int
-	}
-	dt := depthTester{indirCir1{nil}, [1]string{"arr"}, []string{"slice"},
-		map[string]int{"one": 1}}
-
-	// Variable for tests on types which implement error interface.
-	te := customError(10)
-
-	spewTests = []spewTest{
-		{scsDefault, fCSFdump, "", int8(127), "(int8) 127\n"},
-		{scsDefault, fCSFprint, "", int16(32767), "32767"},
-		{scsDefault, fCSFprintf, "%v", int32(2147483647), "2147483647"},
-		{scsDefault, fCSFprintln, "", int(2147483647), "2147483647\n"},
-		{scsDefault, fCSPrint, "", int64(9223372036854775807), "9223372036854775807"},
-		{scsDefault, fCSPrintln, "", uint8(255), "255\n"},
-		{scsDefault, fCSSdump, "", uint8(64), "(uint8) 64\n"},
-		{scsDefault, fCSSprint, "", complex(1, 2), "(1+2i)"},
-		{scsDefault, fCSSprintf, "%v", complex(float32(3), 4), "(3+4i)"},
-		{scsDefault, fCSSprintln, "", complex(float64(5), 6), "(5+6i)\n"},
-		{scsDefault, fCSErrorf, "%#v", uint16(65535), "(uint16)65535"},
-		{scsDefault, fCSNewFormatter, "%v", uint32(4294967295), "4294967295"},
-		{scsDefault, fErrorf, "%v", uint64(18446744073709551615), "18446744073709551615"},
-		{scsDefault, fFprint, "", float32(3.14), "3.14"},
-		{scsDefault, fFprintln, "", float64(6.28), "6.28\n"},
-		{scsDefault, fPrint, "", true, "true"},
-		{scsDefault, fPrintln, "", false, "false\n"},
-		{scsDefault, fSdump, "", complex(-10, -20), "(complex128) (-10-20i)\n"},
-		{scsDefault, fSprint, "", complex(-1, -2), "(-1-2i)"},
-		{scsDefault, fSprintf, "%v", complex(float32(-3), -4), "(-3-4i)"},
-		{scsDefault, fSprintln, "", complex(float64(-5), -6), "(-5-6i)\n"},
-		{scsNoMethods, fCSFprint, "", ts, "test"},
-		{scsNoMethods, fCSFprint, "", &ts, "<*>test"},
-		{scsNoMethods, fCSFprint, "", tps, "test"},
-		{scsNoMethods, fCSFprint, "", &tps, "<*>test"},
-		{scsNoPmethods, fCSFprint, "", ts, "stringer test"},
-		{scsNoPmethods, fCSFprint, "", &ts, "<*>stringer test"},
-		{scsNoPmethods, fCSFprint, "", tps, "test"},
-		{scsNoPmethods, fCSFprint, "", &tps, "<*>stringer test"},
-		{scsMaxDepth, fCSFprint, "", dt, "{{<max>} [<max>] [<max>] map[<max>]}"},
-		{scsMaxDepth, fCSFdump, "", dt, "(spew_test.depthTester) {\n" +
-			" ic: (spew_test.indirCir1) {\n  <max depth reached>\n },\n" +
-			" arr: ([1]string) (len=1 cap=1) {\n  <max depth reached>\n },\n" +
-			" slice: ([]string) (len=1 cap=1) {\n  <max depth reached>\n },\n" +
-			" m: (map[string]int) (len=1) {\n  <max depth reached>\n }\n}\n"},
-		{scsContinue, fCSFprint, "", ts, "(stringer test) test"},
-		{scsContinue, fCSFdump, "", ts, "(spew_test.stringer) " +
-			"(len=4) (stringer test) \"test\"\n"},
-		{scsContinue, fCSFprint, "", te, "(error: 10) 10"},
-		{scsContinue, fCSFdump, "", te, "(spew_test.customError) " +
-			"(error: 10) 10\n"},
-	}
-}
-
-// TestSpew executes all of the tests described by spewTests.
-func TestSpew(t *testing.T) {
-	initSpewTests()
-
-	t.Logf("Running %d tests", len(spewTests))
-	for i, test := range spewTests {
-		buf := new(bytes.Buffer)
-		switch test.f {
-		case fCSFdump:
-			test.cs.Fdump(buf, test.in)
-
-		case fCSFprint:
-			test.cs.Fprint(buf, test.in)
-
-		case fCSFprintf:
-			test.cs.Fprintf(buf, test.format, test.in)
-
-		case fCSFprintln:
-			test.cs.Fprintln(buf, test.in)
-
-		case fCSPrint:
-			b, err := redirStdout(func() { test.cs.Print(test.in) })
-			if err != nil {
-				t.Errorf("%v #%d %v", test.f, i, err)
-				continue
-			}
-			buf.Write(b)
-
-		case fCSPrintln:
-			b, err := redirStdout(func() { test.cs.Println(test.in) })
-			if err != nil {
-				t.Errorf("%v #%d %v", test.f, i, err)
-				continue
-			}
-			buf.Write(b)
-
-		case fCSSdump:
-			str := test.cs.Sdump(test.in)
-			buf.WriteString(str)
-
-		case fCSSprint:
-			str := test.cs.Sprint(test.in)
-			buf.WriteString(str)
-
-		case fCSSprintf:
-			str := test.cs.Sprintf(test.format, test.in)
-			buf.WriteString(str)
-
-		case fCSSprintln:
-			str := test.cs.Sprintln(test.in)
-			buf.WriteString(str)
-
-		case fCSErrorf:
-			err := test.cs.Errorf(test.format, test.in)
-			buf.WriteString(err.Error())
-
-		case fCSNewFormatter:
-			fmt.Fprintf(buf, test.format, test.cs.NewFormatter(test.in))
-
-		case fErrorf:
-			err := spew.Errorf(test.format, test.in)
-			buf.WriteString(err.Error())
-
-		case fFprint:
-			spew.Fprint(buf, test.in)
-
-		case fFprintln:
-			spew.Fprintln(buf, test.in)
-
-		case fPrint:
-			b, err := redirStdout(func() { spew.Print(test.in) })
-			if err != nil {
-				t.Errorf("%v #%d %v", test.f, i, err)
-				continue
-			}
-			buf.Write(b)
-
-		case fPrintln:
-			b, err := redirStdout(func() { spew.Println(test.in) })
-			if err != nil {
-				t.Errorf("%v #%d %v", test.f, i, err)
-				continue
-			}
-			buf.Write(b)
-
-		case fSdump:
-			str := spew.Sdump(test.in)
-			buf.WriteString(str)
-
-		case fSprint:
-			str := spew.Sprint(test.in)
-			buf.WriteString(str)
-
-		case fSprintf:
-			str := spew.Sprintf(test.format, test.in)
-			buf.WriteString(str)
-
-		case fSprintln:
-			str := spew.Sprintln(test.in)
-			buf.WriteString(str)
-
-		default:
-			t.Errorf("%v #%d unrecognized function", test.f, i)
-			continue
-		}
-		s := buf.String()
-		if test.want != s {
-			t.Errorf("ConfigState #%d\n got: %s want: %s", i, s, test.want)
-			continue
-		}
-	}
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/testdata/dumpcgo.go

@@ -1,82 +0,0 @@
-// Copyright (c) 2013 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 both cgo is supported and "-tags testcgo" is added to the go test
-// command line.  This code should really only be in the dumpcgo_test.go file,
-// but unfortunately Go will not allow cgo in test files, so this is a
-// workaround to allow cgo types to be tested.  This configuration is used
-// because spew itself does not require cgo to run even though it does handle
-// certain cgo types specially.  Rather than forcing all clients to require cgo
-// and an external C compiler just to run the tests, this scheme makes them
-// optional.
-// +build cgo,testcgo
-
-package testdata
-
-/*
-#include <stdint.h>
-typedef unsigned char custom_uchar_t;
-
-char            *ncp = 0;
-char            *cp = "test";
-char             ca[6] = {'t', 'e', 's', 't', '2', '\0'};
-unsigned char    uca[6] = {'t', 'e', 's', 't', '3', '\0'};
-signed char      sca[6] = {'t', 'e', 's', 't', '4', '\0'};
-uint8_t          ui8ta[6] = {'t', 'e', 's', 't', '5', '\0'};
-custom_uchar_t   tuca[6] = {'t', 'e', 's', 't', '6', '\0'};
-*/
-import "C"
-
-// GetCgoNullCharPointer returns a null char pointer via cgo.  This is only
-// used for tests.
-func GetCgoNullCharPointer() interface{} {
-	return C.ncp
-}
-
-// GetCgoCharPointer returns a char pointer via cgo.  This is only used for
-// tests.
-func GetCgoCharPointer() interface{} {
-	return C.cp
-}
-
-// GetCgoCharArray returns a char array via cgo and the array's len and cap.
-// This is only used for tests.
-func GetCgoCharArray() (interface{}, int, int) {
-	return C.ca, len(C.ca), cap(C.ca)
-}
-
-// GetCgoUnsignedCharArray returns an unsigned char array via cgo and the
-// array's len and cap.  This is only used for tests.
-func GetCgoUnsignedCharArray() (interface{}, int, int) {
-	return C.uca, len(C.uca), cap(C.uca)
-}
-
-// GetCgoSignedCharArray returns a signed char array via cgo and the array's len
-// and cap.  This is only used for tests.
-func GetCgoSignedCharArray() (interface{}, int, int) {
-	return C.sca, len(C.sca), cap(C.sca)
-}
-
-// GetCgoUint8tArray returns a uint8_t array via cgo and the array's len and
-// cap.  This is only used for tests.
-func GetCgoUint8tArray() (interface{}, int, int) {
-	return C.ui8ta, len(C.ui8ta), cap(C.ui8ta)
-}
-
-// GetCgoTypdefedUnsignedCharArray returns a typedefed unsigned char array via
-// cgo and the array's len and cap.  This is only used for tests.
-func GetCgoTypdefedUnsignedCharArray() (interface{}, int, int) {
-	return C.tuca, len(C.tuca), cap(C.tuca)
-}

Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/CMakeParseArguments.cmake

@@ -1,161 +0,0 @@
-#.rst:
-# CMakeParseArguments
-# -------------------
-#
-#
-#
-# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords>
-# <multi_value_keywords> args...)
-#
-# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions
-# for parsing the arguments given to that macro or function.  It
-# processes the arguments and defines a set of variables which hold the
-# values of the respective options.
-#
-# The <options> argument contains all options for the respective macro,
-# i.e.  keywords which can be used when calling the macro without any
-# value following, like e.g.  the OPTIONAL keyword of the install()
-# command.
-#
-# The <one_value_keywords> argument contains all keywords for this macro
-# which are followed by one value, like e.g.  DESTINATION keyword of the
-# install() command.
-#
-# The <multi_value_keywords> argument contains all keywords for this
-# macro which can be followed by more than one value, like e.g.  the
-# TARGETS or FILES keywords of the install() command.
-#
-# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the
-# keywords listed in <options>, <one_value_keywords> and
-# <multi_value_keywords> a variable composed of the given <prefix>
-# followed by "_" and the name of the respective keyword.  These
-# variables will then hold the respective value from the argument list.
-# For the <options> keywords this will be TRUE or FALSE.
-#
-# All remaining arguments are collected in a variable
-# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see
-# whether your macro was called with unrecognized parameters.
-#
-# As an example here a my_install() macro, which takes similar arguments
-# as the real install() command:
-#
-# ::
-#
-#    function(MY_INSTALL)
-#      set(options OPTIONAL FAST)
-#      set(oneValueArgs DESTINATION RENAME)
-#      set(multiValueArgs TARGETS CONFIGURATIONS)
-#      cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}"
-#                            "${multiValueArgs}" ${ARGN} )
-#      ...
-#
-#
-#
-# Assume my_install() has been called like this:
-#
-# ::
-#
-#    my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)
-#
-#
-#
-# After the cmake_parse_arguments() call the macro will have set the
-# following variables:
-#
-# ::
-#
-#    MY_INSTALL_OPTIONAL = TRUE
-#    MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
-#    MY_INSTALL_DESTINATION = "bin"
-#    MY_INSTALL_RENAME = "" (was not used)
-#    MY_INSTALL_TARGETS = "foo;bar"
-#    MY_INSTALL_CONFIGURATIONS = "" (was not used)
-#    MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"
-#
-#
-#
-# You can then continue and process these variables.
-#
-# Keywords terminate lists of values, e.g.  if directly after a
-# one_value_keyword another recognized keyword follows, this is
-# interpreted as the beginning of the new option.  E.g.
-# my_install(TARGETS foo DESTINATION OPTIONAL) would result in
-# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION
-# would be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
-
-#=============================================================================
-# Copyright 2010 Alexander Neundorf <neundorf@kde.org>
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-
-if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)
-  return()
-endif()
-set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)
-
-
-function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)
-  # first set all result variables to empty/FALSE
-  foreach(arg_name ${_singleArgNames} ${_multiArgNames})
-    set(${prefix}_${arg_name})
-  endforeach()
-
-  foreach(option ${_optionNames})
-    set(${prefix}_${option} FALSE)
-  endforeach()
-
-  set(${prefix}_UNPARSED_ARGUMENTS)
-
-  set(insideValues FALSE)
-  set(currentArgName)
-
-  # now iterate over all arguments and fill the result variables
-  foreach(currentArg ${ARGN})
-    list(FIND _optionNames "${currentArg}" optionIndex)  # ... then this marks the end of the arguments belonging to this keyword
-    list(FIND _singleArgNames "${currentArg}" singleArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
-    list(FIND _multiArgNames "${currentArg}" multiArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
-
-    if(${optionIndex} EQUAL -1  AND  ${singleArgIndex} EQUAL -1  AND  ${multiArgIndex} EQUAL -1)
-      if(insideValues)
-        if("${insideValues}" STREQUAL "SINGLE")
-          set(${prefix}_${currentArgName} ${currentArg})
-          set(insideValues FALSE)
-        elseif("${insideValues}" STREQUAL "MULTI")
-          list(APPEND ${prefix}_${currentArgName} ${currentArg})
-        endif()
-      else()
-        list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})
-      endif()
-    else()
-      if(NOT ${optionIndex} EQUAL -1)
-        set(${prefix}_${currentArg} TRUE)
-        set(insideValues FALSE)
-      elseif(NOT ${singleArgIndex} EQUAL -1)
-        set(currentArgName ${currentArg})
-        set(${prefix}_${currentArgName})
-        set(insideValues "SINGLE")
-      elseif(NOT ${multiArgIndex} EQUAL -1)
-        set(currentArgName ${currentArg})
-        set(${prefix}_${currentArgName})
-        set(insideValues "MULTI")
-      endif()
-    endif()
-
-  endforeach()
-
-  # propagate the result variables to the caller:
-  foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})
-    set(${prefix}_${arg_name}  ${${prefix}_${arg_name}} PARENT_SCOPE)
-  endforeach()
-  set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)
-
-endfunction()

Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindCryptoPP.cmake

@@ -1,108 +0,0 @@
-# Module for locating the Crypto++ encryption library.
-#
-# Customizable variables:
-#   CRYPTOPP_ROOT_DIR
-#     This variable points to the CryptoPP root directory. On Windows the
-#     library location typically will have to be provided explicitly using the
-#     -D command-line option. The directory should include the include/cryptopp,
-#     lib and/or bin sub-directories.
-#
-# Read-only variables:
-#   CRYPTOPP_FOUND
-#     Indicates whether the library has been found.
-#
-#   CRYPTOPP_INCLUDE_DIRS
-#     Points to the CryptoPP include directory.
-#
-#   CRYPTOPP_LIBRARIES
-#     Points to the CryptoPP libraries that should be passed to
-#     target_link_libararies.
-#
-#
-# Copyright (c) 2012 Sergiu Dotenco
-#
-# 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.
-
-INCLUDE (FindPackageHandleStandardArgs)
-
-FIND_PATH (CRYPTOPP_ROOT_DIR
-  NAMES cryptopp/cryptlib.h include/cryptopp/cryptlib.h
-  PATHS ENV CRYPTOPPROOT
-  DOC "CryptoPP root directory")
-
-# Re-use the previous path:
-FIND_PATH (CRYPTOPP_INCLUDE_DIR
-  NAMES cryptopp/cryptlib.h
-  HINTS ${CRYPTOPP_ROOT_DIR}
-  PATH_SUFFIXES include
-  DOC "CryptoPP include directory")
-
-FIND_LIBRARY (CRYPTOPP_LIBRARY_DEBUG
-  NAMES cryptlibd cryptoppd
-  HINTS ${CRYPTOPP_ROOT_DIR}
-  PATH_SUFFIXES lib
-  DOC "CryptoPP debug library")
-
-FIND_LIBRARY (CRYPTOPP_LIBRARY_RELEASE
-  NAMES cryptlib cryptopp
-  HINTS ${CRYPTOPP_ROOT_DIR}
-  PATH_SUFFIXES lib
-  DOC "CryptoPP release library")
-
-IF (CRYPTOPP_LIBRARY_DEBUG AND CRYPTOPP_LIBRARY_RELEASE)
-  SET (CRYPTOPP_LIBRARY
-    optimized ${CRYPTOPP_LIBRARY_RELEASE}
-    debug ${CRYPTOPP_LIBRARY_DEBUG} CACHE DOC "CryptoPP library")
-ELSEIF (CRYPTOPP_LIBRARY_RELEASE)
-  SET (CRYPTOPP_LIBRARY ${CRYPTOPP_LIBRARY_RELEASE} CACHE DOC
-    "CryptoPP library")
-ENDIF (CRYPTOPP_LIBRARY_DEBUG AND CRYPTOPP_LIBRARY_RELEASE)
-
-IF (CRYPTOPP_INCLUDE_DIR)
-  SET (_CRYPTOPP_VERSION_HEADER ${CRYPTOPP_INCLUDE_DIR}/cryptopp/config.h)
-
-  IF (EXISTS ${_CRYPTOPP_VERSION_HEADER})
-    FILE (STRINGS ${_CRYPTOPP_VERSION_HEADER} _CRYPTOPP_VERSION_TMP REGEX
-      "^#define CRYPTOPP_VERSION[ \t]+[0-9]+$")
-
-    STRING (REGEX REPLACE
-      "^#define CRYPTOPP_VERSION[ \t]+([0-9]+)" "\\1" _CRYPTOPP_VERSION_TMP
-      ${_CRYPTOPP_VERSION_TMP})
-
-    STRING (REGEX REPLACE "([0-9]+)[0-9][0-9]" "\\1" CRYPTOPP_VERSION_MAJOR
-      ${_CRYPTOPP_VERSION_TMP})
-    STRING (REGEX REPLACE "[0-9]([0-9])[0-9]" "\\1" CRYPTOPP_VERSION_MINOR
-      ${_CRYPTOPP_VERSION_TMP})
-    STRING (REGEX REPLACE "[0-9][0-9]([0-9])" "\\1" CRYPTOPP_VERSION_PATCH
-      ${_CRYPTOPP_VERSION_TMP})
-
-    SET (CRYPTOPP_VERSION_COUNT 3)
-    SET (CRYPTOPP_VERSION
-      ${CRYPTOPP_VERSION_MAJOR}.${CRYPTOPP_VERSION_MINOR}.${CRYPTOPP_VERSION_PATCH})
-  ENDIF (EXISTS ${_CRYPTOPP_VERSION_HEADER})
-ENDIF (CRYPTOPP_INCLUDE_DIR)
-
-SET (CRYPTOPP_INCLUDE_DIRS ${CRYPTOPP_INCLUDE_DIR})
-SET (CRYPTOPP_LIBRARIES ${CRYPTOPP_LIBRARY})
-
-MARK_AS_ADVANCED (CRYPTOPP_INCLUDE_DIR CRYPTOPP_LIBRARY CRYPTOPP_LIBRARY_DEBUG
-  CRYPTOPP_LIBRARY_RELEASE)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS (CryptoPP REQUIRED_VARS CRYPTOPP_ROOT_DIR
-  CRYPTOPP_INCLUDE_DIR CRYPTOPP_LIBRARY VERSION_VAR CRYPTOPP_VERSION)

Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindOpenCL.cmake

@@ -1,148 +0,0 @@
-#.rst:
-# FindOpenCL
-# ----------
-#
-# Try to find OpenCL
-#
-# Once done this will define::
-#
-#   OpenCL_FOUND          - True if OpenCL was found
-#   OpenCL_INCLUDE_DIRS   - include directories for OpenCL
-#   OpenCL_LIBRARIES      - link against this library to use OpenCL
-#   OpenCL_VERSION_STRING - Highest supported OpenCL version (eg. 1.2)
-#   OpenCL_VERSION_MAJOR  - The major version of the OpenCL implementation
-#   OpenCL_VERSION_MINOR  - The minor version of the OpenCL implementation
-#
-# The module will also define two cache variables::
-#
-#   OpenCL_INCLUDE_DIR    - the OpenCL include directory
-#   OpenCL_LIBRARY        - the path to the OpenCL library
-#
-
-#=============================================================================
-# Copyright 2014 Matthaeus G. Chajdas
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-function(_FIND_OPENCL_VERSION)
-  include(CheckSymbolExists)
-  include(CMakePushCheckState)
-  set(CMAKE_REQUIRED_QUIET ${OpenCL_FIND_QUIETLY})
-
-  CMAKE_PUSH_CHECK_STATE()
-  foreach(VERSION "2_0" "1_2" "1_1" "1_0")
-    set(CMAKE_REQUIRED_INCLUDES "${OpenCL_INCLUDE_DIR}")
-
-    if(APPLE)
-      CHECK_SYMBOL_EXISTS(
-        CL_VERSION_${VERSION}
-        "${OpenCL_INCLUDE_DIR}/OpenCL/cl.h"
-        OPENCL_VERSION_${VERSION})
-    else()
-      CHECK_SYMBOL_EXISTS(
-        CL_VERSION_${VERSION}
-        "${OpenCL_INCLUDE_DIR}/CL/cl.h"
-        OPENCL_VERSION_${VERSION})
-    endif()
-
-    if(OPENCL_VERSION_${VERSION})
-      string(REPLACE "_" "." VERSION "${VERSION}")
-      set(OpenCL_VERSION_STRING ${VERSION} PARENT_SCOPE)
-      string(REGEX MATCHALL "[0-9]+" version_components "${VERSION}")
-      list(GET version_components 0 major_version)
-      list(GET version_components 1 minor_version)
-      set(OpenCL_VERSION_MAJOR ${major_version} PARENT_SCOPE)
-      set(OpenCL_VERSION_MINOR ${minor_version} PARENT_SCOPE)
-      break()
-    endif()
-  endforeach()
-  CMAKE_POP_CHECK_STATE()
-endfunction()
-
-find_path(OpenCL_INCLUDE_DIR
-  NAMES
-    CL/cl.h OpenCL/cl.h
-  PATHS
-    ENV "PROGRAMFILES(X86)"
-    ENV AMDAPPSDKROOT
-    ENV INTELOCLSDKROOT
-    ENV NVSDKCOMPUTE_ROOT
-    ENV CUDA_PATH
-    ENV ATISTREAMSDKROOT
-  PATH_SUFFIXES
-    include
-    OpenCL/common/inc
-    "AMD APP/include")
-
-_FIND_OPENCL_VERSION()
-
-if(WIN32)
-  if(CMAKE_SIZEOF_VOID_P EQUAL 4)
-    find_library(OpenCL_LIBRARY
-      NAMES OpenCL
-      PATHS
-        ENV "PROGRAMFILES(X86)"
-        ENV AMDAPPSDKROOT
-        ENV INTELOCLSDKROOT
-        ENV CUDA_PATH
-        ENV NVSDKCOMPUTE_ROOT
-        ENV ATISTREAMSDKROOT
-      PATH_SUFFIXES
-        "AMD APP/lib/x86"
-        lib/x86
-        lib/Win32
-        OpenCL/common/lib/Win32)
-  elseif(CMAKE_SIZEOF_VOID_P EQUAL 8)
-    find_library(OpenCL_LIBRARY
-      NAMES OpenCL
-      PATHS
-        ENV "PROGRAMFILES(X86)"
-        ENV AMDAPPSDKROOT
-        ENV INTELOCLSDKROOT
-        ENV CUDA_PATH
-        ENV NVSDKCOMPUTE_ROOT
-        ENV ATISTREAMSDKROOT
-      PATH_SUFFIXES
-        "AMD APP/lib/x86_64"
-        lib/x86_64
-        lib/x64
-        OpenCL/common/lib/x64)
-  endif()
-else()
-  find_library(OpenCL_LIBRARY
-    NAMES OpenCL
-    PATHS
-        ENV "PROGRAMFILES(X86)"
-        ENV AMDAPPSDKROOT
-        ENV INTELOCLSDKROOT
-        ENV CUDA_PATH
-        ENV NVSDKCOMPUTE_ROOT
-        ENV ATISTREAMSDKROOT
-    PATH_SUFFIXES
-        "AMD APP/lib/x86_64"
-        lib/x86_64
-        lib/x64
-        OpenCL/common/lib/x64)
-endif()
-
-set(OpenCL_LIBRARIES ${OpenCL_LIBRARY})
-set(OpenCL_INCLUDE_DIRS ${OpenCL_INCLUDE_DIR})
-
-include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
-find_package_handle_standard_args(
-  OpenCL
-  FOUND_VAR OpenCL_FOUND
-  REQUIRED_VARS OpenCL_LIBRARY OpenCL_INCLUDE_DIR
-  VERSION_VAR OpenCL_VERSION_STRING)
-
-mark_as_advanced(
-  OpenCL_INCLUDE_DIR
-  OpenCL_LIBRARY)

Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageHandleStandardArgs.cmake

@@ -1,382 +0,0 @@
-#.rst:
-# FindPackageHandleStandardArgs
-# -----------------------------
-#
-#
-#
-# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> ...  )
-#
-# This function is intended to be used in FindXXX.cmake modules files.
-# It handles the REQUIRED, QUIET and version-related arguments to
-# find_package().  It also sets the <packagename>_FOUND variable.  The
-# package is considered found if all variables <var1>...  listed contain
-# valid results, e.g.  valid filepaths.
-#
-# There are two modes of this function.  The first argument in both
-# modes is the name of the Find-module where it is called (in original
-# casing).
-#
-# The first simple mode looks like this:
-#
-# ::
-#
-#     FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name>
-#       (DEFAULT_MSG|"Custom failure message") <var1>...<varN> )
-#
-# If the variables <var1> to <varN> are all valid, then
-# <UPPERCASED_NAME>_FOUND will be set to TRUE.  If DEFAULT_MSG is given
-# as second argument, then the function will generate itself useful
-# success and error messages.  You can also supply a custom error
-# message for the failure case.  This is not recommended.
-#
-# The second mode is more powerful and also supports version checking:
-#
-# ::
-#
-#     FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME
-#       [FOUND_VAR <resultVar>]
-#       [REQUIRED_VARS <var1>...<varN>]
-#       [VERSION_VAR   <versionvar>]
-#       [HANDLE_COMPONENTS]
-#       [CONFIG_MODE]
-#       [FAIL_MESSAGE "Custom failure message"] )
-#
-# In this mode, the name of the result-variable can be set either to
-# either <UPPERCASED_NAME>_FOUND or <OriginalCase_Name>_FOUND using the
-# FOUND_VAR option.  Other names for the result-variable are not
-# allowed.  So for a Find-module named FindFooBar.cmake, the two
-# possible names are FooBar_FOUND and FOOBAR_FOUND.  It is recommended
-# to use the original case version.  If the FOUND_VAR option is not
-# used, the default is <UPPERCASED_NAME>_FOUND.
-#
-# As in the simple mode, if <var1> through <varN> are all valid,
-# <packagename>_FOUND will be set to TRUE.  After REQUIRED_VARS the
-# variables which are required for this package are listed.  Following
-# VERSION_VAR the name of the variable can be specified which holds the
-# version of the package which has been found.  If this is done, this
-# version will be checked against the (potentially) specified required
-# version used in the find_package() call.  The EXACT keyword is also
-# handled.  The default messages include information about the required
-# version and the version which has been actually found, both if the
-# version is ok or not.  If the package supports components, use the
-# HANDLE_COMPONENTS option to enable handling them.  In this case,
-# find_package_handle_standard_args() will report which components have
-# been found and which are missing, and the <packagename>_FOUND variable
-# will be set to FALSE if any of the required components (i.e.  not the
-# ones listed after OPTIONAL_COMPONENTS) are missing.  Use the option
-# CONFIG_MODE if your FindXXX.cmake module is a wrapper for a
-# find_package(...  NO_MODULE) call.  In this case VERSION_VAR will be
-# set to <NAME>_VERSION and the macro will automatically check whether
-# the Config module was found.  Via FAIL_MESSAGE a custom failure
-# message can be specified, if this is not used, the default message
-# will be displayed.
-#
-# Example for mode 1:
-#
-# ::
-#
-#     find_package_handle_standard_args(LibXml2  DEFAULT_MSG
-#       LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
-#
-#
-#
-# LibXml2 is considered to be found, if both LIBXML2_LIBRARY and
-# LIBXML2_INCLUDE_DIR are valid.  Then also LIBXML2_FOUND is set to
-# TRUE.  If it is not found and REQUIRED was used, it fails with
-# FATAL_ERROR, independent whether QUIET was used or not.  If it is
-# found, success will be reported, including the content of <var1>.  On
-# repeated Cmake runs, the same message won't be printed again.
-#
-# Example for mode 2:
-#
-# ::
-#
-#     find_package_handle_standard_args(LibXslt
-#       FOUND_VAR LibXslt_FOUND
-#       REQUIRED_VARS LibXslt_LIBRARIES LibXslt_INCLUDE_DIRS
-#       VERSION_VAR LibXslt_VERSION_STRING)
-#
-# In this case, LibXslt is considered to be found if the variable(s)
-# listed after REQUIRED_VAR are all valid, i.e.  LibXslt_LIBRARIES and
-# LibXslt_INCLUDE_DIRS in this case.  The result will then be stored in
-# LibXslt_FOUND .  Also the version of LibXslt will be checked by using
-# the version contained in LibXslt_VERSION_STRING.  Since no
-# FAIL_MESSAGE is given, the default messages will be printed.
-#
-# Another example for mode 2:
-#
-# ::
-#
-#     find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4)
-#     find_package_handle_standard_args(Automoc4  CONFIG_MODE)
-#
-# In this case, FindAutmoc4.cmake wraps a call to find_package(Automoc4
-# NO_MODULE) and adds an additional search directory for automoc4.  Here
-# the result will be stored in AUTOMOC4_FOUND.  The following
-# FIND_PACKAGE_HANDLE_STANDARD_ARGS() call produces a proper
-# success/error message.
-
-#=============================================================================
-# Copyright 2007-2009 Kitware, Inc.
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake)
-include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake)
-
-# internal helper macro
-macro(_FPHSA_FAILURE_MESSAGE _msg)
-  if (${_NAME}_FIND_REQUIRED)
-    message(FATAL_ERROR "${_msg}")
-  else ()
-    if (NOT ${_NAME}_FIND_QUIETLY)
-      message(STATUS "${_msg}")
-    endif ()
-  endif ()
-endmacro()
-
-
-# internal helper macro to generate the failure message when used in CONFIG_MODE:
-macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE)
-  # <name>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found:
-  if(${_NAME}_CONFIG)
-    _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing: ${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})")
-  else()
-    # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version.
-    # List them all in the error message:
-    if(${_NAME}_CONSIDERED_CONFIGS)
-      set(configsText "")
-      list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount)
-      math(EXPR configsCount "${configsCount} - 1")
-      foreach(currentConfigIndex RANGE ${configsCount})
-        list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename)
-        list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version)
-        set(configsText "${configsText}    ${filename} (version ${version})\n")
-      endforeach()
-      if (${_NAME}_NOT_FOUND_MESSAGE)
-        set(configsText "${configsText}    Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n")
-      endif()
-      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}")
-
-    else()
-      # Simple case: No Config-file was found at all:
-      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}")
-    endif()
-  endif()
-endmacro()
-
-
-function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG)
-
-# set up the arguments for CMAKE_PARSE_ARGUMENTS and check whether we are in
-# new extended or in the "old" mode:
-  set(options  CONFIG_MODE  HANDLE_COMPONENTS)
-  set(oneValueArgs  FAIL_MESSAGE  VERSION_VAR  FOUND_VAR)
-  set(multiValueArgs REQUIRED_VARS)
-  set(_KEYWORDS_FOR_EXTENDED_MODE  ${options} ${oneValueArgs} ${multiValueArgs} )
-  list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)
-
-  if(${INDEX} EQUAL -1)
-    set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})
-    set(FPHSA_REQUIRED_VARS ${ARGN})
-    set(FPHSA_VERSION_VAR)
-  else()
-
-    CMAKE_PARSE_ARGUMENTS(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${_FIRST_ARG} ${ARGN})
-
-    if(FPHSA_UNPARSED_ARGUMENTS)
-      message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")
-    endif()
-
-    if(NOT FPHSA_FAIL_MESSAGE)
-      set(FPHSA_FAIL_MESSAGE  "DEFAULT_MSG")
-    endif()
-  endif()
-
-# now that we collected all arguments, process them
-
-  if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG")
-    set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")
-  endif()
-
-  # In config-mode, we rely on the variable <package>_CONFIG, which is set by find_package()
-  # when it successfully found the config-file, including version checking:
-  if(FPHSA_CONFIG_MODE)
-    list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG)
-    list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS)
-    set(FPHSA_VERSION_VAR ${_NAME}_VERSION)
-  endif()
-
-  if(NOT FPHSA_REQUIRED_VARS)
-    message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")
-  endif()
-
-  list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)
-
-  string(TOUPPER ${_NAME} _NAME_UPPER)
-  string(TOLOWER ${_NAME} _NAME_LOWER)
-
-  if(FPHSA_FOUND_VAR)
-    if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$"  OR  FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$")
-      set(_FOUND_VAR ${FPHSA_FOUND_VAR})
-    else()
-      message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.")
-    endif()
-  else()
-    set(_FOUND_VAR ${_NAME_UPPER}_FOUND)
-  endif()
-
-  # collect all variables which were not found, so they can be printed, so the
-  # user knows better what went wrong (#6375)
-  set(MISSING_VARS "")
-  set(DETAILS "")
-  # check if all passed variables are valid
-  unset(${_FOUND_VAR})
-  foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})
-    if(NOT ${_CURRENT_VAR})
-      set(${_FOUND_VAR} FALSE)
-      set(MISSING_VARS "${MISSING_VARS} ${_CURRENT_VAR}")
-    else()
-      set(DETAILS "${DETAILS}[${${_CURRENT_VAR}}]")
-    endif()
-  endforeach()
-  if(NOT "${${_FOUND_VAR}}" STREQUAL "FALSE")
-    set(${_FOUND_VAR} TRUE)
-  endif()
-
-  # component handling
-  unset(FOUND_COMPONENTS_MSG)
-  unset(MISSING_COMPONENTS_MSG)
-
-  if(FPHSA_HANDLE_COMPONENTS)
-    foreach(comp ${${_NAME}_FIND_COMPONENTS})
-      if(${_NAME}_${comp}_FOUND)
-
-        if(NOT DEFINED FOUND_COMPONENTS_MSG)
-          set(FOUND_COMPONENTS_MSG "found components: ")
-        endif()
-        set(FOUND_COMPONENTS_MSG "${FOUND_COMPONENTS_MSG} ${comp}")
-
-      else()
-
-        if(NOT DEFINED MISSING_COMPONENTS_MSG)
-          set(MISSING_COMPONENTS_MSG "missing components: ")
-        endif()
-        set(MISSING_COMPONENTS_MSG "${MISSING_COMPONENTS_MSG} ${comp}")
-
-        if(${_NAME}_FIND_REQUIRED_${comp})
-          set(${_FOUND_VAR} FALSE)
-          set(MISSING_VARS "${MISSING_VARS} ${comp}")
-        endif()
-
-      endif()
-    endforeach()
-    set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}")
-    set(DETAILS "${DETAILS}[c${COMPONENT_MSG}]")
-  endif()
-
-  # version handling:
-  set(VERSION_MSG "")
-  set(VERSION_OK TRUE)
-  set(VERSION ${${FPHSA_VERSION_VAR}})
-
-  # check with DEFINED here as the requested or found version may be "0"
-  if (DEFINED ${_NAME}_FIND_VERSION)
-    if(DEFINED ${FPHSA_VERSION_VAR})
-
-      if(${_NAME}_FIND_VERSION_EXACT)       # exact version required
-        # count the dots in the version string
-        string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${VERSION}")
-        # add one dot because there is one dot more than there are components
-        string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS)
-        if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT)
-          # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT
-          # is at most 4 here. Therefore a simple lookup table is used.
-          if (${_NAME}_FIND_VERSION_COUNT EQUAL 1)
-            set(_VERSION_REGEX "[^.]*")
-          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2)
-            set(_VERSION_REGEX "[^.]*\\.[^.]*")
-          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3)
-            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*")
-          else ()
-            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*")
-          endif ()
-          string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${VERSION}")
-          unset(_VERSION_REGEX)
-          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD)
-            set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
-            set(VERSION_OK FALSE)
-          else ()
-            set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
-          endif ()
-          unset(_VERSION_HEAD)
-        else ()
-          if (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}")
-            set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
-            set(VERSION_OK FALSE)
-          else ()
-            set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
-          endif ()
-        endif ()
-        unset(_VERSION_DOTS)
-
-      else()     # minimum version specified:
-        if ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")
-          set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"")
-          set(VERSION_OK FALSE)
-        else ()
-          set(VERSION_MSG "(found suitable version \"${VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")")
-        endif ()
-      endif()
-
-    else()
-
-      # if the package was not found, but a version was given, add that to the output:
-      if(${_NAME}_FIND_VERSION_EXACT)
-         set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")")
-      else()
-         set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")")
-      endif()
-
-    endif()
-  else ()
-    if(VERSION)
-      set(VERSION_MSG "(found version \"${VERSION}\")")
-    endif()
-  endif ()
-
-  if(VERSION_OK)
-    set(DETAILS "${DETAILS}[v${VERSION}(${${_NAME}_FIND_VERSION})]")
-  else()
-    set(${_FOUND_VAR} FALSE)
-  endif()
-
-
-  # print the result:
-  if (${_FOUND_VAR})
-    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}")
-  else ()
-
-    if(FPHSA_CONFIG_MODE)
-      _FPHSA_HANDLE_FAILURE_CONFIG_MODE()
-    else()
-      if(NOT VERSION_OK)
-        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})")
-      else()
-        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}")
-      endif()
-    endif()
-
-  endif ()
-
-  set(${_FOUND_VAR} ${${_FOUND_VAR}} PARENT_SCOPE)
-
-endfunction()

Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageMessage.cmake

@@ -1,57 +0,0 @@
-#.rst:
-# FindPackageMessage
-# ------------------
-#
-#
-#
-# FIND_PACKAGE_MESSAGE(<name> "message for user" "find result details")
-#
-# This macro is intended to be used in FindXXX.cmake modules files.  It
-# will print a message once for each unique find result.  This is useful
-# for telling the user where a package was found.  The first argument
-# specifies the name (XXX) of the package.  The second argument
-# specifies the message to display.  The third argument lists details
-# about the find result so that if they change the message will be
-# displayed again.  The macro also obeys the QUIET argument to the
-# find_package command.
-#
-# Example:
-#
-# ::
-#
-#   if(X11_FOUND)
-#     FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}"
-#       "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
-#   else()
-#    ...
-#   endif()
-
-#=============================================================================
-# Copyright 2008-2009 Kitware, Inc.
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-function(FIND_PACKAGE_MESSAGE pkg msg details)
-  # Avoid printing a message repeatedly for the same find result.
-  if(NOT ${pkg}_FIND_QUIETLY)
-    string(REPLACE "\n" "" details "${details}")
-    set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg})
-    if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}")
-      # The message has not yet been printed.
-      message(STATUS "${msg}")
-
-      # Save the find details in the cache to avoid printing the same
-      # message again.
-      set("${DETAILS_VAR}" "${details}"
-        CACHE INTERNAL "Details about finding ${pkg}")
-    endif()
-  endif()
-endfunction()

Godeps/_workspace/src/github.com/ethereum/ethash/cryptopp/CMakeLists.txt

@@ -1,13 +0,0 @@
-set(LIBRARY cryptopp)
-
-include_directories(../../cryptopp)
-
-# todo, subset
-file(GLOB HEADERS "../../cryptopp/*.h")
-file(GLOB SOURCE "../../cryptopp/*.cpp")
-
-add_library(${LIBRARY} ${HEADERS} ${SOURCE})
-
-set(CRYPTOPP_INCLUDE_DIRS "../.." "../../../" PARENT_SCOPE)
-set(CRYPTOPP_LIBRARIES ${LIBRARY} PARENT_SCOPE)
-set(CRYPTOPP_FOUND TRUE PARENT_SCOPE)

Godeps/_workspace/src/github.com/ethereum/ethash/ethash_test.go

@@ -1,204 +0,0 @@
-package ethash
-
-import (
-	"bytes"
-	"crypto/rand"
-	"encoding/hex"
-	"log"
-	"math/big"
-	"os"
-	"sync"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-func init() {
-	// glog.SetV(6)
-	// glog.SetToStderr(true)
-}
-
-type testBlock struct {
-	difficulty  *big.Int
-	hashNoNonce common.Hash
-	nonce       uint64
-	mixDigest   common.Hash
-	number      uint64
-}
-
-func (b *testBlock) Difficulty() *big.Int     { return b.difficulty }
-func (b *testBlock) HashNoNonce() common.Hash { return b.hashNoNonce }
-func (b *testBlock) Nonce() uint64            { return b.nonce }
-func (b *testBlock) MixDigest() common.Hash   { return b.mixDigest }
-func (b *testBlock) NumberU64() uint64        { return b.number }
-
-var validBlocks = []*testBlock{
-	// from proof of concept nine testnet, epoch 0
-	{
-		number:      22,
-		hashNoNonce: common.HexToHash("372eca2454ead349c3df0ab5d00b0b706b23e49d469387db91811cee0358fc6d"),
-		difficulty:  big.NewInt(132416),
-		nonce:       0x495732e0ed7a801c,
-		mixDigest:   common.HexToHash("2f74cdeb198af0b9abe65d22d372e22fb2d474371774a9583c1cc427a07939f5"),
-	},
-	// from proof of concept nine testnet, epoch 1
-	{
-		number:      30001,
-		hashNoNonce: common.HexToHash("7e44356ee3441623bc72a683fd3708fdf75e971bbe294f33e539eedad4b92b34"),
-		difficulty:  big.NewInt(1532671),
-		nonce:       0x318df1c8adef7e5e,
-		mixDigest:   common.HexToHash("144b180aad09ae3c81fb07be92c8e6351b5646dda80e6844ae1b697e55ddde84"),
-	},
-	// from proof of concept nine testnet, epoch 2
-	{
-		number:      60000,
-		hashNoNonce: common.HexToHash("5fc898f16035bf5ac9c6d9077ae1e3d5fc1ecc3c9fd5bee8bb00e810fdacbaa0"),
-		difficulty:  big.NewInt(2467358),
-		nonce:       0x50377003e5d830ca,
-		mixDigest:   common.HexToHash("ab546a5b73c452ae86dadd36f0ed83a6745226717d3798832d1b20b489e82063"),
-	},
-}
-
-var invalidZeroDiffBlock = testBlock{
-	number:      61440000,
-	hashNoNonce: crypto.Sha3Hash([]byte("foo")),
-	difficulty:  big.NewInt(0),
-	nonce:       0xcafebabec00000fe,
-	mixDigest:   crypto.Sha3Hash([]byte("bar")),
-}
-
-func TestEthashVerifyValid(t *testing.T) {
-	eth := New()
-	for i, block := range validBlocks {
-		if !eth.Verify(block) {
-			t.Errorf("block %d (%x) did not validate.", i, block.hashNoNonce[:6])
-		}
-	}
-}
-
-func TestEthashVerifyInvalid(t *testing.T) {
-	eth := New()
-	if eth.Verify(&invalidZeroDiffBlock) {
-		t.Errorf("should not validate - we just ensure it does not panic on this block")
-	}
-}
-
-func TestEthashConcurrentVerify(t *testing.T) {
-	eth, err := NewForTesting()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(eth.Full.Dir)
-
-	block := &testBlock{difficulty: big.NewInt(10)}
-	nonce, md := eth.Search(block, nil)
-	block.nonce = nonce
-	block.mixDigest = common.BytesToHash(md)
-
-	// Verify the block concurrently to check for data races.
-	var wg sync.WaitGroup
-	wg.Add(100)
-	for i := 0; i < 100; i++ {
-		go func() {
-			if !eth.Verify(block) {
-				t.Error("Block could not be verified")
-			}
-			wg.Done()
-		}()
-	}
-	wg.Wait()
-}
-
-func TestEthashConcurrentSearch(t *testing.T) {
-	eth, err := NewForTesting()
-	if err != nil {
-		t.Fatal(err)
-	}
-	eth.Turbo(true)
-	defer os.RemoveAll(eth.Full.Dir)
-
-	type searchRes struct {
-		n  uint64
-		md []byte
-	}
-
-	var (
-		block   = &testBlock{difficulty: big.NewInt(35000)}
-		nsearch = 10
-		wg      = new(sync.WaitGroup)
-		found   = make(chan searchRes)
-		stop    = make(chan struct{})
-	)
-	rand.Read(block.hashNoNonce[:])
-	wg.Add(nsearch)
-	// launch n searches concurrently.
-	for i := 0; i < nsearch; i++ {
-		go func() {
-			nonce, md := eth.Search(block, stop)
-			select {
-			case found <- searchRes{n: nonce, md: md}:
-			case <-stop:
-			}
-			wg.Done()
-		}()
-	}
-
-	// wait for one of them to find the nonce
-	res := <-found
-	// stop the others
-	close(stop)
-	wg.Wait()
-
-	block.nonce = res.n
-	block.mixDigest = common.BytesToHash(res.md)
-	if !eth.Verify(block) {
-		t.Error("Block could not be verified")
-	}
-}
-
-func TestEthashSearchAcrossEpoch(t *testing.T) {
-	eth, err := NewForTesting()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(eth.Full.Dir)
-
-	for i := epochLength - 40; i < epochLength+40; i++ {
-		block := &testBlock{number: i, difficulty: big.NewInt(90)}
-		rand.Read(block.hashNoNonce[:])
-		nonce, md := eth.Search(block, nil)
-		block.nonce = nonce
-		block.mixDigest = common.BytesToHash(md)
-		if !eth.Verify(block) {
-			t.Fatalf("Block could not be verified")
-		}
-	}
-}
-
-func TestGetSeedHash(t *testing.T) {
-	seed0, err := GetSeedHash(0)
-	if err != nil {
-		t.Errorf("Failed to get seedHash for block 0: %v", err)
-	}
-	if bytes.Compare(seed0, make([]byte, 32)) != 0 {
-		log.Printf("seedHash for block 0 should be 0s, was: %v\n", seed0)
-	}
-	seed1, err := GetSeedHash(30000)
-	if err != nil {
-		t.Error(err)
-	}
-
-	// From python:
-	// > from pyethash import get_seedhash
-	// > get_seedhash(30000)
-	expectedSeed1, err := hex.DecodeString("290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563")
-	if err != nil {
-		t.Error(err)
-	}
-
-	if bytes.Compare(seed1, expectedSeed1) != 0 {
-		log.Printf("seedHash for block 1 should be: %v,\nactual value: %v\n", expectedSeed1, seed1)
-	}
-
-}

Godeps/_workspace/src/github.com/ethereum/ethash/js/ethash.js

@@ -1,190 +0,0 @@
-// ethash.js
-// Tim Hughes <tim@twistedfury.com>
-// Revision 19
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-var Keccak = require('./keccak');
-var util = require('./util');
-
-// 32-bit unsigned modulo
-function mod32(x, n)
-{
-	return (x>>>0) % (n>>>0);
-}
-
-function fnv(x, y)
-{
-	// js integer multiply by 0x01000193 will lose precision
-	return ((x*0x01000000 | 0) + (x*0x193 | 0)) ^ y;	
-}
-
-function computeCache(params, seedWords)
-{
-	var cache = new Uint32Array(params.cacheSize >> 2);
-	var cacheNodeCount = params.cacheSize >> 6;
-
-	// Initialize cache
-	var keccak = new Keccak();
-	keccak.digestWords(cache, 0, 16, seedWords, 0, seedWords.length);
-	for (var n = 1; n < cacheNodeCount; ++n)
-	{
-		keccak.digestWords(cache, n<<4, 16, cache, (n-1)<<4, 16);
-	}
-	
-	var tmp = new Uint32Array(16);
-	
-	// Do randmemohash passes
-	for (var r = 0; r < params.cacheRounds; ++r)
-	{
-		for (var n = 0; n < cacheNodeCount; ++n)
-		{
-			var p0 = mod32(n + cacheNodeCount - 1, cacheNodeCount) << 4;
-			var p1 = mod32(cache[n<<4|0], cacheNodeCount) << 4;
-			
-			for (var w = 0; w < 16; w=(w+1)|0)
-			{
-				tmp[w] = cache[p0 | w] ^ cache[p1 | w];
-			}
-			
-			keccak.digestWords(cache, n<<4, 16, tmp, 0, tmp.length);
-		}
-	}	
-	return cache;
-}
-
-function computeDagNode(o_node, params, cache, keccak, nodeIndex)
-{
-	var cacheNodeCount = params.cacheSize >> 6;
-	var dagParents = params.dagParents;
-	
-	var c = (nodeIndex % cacheNodeCount) << 4;
-	var mix = o_node;
-	for (var w = 0; w < 16; ++w)
-	{
-		mix[w] = cache[c|w];
-	}
-	mix[0] ^= nodeIndex;
-	keccak.digestWords(mix, 0, 16, mix, 0, 16);
-	
-	for (var p = 0; p < dagParents; ++p)
-	{
-		// compute cache node (word) index
-		c = mod32(fnv(nodeIndex ^ p, mix[p&15]), cacheNodeCount) << 4;
-		
-		for (var w = 0; w < 16; ++w)
-		{
-			mix[w] = fnv(mix[w], cache[c|w]);
-		}
-	}
-	
-	keccak.digestWords(mix, 0, 16, mix, 0, 16);
-}
-
-function computeHashInner(mix, params, cache, keccak, tempNode)
-{
-	var mixParents = params.mixParents|0;
-	var mixWordCount = params.mixSize >> 2;
-	var mixNodeCount = mixWordCount >> 4;
-	var dagPageCount = (params.dagSize / params.mixSize) >> 0;
-	
-	// grab initial first word
-	var s0 = mix[0];
-	
-	// initialise mix from initial 64 bytes
-	for (var w = 16; w < mixWordCount; ++w)
-	{
-		mix[w] = mix[w & 15];
-	}
-	
-	for (var a = 0; a < mixParents; ++a)
-	{
-		var p = mod32(fnv(s0 ^ a, mix[a & (mixWordCount-1)]), dagPageCount);
-		var d = (p * mixNodeCount)|0;
-		
-		for (var n = 0, w = 0; n < mixNodeCount; ++n, w += 16)
-		{
-			computeDagNode(tempNode, params, cache, keccak, (d + n)|0);
-			
-			for (var v = 0; v < 16; ++v)
-			{
-				mix[w|v] = fnv(mix[w|v], tempNode[v]);
-			}
-		}
-	}
-}
-
-function convertSeed(seed)
-{
-	// todo, reconcile with spec, byte ordering?
-	// todo, big-endian conversion
-	var newSeed = util.toWords(seed);
-	if (newSeed === null)
-		throw Error("Invalid seed '" + seed + "'");
-	return newSeed;
-}
-
-exports.defaultParams = function()
-{
-	return {
-		cacheSize: 1048384,
-		cacheRounds: 3,
-		dagSize: 1073739904,
-		dagParents: 256,
-		mixSize: 128,
-		mixParents: 64,
-	};
-};
-
-exports.Ethash = function(params, seed)
-{
-	// precompute cache and related values
-	seed = convertSeed(seed);
-	var cache = computeCache(params, seed);
-	
-	// preallocate buffers/etc
-	var initBuf = new ArrayBuffer(96);
-	var initBytes = new Uint8Array(initBuf);
-	var initWords = new Uint32Array(initBuf);
-	var mixWords = new Uint32Array(params.mixSize / 4);
-	var tempNode = new Uint32Array(16);
-	var keccak = new Keccak();
-	
-	var retWords = new Uint32Array(8);
-	var retBytes = new Uint8Array(retWords.buffer); // supposedly read-only
-	
-	this.hash = function(header, nonce)
-	{
-		// compute initial hash
-		initBytes.set(header, 0);
-		initBytes.set(nonce, 32);
-		keccak.digestWords(initWords, 0, 16, initWords, 0, 8 + nonce.length/4);
-		
-		// compute mix
-		for (var i = 0; i != 16; ++i)
-		{
-			mixWords[i] = initWords[i];
-		}
-		computeHashInner(mixWords, params, cache, keccak, tempNode);
-		
-		// compress mix and append to initWords
-		for (var i = 0; i != mixWords.length; i += 4)
-		{
-			initWords[16 + i/4] = fnv(fnv(fnv(mixWords[i], mixWords[i+1]), mixWords[i+2]), mixWords[i+3]);
-		}
-			
-		// final Keccak hashes
-		keccak.digestWords(retWords, 0, 8, initWords, 0, 24); // Keccak-256(s + cmix)
-		return retBytes;
-	};
-	
-	this.cacheDigest = function()
-	{
-		return keccak.digest(32, new Uint8Array(cache.buffer));
-	};
-};
-
-
-
-

Godeps/_workspace/src/github.com/ethereum/ethash/js/keccak.js

@@ -1,404 +0,0 @@
-// keccak.js
-// Tim Hughes <tim@twistedfury.com>
-// derived from Markku-Juhani O. Saarinen's C code (http://keccak.noekeon.org/readable_code.html)
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-var Keccak_f1600_RC = new Uint32Array([
-	0x00000001, 0x00000000,
-	0x00008082, 0x00000000,
-	0x0000808a, 0x80000000,
-	0x80008000, 0x80000000,
-	0x0000808b, 0x00000000,
-	0x80000001, 0x00000000,
-	0x80008081, 0x80000000,
-	0x00008009, 0x80000000,
-	0x0000008a, 0x00000000,
-	0x00000088, 0x00000000,
-	0x80008009, 0x00000000,
-	0x8000000a, 0x00000000,
-	0x8000808b, 0x00000000,
-	0x0000008b, 0x80000000,
-	0x00008089, 0x80000000,
-	0x00008003, 0x80000000,
-	0x00008002, 0x80000000,
-	0x00000080, 0x80000000,
-	0x0000800a, 0x00000000,
-	0x8000000a, 0x80000000,
-	0x80008081, 0x80000000,
-	0x00008080, 0x80000000,
-	0x80000001, 0x00000000,
-	0x80008008, 0x80000000
-]);
-
-function keccak_f1600(outState, outOffset, outSize, inState)
-{
-	// todo, handle big endian loads
-	var a00l = inState[0]|0;
-	var a00h = inState[1]|0;
-	var a01l = inState[2]|0;
-	var a01h = inState[3]|0;
-	var a02l = inState[4]|0;
-	var a02h = inState[5]|0;
-	var a03l = inState[6]|0;
-	var a03h = inState[7]|0;
-	var a04l = inState[8]|0;
-	var a04h = inState[9]|0;
-	var a05l = inState[10]|0;
-	var a05h = inState[11]|0;
-	var a06l = inState[12]|0;
-	var a06h = inState[13]|0;
-	var a07l = inState[14]|0;
-	var a07h = inState[15]|0;
-	var a08l = inState[16]|0;
-	var a08h = inState[17]|0;
-	var a09l = inState[18]|0;
-	var a09h = inState[19]|0;
-	var a10l = inState[20]|0;
-	var a10h = inState[21]|0;
-	var a11l = inState[22]|0;
-	var a11h = inState[23]|0;
-	var a12l = inState[24]|0;
-	var a12h = inState[25]|0;
-	var a13l = inState[26]|0;
-	var a13h = inState[27]|0;
-	var a14l = inState[28]|0;
-	var a14h = inState[29]|0;
-	var a15l = inState[30]|0;
-	var a15h = inState[31]|0;
-	var a16l = inState[32]|0;
-	var a16h = inState[33]|0;
-	var a17l = inState[34]|0;
-	var a17h = inState[35]|0;
-	var a18l = inState[36]|0;
-	var a18h = inState[37]|0;
-	var a19l = inState[38]|0;
-	var a19h = inState[39]|0;
-	var a20l = inState[40]|0;
-	var a20h = inState[41]|0;
-	var a21l = inState[42]|0;
-	var a21h = inState[43]|0;
-	var a22l = inState[44]|0;
-	var a22h = inState[45]|0;
-	var a23l = inState[46]|0;
-	var a23h = inState[47]|0;
-	var a24l = inState[48]|0;
-	var a24h = inState[49]|0;
-	var b00l, b00h, b01l, b01h, b02l, b02h, b03l, b03h, b04l, b04h;
-	var b05l, b05h, b06l, b06h, b07l, b07h, b08l, b08h, b09l, b09h;
-	var b10l, b10h, b11l, b11h, b12l, b12h, b13l, b13h, b14l, b14h;
-	var b15l, b15h, b16l, b16h, b17l, b17h, b18l, b18h, b19l, b19h;
-	var b20l, b20h, b21l, b21h, b22l, b22h, b23l, b23h, b24l, b24h;
-	var tl, nl;
-	var th, nh;
-
-	for (var r = 0; r < 48; r = (r+2)|0)
-	{
-		// Theta
-		b00l = a00l ^ a05l ^ a10l ^ a15l ^ a20l;
-		b00h = a00h ^ a05h ^ a10h ^ a15h ^ a20h;
-		b01l = a01l ^ a06l ^ a11l ^ a16l ^ a21l;
-		b01h = a01h ^ a06h ^ a11h ^ a16h ^ a21h;
-		b02l = a02l ^ a07l ^ a12l ^ a17l ^ a22l;
-		b02h = a02h ^ a07h ^ a12h ^ a17h ^ a22h;
-		b03l = a03l ^ a08l ^ a13l ^ a18l ^ a23l;
-		b03h = a03h ^ a08h ^ a13h ^ a18h ^ a23h;
-		b04l = a04l ^ a09l ^ a14l ^ a19l ^ a24l;
-		b04h = a04h ^ a09h ^ a14h ^ a19h ^ a24h;
-		tl = b04l ^ (b01l << 1 | b01h >>> 31);
-		th = b04h ^ (b01h << 1 | b01l >>> 31);
-		a00l ^= tl;
-		a00h ^= th;
-		a05l ^= tl;
-		a05h ^= th;
-		a10l ^= tl;
-		a10h ^= th;
-		a15l ^= tl;
-		a15h ^= th;
-		a20l ^= tl;
-		a20h ^= th;
-		tl = b00l ^ (b02l << 1 | b02h >>> 31);
-		th = b00h ^ (b02h << 1 | b02l >>> 31);
-		a01l ^= tl;
-		a01h ^= th;
-		a06l ^= tl;
-		a06h ^= th;
-		a11l ^= tl;
-		a11h ^= th;
-		a16l ^= tl;
-		a16h ^= th;
-		a21l ^= tl;
-		a21h ^= th;
-		tl = b01l ^ (b03l << 1 | b03h >>> 31);
-		th = b01h ^ (b03h << 1 | b03l >>> 31);
-		a02l ^= tl;
-		a02h ^= th;
-		a07l ^= tl;
-		a07h ^= th;
-		a12l ^= tl;
-		a12h ^= th;
-		a17l ^= tl;
-		a17h ^= th;
-		a22l ^= tl;
-		a22h ^= th;
-		tl = b02l ^ (b04l << 1 | b04h >>> 31);
-		th = b02h ^ (b04h << 1 | b04l >>> 31);
-		a03l ^= tl;
-		a03h ^= th;
-		a08l ^= tl;
-		a08h ^= th;
-		a13l ^= tl;
-		a13h ^= th;
-		a18l ^= tl;
-		a18h ^= th;
-		a23l ^= tl;
-		a23h ^= th;
-		tl = b03l ^ (b00l << 1 | b00h >>> 31);
-		th = b03h ^ (b00h << 1 | b00l >>> 31);
-		a04l ^= tl;
-		a04h ^= th;
-		a09l ^= tl;
-		a09h ^= th;
-		a14l ^= tl;
-		a14h ^= th;
-		a19l ^= tl;
-		a19h ^= th;
-		a24l ^= tl;
-		a24h ^= th;
-
-		// Rho Pi
-		b00l = a00l;
-		b00h = a00h;
-		b10l = a01l << 1 | a01h >>> 31;
-		b10h = a01h << 1 | a01l >>> 31;
-		b07l = a10l << 3 | a10h >>> 29;
-		b07h = a10h << 3 | a10l >>> 29;
-		b11l = a07l << 6 | a07h >>> 26;
-		b11h = a07h << 6 | a07l >>> 26;
-		b17l = a11l << 10 | a11h >>> 22;
-		b17h = a11h << 10 | a11l >>> 22;
-		b18l = a17l << 15 | a17h >>> 17;
-		b18h = a17h << 15 | a17l >>> 17;
-		b03l = a18l << 21 | a18h >>> 11;
-		b03h = a18h << 21 | a18l >>> 11;
-		b05l = a03l << 28 | a03h >>> 4;
-		b05h = a03h << 28 | a03l >>> 4;
-		b16l = a05h << 4 | a05l >>> 28;
-		b16h = a05l << 4 | a05h >>> 28;
-		b08l = a16h << 13 | a16l >>> 19;
-		b08h = a16l << 13 | a16h >>> 19;
-		b21l = a08h << 23 | a08l >>> 9;
-		b21h = a08l << 23 | a08h >>> 9;
-		b24l = a21l << 2 | a21h >>> 30;
-		b24h = a21h << 2 | a21l >>> 30;
-		b04l = a24l << 14 | a24h >>> 18;
-		b04h = a24h << 14 | a24l >>> 18;
-		b15l = a04l << 27 | a04h >>> 5;
-		b15h = a04h << 27 | a04l >>> 5;
-		b23l = a15h << 9 | a15l >>> 23;
-		b23h = a15l << 9 | a15h >>> 23;
-		b19l = a23h << 24 | a23l >>> 8;
-		b19h = a23l << 24 | a23h >>> 8;
-		b13l = a19l << 8 | a19h >>> 24;
-		b13h = a19h << 8 | a19l >>> 24;
-		b12l = a13l << 25 | a13h >>> 7;
-		b12h = a13h << 25 | a13l >>> 7;
-		b02l = a12h << 11 | a12l >>> 21;
-		b02h = a12l << 11 | a12h >>> 21;
-		b20l = a02h << 30 | a02l >>> 2;
-		b20h = a02l << 30 | a02h >>> 2;
-		b14l = a20l << 18 | a20h >>> 14;
-		b14h = a20h << 18 | a20l >>> 14;
-		b22l = a14h << 7 | a14l >>> 25;
-		b22h = a14l << 7 | a14h >>> 25;
-		b09l = a22h << 29 | a22l >>> 3;
-		b09h = a22l << 29 | a22h >>> 3;
-		b06l = a09l << 20 | a09h >>> 12;
-		b06h = a09h << 20 | a09l >>> 12;
-		b01l = a06h << 12 | a06l >>> 20;
-		b01h = a06l << 12 | a06h >>> 20;
-
-		// Chi
-		a00l = b00l ^ ~b01l & b02l;
-		a00h = b00h ^ ~b01h & b02h;
-		a01l = b01l ^ ~b02l & b03l;
-		a01h = b01h ^ ~b02h & b03h;
-		a02l = b02l ^ ~b03l & b04l;
-		a02h = b02h ^ ~b03h & b04h;
-		a03l = b03l ^ ~b04l & b00l;
-		a03h = b03h ^ ~b04h & b00h;
-		a04l = b04l ^ ~b00l & b01l;
-		a04h = b04h ^ ~b00h & b01h;
-		a05l = b05l ^ ~b06l & b07l;
-		a05h = b05h ^ ~b06h & b07h;
-		a06l = b06l ^ ~b07l & b08l;
-		a06h = b06h ^ ~b07h & b08h;
-		a07l = b07l ^ ~b08l & b09l;
-		a07h = b07h ^ ~b08h & b09h;
-		a08l = b08l ^ ~b09l & b05l;
-		a08h = b08h ^ ~b09h & b05h;
-		a09l = b09l ^ ~b05l & b06l;
-		a09h = b09h ^ ~b05h & b06h;
-		a10l = b10l ^ ~b11l & b12l;
-		a10h = b10h ^ ~b11h & b12h;
-		a11l = b11l ^ ~b12l & b13l;
-		a11h = b11h ^ ~b12h & b13h;
-		a12l = b12l ^ ~b13l & b14l;
-		a12h = b12h ^ ~b13h & b14h;
-		a13l = b13l ^ ~b14l & b10l;
-		a13h = b13h ^ ~b14h & b10h;
-		a14l = b14l ^ ~b10l & b11l;
-		a14h = b14h ^ ~b10h & b11h;
-		a15l = b15l ^ ~b16l & b17l;
-		a15h = b15h ^ ~b16h & b17h;
-		a16l = b16l ^ ~b17l & b18l;
-		a16h = b16h ^ ~b17h & b18h;
-		a17l = b17l ^ ~b18l & b19l;
-		a17h = b17h ^ ~b18h & b19h;
-		a18l = b18l ^ ~b19l & b15l;
-		a18h = b18h ^ ~b19h & b15h;
-		a19l = b19l ^ ~b15l & b16l;
-		a19h = b19h ^ ~b15h & b16h;
-		a20l = b20l ^ ~b21l & b22l;
-		a20h = b20h ^ ~b21h & b22h;
-		a21l = b21l ^ ~b22l & b23l;
-		a21h = b21h ^ ~b22h & b23h;
-		a22l = b22l ^ ~b23l & b24l;
-		a22h = b22h ^ ~b23h & b24h;
-		a23l = b23l ^ ~b24l & b20l;
-		a23h = b23h ^ ~b24h & b20h;
-		a24l = b24l ^ ~b20l & b21l;
-		a24h = b24h ^ ~b20h & b21h;
-
-		// Iota
-		a00l ^= Keccak_f1600_RC[r|0];
-		a00h ^= Keccak_f1600_RC[r|1];
-	}
-	
-	// todo, handle big-endian stores
-	outState[outOffset|0] = a00l;
-	outState[outOffset|1] = a00h;
-	outState[outOffset|2] = a01l;
-	outState[outOffset|3] = a01h;
-	outState[outOffset|4] = a02l;
-	outState[outOffset|5] = a02h;
-	outState[outOffset|6] = a03l;
-	outState[outOffset|7] = a03h;
-	if (outSize == 8)
-		return;
-	outState[outOffset|8] = a04l;
-	outState[outOffset|9] = a04h;
-	outState[outOffset|10] = a05l;
-	outState[outOffset|11] = a05h;
-	outState[outOffset|12] = a06l;
-	outState[outOffset|13] = a06h;
-	outState[outOffset|14] = a07l;
-	outState[outOffset|15] = a07h;
-	if (outSize == 16)
-		return;
-	outState[outOffset|16] = a08l;
-	outState[outOffset|17] = a08h;
-	outState[outOffset|18] = a09l;
-	outState[outOffset|19] = a09h;
-	outState[outOffset|20] = a10l;
-	outState[outOffset|21] = a10h;
-	outState[outOffset|22] = a11l;
-	outState[outOffset|23] = a11h;
-	outState[outOffset|24] = a12l;
-	outState[outOffset|25] = a12h;
-	outState[outOffset|26] = a13l;
-	outState[outOffset|27] = a13h;
-	outState[outOffset|28] = a14l;
-	outState[outOffset|29] = a14h;
-	outState[outOffset|30] = a15l;
-	outState[outOffset|31] = a15h;
-	outState[outOffset|32] = a16l;
-	outState[outOffset|33] = a16h;
-	outState[outOffset|34] = a17l;
-	outState[outOffset|35] = a17h;
-	outState[outOffset|36] = a18l;
-	outState[outOffset|37] = a18h;
-	outState[outOffset|38] = a19l;
-	outState[outOffset|39] = a19h;
-	outState[outOffset|40] = a20l;
-	outState[outOffset|41] = a20h;
-	outState[outOffset|42] = a21l;
-	outState[outOffset|43] = a21h;
-	outState[outOffset|44] = a22l;
-	outState[outOffset|45] = a22h;
-	outState[outOffset|46] = a23l;
-	outState[outOffset|47] = a23h;
-	outState[outOffset|48] = a24l;
-	outState[outOffset|49] = a24h;
-}
-
-var Keccak = function()
-{
-	var stateBuf = new ArrayBuffer(200);
-	var stateBytes = new Uint8Array(stateBuf);
-	var stateWords = new Uint32Array(stateBuf);
-	
-	this.digest = function(oSize, iBytes)
-	{
-		for (var i = 0; i < 50; ++i)
-		{
-			stateWords[i] = 0;
-		}
-		
-		var r = 200 - oSize*2;
-		var iLength = iBytes.length;
-		var iOffset = 0;	
-		for ( ; ;)
-		{
-			var len = iLength < r ? iLength : r;
-			for (i = 0; i < len; ++i, ++iOffset)
-			{
-				stateBytes[i] ^= iBytes[iOffset];
-			}
-			
-			if (iLength < r)
-				break;
-			iLength -= len;
-			
-			keccak_f1600(stateWords, 0, 50, stateWords);
-		}
-		
-		stateBytes[iLength] ^= 1;
-		stateBytes[r-1] ^= 0x80;
-		keccak_f1600(stateWords, 0, 50, stateWords);
-		return stateBytes.subarray(0, oSize);
-	};
-	
-	this.digestWords = function(oWords, oOffset, oLength, iWords, iOffset, iLength)
-	{
-		for (var i = 0; i < 50; ++i)
-		{
-			stateWords[i] = 0;
-		}
-		
-		var r = 50 - oLength*2;
-		for (; ; )
-		{
-			var len = iLength < r ? iLength : r;
-			for (i = 0; i < len; ++i, ++iOffset)
-			{
-				stateWords[i] ^= iWords[iOffset];
-			}
-			
-			if (iLength < r)
-				break;
-			iLength -= len;
-			
-			keccak_f1600(stateWords, 0, 50, stateWords);
-		}
-		
-		stateBytes[iLength<<2] ^= 1;
-		stateBytes[(r<<2) - 1] ^= 0x80;
-		keccak_f1600(oWords, oOffset, oLength, stateWords);
-	};
-};
-
-module.exports = Keccak;
-
-

Godeps/_workspace/src/github.com/ethereum/ethash/js/makekeccak.js

@@ -1,201 +0,0 @@
-#!/usr/bin/env node
-// makekeccak.js
-// Tim Hughes <tim@twistedfury.com>
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-var Keccak_f1600_Rho = [
-	1,  3,  6,  10, 15, 21, 28, 36, 45, 55, 2,  14, 
-	27, 41, 56, 8,  25, 43, 62, 18, 39, 61, 20, 44
-];
-
-var Keccak_f1600_Pi= [
-	10, 7,  11, 17, 18, 3, 5,  16, 8,  21, 24, 4, 
-	15, 23, 19, 13, 12, 2, 20, 14, 22, 9,  6,  1 
-];
-
-var Keccak_f1600_RC = [ 
-	0x00000001, 0x00000000,
-	0x00008082, 0x00000000,
-	0x0000808a, 0x80000000,
-	0x80008000, 0x80000000,
-	0x0000808b, 0x00000000,
-	0x80000001, 0x00000000,
-	0x80008081, 0x80000000,
-	0x00008009, 0x80000000,
-	0x0000008a, 0x00000000,
-	0x00000088, 0x00000000,
-	0x80008009, 0x00000000,
-	0x8000000a, 0x00000000,
-	0x8000808b, 0x00000000,
-	0x0000008b, 0x80000000,
-	0x00008089, 0x80000000,
-	0x00008003, 0x80000000,
-	0x00008002, 0x80000000,
-	0x00000080, 0x80000000,
-	0x0000800a, 0x00000000,
-	0x8000000a, 0x80000000,
-	0x80008081, 0x80000000,
-	0x00008080, 0x80000000,
-	0x80000001, 0x00000000,
-	0x80008008, 0x80000000,
-];
-
-function makeRotLow(lo, hi, n)
-{
-	if (n === 0 || n === 32) throw Error("unsupported");
-	if ((n & 0x20) !== 0)
-	{
-		n &= ~0x20;
-		var t = hi;
-		hi = lo;
-		lo = t;
-	}
-	var hir = hi + " >>> " + (32 - n);
-	var los = lo + " << " + n;
-	return los + " | " + hir;
-}
-
-function makeRotHigh(lo, hi, n)
-{
-	if (n === 0 || n === 32) throw Error("unsupported");
-	if ((n & 0x20) !== 0)
-	{
-		n &= ~0x20;
-		var t = hi;
-		hi = lo;
-		lo = t;
-	}
-	var his = hi + " << " + n;
-	var lor = lo + " >>> " + (32 - n);
-	return his + " | " + lor;
-}
-
-function makeKeccak_f1600()
-{
-	var format = function(n)
-	{
-		return n < 10 ? "0"+n : ""+n;
-	};
-	
-	var a = function(n, w)
-	{
-		return "a" + format(n) + (w !== 0?'h':'l');
-	};
-	
-	var b = function(n, w)
-	{
-		return "b" + format(n) + (w !== 0?'h':'l');
-	};
-	
-	var str = "";	
-	str += "function keccak_f1600(outState, outOffset, outSize, inState)\n";
-	str += "{\n";
-	
-	for (var i = 0; i < 25; ++i)
-	{
-		for (var w = 0; w <= 1; ++w)
-		{
-			str += "\tvar " + a(i,w) + " = inState["+(i<<1|w)+"]|0;\n";
-		}
-	}
-	
-	for (var j = 0; j < 5; ++j)
-	{
-		str += "\tvar ";
-		for (var i = 0; i < 5; ++i)
-		{
-			if (i !== 0)
-				str += ", ";
-			str += b(j*5+i,0) + ", " + b(j*5+i,1);
-		}
-		str += ";\n";
-	}
-	
-	str += "\tvar tl, th;\n";
-	str += "\n";
-	str += "\tfor (var r = 0; r < 48; r = (r+2)|0)\n";
-	str += "\t{\n";
-	
-	
-	// Theta
-	str += "\t\t// Theta\n";
-	for (var i = 0; i < 5; ++i)
-	{
-		for (var w = 0; w <= 1; ++w)
-		{
-			str += "\t\t" + b(i,w) + " = " + a(i,w) + " ^ " + a(i+5,w) + " ^ " + a(i+10,w) + " ^ " + a(i+15,w) + " ^ " + a(i+20,w) + ";\n";
-		}
-	}
-	
-	for (var i = 0; i < 5; ++i)
-	{
-		var i4 = (i + 4) % 5;
-		var i1 = (i + 1) % 5;
-		str += "\t\ttl = " + b(i4,0) + " ^ (" + b(i1,0) + " << 1 | " + b(i1,1) + " >>> 31);\n";
-		str += "\t\tth = " + b(i4,1) + " ^ (" + b(i1,1) + " << 1 | " + b(i1,0) + " >>> 31);\n";
-
-		for (var j = 0; j < 25; j = (j+5)|0)
-		{
-			str += "\t\t" + a((j+i),0) + " ^= tl;\n";
-			str += "\t\t" + a((j+i),1) + " ^= th;\n";
-		}
-	}
-	
-
-	// Rho Pi
-	str += "\n\t\t// Rho Pi\n";
-	for (var w = 0; w <= 1; ++w)
-	{
-		str += "\t\t" + b(0,w) + " = " + a(0,w) + ";\n";
-	}
-	var opi = 1;
-	for (var i = 0; i < 24; ++i)
-	{
-		var pi = Keccak_f1600_Pi[i];
-		str += "\t\t" + b(pi,0) + " = " + makeRotLow(a(opi,0), a(opi,1), Keccak_f1600_Rho[i]) + ";\n";
-		str += "\t\t" + b(pi,1) + " = " + makeRotHigh(a(opi,0), a(opi,1), Keccak_f1600_Rho[i]) + ";\n";
-		opi = pi;
-	}
-	
-	//  Chi
-	str += "\n\t\t// Chi\n";
-	for (var j = 0; j < 25; j += 5)
-	{
-		for (var i = 0; i < 5; ++i)
-		{
-			for (var w = 0; w <= 1; ++w)
-			{
-				str += "\t\t" + a(j+i,w) + " = " + b(j+i,w) + " ^ ~" + b(j+(i+1)%5,w) + " & " + b(j+(i+2)%5,w) + ";\n";
-			}
-		}
-	}
-
-	//  Iota
-	str += "\n\t\t// Iota\n";
-	for (var w = 0; w <= 1; ++w)
-	{
-		str += "\t\t" + a(0,w) + " ^= Keccak_f1600_RC[r|" + w + "];\n";
-	}
-	
-	
-	str += "\t}\n";
-	
-	for (var i = 0; i < 25; ++i)
-	{
-		if (i == 4 || i == 8)
-		{
-			str += "\tif (outSize == " + i*2 + ")\n\t\treturn;\n";
-		}
-		for (var w = 0; w <= 1; ++w)
-		{
-			str += "\toutState[outOffset|"+(i<<1|w)+"] = " + a(i,w) + ";\n";
-		}
-	}
-	str += "}\n";
-	
-	return str;
-}
-
-console.log(makeKeccak_f1600());

Godeps/_workspace/src/github.com/ethereum/ethash/js/test.js

@@ -1,53 +0,0 @@
-// test.js
-// Tim Hughes <tim@twistedfury.com>
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-var ethash = require('./ethash');
-var util = require('./util');
-var Keccak = require('./keccak');
-
-// sanity check hash functions
-var src = util.stringToBytes("");
-if (util.bytesToHexString(new Keccak().digest(32, src)) != "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") throw Error("Keccak-256 failed");
-if (util.bytesToHexString(new Keccak().digest(64, src)) != "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e") throw Error("Keccak-512 failed");
-
-src = new Uint32Array(src.buffer);
-var dst = new Uint32Array(8);
-new Keccak().digestWords(dst, 0, dst.length, src, 0, src.length);
-if (util.wordsToHexString(dst) != "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") throw Error("Keccak-256 Fast failed");
-
-var dst = new Uint32Array(16);
-new Keccak().digestWords(dst, 0, dst.length, src, 0, src.length);
-if (util.wordsToHexString(dst) != "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e") throw Error("Keccak-512 Fast failed");
-
-
-// init params
-var ethashParams = ethash.defaultParams();
-//ethashParams.cacheRounds = 0;
-
-// create hasher
-var seed = util.hexStringToBytes("9410b944535a83d9adf6bbdcc80e051f30676173c16ca0d32d6f1263fc246466")
-var startTime = new Date().getTime();
-var hasher = new ethash.Ethash(ethashParams, seed);
-console.log('Ethash startup took: '+(new Date().getTime() - startTime) + "ms");
-console.log('Ethash cache hash: ' + util.bytesToHexString(hasher.cacheDigest()));
-
-var testHexString = "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470";
-if (testHexString != util.bytesToHexString(util.hexStringToBytes(testHexString)))
-	throw Error("bytesToHexString or hexStringToBytes broken");
-
-		
-var header = util.hexStringToBytes("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470");
-var nonce = util.hexStringToBytes("0000000000000000");
-var hash;
-
-startTime = new Date().getTime();
-var trials = 10;
-for (var i = 0; i < trials; ++i)
-{
-	hash = hasher.hash(header, nonce);
-}
-console.log("Light client hashes averaged: " + (new Date().getTime() - startTime)/trials + "ms");
-console.log("Hash = " + util.bytesToHexString(hash));

Godeps/_workspace/src/github.com/ethereum/ethash/js/util.js

@@ -1,100 +0,0 @@
-// util.js
-// Tim Hughes <tim@twistedfury.com>
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-function nibbleToChar(nibble)
-{
-	return String.fromCharCode((nibble < 10 ? 48 : 87) + nibble);
-}
-
-function charToNibble(chr)
-{
-	if (chr >= 48 && chr <= 57)
-	{
-		return chr - 48;
-	}
-	if (chr >= 65 && chr <= 70)
-	{
-		return chr - 65 + 10;
-	}
-	if (chr >= 97 && chr <= 102)
-	{
-		return chr - 97 + 10;
-	}
-	return 0;
-}
-
-function stringToBytes(str)
-{
-	var bytes = new Uint8Array(str.length);
-	for (var i = 0; i != str.length; ++i)
-	{
-		bytes[i] = str.charCodeAt(i);
-	}
-	return bytes;
-}
-
-function hexStringToBytes(str)
-{
-	var bytes = new Uint8Array(str.length>>>1);
-	for (var i = 0; i != bytes.length; ++i)
-	{
-		bytes[i] = charToNibble(str.charCodeAt(i<<1 | 0)) << 4;
-		bytes[i] |= charToNibble(str.charCodeAt(i<<1 | 1));
-	}
-	return bytes;
-}
-
-function bytesToHexString(bytes)
-{
-	var str = "";
-	for (var i = 0; i != bytes.length; ++i)
-	{
-		str += nibbleToChar(bytes[i] >>> 4);
-		str += nibbleToChar(bytes[i] & 0xf);
-	}
-	return str;
-}
-
-function wordsToHexString(words)
-{
-	return bytesToHexString(new Uint8Array(words.buffer));
-}
-
-function uint32ToHexString(num)
-{
-	var buf = new Uint8Array(4);
-	buf[0] = (num >> 24) & 0xff;
-	buf[1] = (num >> 16) & 0xff;
-	buf[2] = (num >> 8) & 0xff;
-	buf[3] = (num >> 0) & 0xff;
-	return bytesToHexString(buf);
-}
-
-function toWords(input)
-{
-	if (input instanceof Uint32Array)
-	{
-		return input;
-	}
-	else if (input instanceof Uint8Array)
-	{
-		var tmp = new Uint8Array((input.length + 3) & ~3);
-		tmp.set(input);
-		return new Uint32Array(tmp.buffer);
-	}
-	else if (typeof input === typeof "")
-	{
-		return toWords(stringToBytes(input));
-	}
-	return null;
-}
-
-exports.stringToBytes = stringToBytes;
-exports.hexStringToBytes = hexStringToBytes;
-exports.bytesToHexString = bytesToHexString;
-exports.wordsToHexString = wordsToHexString;
-exports.uint32ToHexString = uint32ToHexString;
-exports.toWords = toWords;

Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/CMakeLists.txt

@@ -1,58 +0,0 @@
-include_directories(..)
-
-set(CMAKE_BUILD_TYPE Release)
-
-if (MSVC)
-  add_definitions("/openmp")
-endif()
-
-# enable C++11, should probably be a bit more specific about compiler
-if (NOT MSVC)
-  SET(CMAKE_CXX_FLAGS "-std=c++11")
-endif()
-
-if (NOT MPI_FOUND)
-  find_package(MPI)
-endif()
-
-if (NOT CRYPTOPP_FOUND)
-  find_package(CryptoPP 5.6.2)
-endif()
-
-if (CRYPTOPP_FOUND)
-  add_definitions(-DWITH_CRYPTOPP)
-  find_package (Threads REQUIRED)
-endif()
-
-if (NOT OpenCL_FOUND)
-  find_package(OpenCL)
-endif()
-if (OpenCL_FOUND)
-  add_definitions(-DWITH_OPENCL)
-  include_directories(${OpenCL_INCLUDE_DIRS})
-  list(APPEND FILES ethash_cl_miner.cpp ethash_cl_miner.h)
-endif()
-
-if (MPI_FOUND)
-  include_directories(${MPI_INCLUDE_PATH})
-  add_executable (Benchmark_MPI_FULL benchmark.cpp)
-  target_link_libraries (Benchmark_MPI_FULL ${ETHHASH_LIBS} ${MPI_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
-  SET_TARGET_PROPERTIES(Benchmark_MPI_FULL PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} ${MPI_COMPILE_FLAGS} -DFULL -DMPI")
-
-  add_executable (Benchmark_MPI_LIGHT benchmark.cpp)
-  target_link_libraries (Benchmark_MPI_LIGHT ${ETHHASH_LIBS} ${MPI_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
-  SET_TARGET_PROPERTIES(Benchmark_MPI_LIGHT PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} ${MPI_COMPILE_FLAGS} -DMPI")
-endif()
-
-add_executable (Benchmark_FULL benchmark.cpp)
-target_link_libraries (Benchmark_FULL ${ETHHASH_LIBS} ${CMAKE_THREAD_LIBS_INIT})
-SET_TARGET_PROPERTIES(Benchmark_FULL PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -DFULL")
-
-add_executable (Benchmark_LIGHT benchmark.cpp)
-target_link_libraries (Benchmark_LIGHT ${ETHHASH_LIBS} ${CMAKE_THREAD_LIBS_INIT})
-
-if (OpenCL_FOUND)
-  add_executable (Benchmark_CL benchmark.cpp)
-  target_link_libraries (Benchmark_CL ${ETHHASH_LIBS} ethash-cl ${CMAKE_THREAD_LIBS_INIT})
-  SET_TARGET_PROPERTIES(Benchmark_CL PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -DOPENCL")
-endif()

Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/benchmark.cpp

@@ -1,278 +0,0 @@
-/*
-  This file is part of cpp-ethereum.
-
-  cpp-ethereum is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  cpp-ethereum is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/** @file benchmark.cpp
- * @author Tim Hughes <tim@twistedfury.com>
- * @date 2015
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <chrono>
-#include <libethash/ethash.h>
-#include <libethash/util.h>
-#ifdef OPENCL
-#include <libethash-cl/ethash_cl_miner.h>
-#endif
-#include <vector>
-#include <algorithm>
-
-#ifdef WITH_CRYPTOPP
-#include <libethash/sha3_cryptopp.h>
-#include <string>
-
-#else
-#include "libethash/sha3.h"
-#endif // WITH_CRYPTOPP
-
-#undef min
-#undef max
-
-using std::chrono::high_resolution_clock;
-
-#if defined(OPENCL)
-const unsigned trials = 1024*1024*32;
-#elif defined(FULL)
-const unsigned trials = 1024*1024/8;
-#else
-const unsigned trials = 1024*1024/1024;
-#endif
-uint8_t g_hashes[1024*32];
-
-static char nibbleToChar(unsigned nibble)
-{
-	return (char) ((nibble >= 10 ? 'a'-10 : '0') + nibble);
-}
-
-static uint8_t charToNibble(char chr)
-{
-	if (chr >= '0' && chr <= '9')
-	{
-		return (uint8_t) (chr - '0');
-	}
-	if (chr >= 'a' && chr <= 'z')
-	{
-		return (uint8_t) (chr - 'a' + 10);
-	}
-	if (chr >= 'A' && chr <= 'Z')
-	{
-		return (uint8_t) (chr - 'A' + 10);
-	}
-	return 0;
-}
-
-static std::vector<uint8_t> hexStringToBytes(char const* str)
-{
-	std::vector<uint8_t> bytes(strlen(str) >> 1);
-	for (unsigned i = 0; i != bytes.size(); ++i)
-	{
-		bytes[i] = charToNibble(str[i*2 | 0]) << 4;
-		bytes[i] |= charToNibble(str[i*2 | 1]);
-	}
-	return bytes;
-}
-
-static std::string bytesToHexString(uint8_t const* bytes, unsigned size)
-{
-	std::string str;
-	for (unsigned i = 0; i != size; ++i)
-	{
-		str += nibbleToChar(bytes[i] >> 4);
-		str += nibbleToChar(bytes[i] & 0xf);
-	}
-	return str;
-}
-
-static std::string bytesToHexString(ethash_h256_t const *hash, unsigned size)
-{
-	return bytesToHexString((uint8_t*)hash, size);
-}
-
-extern "C" int main(void)
-{
-	// params for ethash
-	ethash_params params;
-	ethash_params_init(&params, 0);
-	//params.full_size = 262147 * 4096;	// 1GBish;
-	//params.full_size = 32771 * 4096;	// 128MBish;
-	//params.full_size = 8209 * 4096;	// 8MBish;
-	//params.cache_size = 8209*4096;
-	//params.cache_size = 2053*4096;
-	ethash_h256_t seed;
-	ethash_h256_t previous_hash;
-
-	memcpy(&seed, hexStringToBytes("9410b944535a83d9adf6bbdcc80e051f30676173c16ca0d32d6f1263fc246466").data(), 32);
-	memcpy(&previous_hash, hexStringToBytes("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").data(), 32);
-
-	// allocate page aligned buffer for dataset
-#ifdef FULL
-	void* full_mem_buf = malloc(params.full_size + 4095);
-	void* full_mem = (void*)((uintptr_t(full_mem_buf) + 4095) & ~4095);
-#endif
-	void* cache_mem_buf = malloc(params.cache_size + 63);
-	void* cache_mem = (void*)((uintptr_t(cache_mem_buf) + 63) & ~63);
-
-	ethash_cache cache;
-	cache.mem = cache_mem;
-
-	// compute cache or full data
-	{
-		auto startTime = high_resolution_clock::now();
-		ethash_mkcache(&cache, &params, &seed);
-		auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-
-		ethash_h256_t cache_hash;
-		SHA3_256(&cache_hash, (uint8_t const*)cache_mem, params.cache_size);
-		debugf("ethash_mkcache: %ums, sha3: %s\n", (unsigned)((time*1000)/CLOCKS_PER_SEC), bytesToHexString(&cache_hash, sizeof(cache_hash)).data());
-
-		// print a couple of test hashes
-		{
-			auto startTime = high_resolution_clock::now();
-			ethash_return_value hash;
-			ethash_light(&hash, &cache, &params, &previous_hash, 0);
-			auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-			debugf("ethash_light test: %ums, %s\n", (unsigned)time, bytesToHexString(&hash.result, 32).data());
-		}
-
-		#ifdef FULL
-			startTime = high_resolution_clock::now();
-			ethash_compute_full_data(full_mem, &params, &cache);
-			time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-			debugf("ethash_compute_full_data: %ums\n", (unsigned)time);
-		#endif // FULL
-	}
-
-#ifdef OPENCL
-	ethash_cl_miner miner;
-	{
-		auto startTime = high_resolution_clock::now();
-		if (!miner.init(params, &seed))
-			exit(-1);
-		auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-		debugf("ethash_cl_miner init: %ums\n", (unsigned)time);
-	}
-#endif
-
-
-#ifdef FULL
-	{
-		auto startTime = high_resolution_clock::now();
-		ethash_return_value hash;
-		ethash_full(&hash, full_mem, &params, &previous_hash, 0);
-		auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-		debugf("ethash_full test: %uns\n", (unsigned)time);
-	}
-#endif
-
-#ifdef OPENCL
-	// validate 1024 hashes against CPU
-	miner.hash(g_hashes, (uint8_t*)&previous_hash, 0, 1024);
-	for (unsigned i = 0; i != 1024; ++i)
-	{
-		ethash_return_value hash;
-		ethash_light(&hash, &cache, &params, &previous_hash, i);
-		if (memcmp(&hash.result, g_hashes + 32*i, 32) != 0)
-		{
-			debugf("nonce %u failed: %s %s\n", i, bytesToHexString(g_hashes + 32*i, 32).c_str(), bytesToHexString(&hash.result, 32).c_str());
-			static unsigned c = 0;
-			if (++c == 16)
-			{
-				exit(-1);
-			}
-		}
-	}
-
-	// ensure nothing else is going on
-	miner.finish();
-#endif
-
-	auto startTime = high_resolution_clock::now();
-	unsigned hash_count = trials;
-
-	#ifdef OPENCL
-	{
-		struct search_hook : ethash_cl_miner::search_hook
-		{
-			unsigned hash_count;
-			std::vector<uint64_t> nonce_vec;
-
-			virtual bool found(uint64_t const* nonces, uint32_t count)
-			{
-				nonce_vec.insert(nonce_vec.end(), nonces, nonces + count);
-				return false;
-			}
-
-			virtual bool searched(uint64_t start_nonce, uint32_t count)
-			{
-				// do nothing
-				hash_count += count;
-				return hash_count >= trials;
-			}
-		};
-		search_hook hook;
-		hook.hash_count = 0;
-
-		miner.search((uint8_t*)&previous_hash, 0x000000ffffffffff, hook);
-
-		for (unsigned i = 0; i != hook.nonce_vec.size(); ++i)
-		{
-			uint64_t nonce = hook.nonce_vec[i];
-			ethash_return_value hash;
-			ethash_light(&hash, &cache, &params, &previous_hash, nonce);
-			debugf("found: %.8x%.8x -> %s\n", unsigned(nonce>>32), unsigned(nonce), bytesToHexString(&hash.result, 32).c_str());
-		}
-
-		hash_count = hook.hash_count;
-	}
-	#else
-	{
-		//#pragma omp parallel for
-		for (int nonce = 0; nonce < trials; ++nonce)
-		{
-			ethash_return_value hash;
-			#ifdef FULL
-				ethash_full(&hash, full_mem, &params, &previous_hash, nonce);
-			#else
-				ethash_light(&hash, &cache, &params, &previous_hash, nonce);
-			#endif // FULL
-		}
-	}
-	#endif
-	auto time = std::chrono::duration_cast<std::chrono::microseconds>(high_resolution_clock::now() - startTime).count();
-	debugf("Search took: %ums\n", (unsigned)time/1000);
-
-	unsigned read_size = ETHASH_ACCESSES * ETHASH_MIX_BYTES;
-#if defined(OPENCL) || defined(FULL)
-	debugf(
-		"hashrate: %8.2f Mh/s, bw: %8.2f GB/s\n",
-		(double)hash_count * (1000*1000)/time / (1000*1000),
-		(double)hash_count*read_size * (1000*1000)/time / (1024*1024*1024)
-		);
-#else
-	debugf(
-		"hashrate: %8.2f Kh/s, bw: %8.2f MB/s\n",
-		(double)hash_count * (1000*1000)/time / (1000),
-		(double)hash_count*read_size * (1000*1000)/time / (1024*1024)
-		);
-#endif
-
-	free(cache_mem_buf);
-#ifdef FULL
-	free(full_mem_buf);
-#endif
-
-	return 0;
-}

Godeps/_workspace/src/github.com/ethereum/ethash/src/python/core.c

@@ -1,267 +0,0 @@
-#include <Python.h>
-#include <alloca.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <time.h>
-#include "../libethash/ethash.h"
-#include "../libethash/internal.h"
-
-#if PY_MAJOR_VERSION >= 3
-#define PY_STRING_FORMAT "y#"
-#define PY_CONST_STRING_FORMAT "y"
-#else
-#define PY_STRING_FORMAT "s#"
-#define PY_CONST_STRING_FORMAT "s"
-#endif
-
-#define MIX_WORDS (ETHASH_MIX_BYTES/4)
-
-static PyObject *
-mkcache_bytes(PyObject *self, PyObject *args) {
-    unsigned long block_number;
-    unsigned long cache_size;
-
-    if (!PyArg_ParseTuple(args, "k", &block_number))
-        return 0;
-
-    ethash_light_t L = ethash_light_new(block_number);
-    PyObject * val = Py_BuildValue(PY_STRING_FORMAT, L->cache, L->cache_size);
-    free(L->cache);
-    return val;
-}
-
-/*
-static PyObject *
-calc_dataset_bytes(PyObject *self, PyObject *args) {
-    char *cache_bytes;
-    unsigned long full_size;
-    int cache_size;
-
-    if (!PyArg_ParseTuple(args, "k" PY_STRING_FORMAT, &full_size, &cache_bytes, &cache_size))
-        return 0;
-
-    if (full_size % MIX_WORDS != 0) {
-        char error_message[1024];
-        sprintf(error_message, "The size of data set must be a multiple of %i bytes (was %lu)", MIX_WORDS, full_size);
-        PyErr_SetString(PyExc_ValueError, error_message);
-        return 0;
-    }
-
-    if (cache_size % ETHASH_HASH_BYTES != 0) {
-        char error_message[1024];
-        sprintf(error_message, "The size of the cache must be a multiple of %i bytes (was %i)", ETHASH_HASH_BYTES, cache_size);
-        PyErr_SetString(PyExc_ValueError, error_message);
-        return 0;
-    }
-
-    ethash_params params;
-    params.cache_size = (size_t) cache_size;
-    params.full_size = (size_t) full_size;
-    ethash_cache cache;
-    cache.mem = (void *) cache_bytes;
-    void *mem = malloc(params.full_size);
-    ethash_compute_full_data(mem, &params, &cache);
-    PyObject * val = Py_BuildValue(PY_STRING_FORMAT, (char *) mem, full_size);
-    free(mem);
-    return val;
-}*/
-
-// hashimoto_light(full_size, cache, header, nonce)
-static PyObject *
-hashimoto_light(PyObject *self, PyObject *args) {
-    char *cache_bytes;
-    char *header;
-    unsigned long block_number;
-    unsigned long long nonce;
-    int cache_size, header_size;
-    if (!PyArg_ParseTuple(args, "k" PY_STRING_FORMAT PY_STRING_FORMAT "K", &block_number, &cache_bytes, &cache_size, &header, &header_size, &nonce))
-        return 0;
-    if (header_size != 32) {
-        char error_message[1024];
-        sprintf(error_message, "Seed must be 32 bytes long (was %i)", header_size);
-        PyErr_SetString(PyExc_ValueError, error_message);
-        return 0;
-    }
-    struct ethash_light *s;
-    s = calloc(sizeof(*s), 1);
-    s->cache = cache_bytes;
-    s->cache_size = cache_size;
-    s->block_number = block_number;
-    struct ethash_h256 *h;
-    h = calloc(sizeof(*h), 1);
-    for (int i = 0; i < 32; i++) h->b[i] = header[i];
-    struct ethash_return_value out = ethash_light_compute(s, *h, nonce);
-    return Py_BuildValue("{" PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT "," PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT "}",
-                         "mix digest", &out.mix_hash, 32,
-                         "result", &out.result, 32);
-}
-/*
-// hashimoto_full(dataset, header, nonce)
-static PyObject *
-hashimoto_full(PyObject *self, PyObject *args) {
-    char *full_bytes;
-    char *header;
-    unsigned long long nonce;
-    int full_size, header_size;
-
-    if (!PyArg_ParseTuple(args, PY_STRING_FORMAT PY_STRING_FORMAT "K", &full_bytes, &full_size, &header, &header_size, &nonce))
-        return 0;
-
-    if (full_size % MIX_WORDS != 0) {
-        char error_message[1024];
-        sprintf(error_message, "The size of data set must be a multiple of %i bytes (was %i)", MIX_WORDS, full_size);
-        PyErr_SetString(PyExc_ValueError, error_message);
-        return 0;
-    }
-
-    if (header_size != 32) {
-        char error_message[1024];
-        sprintf(error_message, "Header must be 32 bytes long (was %i)", header_size);
-        PyErr_SetString(PyExc_ValueError, error_message);
-        return 0;
-    }
-
-
-    ethash_return_value out;
-    ethash_params params;
-    params.full_size = (size_t) full_size;
-    ethash_full(&out, (void *) full_bytes, &params, (ethash_h256_t *) header, nonce);
-    return Py_BuildValue("{" PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT ", " PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT "}",
-                         "mix digest", &out.mix_hash, 32,
-                         "result", &out.result, 32);
-}
-
-// mine(dataset_bytes, header, difficulty_bytes)
-static PyObject *
-mine(PyObject *self, PyObject *args) {
-    char *full_bytes;
-    char *header;
-    char *difficulty;
-    srand(time(0));
-    uint64_t nonce = ((uint64_t) rand()) << 32 | rand();
-    int full_size, header_size, difficulty_size;
-
-    if (!PyArg_ParseTuple(args, PY_STRING_FORMAT PY_STRING_FORMAT PY_STRING_FORMAT, &full_bytes, &full_size, &header, &header_size, &difficulty, &difficulty_size))
-        return 0;
-
-    if (full_size % MIX_WORDS != 0) {
-        char error_message[1024];
-        sprintf(error_message, "The size of data set must be a multiple of %i bytes (was %i)", MIX_WORDS, full_size);
-        PyErr_SetString(PyExc_ValueError, error_message);
-        return 0;
-    }
-
-    if (header_size != 32) {
-        char error_message[1024];
-        sprintf(error_message, "Header must be 32 bytes long (was %i)", header_size);
-        PyErr_SetString(PyExc_ValueError, error_message);
-        return 0;
-    }
-
-    if (difficulty_size != 32) {
-        char error_message[1024];
-        sprintf(error_message, "Difficulty must be an array of 32 bytes (only had %i)", difficulty_size);
-        PyErr_SetString(PyExc_ValueError, error_message);
-        return 0;
-    }
-
-    ethash_return_value out;
-    ethash_params params;
-    params.full_size = (size_t) full_size;
-
-    // TODO: Multi threading?
-    do {
-        ethash_full(&out, (void *) full_bytes, &params, (const ethash_h256_t *) header, nonce++);
-        // TODO: disagrees with the spec https://github.com/ethereum/wiki/wiki/Ethash#mining
-    } while (!ethash_check_difficulty(&out.result, (const ethash_h256_t *) difficulty));
-
-    return Py_BuildValue("{" PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT ", " PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT ", " PY_CONST_STRING_FORMAT ":K}",
-            "mix digest", &out.mix_hash, 32,
-            "result", &out.result, 32,
-            "nonce", nonce);
-}
-*/
-
-//get_seedhash(block_number)
-static PyObject *
-get_seedhash(PyObject *self, PyObject *args) {
-    unsigned long block_number;
-    if (!PyArg_ParseTuple(args, "k", &block_number))
-        return 0;
-    if (block_number >= ETHASH_EPOCH_LENGTH * 2048) {
-        char error_message[1024];
-        sprintf(error_message, "Block number must be less than %i (was %lu)", ETHASH_EPOCH_LENGTH * 2048, block_number);
-
-        PyErr_SetString(PyExc_ValueError, error_message);
-        return 0;
-    }
-    ethash_h256_t seedhash = ethash_get_seedhash(block_number);
-    return Py_BuildValue(PY_STRING_FORMAT, (char *) &seedhash, 32);
-}
-
-static PyMethodDef PyethashMethods[] =
-        {
-                {"get_seedhash", get_seedhash, METH_VARARGS,
-                        "get_seedhash(block_number)\n\n"
-                                "Gets the seedhash for a block."},
-                {"mkcache_bytes", mkcache_bytes, METH_VARARGS,
-                        "mkcache_bytes(block_number)\n\n"
-                                "Makes a byte array for the cache for given block number\n"},
-                /*{"calc_dataset_bytes", calc_dataset_bytes, METH_VARARGS,
-                        "calc_dataset_bytes(full_size, cache_bytes)\n\n"
-                                "Makes a byte array for the dataset for a given size given cache bytes"},*/
-                {"hashimoto_light", hashimoto_light, METH_VARARGS,
-                        "hashimoto_light(block_number, cache_bytes, header, nonce)\n\n"
-                                "Runs the hashimoto hashing function just using cache bytes. Takes an int (full_size), byte array (cache_bytes), another byte array (header), and an int (nonce). Returns an object containing the mix digest, and hash result."},
-                /*{"hashimoto_full", hashimoto_full, METH_VARARGS,
-                        "hashimoto_full(dataset_bytes, header, nonce)\n\n"
-                                "Runs the hashimoto hashing function using the dataset bytes. Useful for testing. Returns an object containing the mix digest (byte array), and hash result (another byte array)."},
-                {"mine", mine, METH_VARARGS,
-                        "mine(dataset_bytes, header, difficulty_bytes)\n\n"
-                                "Mine for an adequate header. Returns an object containing the mix digest (byte array), hash result (another byte array) and nonce (an int)."},*/
-                {NULL, NULL, 0, NULL}
-        };
-
-#if PY_MAJOR_VERSION >= 3
-static struct PyModuleDef PyethashModule = {
-    PyModuleDef_HEAD_INIT,
-    "pyethash",
-    "...",
-    -1,
-    PyethashMethods
-};
-
-PyMODINIT_FUNC PyInit_pyethash(void) {
-    PyObject *module =  PyModule_Create(&PyethashModule);
-    // Following Spec: https://github.com/ethereum/wiki/wiki/Ethash#definitions
-    PyModule_AddIntConstant(module, "REVISION", (long) ETHASH_REVISION);
-    PyModule_AddIntConstant(module, "DATASET_BYTES_INIT", (long) ETHASH_DATASET_BYTES_INIT);
-    PyModule_AddIntConstant(module, "DATASET_BYTES_GROWTH", (long) ETHASH_DATASET_BYTES_GROWTH);
-    PyModule_AddIntConstant(module, "CACHE_BYTES_INIT", (long) ETHASH_CACHE_BYTES_INIT);
-    PyModule_AddIntConstant(module, "CACHE_BYTES_GROWTH", (long) ETHASH_CACHE_BYTES_GROWTH);
-    PyModule_AddIntConstant(module, "EPOCH_LENGTH", (long) ETHASH_EPOCH_LENGTH);
-    PyModule_AddIntConstant(module, "MIX_BYTES", (long) ETHASH_MIX_BYTES);
-    PyModule_AddIntConstant(module, "HASH_BYTES", (long) ETHASH_HASH_BYTES);
-    PyModule_AddIntConstant(module, "DATASET_PARENTS", (long) ETHASH_DATASET_PARENTS);
-    PyModule_AddIntConstant(module, "CACHE_ROUNDS", (long) ETHASH_CACHE_ROUNDS);
-    PyModule_AddIntConstant(module, "ACCESSES", (long) ETHASH_ACCESSES);
-    return module;
-}
-#else
-PyMODINIT_FUNC
-initpyethash(void) {
-    PyObject *module = Py_InitModule("pyethash", PyethashMethods);
-    // Following Spec: https://github.com/ethereum/wiki/wiki/Ethash#definitions
-    PyModule_AddIntConstant(module, "REVISION", (long) ETHASH_REVISION);
-    PyModule_AddIntConstant(module, "DATASET_BYTES_INIT", (long) ETHASH_DATASET_BYTES_INIT);
-    PyModule_AddIntConstant(module, "DATASET_BYTES_GROWTH", (long) ETHASH_DATASET_BYTES_GROWTH);
-    PyModule_AddIntConstant(module, "CACHE_BYTES_INIT", (long) ETHASH_CACHE_BYTES_INIT);
-    PyModule_AddIntConstant(module, "CACHE_BYTES_GROWTH", (long) ETHASH_CACHE_BYTES_GROWTH);
-    PyModule_AddIntConstant(module, "EPOCH_LENGTH", (long) ETHASH_EPOCH_LENGTH);
-    PyModule_AddIntConstant(module, "MIX_BYTES", (long) ETHASH_MIX_BYTES);
-    PyModule_AddIntConstant(module, "HASH_BYTES", (long) ETHASH_HASH_BYTES);
-    PyModule_AddIntConstant(module, "DATASET_PARENTS", (long) ETHASH_DATASET_PARENTS);
-    PyModule_AddIntConstant(module, "CACHE_ROUNDS", (long) ETHASH_CACHE_ROUNDS);
-    PyModule_AddIntConstant(module, "ACCESSES", (long) ETHASH_ACCESSES);
-}
-#endif

Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt

@@ -1,66 +0,0 @@
-if (MSVC)
-    if (NOT BOOST_ROOT)
-        set (BOOST_ROOT "$ENV{BOOST_ROOT}")
-    endif()
-    set (CMAKE_PREFIX_PATH BOOST_ROOT)
-endif()
-
-IF( NOT Boost_FOUND )
-    # use multithreaded boost libraries, with -mt suffix
-    set(Boost_USE_MULTITHREADED ON)
-
-    if (MSVC)
-        # TODO handle other msvc versions or it will fail find them
-        set(Boost_COMPILER -vc120)
-        # use static boost libraries *.lib
-        set(Boost_USE_STATIC_LIBS ON)
-    elseif (APPLE)
-
-        # use static boost libraries *.a
-        set(Boost_USE_STATIC_LIBS ON)
-
-    elseif (UNIX)
-        # use dynamic boost libraries .dll
-        set(Boost_USE_STATIC_LIBS OFF)
-
-    endif()
-    find_package(Boost 1.48.0 COMPONENTS unit_test_framework system filesystem)
-ENDIF()
-
-IF (Boost_FOUND)
-    message(STATUS "boost header: ${Boost_INCLUDE_DIRS}")
-    message(STATUS "boost libs  : ${Boost_LIBRARIES}")
-
-    include_directories( ${Boost_INCLUDE_DIR} )
-    include_directories(../../src)
-
-    link_directories(${Boost_LIBRARY_DIRS})
-    file(GLOB HEADERS "*.h")
-    if ((NOT MSVC) AND (NOT APPLE))
-        ADD_DEFINITIONS(-DBOOST_TEST_DYN_LINK)
-    endif()
-    if (NOT CRYPTOPP_FOUND)
-        find_package (CryptoPP)
-    endif()
-
-    if (CRYPTOPP_FOUND)
-        add_definitions(-DWITH_CRYPTOPP)
-    endif()
-
-   if (NOT MSVC)
-        set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -std=c++11 ")
-   endif()
-
-    add_executable (Test "./test.cpp" ${HEADERS})
-    target_link_libraries(Test ${ETHHASH_LIBS})
-    target_link_libraries(Test ${Boost_FILESYSTEM_LIBRARIES})
-    target_link_libraries(Test ${Boost_SYSTEM_LIBRARIES})
-    target_link_libraries(Test ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
-
-    if (CRYPTOPP_FOUND)
-        TARGET_LINK_LIBRARIES(Test ${CRYPTOPP_LIBRARIES})
-    endif()
-
-    enable_testing ()
-    add_test(NAME ethash COMMAND Test)
-ENDIF()

Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.cpp

@@ -1,669 +0,0 @@
-#include <iomanip>
-#include <libethash/fnv.h>
-#include <libethash/ethash.h>
-#include <libethash/internal.h>
-#include <libethash/io.h>
-
-#ifdef WITH_CRYPTOPP
-
-#include <libethash/sha3_cryptopp.h>
-
-#else
-#include <libethash/sha3.h>
-#endif // WITH_CRYPTOPP
-
-#ifdef _WIN32
-#include <windows.h>
-#include <Shlobj.h>
-#endif
-
-#define BOOST_TEST_MODULE Daggerhashimoto
-#define BOOST_TEST_MAIN
-
-#include <iostream>
-#include <fstream>
-#include <vector>
-#include <boost/filesystem.hpp>
-#include <boost/test/unit_test.hpp>
-
-using namespace std;
-using byte = uint8_t;
-using bytes = std::vector<byte>;
-namespace fs = boost::filesystem;
-
-// Just an alloca "wrapper" to silence uint64_t to size_t conversion warnings in windows
-// consider replacing alloca calls with something better though!
-#define our_alloca(param__) alloca((size_t)(param__))
-
-
-// some functions taken from eth::dev for convenience.
-std::string bytesToHexString(const uint8_t *str, const uint64_t s)
-{
-	std::ostringstream ret;
-
-	for (size_t i = 0; i < s; ++i)
-		ret << std::hex << std::setfill('0') << std::setw(2) << std::nouppercase << (int) str[i];
-
-	return ret.str();
-}
-
-std::string blockhashToHexString(ethash_h256_t* _hash)
-{
-	return bytesToHexString((uint8_t*)_hash, 32);
-}
-
-int fromHex(char _i)
-{
-	if (_i >= '0' && _i <= '9')
-		return _i - '0';
-	if (_i >= 'a' && _i <= 'f')
-		return _i - 'a' + 10;
-	if (_i >= 'A' && _i <= 'F')
-		return _i - 'A' + 10;
-
-	BOOST_REQUIRE_MESSAGE(false, "should never get here");
-	return -1;
-}
-
-bytes hexStringToBytes(std::string const& _s)
-{
-	unsigned s = (_s[0] == '0' && _s[1] == 'x') ? 2 : 0;
-	std::vector<uint8_t> ret;
-	ret.reserve((_s.size() - s + 1) / 2);
-
-	if (_s.size() % 2)
-		try
-		{
-			ret.push_back(fromHex(_s[s++]));
-		}
-		catch (...)
-		{
-			ret.push_back(0);
-		}
-	for (unsigned i = s; i < _s.size(); i += 2)
-		try
-		{
-			ret.push_back((byte)(fromHex(_s[i]) * 16 + fromHex(_s[i + 1])));
-		}
-		catch (...){
-			ret.push_back(0);
-		}
-	return ret;
-}
-
-ethash_h256_t stringToBlockhash(std::string const& _s)
-{
-	ethash_h256_t ret;
-	bytes b = hexStringToBytes(_s);
-	memcpy(&ret, b.data(), b.size());
-	return ret;
-}
-
-
-
-BOOST_AUTO_TEST_CASE(fnv_hash_check) {
-	uint32_t x = 1235U;
-	const uint32_t
-			y = 9999999U,
-			expected = (FNV_PRIME * x) ^y;
-
-	x = fnv_hash(x, y);
-
-	BOOST_REQUIRE_MESSAGE(x == expected,
-			"\nexpected: " << expected << "\n"
-					<< "actual: " << x << "\n");
-
-}
-
-BOOST_AUTO_TEST_CASE(SHA256_check) {
-	ethash_h256_t input;
-	ethash_h256_t out;
-	memcpy(&input, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-	SHA3_256(&out, (uint8_t*)&input, 32);
-	const std::string
-			expected = "2b5ddf6f4d21c23de216f44d5e4bdc68e044b71897837ea74c83908be7037cd7",
-		actual = bytesToHexString((uint8_t*)&out, 32);
-	BOOST_REQUIRE_MESSAGE(expected == actual,
-			"\nexpected: " << expected.c_str() << "\n"
-					<< "actual: " << actual.c_str() << "\n");
-}
-
-BOOST_AUTO_TEST_CASE(SHA512_check) {
-	uint8_t input[64], out[64];
-	memcpy(input, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 64);
-	SHA3_512(out, input, 64);
-	const std::string
-			expected = "0be8a1d334b4655fe58c6b38789f984bb13225684e86b20517a55ab2386c7b61c306f25e0627c60064cecd6d80cd67a82b3890bd1289b7ceb473aad56a359405",
-			actual = bytesToHexString(out, 64);
-	BOOST_REQUIRE_MESSAGE(expected == actual,
-			"\nexpected: " << expected.c_str() << "\n"
-					<< "actual: " << actual.c_str() << "\n");
-}
-
-BOOST_AUTO_TEST_CASE(test_swap_endian32) {
-	uint32_t v32 = (uint32_t)0xBAADF00D;
-	v32 = ethash_swap_u32(v32);
-	BOOST_REQUIRE_EQUAL(v32, (uint32_t)0x0DF0ADBA);
-}
-
-BOOST_AUTO_TEST_CASE(test_swap_endian64) {
-	uint64_t v64 = (uint64_t)0xFEE1DEADDEADBEEF;
-	v64 = ethash_swap_u64(v64);
-	BOOST_REQUIRE_EQUAL(v64, (uint64_t)0xEFBEADDEADDEE1FE);
-}
-
-BOOST_AUTO_TEST_CASE(ethash_params_init_genesis_check) {
-	uint64_t full_size = ethash_get_datasize(0);
-	uint64_t cache_size = ethash_get_cachesize(0);
-	BOOST_REQUIRE_MESSAGE(full_size < ETHASH_DATASET_BYTES_INIT,
-			"\nfull size: " << full_size << "\n"
-					<< "should be less than or equal to: " << ETHASH_DATASET_BYTES_INIT << "\n");
-	BOOST_REQUIRE_MESSAGE(full_size + 20 * ETHASH_MIX_BYTES >= ETHASH_DATASET_BYTES_INIT,
-			"\nfull size + 20*MIX_BYTES: " << full_size + 20 * ETHASH_MIX_BYTES << "\n"
-					<< "should be greater than or equal to: " << ETHASH_DATASET_BYTES_INIT << "\n");
-	BOOST_REQUIRE_MESSAGE(cache_size < ETHASH_DATASET_BYTES_INIT / 32,
-			"\ncache size: " << cache_size << "\n"
-					<< "should be less than or equal to: " << ETHASH_DATASET_BYTES_INIT / 32 << "\n");
-}
-
-BOOST_AUTO_TEST_CASE(ethash_params_init_genesis_calcifide_check) {
-	uint64_t full_size = ethash_get_datasize(0);
-	uint64_t cache_size = ethash_get_cachesize(0);
-	const uint32_t expected_full_size = 1073739904;
-	const uint32_t expected_cache_size = 16776896;
-	BOOST_REQUIRE_MESSAGE(full_size == expected_full_size,
-			"\nexpected: " << expected_cache_size << "\n"
-					<< "actual: " << full_size << "\n");
-	BOOST_REQUIRE_MESSAGE(cache_size == expected_cache_size,
-			"\nexpected: " << expected_cache_size << "\n"
-					<< "actual: " << cache_size << "\n");
-}
-
-BOOST_AUTO_TEST_CASE(ethash_check_difficulty_check) {
-	ethash_h256_t hash;
-	ethash_h256_t target;
-	memcpy(&hash, "11111111111111111111111111111111", 32);
-	memcpy(&target, "22222222222222222222222222222222", 32);
-	BOOST_REQUIRE_MESSAGE(
-			ethash_check_difficulty(&hash, &target),
-			"\nexpected \"" << std::string((char *) &hash, 32).c_str() << "\" to have the same or less difficulty than \"" << std::string((char *) &target, 32).c_str() << "\"\n");
-	BOOST_REQUIRE_MESSAGE(
-		ethash_check_difficulty(&hash, &hash), "");
-			// "\nexpected \"" << hash << "\" to have the same or less difficulty than \"" << hash << "\"\n");
-	memcpy(&target, "11111111111111111111111111111112", 32);
-	BOOST_REQUIRE_MESSAGE(
-		ethash_check_difficulty(&hash, &target), "");
-			// "\nexpected \"" << hash << "\" to have the same or less difficulty than \"" << target << "\"\n");
-	memcpy(&target, "11111111111111111111111111111110", 32);
-	BOOST_REQUIRE_MESSAGE(
-			!ethash_check_difficulty(&hash, &target), "");
-			// "\nexpected \"" << hash << "\" to have more difficulty than \"" << target << "\"\n");
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_io_mutable_name) {
-	char mutable_name[DAG_MUTABLE_NAME_MAX_SIZE];
-	// should have at least 8 bytes provided since this is what we test :)
-	ethash_h256_t seed1 = ethash_h256_static_init(0, 10, 65, 255, 34, 55, 22, 8);
-	ethash_io_mutable_name(1, &seed1, mutable_name);
-	BOOST_REQUIRE_EQUAL(0, strcmp(mutable_name, "full-R1-000a41ff22371608"));
-	ethash_h256_t seed2 = ethash_h256_static_init(0, 0, 0, 0, 0, 0, 0, 0);
-	ethash_io_mutable_name(44, &seed2, mutable_name);
-	BOOST_REQUIRE_EQUAL(0, strcmp(mutable_name, "full-R44-0000000000000000"));
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_dir_creation) {
-	ethash_h256_t seedhash;
-	FILE *f = NULL;
-	memset(&seedhash, 0, 32);
-	BOOST_REQUIRE_EQUAL(
-		ETHASH_IO_MEMO_MISMATCH,
-		ethash_io_prepare("./test_ethash_directory/", seedhash, &f, 64, false)
-	);
-	BOOST_REQUIRE(f);
-
-	// let's make sure that the directory was created
-	BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
-
-	// cleanup
-	fclose(f);
-	fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_io_memo_file_match) {
-	uint64_t full_size;
-	uint64_t cache_size;
-	ethash_h256_t seed;
-	ethash_h256_t hash;
-	FILE* f;
-	memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-	memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
-	cache_size = 1024;
-	full_size = 1024 * 32;
-
-	ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
-	ethash_full_t full = ethash_full_new_internal(
-		"./test_ethash_directory/",
-		seed,
-		full_size,
-		light,
-		NULL
-	);
-	BOOST_ASSERT(full);
-	// let's make sure that the directory was created
-	BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
-	// delete the full here so that memory is properly unmapped and FILE handler freed
-	ethash_full_delete(full);
-	// and check that we have a match when checking again
-	BOOST_REQUIRE_EQUAL(
-		ETHASH_IO_MEMO_MATCH,
-		ethash_io_prepare("./test_ethash_directory/", seed, &f, full_size, false)
-	);
-	BOOST_REQUIRE(f);
-
-	// cleanup
-	fclose(f);
-	ethash_light_delete(light);
-	fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_io_memo_file_size_mismatch) {
-	static const int blockn = 0;
-	ethash_h256_t seedhash = ethash_get_seedhash(blockn);
-	FILE *f = NULL;
-	BOOST_REQUIRE_EQUAL(
-		ETHASH_IO_MEMO_MISMATCH,
-		ethash_io_prepare("./test_ethash_directory/", seedhash, &f, 64, false)
-	);
-	BOOST_REQUIRE(f);
-	fclose(f);
-
-	// let's make sure that the directory was created
-	BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
-	// and check that we get the size mismatch detected if we request diffferent size
-	BOOST_REQUIRE_EQUAL(
-		ETHASH_IO_MEMO_SIZE_MISMATCH,
-		ethash_io_prepare("./test_ethash_directory/", seedhash, &f, 65, false)
-	);
-
-	// cleanup
-	fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_get_default_dirname) {
-	char result[256];
-	// this is really not an easy thing to test for in a unit test
-	// TODO: Improve this test ...
-#ifdef _WIN32
-	char homedir[256];
-	BOOST_REQUIRE(SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_PROFILE, NULL, 0, (CHAR*)homedir)));
-	BOOST_REQUIRE(ethash_get_default_dirname(result, 256));
-	std::string res = std::string(homedir) + std::string("\\AppData\\Local\\Ethash\\");
-#else
-	char* homedir = getenv("HOME");
-	BOOST_REQUIRE(ethash_get_default_dirname(result, 256));
-	std::string res = std::string(homedir) + std::string("/.ethash/");
-#endif
-	BOOST_CHECK_MESSAGE(strcmp(res.c_str(), result) == 0,
-		"Expected \"" + res + "\" but got \"" + std::string(result) +  "\""
-	);
-}
-
-BOOST_AUTO_TEST_CASE(light_and_full_client_checks) {
-	uint64_t full_size;
-	uint64_t cache_size;
-	ethash_h256_t seed;
-	ethash_h256_t hash;
-	ethash_h256_t difficulty;
-	ethash_return_value_t light_out;
-	ethash_return_value_t full_out;
-	memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-	memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
-	// Set the difficulty
-	ethash_h256_set(&difficulty, 0, 197);
-	ethash_h256_set(&difficulty, 1, 90);
-	for (int i = 2; i < 32; i++)
-		ethash_h256_set(&difficulty, i, 255);
-
-	cache_size = 1024;
-	full_size = 1024 * 32;
-
-	ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
-	ethash_full_t full = ethash_full_new_internal(
-		"./test_ethash_directory/",
-		seed,
-		full_size,
-		light,
-		NULL
-	);
-	BOOST_ASSERT(full);
-	{
-		const std::string
-				expected = "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",
-				actual = bytesToHexString((uint8_t const *) light->cache, cache_size);
-
-		BOOST_REQUIRE_MESSAGE(expected == actual,
-				"\nexpected: " << expected.c_str() << "\n"
-						<< "actual: " << actual.c_str() << "\n");
-	}
-	{
-		node node;
-		ethash_calculate_dag_item(&node, 0, light);
-		const std::string
-				actual = bytesToHexString((uint8_t const *) &node, sizeof(node)),
-				expected = "b1698f829f90b35455804e5185d78f549fcb1bdce2bee006d4d7e68eb154b596be1427769eb1c3c3e93180c760af75f81d1023da6a0ffbe321c153a7c0103597";
-		BOOST_REQUIRE_MESSAGE(actual == expected,
-				"\n" << "expected: " << expected.c_str() << "\n"
-						<< "actual: " << actual.c_str() << "\n");
-	}
-	{
-		for (int i = 0; i < full_size / sizeof(node); ++i) {
-			for (uint32_t j = 0; j < 32; ++j) {
-				node expected_node;
-				ethash_calculate_dag_item(&expected_node, j, light);
-				const std::string
-						actual = bytesToHexString((uint8_t const *) &(full->data[j]), sizeof(node)),
-						expected = bytesToHexString((uint8_t const *) &expected_node, sizeof(node));
-				BOOST_REQUIRE_MESSAGE(actual == expected,
-						"\ni: " << j << "\n"
-								<< "expected: " << expected.c_str() << "\n"
-								<< "actual: " << actual.c_str() << "\n");
-			}
-		}
-	}
-	{
-		uint64_t nonce = 0x7c7c597c;
-		full_out = ethash_full_compute(full, hash, nonce);
-		BOOST_REQUIRE(full_out.success);
-		light_out = ethash_light_compute_internal(light, full_size, hash, nonce);
-		BOOST_REQUIRE(light_out.success);
-		const std::string
-				light_result_string = blockhashToHexString(&light_out.result),
-				full_result_string = blockhashToHexString(&full_out.result);
-		BOOST_REQUIRE_MESSAGE(light_result_string == full_result_string,
-				"\nlight result: " << light_result_string.c_str() << "\n"
-						<< "full result: " << full_result_string.c_str() << "\n");
-		const std::string
-				light_mix_hash_string = blockhashToHexString(&light_out.mix_hash),
-				full_mix_hash_string = blockhashToHexString(&full_out.mix_hash);
-		BOOST_REQUIRE_MESSAGE(full_mix_hash_string == light_mix_hash_string,
-				"\nlight mix hash: " << light_mix_hash_string.c_str() << "\n"
-						<< "full mix hash: " << full_mix_hash_string.c_str() << "\n");
-		ethash_h256_t check_hash;
-		ethash_quick_hash(&check_hash, &hash, nonce, &full_out.mix_hash);
-		const std::string check_hash_string = blockhashToHexString(&check_hash);
-		BOOST_REQUIRE_MESSAGE(check_hash_string == full_result_string,
-				"\ncheck hash string: " << check_hash_string.c_str() << "\n"
-						<< "full result: " << full_result_string.c_str() << "\n");
-	}
-	{
-		full_out = ethash_full_compute(full, hash, 5);
-		BOOST_REQUIRE(full_out.success);
-		std::string
-				light_result_string = blockhashToHexString(&light_out.result),
-				full_result_string = blockhashToHexString(&full_out.result);
-		BOOST_REQUIRE_MESSAGE(light_result_string != full_result_string,
-				"\nlight result and full result should differ: " << light_result_string.c_str() << "\n");
-
-		light_out = ethash_light_compute_internal(light, full_size, hash, 5);
-		BOOST_REQUIRE(light_out.success);
-		light_result_string = blockhashToHexString(&light_out.result);
-		BOOST_REQUIRE_MESSAGE(light_result_string == full_result_string,
-				"\nlight result and full result should be the same\n"
-						<< "light result: " << light_result_string.c_str() << "\n"
-						<< "full result: " << full_result_string.c_str() << "\n");
-		std::string
-				light_mix_hash_string = blockhashToHexString(&light_out.mix_hash),
-				full_mix_hash_string = blockhashToHexString(&full_out.mix_hash);
-		BOOST_REQUIRE_MESSAGE(full_mix_hash_string == light_mix_hash_string,
-				"\nlight mix hash: " << light_mix_hash_string.c_str() << "\n"
-						<< "full mix hash: " << full_mix_hash_string.c_str() << "\n");
-		BOOST_REQUIRE_MESSAGE(ethash_check_difficulty(&full_out.result, &difficulty),
-				"ethash_check_difficulty failed"
-		);
-		BOOST_REQUIRE_MESSAGE(ethash_quick_check_difficulty(&hash, 5U, &full_out.mix_hash, &difficulty),
-				"ethash_quick_check_difficulty failed"
-		);
-	}
-	ethash_light_delete(light);
-	ethash_full_delete(full);
-	fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(ethash_full_new_when_dag_exists_with_wrong_size) {
-	uint64_t full_size;
-	uint64_t cache_size;
-	ethash_h256_t seed;
-	ethash_h256_t hash;
-	ethash_return_value_t full_out;
-	ethash_return_value_t light_out;
-	memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-	memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
-	cache_size = 1024;
-	full_size = 1024 * 32;
-
-	// first make a DAG file of "wrong size"
-	FILE *f;
-	BOOST_REQUIRE_EQUAL(
-		ETHASH_IO_MEMO_MISMATCH,
-		ethash_io_prepare("./test_ethash_directory/", seed, &f, 64, false)
-	);
-	fclose(f);
-
-	// then create new DAG, which should detect the wrong size and force create a new file
-	ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
-	BOOST_ASSERT(light);
-	ethash_full_t full = ethash_full_new_internal(
-		"./test_ethash_directory/",
-		seed,
-		full_size,
-		light,
-		NULL
-	);
-	BOOST_ASSERT(full);
-	{
-		uint64_t nonce = 0x7c7c597c;
-		full_out = ethash_full_compute(full, hash, nonce);
-		BOOST_REQUIRE(full_out.success);
-		light_out = ethash_light_compute_internal(light, full_size, hash, nonce);
-		BOOST_REQUIRE(light_out.success);
-		const std::string
-				light_result_string = blockhashToHexString(&light_out.result),
-				full_result_string = blockhashToHexString(&full_out.result);
-		BOOST_REQUIRE_MESSAGE(light_result_string == full_result_string,
-				"\nlight result: " << light_result_string.c_str() << "\n"
-						<< "full result: " << full_result_string.c_str() << "\n");
-		const std::string
-				light_mix_hash_string = blockhashToHexString(&light_out.mix_hash),
-				full_mix_hash_string = blockhashToHexString(&full_out.mix_hash);
-		BOOST_REQUIRE_MESSAGE(full_mix_hash_string == light_mix_hash_string,
-				"\nlight mix hash: " << light_mix_hash_string.c_str() << "\n"
-						<< "full mix hash: " << full_mix_hash_string.c_str() << "\n");
-		ethash_h256_t check_hash;
-		ethash_quick_hash(&check_hash, &hash, nonce, &full_out.mix_hash);
-		const std::string check_hash_string = blockhashToHexString(&check_hash);
-		BOOST_REQUIRE_MESSAGE(check_hash_string == full_result_string,
-				"\ncheck hash string: " << check_hash_string.c_str() << "\n"
-						<< "full result: " << full_result_string.c_str() << "\n");
-	}
-
-	ethash_light_delete(light);
-	ethash_full_delete(full);
-	fs::remove_all("./test_ethash_directory/");
-}
-
-static bool g_executed = false;
-static unsigned g_prev_progress = 0;
-static int test_full_callback(unsigned _progress)
-{
-	g_executed = true;
-	BOOST_CHECK(_progress >= g_prev_progress);
-	g_prev_progress = _progress;
-	return 0;
-}
-
-static int test_full_callback_that_fails(unsigned _progress)
-{
-	return 1;
-}
-
-static int test_full_callback_create_incomplete_dag(unsigned _progress)
-{
-	if (_progress >= 30) {
-		return 1;
-	}
-	return 0;
-}
-
-BOOST_AUTO_TEST_CASE(full_client_callback) {
-	uint64_t full_size;
-	uint64_t cache_size;
-	ethash_h256_t seed;
-	ethash_h256_t hash;
-	memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-	memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
-	cache_size = 1024;
-	full_size = 1024 * 32;
-
-	ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
-	ethash_full_t full = ethash_full_new_internal(
-		"./test_ethash_directory/",
-		seed,
-		full_size,
-		light,
-		test_full_callback
-	);
-	BOOST_ASSERT(full);
-	BOOST_CHECK(g_executed);
-	BOOST_REQUIRE_EQUAL(g_prev_progress, 100);
-
-	ethash_full_delete(full);
-	ethash_light_delete(light);
-	fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(failing_full_client_callback) {
-	uint64_t full_size;
-	uint64_t cache_size;
-	ethash_h256_t seed;
-	ethash_h256_t hash;
-	memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-	memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
-	cache_size = 1024;
-	full_size = 1024 * 32;
-
-	ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
-	ethash_full_t full = ethash_full_new_internal(
-		"./test_ethash_directory/",
-		seed,
-		full_size,
-		light,
-		test_full_callback_that_fails
-	);
-	BOOST_ASSERT(!full);
-	ethash_light_delete(light);
-	fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_incomplete_dag_file) {
-	uint64_t full_size;
-	uint64_t cache_size;
-	ethash_h256_t seed;
-	ethash_h256_t hash;
-	memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-	memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
-	cache_size = 1024;
-	full_size = 1024 * 32;
-
-	ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
-	// create a full but stop at 30%, so no magic number is written
-	ethash_full_t full = ethash_full_new_internal(
-		"./test_ethash_directory/",
-		seed,
-		full_size,
-		light,
-		test_full_callback_create_incomplete_dag
-	);
-	BOOST_ASSERT(!full);
-	FILE *f = NULL;
-	// confirm that we get a size_mismatch because the magic number is missing
-	BOOST_REQUIRE_EQUAL(
-		ETHASH_IO_MEMO_SIZE_MISMATCH,
-		ethash_io_prepare("./test_ethash_directory/", seed, &f, full_size, false)
-	);
-	ethash_light_delete(light);
-	fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_block22_verification) {
-	// from POC-9 testnet, epoch 0
-	ethash_light_t light = ethash_light_new(22);
-	ethash_h256_t seedhash = stringToBlockhash("372eca2454ead349c3df0ab5d00b0b706b23e49d469387db91811cee0358fc6d");
-	BOOST_ASSERT(light);
-	ethash_return_value_t ret = ethash_light_compute(
-		light,
-		seedhash,
-		0x495732e0ed7a801cU
-	);
-	BOOST_REQUIRE_EQUAL(blockhashToHexString(&ret.result), "00000b184f1fdd88bfd94c86c39e65db0c36144d5e43f745f722196e730cb614");
-	ethash_h256_t difficulty = ethash_h256_static_init(0x2, 0x5, 0x40);
-	BOOST_REQUIRE(ethash_check_difficulty(&ret.result, &difficulty));
-	ethash_light_delete(light);
-}
-
-BOOST_AUTO_TEST_CASE(test_block30001_verification) {
-	// from POC-9 testnet, epoch 1
-	ethash_light_t light = ethash_light_new(30001);
-	ethash_h256_t seedhash = stringToBlockhash("7e44356ee3441623bc72a683fd3708fdf75e971bbe294f33e539eedad4b92b34");
-	BOOST_ASSERT(light);
-	ethash_return_value_t ret = ethash_light_compute(
-		light,
-		seedhash,
-		0x318df1c8adef7e5eU
-	);
-	ethash_h256_t difficulty = ethash_h256_static_init(0x17, 0x62, 0xff);
-	BOOST_REQUIRE(ethash_check_difficulty(&ret.result, &difficulty));
-	ethash_light_delete(light);
-}
-
-BOOST_AUTO_TEST_CASE(test_block60000_verification) {
-	// from POC-9 testnet, epoch 2
-	ethash_light_t light = ethash_light_new(60000);
-	ethash_h256_t seedhash = stringToBlockhash("5fc898f16035bf5ac9c6d9077ae1e3d5fc1ecc3c9fd5bee8bb00e810fdacbaa0");
-	BOOST_ASSERT(light);
-	ethash_return_value_t ret = ethash_light_compute(
-		light,
-		seedhash,
-		0x50377003e5d830caU
-	);
-	ethash_h256_t difficulty = ethash_h256_static_init(0x25, 0xa6, 0x1e);
-	BOOST_REQUIRE(ethash_check_difficulty(&ret.result, &difficulty));
-	ethash_light_delete(light);
-}
-
-// Test of Full DAG creation with the minimal ethash.h API.
-// Commented out since travis tests would take too much time.
-// Uncomment and run on your own machine if you want to confirm
-// it works fine.
-#if 0
-static int progress_cb(unsigned _progress)
-{
-	printf("CREATING DAG. PROGRESS: %u\n", _progress);
-	fflush(stdout);
-	return 0;
-}
-
-BOOST_AUTO_TEST_CASE(full_dag_test) {
-	ethash_light_t light = ethash_light_new(55);
-	BOOST_ASSERT(light);
-	ethash_full_t full = ethash_full_new(light, progress_cb);
-	BOOST_ASSERT(full);
-	ethash_light_delete(light);
-	ethash_full_delete(full);
-}
-#endif

Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.sh

@@ -1,32 +0,0 @@
-#!/bin/bash
-
-# Strict mode
-set -e
-
-VALGRIND_ARGS="--tool=memcheck"
-VALGRIND_ARGS+=" --leak-check=yes"
-VALGRIND_ARGS+=" --track-origins=yes"
-VALGRIND_ARGS+=" --show-reachable=yes"
-VALGRIND_ARGS+=" --num-callers=20"
-VALGRIND_ARGS+=" --track-fds=yes"
-
-SOURCE="${BASH_SOURCE[0]}"
-while [ -h "$SOURCE" ]; do
-  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-  SOURCE="$(readlink "$SOURCE")"
-  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
-done
-TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-
-rm -rf $TEST_DIR/build 
-mkdir -p $TEST_DIR/build 
-cd $TEST_DIR/build ; 
-cmake ../../.. > /dev/null 
-make Test 
-./test/c/Test
-
-# If we have valgrind also run memory check tests
-if hash valgrind 2>/dev/null; then
-	echo "======== Running tests under valgrind ========";
-	cd $TEST_DIR/build/ && valgrind $VALGRIND_ARGS ./test/c/Test
-fi

Godeps/_workspace/src/github.com/ethereum/ethash/test/python/.gitignore

@@ -1 +0,0 @@
-python-virtual-env/

Godeps/_workspace/src/github.com/ethereum/ethash/test/python/requirements.txt

@@ -1,3 +0,0 @@
-pyethereum==0.7.522
-nose==1.3.4
-pysha3==0.3

Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test.sh

@@ -1,30 +0,0 @@
-#!/bin/bash
-
-# Strict mode
-set -e
-
-if [ -x "$(which virtualenv2)" ] ; then
-   VIRTUALENV_EXEC=virtualenv2
-elif [ -x "$(which virtualenv)" ] ; then
-   VIRTUALENV_EXEC=virtualenv
-else
-   echo "Could not find a suitable version of virtualenv"
-   false
-fi
-
-SOURCE="${BASH_SOURCE[0]}"
-while [ -h "$SOURCE" ]; do
-  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-  SOURCE="$(readlink "$SOURCE")"
-  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
-done
-TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-
-[ -d $TEST_DIR/python-virtual-env ] || $VIRTUALENV_EXEC --system-site-packages $TEST_DIR/python-virtual-env
-source $TEST_DIR/python-virtual-env/bin/activate
-pip install -r $TEST_DIR/requirements.txt > /dev/null
-# force installation of nose in virtualenv even if existing in thereuser's system
-pip install nose -I
-pip install --upgrade --no-deps --force-reinstall -e $TEST_DIR/../..
-cd $TEST_DIR
-nosetests --with-doctest -v --nocapture

Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test_pyethash.py

@@ -1,105 +0,0 @@
-import pyethash
-from random import randint
-
-def test_get_cache_size_not_None():
-    for _ in range(100):
-        block_num = randint(0,12456789)
-        out = pyethash.get_cache_size(block_num)
-        assert out != None
-
-def test_get_full_size_not_None():
-    for _ in range(100):
-        block_num = randint(0,12456789)
-        out = pyethash.get_full_size(block_num)
-        assert out != None
-
-def test_get_cache_size_based_on_EPOCH():
-    for _ in range(100):
-        block_num = randint(0,12456789)
-        out1 = pyethash.get_cache_size(block_num)
-        out2 = pyethash.get_cache_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH)
-        assert out1 == out2
-
-def test_get_full_size_based_on_EPOCH():
-    for _ in range(100):
-        block_num = randint(0,12456789)
-        out1 = pyethash.get_full_size(block_num)
-        out2 = pyethash.get_full_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH)
-        assert out1 == out2
-
-# See light_and_full_client_checks in test.cpp
-def test_mkcache_is_as_expected():
-    actual = pyethash.mkcache_bytes(
-        1024,
-        "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~").encode('hex')
-    expected = "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"
-    assert actual == expected
-
-def test_calc_dataset_is_not_None():
-    cache = pyethash.mkcache_bytes(
-              1024,
-              "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
-    assert pyethash.calc_dataset_bytes(1024 * 32, cache) != None
-
-def test_light_and_full_agree():
-    cache = pyethash.mkcache_bytes(
-              1024,
-              "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
-    full_size = 1024 * 32
-    header = "~~~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~"
-    light_result = pyethash.hashimoto_light(full_size, cache, header, 0)
-    dataset = pyethash.calc_dataset_bytes(full_size, cache)
-    full_result = pyethash.hashimoto_full(dataset, header, 0)
-    assert light_result["mix digest"] != None
-    assert len(light_result["mix digest"]) == 32
-    assert light_result["mix digest"] == full_result["mix digest"]
-    assert light_result["result"] != None
-    assert len(light_result["result"]) == 32
-    assert light_result["result"] == full_result["result"]
-
-def int_to_bytes(i):
-    b = []
-    for _ in range(32):
-        b.append(chr(i & 0xff))
-        i >>= 8
-    b.reverse()
-    return "".join(b)
-
-def test_mining_basic():
-    easy_difficulty = int_to_bytes(2**256 - 1)
-    assert easy_difficulty.encode('hex') == 'f' * 64
-    cache = pyethash.mkcache_bytes(
-              1024,
-              "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
-    full_size = 1024 * 32
-    header = "~~~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~"
-    dataset = pyethash.calc_dataset_bytes(full_size, cache)
-    # Check type of outputs
-    assert type(pyethash.mine(dataset,header,easy_difficulty)) == dict
-    assert type(pyethash.mine(dataset,header,easy_difficulty)["nonce"]) == long
-    assert type(pyethash.mine(dataset,header,easy_difficulty)["mix digest"]) == str
-    assert type(pyethash.mine(dataset,header,easy_difficulty)["result"]) == str
-
-def test_mining_doesnt_always_return_the_same_value():
-    easy_difficulty1 = int_to_bytes(int(2**256 * 0.999))
-    # 1 in 1000 difficulty
-    easy_difficulty2 = int_to_bytes(int(2**256 * 0.001))
-    assert easy_difficulty1 != easy_difficulty2
-    cache = pyethash.mkcache_bytes(
-              1024,
-              "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
-    full_size = 1024 * 32
-    header = "~~~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~"
-    dataset = pyethash.calc_dataset_bytes(full_size, cache)
-    # Check type of outputs
-    assert pyethash.mine(dataset, header, easy_difficulty1)['nonce'] != pyethash.mine(dataset, header, easy_difficulty2)['nonce']
-
-def test_get_seedhash():
-    assert pyethash.get_seedhash(0).encode('hex') == '0' * 64
-    import hashlib, sha3
-    expected = pyethash.get_seedhash(0)
-    #print "checking seed hashes:",
-    for i in range(0, 30000*2048, 30000):
-        #print i // 30000,
-        assert pyethash.get_seedhash(i) == expected
-        expected = hashlib.sha3_256(expected).digest()

Godeps/_workspace/src/github.com/ethereum/ethash/test/test.sh

@@ -1,32 +0,0 @@
-#!/bin/bash
-
-# Strict mode
-set -e
-
-SOURCE="${BASH_SOURCE[0]}"
-while [ -h "$SOURCE" ]; do
-  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-  SOURCE="$(readlink "$SOURCE")"
-  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
-done
-TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-
-echo -e "\n################# Testing JS ##################"
-# TODO: Use mocha and real testing tools instead of rolling our own
-cd $TEST_DIR/../js 
-if [ -x "$(which nodejs)" ] ; then 
-	nodejs test.js
-fi
-if [ -x "$(which node)" ] ; then 
-	node test.js
-fi
-
-echo -e "\n################# Testing C ##################"
-$TEST_DIR/c/test.sh
-
-# Temporarily commenting out python tests until they conform to the API
-#echo -e "\n################# Testing Python ##################"
-#$TEST_DIR/python/test.sh
-
-echo "################# Testing Go ##################"
-cd $TEST_DIR/.. && go test -timeout 9999s

Godeps/_workspace/src/github.com/gizak/termui/README.md

@@ -1,159 +0,0 @@
-# termui [![Build Status](https://travis-ci.org/gizak/termui.svg?branch=master)](https://travis-ci.org/gizak/termui) [![Doc Status](https://godoc.org/github.com/gizak/termui?status.png)](https://godoc.org/github.com/gizak/termui)
-
-## Update 23/06/2015
-Pull requests and master branch are freezing, waiting for merging from `refactoring` branch.
-
-## Notice
-termui comes with ABSOLUTELY NO WARRANTY, and there is a breaking change coming up (see refactoring branch) which will change the `Bufferer` interface and many others. These changes reduce calculation overhead and introduce a new drawing buffer with better capacibilities. We will step into the next stage (call it beta) after merging these changes.
-
-## Introduction
-Go terminal dashboard. Inspired by [blessed-contrib](https://github.com/yaronn/blessed-contrib), but purely in Go.
-
-Cross-platform, easy to compile, and fully-customizable.
-
-__Demo:__ (cast under osx 10.10; Terminal.app; Menlo Regular 12pt.)
-
-<img src="./example/dashboard.gif" alt="demo" width="600">
-
-__Grid layout:__
-
-Expressive syntax, using [12 columns grid system](http://www.w3schools.com/bootstrap/bootstrap_grid_system.asp)
-```go
-	import ui "github.com/gizak/termui"
-	// init and create widgets...
-
-	// build
-	ui.Body.AddRows(
-		ui.NewRow(
-			ui.NewCol(6, 0, widget0),
-			ui.NewCol(6, 0, widget1)),
-		ui.NewRow(
-			ui.NewCol(3, 0, widget2),
-			ui.NewCol(3, 0, widget30, widget31, widget32),
-			ui.NewCol(6, 0, widget4)))
-
-	// calculate layout
-	ui.Body.Align()
-
-	ui.Render(ui.Body)
-```
-[demo code:](https://github.com/gizak/termui/blob/master/example/grid.go)
-
-<img src="./example/grid.gif" alt="grid" width="500">
-
-## Installation
-
-	go get github.com/gizak/termui
-
-## Usage
-
-Each component's layout is a bit like HTML block (box model), which has border and padding.
-
-The `Border` property can be chosen to hide or display (with its border label), when it comes to display, the label takes 1 padding space (i.e. in css: `padding: 1;`, innerHeight and innerWidth therefore shrunk by 1).
-
-`````go
-	import ui "github.com/gizak/termui" // <- ui shortcut, optional
-
-	func main() {
-		err := ui.Init()
-		if err != nil {
-			panic(err)
-		}
-		defer ui.Close()
-
-		p := ui.NewPar(":PRESS q TO QUIT DEMO")
-		p.Height = 3
-		p.Width = 50
-		p.TextFgColor = ui.ColorWhite
-		p.Border.Label = "Text Box"
-		p.Border.FgColor = ui.ColorCyan
-
-		g := ui.NewGauge()
-		g.Percent = 50
-		g.Width = 50
-		g.Height = 3
-		g.Y = 11
-		g.Border.Label = "Gauge"
-		g.BarColor = ui.ColorRed
-		g.Border.FgColor = ui.ColorWhite
-		g.Border.LabelFgColor = ui.ColorCyan
-
-		ui.Render(p, g)
-
-		// event handler...
-	}
-`````
-
-Note that components can be overlapped (I'd rather call this a feature...), `Render(rs ...Renderer)` renders its args from left to right (i.e. each component's weight is arising from left to right).
-
-## Themes
-
-_All_ colors in _all_ components can be changed at _any_ time, while there provides some predefined color schemes:
-
-```go
-// for now there are only two themes: default and helloworld
-termui.UseTheme("helloworld")
-
-// create components...
-```
-The `default ` theme's settings depend on the user's terminal color scheme, which is saying if your terminal default font color is white and background is white, it will be like:
-
-<img src="./example/themedefault.png" alt="default" type="image/png" width="600">
-
-The `helloworld` color scheme drops in some colors!
-
-<img src="./example/themehelloworld.png" alt="helloworld" type="image/png" width="600">
-
-## Widgets
-
-#### Par
-
-[demo code](https://github.com/gizak/termui/blob/master/example/par.go)
-
-<img src="./example/par.png" alt="par" type="image/png" width="300">
-
-#### List
-[demo code](https://github.com/gizak/termui/blob/master/example/list.go)
-
-<img src="./example/list.png" alt="list" type="image/png" width="200">
-
-#### Gauge
-[demo code](https://github.com/gizak/termui/blob/master/example/gauge.go)
-
-<img src="./example/gauge.png" alt="gauge" type="image/png" width="350">
-
-#### Line Chart
-[demo code](https://github.com/gizak/termui/blob/master/example/linechart.go)
-
-<img src="./example/linechart.png" alt="linechart" type="image/png" width="450">
-
-#### Bar Chart
-[demo code](https://github.com/gizak/termui/blob/master/example/barchart.go)
-
-<img src="./example/barchart.png" alt="barchart" type="image/png" width="150">
-
-#### Mult-Bar / Stacked-Bar Chart
-[demo code](https://github.com/gizak/termui/blob/master/example/mbarchart.go)
-
-<img src="./example/mbarchart.png" alt="barchart" type="image/png" width="150">
-
-#### Sparklines
-[demo code](https://github.com/gizak/termui/blob/master/example/sparklines.go)
-
-<img src="./example/sparklines.png" alt="sparklines" type="image/png" width="350">
-
-
-## GoDoc
-
-[godoc](https://godoc.org/github.com/gizak/termui)
-
-## TODO
-
-- [x] Grid layout
-- [ ] Event system
-- [ ] Canvas widget
-- [ ] Refine APIs
-- [ ] Focusable widgets
-
-## License
-This library is under the [MIT License](http://opensource.org/licenses/MIT)

Godeps/_workspace/src/github.com/gizak/termui/block.go

@@ -1,142 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-// Block is a base struct for all other upper level widgets,
-// consider it as css: display:block.
-// Normally you do not need to create it manually.
-type Block struct {
-	X             int
-	Y             int
-	Border        labeledBorder
-	IsDisplay     bool
-	HasBorder     bool
-	BgColor       Attribute
-	Width         int
-	Height        int
-	innerWidth    int
-	innerHeight   int
-	innerX        int
-	innerY        int
-	PaddingTop    int
-	PaddingBottom int
-	PaddingLeft   int
-	PaddingRight  int
-}
-
-// NewBlock returns a *Block which inherits styles from current theme.
-func NewBlock() *Block {
-	d := Block{}
-	d.IsDisplay = true
-	d.HasBorder = theme.HasBorder
-	d.Border.BgColor = theme.BorderBg
-	d.Border.FgColor = theme.BorderFg
-	d.Border.LabelBgColor = theme.BorderLabelTextBg
-	d.Border.LabelFgColor = theme.BorderLabelTextFg
-	d.BgColor = theme.BlockBg
-	d.Width = 2
-	d.Height = 2
-	return &d
-}
-
-// compute box model
-func (d *Block) align() {
-	d.innerWidth = d.Width - d.PaddingLeft - d.PaddingRight
-	d.innerHeight = d.Height - d.PaddingTop - d.PaddingBottom
-	d.innerX = d.X + d.PaddingLeft
-	d.innerY = d.Y + d.PaddingTop
-
-	if d.HasBorder {
-		d.innerHeight -= 2
-		d.innerWidth -= 2
-		d.Border.X = d.X
-		d.Border.Y = d.Y
-		d.Border.Width = d.Width
-		d.Border.Height = d.Height
-		d.innerX++
-		d.innerY++
-	}
-
-	if d.innerHeight < 0 {
-		d.innerHeight = 0
-	}
-	if d.innerWidth < 0 {
-		d.innerWidth = 0
-	}
-
-}
-
-// InnerBounds returns the internal bounds of the block after aligning and
-// calculating the padding and border, if any.
-func (d *Block) InnerBounds() (x, y, width, height int) {
-	d.align()
-	return d.innerX, d.innerY, d.innerWidth, d.innerHeight
-}
-
-// Buffer implements Bufferer interface.
-// Draw background and border (if any).
-func (d *Block) Buffer() []Point {
-	d.align()
-
-	ps := []Point{}
-	if !d.IsDisplay {
-		return ps
-	}
-
-	if d.HasBorder {
-		ps = d.Border.Buffer()
-	}
-
-	for i := 0; i < d.innerWidth; i++ {
-		for j := 0; j < d.innerHeight; j++ {
-			p := Point{}
-			p.X = d.X + 1 + i
-			p.Y = d.Y + 1 + j
-			p.Ch = ' '
-			p.Bg = d.BgColor
-			ps = append(ps, p)
-		}
-	}
-	return ps
-}
-
-// GetHeight implements GridBufferer.
-// It returns current height of the block.
-func (d Block) GetHeight() int {
-	return d.Height
-}
-
-// SetX implements GridBufferer interface, which sets block's x position.
-func (d *Block) SetX(x int) {
-	d.X = x
-}
-
-// SetY implements GridBufferer interface, it sets y position for block.
-func (d *Block) SetY(y int) {
-	d.Y = y
-}
-
-// SetWidth implements GridBuffer interface, it sets block's width.
-func (d *Block) SetWidth(w int) {
-	d.Width = w
-}
-
-// chop the overflow parts
-func (d *Block) chopOverflow(ps []Point) []Point {
-	nps := make([]Point, 0, len(ps))
-	x := d.X
-	y := d.Y
-	w := d.Width
-	h := d.Height
-	for _, v := range ps {
-		if v.X >= x &&
-			v.X < x+w &&
-			v.Y >= y &&
-			v.Y < y+h {
-			nps = append(nps, v)
-		}
-	}
-	return nps
-}

Godeps/_workspace/src/github.com/gizak/termui/block_test.go

@@ -1,46 +0,0 @@
-package termui
-
-import "testing"
-
-func TestBlock_InnerBounds(t *testing.T) {
-	b := NewBlock()
-	b.X = 10
-	b.Y = 11
-	b.Width = 12
-	b.Height = 13
-
-	assert := func(name string, x, y, w, h int) {
-		t.Log(name)
-		cx, cy, cw, ch := b.InnerBounds()
-		if cx != x {
-			t.Errorf("expected x to be %d but got %d", x, cx)
-		}
-		if cy != y {
-			t.Errorf("expected y to be %d but got %d", y, cy)
-		}
-		if cw != w {
-			t.Errorf("expected width to be %d but got %d", w, cw)
-		}
-		if ch != h {
-			t.Errorf("expected height to be %d but got %d", h, ch)
-		}
-	}
-
-	b.HasBorder = false
-	assert("no border, no padding", 10, 11, 12, 13)
-
-	b.HasBorder = true
-	assert("border, no padding", 11, 12, 10, 11)
-
-	b.PaddingBottom = 2
-	assert("border, 2b padding", 11, 12, 10, 9)
-
-	b.PaddingTop = 3
-	assert("border, 2b 3t padding", 11, 15, 10, 6)
-
-	b.PaddingLeft = 4
-	assert("border, 2b 3t 4l padding", 15, 15, 6, 6)
-
-	b.PaddingRight = 5
-	assert("border, 2b 3t 4l 5r padding", 15, 15, 1, 6)
-}

Godeps/_workspace/src/github.com/gizak/termui/box.go

@@ -1,117 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-type border struct {
-	X       int
-	Y       int
-	Width   int
-	Height  int
-	FgColor Attribute
-	BgColor Attribute
-}
-
-type hline struct {
-	X       int
-	Y       int
-	Length  int
-	FgColor Attribute
-	BgColor Attribute
-}
-
-type vline struct {
-	X       int
-	Y       int
-	Length  int
-	FgColor Attribute
-	BgColor Attribute
-}
-
-// Draw a horizontal line.
-func (l hline) Buffer() []Point {
-	pts := make([]Point, l.Length)
-	for i := 0; i < l.Length; i++ {
-		pts[i].X = l.X + i
-		pts[i].Y = l.Y
-		pts[i].Ch = HORIZONTAL_LINE
-		pts[i].Bg = l.BgColor
-		pts[i].Fg = l.FgColor
-	}
-	return pts
-}
-
-// Draw a vertical line.
-func (l vline) Buffer() []Point {
-	pts := make([]Point, l.Length)
-	for i := 0; i < l.Length; i++ {
-		pts[i].X = l.X
-		pts[i].Y = l.Y + i
-		pts[i].Ch = VERTICAL_LINE
-		pts[i].Bg = l.BgColor
-		pts[i].Fg = l.FgColor
-	}
-	return pts
-}
-
-// Draw a box border.
-func (b border) Buffer() []Point {
-	if b.Width < 2 || b.Height < 2 {
-		return nil
-	}
-	pts := make([]Point, 2*b.Width+2*b.Height-4)
-
-	pts[0].X = b.X
-	pts[0].Y = b.Y
-	pts[0].Fg = b.FgColor
-	pts[0].Bg = b.BgColor
-	pts[0].Ch = TOP_LEFT
-
-	pts[1].X = b.X + b.Width - 1
-	pts[1].Y = b.Y
-	pts[1].Fg = b.FgColor
-	pts[1].Bg = b.BgColor
-	pts[1].Ch = TOP_RIGHT
-
-	pts[2].X = b.X
-	pts[2].Y = b.Y + b.Height - 1
-	pts[2].Fg = b.FgColor
-	pts[2].Bg = b.BgColor
-	pts[2].Ch = BOTTOM_LEFT
-
-	pts[3].X = b.X + b.Width - 1
-	pts[3].Y = b.Y + b.Height - 1
-	pts[3].Fg = b.FgColor
-	pts[3].Bg = b.BgColor
-	pts[3].Ch = BOTTOM_RIGHT
-
-	copy(pts[4:], (hline{b.X + 1, b.Y, b.Width - 2, b.FgColor, b.BgColor}).Buffer())
-	copy(pts[4+b.Width-2:], (hline{b.X + 1, b.Y + b.Height - 1, b.Width - 2, b.FgColor, b.BgColor}).Buffer())
-	copy(pts[4+2*b.Width-4:], (vline{b.X, b.Y + 1, b.Height - 2, b.FgColor, b.BgColor}).Buffer())
-	copy(pts[4+2*b.Width-4+b.Height-2:], (vline{b.X + b.Width - 1, b.Y + 1, b.Height - 2, b.FgColor, b.BgColor}).Buffer())
-
-	return pts
-}
-
-type labeledBorder struct {
-	border
-	Label        string
-	LabelFgColor Attribute
-	LabelBgColor Attribute
-}
-
-// Draw a box border with label.
-func (lb labeledBorder) Buffer() []Point {
-	ps := lb.border.Buffer()
-	maxTxtW := lb.Width - 2
-	rs := trimStr2Runes(lb.Label, maxTxtW)
-
-	for i, j, w := 0, 0, 0; i < len(rs); i++ {
-		w = charWidth(rs[i])
-		ps = append(ps, newPointWithAttrs(rs[i], lb.X+1+j, lb.Y, lb.LabelFgColor, lb.LabelBgColor))
-		j += w
-	}
-
-	return ps
-}

Godeps/_workspace/src/github.com/gizak/termui/canvas_test.go

@@ -1,55 +0,0 @@
-package termui
-
-import (
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-func TestCanvasSet(t *testing.T) {
-	c := NewCanvas()
-	c.Set(0, 0)
-	c.Set(0, 1)
-	c.Set(0, 2)
-	c.Set(0, 3)
-	c.Set(1, 3)
-	c.Set(2, 3)
-	c.Set(3, 3)
-	c.Set(4, 3)
-	c.Set(5, 3)
-	spew.Dump(c)
-}
-
-func TestCanvasUnset(t *testing.T) {
-	c := NewCanvas()
-	c.Set(0, 0)
-	c.Set(0, 1)
-	c.Set(0, 2)
-	c.Unset(0, 2)
-	spew.Dump(c)
-	c.Unset(0, 3)
-	spew.Dump(c)
-}
-
-func TestCanvasBuffer(t *testing.T) {
-	c := NewCanvas()
-	c.Set(0, 0)
-	c.Set(0, 1)
-	c.Set(0, 2)
-	c.Set(0, 3)
-	c.Set(1, 3)
-	c.Set(2, 3)
-	c.Set(3, 3)
-	c.Set(4, 3)
-	c.Set(5, 3)
-	c.Set(6, 3)
-	c.Set(7, 2)
-	c.Set(8, 1)
-	c.Set(9, 0)
-	bufs := c.Buffer()
-	rs := make([]rune, len(bufs))
-	for i, v := range bufs {
-		rs[i] = v.Ch
-	}
-	spew.Dump(string(rs))
-}

Godeps/_workspace/src/github.com/gizak/termui/events.go

@@ -1,219 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-//
-// Portions of this file uses [termbox-go](https://github.com/nsf/termbox-go/blob/54b74d087b7c397c402d0e3b66d2ccb6eaf5c2b4/api_common.go)
-// by [authors](https://github.com/nsf/termbox-go/blob/master/AUTHORS)
-// under [license](https://github.com/nsf/termbox-go/blob/master/LICENSE)
-
-package termui
-
-import "github.com/nsf/termbox-go"
-
-/***********************************termbox-go**************************************/
-
-type (
-	EventType uint8
-	Modifier  uint8
-	Key       uint16
-)
-
-// This type represents a termbox event. The 'Mod', 'Key' and 'Ch' fields are
-// valid if 'Type' is EventKey. The 'Width' and 'Height' fields are valid if
-// 'Type' is EventResize. The 'Err' field is valid if 'Type' is EventError.
-type Event struct {
-	Type   EventType // one of Event* constants
-	Mod    Modifier  // one of Mod* constants or 0
-	Key    Key       // one of Key* constants, invalid if 'Ch' is not 0
-	Ch     rune      // a unicode character
-	Width  int       // width of the screen
-	Height int       // height of the screen
-	Err    error     // error in case if input failed
-	MouseX int       // x coord of mouse
-	MouseY int       // y coord of mouse
-	N      int       // number of bytes written when getting a raw event
-}
-
-const (
-	KeyF1 Key = 0xFFFF - iota
-	KeyF2
-	KeyF3
-	KeyF4
-	KeyF5
-	KeyF6
-	KeyF7
-	KeyF8
-	KeyF9
-	KeyF10
-	KeyF11
-	KeyF12
-	KeyInsert
-	KeyDelete
-	KeyHome
-	KeyEnd
-	KeyPgup
-	KeyPgdn
-	KeyArrowUp
-	KeyArrowDown
-	KeyArrowLeft
-	KeyArrowRight
-	key_min // see terminfo
-	MouseLeft
-	MouseMiddle
-	MouseRight
-)
-
-const (
-	KeyCtrlTilde      Key = 0x00
-	KeyCtrl2          Key = 0x00
-	KeyCtrlSpace      Key = 0x00
-	KeyCtrlA          Key = 0x01
-	KeyCtrlB          Key = 0x02
-	KeyCtrlC          Key = 0x03
-	KeyCtrlD          Key = 0x04
-	KeyCtrlE          Key = 0x05
-	KeyCtrlF          Key = 0x06
-	KeyCtrlG          Key = 0x07
-	KeyBackspace      Key = 0x08
-	KeyCtrlH          Key = 0x08
-	KeyTab            Key = 0x09
-	KeyCtrlI          Key = 0x09
-	KeyCtrlJ          Key = 0x0A
-	KeyCtrlK          Key = 0x0B
-	KeyCtrlL          Key = 0x0C
-	KeyEnter          Key = 0x0D
-	KeyCtrlM          Key = 0x0D
-	KeyCtrlN          Key = 0x0E
-	KeyCtrlO          Key = 0x0F
-	KeyCtrlP          Key = 0x10
-	KeyCtrlQ          Key = 0x11
-	KeyCtrlR          Key = 0x12
-	KeyCtrlS          Key = 0x13
-	KeyCtrlT          Key = 0x14
-	KeyCtrlU          Key = 0x15
-	KeyCtrlV          Key = 0x16
-	KeyCtrlW          Key = 0x17
-	KeyCtrlX          Key = 0x18
-	KeyCtrlY          Key = 0x19
-	KeyCtrlZ          Key = 0x1A
-	KeyEsc            Key = 0x1B
-	KeyCtrlLsqBracket Key = 0x1B
-	KeyCtrl3          Key = 0x1B
-	KeyCtrl4          Key = 0x1C
-	KeyCtrlBackslash  Key = 0x1C
-	KeyCtrl5          Key = 0x1D
-	KeyCtrlRsqBracket Key = 0x1D
-	KeyCtrl6          Key = 0x1E
-	KeyCtrl7          Key = 0x1F
-	KeyCtrlSlash      Key = 0x1F
-	KeyCtrlUnderscore Key = 0x1F
-	KeySpace          Key = 0x20
-	KeyBackspace2     Key = 0x7F
-	KeyCtrl8          Key = 0x7F
-)
-
-// Alt modifier constant, see Event.Mod field and SetInputMode function.
-const (
-	ModAlt Modifier = 0x01
-)
-
-// Event type. See Event.Type field.
-const (
-	EventKey EventType = iota
-	EventResize
-	EventMouse
-	EventError
-	EventInterrupt
-	EventRaw
-	EventNone
-)
-
-/**************************************end**************************************/
-
-// convert termbox.Event to termui.Event
-func uiEvt(e termbox.Event) Event {
-	event := Event{}
-	event.Type = EventType(e.Type)
-	event.Mod = Modifier(e.Mod)
-	event.Key = Key(e.Key)
-	event.Ch = e.Ch
-	event.Width = e.Width
-	event.Height = e.Height
-	event.Err = e.Err
-	event.MouseX = e.MouseX
-	event.MouseY = e.MouseY
-	event.N = e.N
-
-	return event
-}
-
-var evtChs = make([]chan Event, 0)
-
-// EventCh returns an output-only event channel.
-// This function can be called many times (multiplexer).
-func EventCh() <-chan Event {
-	out := make(chan Event)
-	evtChs = append(evtChs, out)
-	return out
-}
-
-// turn on event listener
-func evtListen() {
-	go func() {
-		for {
-			e := termbox.PollEvent()
-			// dispatch
-			for _, c := range evtChs {
-				go func(ch chan Event) {
-					ch <- uiEvt(e)
-				}(c)
-			}
-		}
-	}()
-}
-
-/*
-// EventHandlers is a handler sequence
-var EventHandlers []func(Event)
-
-var signalQuit = make(chan bool)
-
-// Quit sends quit signal to terminate termui
-func Quit() {
-	signalQuit <- true
-}
-
-// Wait listening to signalQuit, block operation.
-func Wait() {
-	<-signalQuit
-}
-
-// RegEvtHandler register function into TSEventHandler sequence.
-func RegEvtHandler(fn func(Event)) {
-	EventHandlers = append(EventHandlers, fn)
-}
-
-// EventLoop handles all events and
-// redirects every event to callbacks in EventHandlers
-func EventLoop() {
-	evt := make(chan termbox.Event)
-
-	go func() {
-		for {
-			evt <- termbox.PollEvent()
-		}
-	}()
-
-	for {
-		select {
-		case c := <-signalQuit:
-			defer func() { signalQuit <- c }()
-			return
-		case e := <-evt:
-			for _, fn := range EventHandlers {
-				fn(uiEvt(e))
-			}
-		}
-	}
-}
-*/

Godeps/_workspace/src/github.com/gizak/termui/events_test.go

@@ -1,28 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-//
-// Portions of this file uses [termbox-go](https://github.com/nsf/termbox-go/blob/54b74d087b7c397c402d0e3b66d2ccb6eaf5c2b4/api_common.go)
-// by [authors](https://github.com/nsf/termbox-go/blob/master/AUTHORS)
-// under [license](https://github.com/nsf/termbox-go/blob/master/LICENSE)
-
-package termui
-
-import (
-	"errors"
-	"testing"
-
-	termbox "github.com/nsf/termbox-go"
-	"github.com/stretchr/testify/assert"
-)
-
-type boxEvent termbox.Event
-
-func TestUiEvt(t *testing.T) {
-	err := errors.New("This is a mock error")
-	event := boxEvent{3, 5, 2, 'H', 200, 500, err, 50, 30, 2}
-	expetced := Event{3, 5, 2, 'H', 200, 500, err, 50, 30, 2}
-
-	// We need to do that ugly casting so that vet does not complain
-	assert.Equal(t, uiEvt(termbox.Event(event)), expetced)
-}

Godeps/_workspace/src/github.com/gizak/termui/example/barchart.go

@@ -1,35 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import "github.com/gizak/termui"
-
-func main() {
-	err := termui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer termui.Close()
-
-	termui.UseTheme("helloworld")
-
-	bc := termui.NewBarChart()
-	data := []int{3, 2, 5, 3, 9, 5, 3, 2, 5, 8, 3, 2, 4, 5, 3, 2, 5, 7, 5, 3, 2, 6, 7, 4, 6, 3, 6, 7, 8, 3, 6, 4, 5, 3, 2, 4, 6, 4, 8, 5, 9, 4, 3, 6, 5, 3, 6}
-	bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"}
-	bc.Border.Label = "Bar Chart"
-	bc.Data = data
-	bc.Width = 26
-	bc.Height = 10
-	bc.DataLabels = bclabels
-	bc.TextColor = termui.ColorGreen
-	bc.BarColor = termui.ColorRed
-	bc.NumColor = termui.ColorYellow
-
-	termui.Render(bc)
-
-	<-termui.EventCh()
-}

Godeps/_workspace/src/github.com/gizak/termui/example/dashboard.go

@@ -1,148 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import ui "github.com/gizak/termui"
-import "math"
-
-import "time"
-
-func main() {
-	err := ui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer ui.Close()
-
-	p := ui.NewPar(":PRESS q TO QUIT DEMO")
-	p.Height = 3
-	p.Width = 50
-	p.TextFgColor = ui.ColorWhite
-	p.Border.Label = "Text Box"
-	p.Border.FgColor = ui.ColorCyan
-
-	strs := []string{"[0] gizak/termui", "[1] editbox.go", "[2] iterrupt.go", "[3] keyboard.go", "[4] output.go", "[5] random_out.go", "[6] dashboard.go", "[7] nsf/termbox-go"}
-	list := ui.NewList()
-	list.Items = strs
-	list.ItemFgColor = ui.ColorYellow
-	list.Border.Label = "List"
-	list.Height = 7
-	list.Width = 25
-	list.Y = 4
-
-	g := ui.NewGauge()
-	g.Percent = 50
-	g.Width = 50
-	g.Height = 3
-	g.Y = 11
-	g.Border.Label = "Gauge"
-	g.BarColor = ui.ColorRed
-	g.Border.FgColor = ui.ColorWhite
-	g.Border.LabelFgColor = ui.ColorCyan
-
-	spark := ui.Sparkline{}
-	spark.Height = 1
-	spark.Title = "srv 0:"
-	spdata := []int{4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6, 4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6, 4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6, 4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6}
-	spark.Data = spdata
-	spark.LineColor = ui.ColorCyan
-	spark.TitleColor = ui.ColorWhite
-
-	spark1 := ui.Sparkline{}
-	spark1.Height = 1
-	spark1.Title = "srv 1:"
-	spark1.Data = spdata
-	spark1.TitleColor = ui.ColorWhite
-	spark1.LineColor = ui.ColorRed
-
-	sp := ui.NewSparklines(spark, spark1)
-	sp.Width = 25
-	sp.Height = 7
-	sp.Border.Label = "Sparkline"
-	sp.Y = 4
-	sp.X = 25
-
-	sinps := (func() []float64 {
-		n := 220
-		ps := make([]float64, n)
-		for i := range ps {
-			ps[i] = 1 + math.Sin(float64(i)/5)
-		}
-		return ps
-	})()
-
-	lc := ui.NewLineChart()
-	lc.Border.Label = "dot-mode Line Chart"
-	lc.Data = sinps
-	lc.Width = 50
-	lc.Height = 11
-	lc.X = 0
-	lc.Y = 14
-	lc.AxesColor = ui.ColorWhite
-	lc.LineColor = ui.ColorRed | ui.AttrBold
-	lc.Mode = "dot"
-
-	bc := ui.NewBarChart()
-	bcdata := []int{3, 2, 5, 3, 9, 5, 3, 2, 5, 8, 3, 2, 4, 5, 3, 2, 5, 7, 5, 3, 2, 6, 7, 4, 6, 3, 6, 7, 8, 3, 6, 4, 5, 3, 2, 4, 6, 4, 8, 5, 9, 4, 3, 6, 5, 3, 6}
-	bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"}
-	bc.Border.Label = "Bar Chart"
-	bc.Width = 26
-	bc.Height = 10
-	bc.X = 51
-	bc.Y = 0
-	bc.DataLabels = bclabels
-	bc.BarColor = ui.ColorGreen
-	bc.NumColor = ui.ColorBlack
-
-	lc1 := ui.NewLineChart()
-	lc1.Border.Label = "braille-mode Line Chart"
-	lc1.Data = sinps
-	lc1.Width = 26
-	lc1.Height = 11
-	lc1.X = 51
-	lc1.Y = 14
-	lc1.AxesColor = ui.ColorWhite
-	lc1.LineColor = ui.ColorYellow | ui.AttrBold
-
-	p1 := ui.NewPar("Hey!\nI am a borderless block!")
-	p1.HasBorder = false
-	p1.Width = 26
-	p1.Height = 2
-	p1.TextFgColor = ui.ColorMagenta
-	p1.X = 52
-	p1.Y = 11
-
-	draw := func(t int) {
-		g.Percent = t % 101
-		list.Items = strs[t%9:]
-		sp.Lines[0].Data = spdata[:30+t%50]
-		sp.Lines[1].Data = spdata[:35+t%50]
-		lc.Data = sinps[t/2:]
-		lc1.Data = sinps[2*t:]
-		bc.Data = bcdata[t/2%10:]
-		ui.Render(p, list, g, sp, lc, bc, lc1, p1)
-	}
-
-	evt := ui.EventCh()
-
-	i := 0
-	for {
-		select {
-		case e := <-evt:
-			if e.Type == ui.EventKey && e.Ch == 'q' {
-				return
-			}
-		default:
-			draw(i)
-			i++
-			if i == 102 {
-				return
-			}
-			time.Sleep(time.Second / 2)
-		}
-	}
-}

Godeps/_workspace/src/github.com/gizak/termui/example/gauge.go

@@ -1,62 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import "github.com/gizak/termui"
-
-func main() {
-	err := termui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer termui.Close()
-
-	termui.UseTheme("helloworld")
-
-	g0 := termui.NewGauge()
-	g0.Percent = 40
-	g0.Width = 50
-	g0.Height = 3
-	g0.Border.Label = "Slim Gauge"
-	g0.BarColor = termui.ColorRed
-	g0.Border.FgColor = termui.ColorWhite
-	g0.Border.LabelFgColor = termui.ColorCyan
-
-	g2 := termui.NewGauge()
-	g2.Percent = 60
-	g2.Width = 50
-	g2.Height = 3
-	g2.PercentColor = termui.ColorBlue
-	g2.Y = 3
-	g2.Border.Label = "Slim Gauge"
-	g2.BarColor = termui.ColorYellow
-	g2.Border.FgColor = termui.ColorWhite
-
-	g1 := termui.NewGauge()
-	g1.Percent = 30
-	g1.Width = 50
-	g1.Height = 5
-	g1.Y = 6
-	g1.Border.Label = "Big Gauge"
-	g1.PercentColor = termui.ColorYellow
-	g1.BarColor = termui.ColorGreen
-	g1.Border.FgColor = termui.ColorWhite
-	g1.Border.LabelFgColor = termui.ColorMagenta
-
-	g3 := termui.NewGauge()
-	g3.Percent = 50
-	g3.Width = 50
-	g3.Height = 3
-	g3.Y = 11
-	g3.Border.Label = "Gauge with custom label"
-	g3.Label = "{{percent}}% (100MBs free)"
-	g3.LabelAlign = termui.AlignRight
-
-	termui.Render(g0, g1, g2, g3)
-
-	<-termui.EventCh()
-}

Godeps/_workspace/src/github.com/gizak/termui/example/grid.go

@@ -1,134 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import ui "github.com/gizak/termui"
-import "math"
-import "time"
-
-func main() {
-	err := ui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer ui.Close()
-
-	sinps := (func() []float64 {
-		n := 400
-		ps := make([]float64, n)
-		for i := range ps {
-			ps[i] = 1 + math.Sin(float64(i)/5)
-		}
-		return ps
-	})()
-	sinpsint := (func() []int {
-		ps := make([]int, len(sinps))
-		for i, v := range sinps {
-			ps[i] = int(100*v + 10)
-		}
-		return ps
-	})()
-
-	ui.UseTheme("helloworld")
-
-	spark := ui.Sparkline{}
-	spark.Height = 8
-	spdata := sinpsint
-	spark.Data = spdata[:100]
-	spark.LineColor = ui.ColorCyan
-	spark.TitleColor = ui.ColorWhite
-
-	sp := ui.NewSparklines(spark)
-	sp.Height = 11
-	sp.Border.Label = "Sparkline"
-
-	lc := ui.NewLineChart()
-	lc.Border.Label = "braille-mode Line Chart"
-	lc.Data = sinps
-	lc.Height = 11
-	lc.AxesColor = ui.ColorWhite
-	lc.LineColor = ui.ColorYellow | ui.AttrBold
-
-	gs := make([]*ui.Gauge, 3)
-	for i := range gs {
-		gs[i] = ui.NewGauge()
-		gs[i].Height = 2
-		gs[i].HasBorder = false
-		gs[i].Percent = i * 10
-		gs[i].PaddingBottom = 1
-		gs[i].BarColor = ui.ColorRed
-	}
-
-	ls := ui.NewList()
-	ls.HasBorder = false
-	ls.Items = []string{
-		"[1] Downloading File 1",
-		"", // == \newline
-		"[2] Downloading File 2",
-		"",
-		"[3] Uploading File 3",
-	}
-	ls.Height = 5
-
-	par := ui.NewPar("<> This row has 3 columns\n<- Widgets can be stacked up like left side\n<- Stacked widgets are treated as a single widget")
-	par.Height = 5
-	par.Border.Label = "Demonstration"
-
-	// build layout
-	ui.Body.AddRows(
-		ui.NewRow(
-			ui.NewCol(6, 0, sp),
-			ui.NewCol(6, 0, lc)),
-		ui.NewRow(
-			ui.NewCol(3, 0, ls),
-			ui.NewCol(3, 0, gs[0], gs[1], gs[2]),
-			ui.NewCol(6, 0, par)))
-
-	// calculate layout
-	ui.Body.Align()
-
-	done := make(chan bool)
-	redraw := make(chan bool)
-
-	update := func() {
-		for i := 0; i < 103; i++ {
-			for _, g := range gs {
-				g.Percent = (g.Percent + 3) % 100
-			}
-
-			sp.Lines[0].Data = spdata[:100+i]
-			lc.Data = sinps[2*i:]
-
-			time.Sleep(time.Second / 2)
-			redraw <- true
-		}
-		done <- true
-	}
-
-	evt := ui.EventCh()
-
-	ui.Render(ui.Body)
-	go update()
-
-	for {
-		select {
-		case e := <-evt:
-			if e.Type == ui.EventKey && e.Ch == 'q' {
-				return
-			}
-			if e.Type == ui.EventResize {
-				ui.Body.Width = ui.TermWidth()
-				ui.Body.Align()
-				go func() { redraw <- true }()
-			}
-		case <-done:
-			return
-		case <-redraw:
-			ui.Render(ui.Body)
-		}
-	}
-}

Godeps/_workspace/src/github.com/gizak/termui/example/linechart.go

@@ -1,68 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"math"
-
-	"github.com/gizak/termui"
-)
-
-func main() {
-	err := termui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer termui.Close()
-
-	termui.UseTheme("helloworld")
-
-	sinps := (func() []float64 {
-		n := 220
-		ps := make([]float64, n)
-		for i := range ps {
-			ps[i] = 1 + math.Sin(float64(i)/5)
-		}
-		return ps
-	})()
-
-	lc0 := termui.NewLineChart()
-	lc0.Border.Label = "braille-mode Line Chart"
-	lc0.Data = sinps
-	lc0.Width = 50
-	lc0.Height = 12
-	lc0.X = 0
-	lc0.Y = 0
-	lc0.AxesColor = termui.ColorWhite
-	lc0.LineColor = termui.ColorGreen | termui.AttrBold
-
-	lc1 := termui.NewLineChart()
-	lc1.Border.Label = "dot-mode Line Chart"
-	lc1.Mode = "dot"
-	lc1.Data = sinps
-	lc1.Width = 26
-	lc1.Height = 12
-	lc1.X = 51
-	lc1.DotStyle = '+'
-	lc1.AxesColor = termui.ColorWhite
-	lc1.LineColor = termui.ColorYellow | termui.AttrBold
-
-	lc2 := termui.NewLineChart()
-	lc2.Border.Label = "dot-mode Line Chart"
-	lc2.Mode = "dot"
-	lc2.Data = sinps[4:]
-	lc2.Width = 77
-	lc2.Height = 16
-	lc2.X = 0
-	lc2.Y = 12
-	lc2.AxesColor = termui.ColorWhite
-	lc2.LineColor = termui.ColorCyan | termui.AttrBold
-
-	termui.Render(lc0, lc1, lc2)
-
-	<-termui.EventCh()
-}

Godeps/_workspace/src/github.com/gizak/termui/example/list.go

@@ -1,41 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import "github.com/gizak/termui"
-
-func main() {
-	err := termui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer termui.Close()
-
-	termui.UseTheme("helloworld")
-
-	strs := []string{
-		"[0] github.com/gizak/termui",
-		"[1] 你好，世界",
-		"[2] こんにちは世界",
-		"[3] keyboard.go",
-		"[4] output.go",
-		"[5] random_out.go",
-		"[6] dashboard.go",
-		"[7] nsf/termbox-go"}
-
-	ls := termui.NewList()
-	ls.Items = strs
-	ls.ItemFgColor = termui.ColorYellow
-	ls.Border.Label = "List"
-	ls.Height = 7
-	ls.Width = 25
-	ls.Y = 0
-
-	termui.Render(ls)
-
-	<-termui.EventCh()
-}

Godeps/_workspace/src/github.com/gizak/termui/example/mbarchart.go

@@ -1,50 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import "github.com/gizak/termui"
-
-func main() {
-	err := termui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer termui.Close()
-
-	termui.UseTheme("helloworld")
-
-	bc := termui.NewMBarChart()
-	math := []int{90, 85, 90, 80}
-	english := []int{70, 85, 75, 60}
-	science := []int{75, 60, 80, 85}
-	compsci := []int{100, 100, 100, 100}
-	bc.Data[0] = math
-	bc.Data[1] = english
-	bc.Data[2] = science
-	bc.Data[3] = compsci
-	studentsName := []string{"Ken", "Rob", "Dennis", "Linus"}
-	bc.Border.Label = "Student's Marks X-Axis=Name Y-Axis=Marks[Math,English,Science,ComputerScience] in %"
-	bc.Width = 100
-	bc.Height = 50
-	bc.Y = 10
-	bc.BarWidth = 10
-	bc.DataLabels = studentsName
-	bc.ShowScale = true //Show y_axis scale value (min and max)
-	bc.SetMax(400)
-
-	bc.TextColor = termui.ColorGreen    //this is color for label (x-axis)
-	bc.BarColor[3] = termui.ColorGreen  //BarColor for computerscience
-	bc.BarColor[1] = termui.ColorYellow //Bar Color for english
-	bc.NumColor[3] = termui.ColorRed    // Num color for computerscience
-	bc.NumColor[1] = termui.ColorRed    // num color for english
-
-	//Other colors are automatically populated, btw All the students seems do well in computerscience. :p
-
-	termui.Render(bc)
-
-	<-termui.EventCh()
-}

Godeps/_workspace/src/github.com/gizak/termui/example/par.go

@@ -1,48 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import "github.com/gizak/termui"
-
-func main() {
-	err := termui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer termui.Close()
-
-	termui.UseTheme("helloworld")
-
-	par0 := termui.NewPar("Borderless Text")
-	par0.Height = 1
-	par0.Width = 20
-	par0.Y = 1
-	par0.HasBorder = false
-
-	par1 := termui.NewPar("你好，世界。")
-	par1.Height = 3
-	par1.Width = 17
-	par1.X = 20
-	par1.Border.Label = "标签"
-
-	par2 := termui.NewPar("Simple text\nwith label. It can be multilined with \\n or break automatically")
-	par2.Height = 5
-	par2.Width = 37
-	par2.Y = 4
-	par2.Border.Label = "Multiline"
-	par2.Border.FgColor = termui.ColorYellow
-
-	par3 := termui.NewPar("Long text with label and it is auto trimmed.")
-	par3.Height = 3
-	par3.Width = 37
-	par3.Y = 9
-	par3.Border.Label = "Auto Trim"
-
-	termui.Render(par0, par1, par2, par3)
-
-	<-termui.EventCh()
-}

Godeps/_workspace/src/github.com/gizak/termui/example/sparklines.go

@@ -1,65 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import "github.com/gizak/termui"
-
-func main() {
-	err := termui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer termui.Close()
-
-	termui.UseTheme("helloworld")
-
-	data := []int{4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6}
-	spl0 := termui.NewSparkline()
-	spl0.Data = data[3:]
-	spl0.Title = "Sparkline 0"
-	spl0.LineColor = termui.ColorGreen
-
-	// single
-	spls0 := termui.NewSparklines(spl0)
-	spls0.Height = 2
-	spls0.Width = 20
-	spls0.HasBorder = false
-
-	spl1 := termui.NewSparkline()
-	spl1.Data = data
-	spl1.Title = "Sparkline 1"
-	spl1.LineColor = termui.ColorRed
-
-	spl2 := termui.NewSparkline()
-	spl2.Data = data[5:]
-	spl2.Title = "Sparkline 2"
-	spl2.LineColor = termui.ColorMagenta
-
-	// group
-	spls1 := termui.NewSparklines(spl0, spl1, spl2)
-	spls1.Height = 8
-	spls1.Width = 20
-	spls1.Y = 3
-	spls1.Border.Label = "Group Sparklines"
-
-	spl3 := termui.NewSparkline()
-	spl3.Data = data
-	spl3.Title = "Enlarged Sparkline"
-	spl3.Height = 8
-	spl3.LineColor = termui.ColorYellow
-
-	spls2 := termui.NewSparklines(spl3)
-	spls2.Height = 11
-	spls2.Width = 30
-	spls2.Border.FgColor = termui.ColorCyan
-	spls2.X = 21
-	spls2.Border.Label = "Tweeked Sparkline"
-
-	termui.Render(spls0, spls1, spls2)
-
-	<-termui.EventCh()
-}

Godeps/_workspace/src/github.com/gizak/termui/example/theme.go

@@ -1,143 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import ui "github.com/gizak/termui"
-import "math"
-
-import "time"
-
-func main() {
-	err := ui.Init()
-	if err != nil {
-		panic(err)
-	}
-	defer ui.Close()
-
-	ui.UseTheme("helloworld")
-
-	p := ui.NewPar(":PRESS q TO QUIT DEMO")
-	p.Height = 3
-	p.Width = 50
-	p.Border.Label = "Text Box"
-
-	strs := []string{"[0] gizak/termui", "[1] editbox.go", "[2] iterrupt.go", "[3] keyboard.go", "[4] output.go", "[5] random_out.go", "[6] dashboard.go", "[7] nsf/termbox-go"}
-	list := ui.NewList()
-	list.Items = strs
-	list.Border.Label = "List"
-	list.Height = 7
-	list.Width = 25
-	list.Y = 4
-
-	g := ui.NewGauge()
-	g.Percent = 50
-	g.Width = 50
-	g.Height = 3
-	g.Y = 11
-	g.Border.Label = "Gauge"
-
-	spark := ui.NewSparkline()
-	spark.Title = "srv 0:"
-	spdata := []int{4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6}
-	spark.Data = spdata
-
-	spark1 := ui.NewSparkline()
-	spark1.Title = "srv 1:"
-	spark1.Data = spdata
-
-	sp := ui.NewSparklines(spark, spark1)
-	sp.Width = 25
-	sp.Height = 7
-	sp.Border.Label = "Sparkline"
-	sp.Y = 4
-	sp.X = 25
-
-	lc := ui.NewLineChart()
-	sinps := (func() []float64 {
-		n := 100
-		ps := make([]float64, n)
-		for i := range ps {
-			ps[i] = 1 + math.Sin(float64(i)/4)
-		}
-		return ps
-	})()
-
-	lc.Border.Label = "Line Chart"
-	lc.Data = sinps
-	lc.Width = 50
-	lc.Height = 11
-	lc.X = 0
-	lc.Y = 14
-	lc.Mode = "dot"
-
-	bc := ui.NewBarChart()
-	bcdata := []int{3, 2, 5, 3, 9, 5, 3, 2, 5, 8, 3, 2, 4, 5, 3, 2, 5, 7, 5, 3, 2, 6, 7, 4, 6, 3, 6, 7, 8, 3, 6, 4, 5, 3, 2, 4, 6, 4, 8, 5, 9, 4, 3, 6, 5, 3, 6}
-	bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"}
-	bc.Border.Label = "Bar Chart"
-	bc.Width = 26
-	bc.Height = 10
-	bc.X = 51
-	bc.Y = 0
-	bc.DataLabels = bclabels
-
-	lc1 := ui.NewLineChart()
-	lc1.Border.Label = "Line Chart"
-	rndwalk := (func() []float64 {
-		n := 150
-		d := make([]float64, n)
-		for i := 1; i < n; i++ {
-			if i < 20 {
-				d[i] = d[i-1] + 0.01
-			}
-			if i > 20 {
-				d[i] = d[i-1] - 0.05
-			}
-		}
-		return d
-	})()
-	lc1.Data = rndwalk
-	lc1.Width = 26
-	lc1.Height = 11
-	lc1.X = 51
-	lc1.Y = 14
-
-	p1 := ui.NewPar("Hey!\nI am a borderless block!")
-	p1.HasBorder = false
-	p1.Width = 26
-	p1.Height = 2
-	p1.X = 52
-	p1.Y = 11
-
-	draw := func(t int) {
-		g.Percent = t % 101
-		list.Items = strs[t%9:]
-		sp.Lines[0].Data = spdata[t%10:]
-		sp.Lines[1].Data = spdata[t/2%10:]
-		lc.Data = sinps[t/2:]
-		lc1.Data = rndwalk[t:]
-		bc.Data = bcdata[t/2%10:]
-		ui.Render(p, list, g, sp, lc, bc, lc1, p1)
-	}
-
-	evt := ui.EventCh()
-	i := 0
-	for {
-		select {
-		case e := <-evt:
-			if e.Type == ui.EventKey && e.Ch == 'q' {
-				return
-			}
-		default:
-			draw(i)
-			i++
-			if i == 102 {
-				return
-			}
-			time.Sleep(time.Second / 2)
-		}
-	}
-}

Godeps/_workspace/src/github.com/gizak/termui/gauge.go

@@ -1,113 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import (
-	"strconv"
-	"strings"
-)
-
-// Gauge is a progress bar like widget.
-// A simple example:
-/*
-  g := termui.NewGauge()
-  g.Percent = 40
-  g.Width = 50
-  g.Height = 3
-  g.Border.Label = "Slim Gauge"
-  g.BarColor = termui.ColorRed
-  g.PercentColor = termui.ColorBlue
-*/
-
-// Align is the position of the gauge's label.
-type Align int
-
-// All supported positions.
-const (
-	AlignLeft Align = iota
-	AlignCenter
-	AlignRight
-)
-
-type Gauge struct {
-	Block
-	Percent      int
-	BarColor     Attribute
-	PercentColor Attribute
-	Label        string
-	LabelAlign   Align
-}
-
-// NewGauge return a new gauge with current theme.
-func NewGauge() *Gauge {
-	g := &Gauge{
-		Block:        *NewBlock(),
-		PercentColor: theme.GaugePercent,
-		BarColor:     theme.GaugeBar,
-		Label:        "{{percent}}%",
-		LabelAlign:   AlignCenter,
-	}
-
-	g.Width = 12
-	g.Height = 5
-	return g
-}
-
-// Buffer implements Bufferer interface.
-func (g *Gauge) Buffer() []Point {
-	ps := g.Block.Buffer()
-
-	// plot bar
-	w := g.Percent * g.innerWidth / 100
-	for i := 0; i < g.innerHeight; i++ {
-		for j := 0; j < w; j++ {
-			p := Point{}
-			p.X = g.innerX + j
-			p.Y = g.innerY + i
-			p.Ch = ' '
-			p.Bg = g.BarColor
-			if p.Bg == ColorDefault {
-				p.Bg |= AttrReverse
-			}
-			ps = append(ps, p)
-		}
-	}
-
-	// plot percentage
-	s := strings.Replace(g.Label, "{{percent}}", strconv.Itoa(g.Percent), -1)
-	pry := g.innerY + g.innerHeight/2
-	rs := str2runes(s)
-	var pos int
-	switch g.LabelAlign {
-	case AlignLeft:
-		pos = 0
-
-	case AlignCenter:
-		pos = (g.innerWidth - strWidth(s)) / 2
-
-	case AlignRight:
-		pos = g.innerWidth - strWidth(s)
-	}
-
-	for i, v := range rs {
-		p := Point{}
-		p.X = 1 + pos + i
-		p.Y = pry
-		p.Ch = v
-		p.Fg = g.PercentColor
-		if w+g.innerX > pos+i {
-			p.Bg = g.BarColor
-			if p.Bg == ColorDefault {
-				p.Bg |= AttrReverse
-			}
-
-		} else {
-			p.Bg = g.Block.BgColor
-		}
-
-		ps = append(ps, p)
-	}
-	return g.Block.chopOverflow(ps)
-}

Godeps/_workspace/src/github.com/gizak/termui/grid_test.go

@@ -1,98 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import (
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-var r *Row
-
-func TestRowWidth(t *testing.T) {
-	p0 := NewPar("p0")
-	p0.Height = 1
-	p1 := NewPar("p1")
-	p1.Height = 1
-	p2 := NewPar("p2")
-	p2.Height = 1
-	p3 := NewPar("p3")
-	p3.Height = 1
-
-	/* test against tree:
-
-	       r
-	     /  \
-	   0:w   1
-	        / \
-	     10:w 11
-	          /
-	        110:w
-	         /
-	       1100:w
-	*/
-	/*
-		r = &row{
-			Span: 12,
-			Cols: []*row{
-				&row{Widget: p0, Span: 6},
-				&row{
-					Span: 6,
-					Cols: []*row{
-						&row{Widget: p1, Span: 6},
-						&row{
-							Span: 6,
-							Cols: []*row{
-								&row{
-									Span:   12,
-									Widget: p2,
-									Cols: []*row{
-										&row{Span: 12, Widget: p3}}}}}}}}}
-	*/
-
-	r = NewRow(
-		NewCol(6, 0, p0),
-		NewCol(6, 0,
-			NewRow(
-				NewCol(6, 0, p1),
-				NewCol(6, 0, p2, p3))))
-
-	r.assignWidth(100)
-	if r.Width != 100 ||
-		(r.Cols[0].Width) != 50 ||
-		(r.Cols[1].Width) != 50 ||
-		(r.Cols[1].Cols[0].Width) != 25 ||
-		(r.Cols[1].Cols[1].Width) != 25 ||
-		(r.Cols[1].Cols[1].Cols[0].Width) != 25 ||
-		(r.Cols[1].Cols[1].Cols[0].Cols[0].Width) != 25 {
-		t.Error("assignWidth fails")
-	}
-}
-
-func TestRowHeight(t *testing.T) {
-	spew.Dump()
-
-	if (r.solveHeight()) != 2 ||
-		(r.Cols[1].Cols[1].Height) != 2 ||
-		(r.Cols[1].Cols[1].Cols[0].Height) != 2 ||
-		(r.Cols[1].Cols[0].Height) != 1 {
-		t.Error("solveHeight fails")
-	}
-}
-
-func TestAssignXY(t *testing.T) {
-	r.assignX(0)
-	r.assignY(0)
-	if (r.Cols[0].X) != 0 ||
-		(r.Cols[1].Cols[0].X) != 50 ||
-		(r.Cols[1].Cols[1].X) != 75 ||
-		(r.Cols[1].Cols[1].Cols[0].X) != 75 ||
-		(r.Cols[1].Cols[0].Y) != 0 ||
-		(r.Cols[1].Cols[1].Cols[0].Y) != 0 ||
-		(r.Cols[1].Cols[1].Cols[0].Cols[0].Y) != 1 {
-		t.Error("assignXY fails")
-	}
-}

Godeps/_workspace/src/github.com/gizak/termui/helper.go

@@ -1,66 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import tm "github.com/nsf/termbox-go"
-import rw "github.com/mattn/go-runewidth"
-
-/* ---------------Port from termbox-go --------------------- */
-
-// Attribute is printable cell's color and style.
-type Attribute uint16
-
-const (
-	ColorDefault Attribute = iota
-	ColorBlack
-	ColorRed
-	ColorGreen
-	ColorYellow
-	ColorBlue
-	ColorMagenta
-	ColorCyan
-	ColorWhite
-)
-
-const NumberofColors = 8 //Have a constant that defines number of colors
-const (
-	AttrBold Attribute = 1 << (iota + 9)
-	AttrUnderline
-	AttrReverse
-)
-
-var (
-	dot  = "…"
-	dotw = rw.StringWidth(dot)
-)
-
-/* ----------------------- End ----------------------------- */
-
-func toTmAttr(x Attribute) tm.Attribute {
-	return tm.Attribute(x)
-}
-
-func str2runes(s string) []rune {
-	return []rune(s)
-}
-
-func trimStr2Runes(s string, w int) []rune {
-	if w <= 0 {
-		return []rune{}
-	}
-	sw := rw.StringWidth(s)
-	if sw > w {
-		return []rune(rw.Truncate(s, w, dot))
-	}
-	return str2runes(s) //[]rune(rw.Truncate(s, w, ""))
-}
-
-func strWidth(s string) int {
-	return rw.StringWidth(s)
-}
-
-func charWidth(ch rune) int {
-	return rw.RuneWidth(ch)
-}

Godeps/_workspace/src/github.com/gizak/termui/helper_test.go

@@ -1,58 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import (
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-func TestStr2Rune(t *testing.T) {
-	s := "你好,世界."
-	rs := str2runes(s)
-	if len(rs) != 6 {
-		t.Error()
-	}
-}
-
-func TestWidth(t *testing.T) {
-	s0 := "つのだ☆HIRO"
-	s1 := "11111111111"
-	spew.Dump(s0)
-	spew.Dump(s1)
-	// above not align for setting East Asian Ambiguous to wide!!
-
-	if strWidth(s0) != strWidth(s1) {
-		t.Error("str len failed")
-	}
-
-	len1 := []rune{'a', '2', '&', '｢', 'ｵ', '｡'} //will false: 'ᆵ', 'ᄚ', 'ᄒ'
-	for _, v := range len1 {
-		if charWidth(v) != 1 {
-			t.Error("len1 failed")
-		}
-	}
-
-	len2 := []rune{'漢', '字', '한', '자', '你', '好', 'だ', '。', '％', 'ｓ', 'Ｅ', 'ョ', '、', 'ヲ'}
-	for _, v := range len2 {
-		if charWidth(v) != 2 {
-			t.Error("len2 failed")
-		}
-	}
-}
-
-func TestTrim(t *testing.T) {
-	s := "つのだ☆HIRO"
-	if string(trimStr2Runes(s, 10)) != "つのだ☆HI"+dot {
-		t.Error("trim failed")
-	}
-	if string(trimStr2Runes(s, 11)) != "つのだ☆HIRO" {
-		t.Error("avoid tail trim failed")
-	}
-	if string(trimStr2Runes(s, 15)) != "つのだ☆HIRO" {
-		t.Error("avoid trim failed")
-	}
-}

Godeps/_workspace/src/github.com/gizak/termui/p.go

@@ -1,71 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-// Par displays a paragraph.
-/*
-  par := termui.NewPar("Simple Text")
-  par.Height = 3
-  par.Width = 17
-  par.Border.Label = "Label"
-*/
-type Par struct {
-	Block
-	Text        string
-	TextFgColor Attribute
-	TextBgColor Attribute
-}
-
-// NewPar returns a new *Par with given text as its content.
-func NewPar(s string) *Par {
-	return &Par{
-		Block:       *NewBlock(),
-		Text:        s,
-		TextFgColor: theme.ParTextFg,
-		TextBgColor: theme.ParTextBg}
-}
-
-// Buffer implements Bufferer interface.
-func (p *Par) Buffer() []Point {
-	ps := p.Block.Buffer()
-
-	rs := str2runes(p.Text)
-	i, j, k := 0, 0, 0
-	for i < p.innerHeight && k < len(rs) {
-		// the width of char is about to print
-		w := charWidth(rs[k])
-
-		if rs[k] == '\n' || j+w > p.innerWidth {
-			i++
-			j = 0 // set x = 0
-			if rs[k] == '\n' {
-				k++
-			}
-
-			if i >= p.innerHeight {
-				ps = append(ps, newPointWithAttrs('…',
-					p.innerX+p.innerWidth-1,
-					p.innerY+p.innerHeight-1,
-					p.TextFgColor, p.TextBgColor))
-				break
-			}
-
-			continue
-		}
-		pi := Point{}
-		pi.X = p.innerX + j
-		pi.Y = p.innerY + i
-
-		pi.Ch = rs[k]
-		pi.Bg = p.TextBgColor
-		pi.Fg = p.TextFgColor
-
-		ps = append(ps, pi)
-
-		k++
-		j += w
-	}
-	return p.Block.chopOverflow(ps)
-}

Godeps/_workspace/src/github.com/gizak/termui/point.go

@@ -1,28 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-// Point stands for a single cell in terminal.
-type Point struct {
-	Ch rune
-	Bg Attribute
-	Fg Attribute
-	X  int
-	Y  int
-}
-
-func newPoint(c rune, x, y int) (p Point) {
-	p.Ch = c
-	p.X = x
-	p.Y = y
-	return
-}
-
-func newPointWithAttrs(c rune, x, y int, fg, bg Attribute) Point {
-	p := newPoint(c, x, y)
-	p.Bg = bg
-	p.Fg = fg
-	return p
-}

Godeps/_workspace/src/github.com/gizak/termui/render.go

@@ -1,60 +0,0 @@
-// Copyright 2015 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import tm "github.com/nsf/termbox-go"
-
-// Bufferer should be implemented by all renderable components.
-type Bufferer interface {
-	Buffer() []Point
-}
-
-// Init initializes termui library. This function should be called before any others.
-// After initialization, the library must be finalized by 'Close' function.
-func Init() error {
-	Body = NewGrid()
-	Body.X = 0
-	Body.Y = 0
-	Body.BgColor = theme.BodyBg
-	defer func() {
-		w, _ := tm.Size()
-		Body.Width = w
-		evtListen()
-	}()
-	return tm.Init()
-}
-
-// Close finalizes termui library,
-// should be called after successful initialization when termui's functionality isn't required anymore.
-func Close() {
-	tm.Close()
-}
-
-// TermWidth returns the current terminal's width.
-func TermWidth() int {
-	tm.Sync()
-	w, _ := tm.Size()
-	return w
-}
-
-// TermHeight returns the current terminal's height.
-func TermHeight() int {
-	tm.Sync()
-	_, h := tm.Size()
-	return h
-}
-
-// Render renders all Bufferer in the given order from left to right,
-// right could overlap on left ones.
-func Render(rs ...Bufferer) {
-	tm.Clear(tm.ColorDefault, toTmAttr(theme.BodyBg))
-	for _, r := range rs {
-		buf := r.Buffer()
-		for _, v := range buf {
-			tm.SetCell(v.X, v.Y, v.Ch, toTmAttr(v.Fg), toTmAttr(v.Bg))
-		}
-	}
-	tm.Flush()
-}

Godeps/_workspace/src/github.com/hashicorp/golang-lru/lru.go

@@ -1,175 +0,0 @@
-// This package provides a simple LRU cache. It is based on the
-// LRU implementation in groupcache:
-// https://github.com/golang/groupcache/tree/master/lru
-package lru
-
-import (
-	"container/list"
-	"errors"
-	"sync"
-)
-
-// Cache is a thread-safe fixed size LRU cache.
-type Cache struct {
-	size      int
-	evictList *list.List
-	items     map[interface{}]*list.Element
-	lock      sync.RWMutex
-	onEvicted func(key interface{}, value interface{})
-}
-
-// entry is used to hold a value in the evictList
-type entry struct {
-	key   interface{}
-	value interface{}
-}
-
-// New creates an LRU of the given size
-func New(size int) (*Cache, error) {
-	return NewWithEvict(size, nil)
-}
-
-func NewWithEvict(size int, onEvicted func(key interface{}, value interface{})) (*Cache, error) {
-	if size <= 0 {
-		return nil, errors.New("Must provide a positive size")
-	}
-	c := &Cache{
-		size:      size,
-		evictList: list.New(),
-		items:     make(map[interface{}]*list.Element, size),
-		onEvicted: onEvicted,
-	}
-	return c, nil
-}
-
-// Purge is used to completely clear the cache
-func (c *Cache) Purge() {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	if c.onEvicted != nil {
-		for k, v := range c.items {
-			c.onEvicted(k, v.Value.(*entry).value)
-		}
-	}
-
-	c.evictList = list.New()
-	c.items = make(map[interface{}]*list.Element, c.size)
-}
-
-// Add adds a value to the cache.  Returns true if an eviction occured.
-func (c *Cache) Add(key, value interface{}) bool {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	// Check for existing item
-	if ent, ok := c.items[key]; ok {
-		c.evictList.MoveToFront(ent)
-		ent.Value.(*entry).value = value
-		return false
-	}
-
-	// Add new item
-	ent := &entry{key, value}
-	entry := c.evictList.PushFront(ent)
-	c.items[key] = entry
-
-	evict := c.evictList.Len() > c.size
-	// Verify size not exceeded
-	if evict {
-		c.removeOldest()
-	}
-	return evict
-}
-
-// Get looks up a key's value from the cache.
-func (c *Cache) Get(key interface{}) (value interface{}, ok bool) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	if ent, ok := c.items[key]; ok {
-		c.evictList.MoveToFront(ent)
-		return ent.Value.(*entry).value, true
-	}
-	return
-}
-
-// Check if a key is in the cache, without updating the recent-ness or deleting it for being stale.
-func (c *Cache) Contains(key interface{}) (ok bool) {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-
-	_, ok = c.items[key]
-	return ok
-}
-
-// Returns the key value (or undefined if not found) without updating the "recently used"-ness of the key.
-// (If you find yourself using this a lot, you might be using the wrong sort of data structure, but there are some use cases where it's handy.)
-func (c *Cache) Peek(key interface{}) (value interface{}, ok bool) {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-
-	if ent, ok := c.items[key]; ok {
-		return ent.Value.(*entry).value, true
-	}
-	return nil, ok
-}
-
-// Remove removes the provided key from the cache.
-func (c *Cache) Remove(key interface{}) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	if ent, ok := c.items[key]; ok {
-		c.removeElement(ent)
-	}
-}
-
-// RemoveOldest removes the oldest item from the cache.
-func (c *Cache) RemoveOldest() {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	c.removeOldest()
-}
-
-// Keys returns a slice of the keys in the cache, from oldest to newest.
-func (c *Cache) Keys() []interface{} {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-
-	keys := make([]interface{}, len(c.items))
-	ent := c.evictList.Back()
-	i := 0
-	for ent != nil {
-		keys[i] = ent.Value.(*entry).key
-		ent = ent.Prev()
-		i++
-	}
-
-	return keys
-}
-
-// Len returns the number of items in the cache.
-func (c *Cache) Len() int {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	return c.evictList.Len()
-}
-
-// removeOldest removes the oldest item from the cache.
-func (c *Cache) removeOldest() {
-	ent := c.evictList.Back()
-	if ent != nil {
-		c.removeElement(ent)
-	}
-}
-
-// removeElement is used to remove a given list element from the cache
-func (c *Cache) removeElement(e *list.Element) {
-	c.evictList.Remove(e)
-	kv := e.Value.(*entry)
-	delete(c.items, kv.key)
-	if c.onEvicted != nil {
-		c.onEvicted(kv.key, kv.value)
-	}
-}

Godeps/_workspace/src/github.com/hashicorp/golang-lru/lru_test.go

@@ -1,127 +0,0 @@
-package lru
-
-import "testing"
-
-func TestLRU(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		if k != v {
-			t.Fatalf("Evict values not equal (%v!=%v)", k, v)
-		}
-		evictCounter += 1
-	}
-	l, err := NewWithEvict(128, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	if l.Len() != 128 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-
-	if evictCounter != 128 {
-		t.Fatalf("bad evict count: %v", evictCounter)
-	}
-
-	for i, k := range l.Keys() {
-		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
-			t.Fatalf("bad key: %v", k)
-		}
-	}
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be evicted")
-		}
-	}
-	for i := 128; i < 256; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("should not be evicted")
-		}
-	}
-	for i := 128; i < 192; i++ {
-		l.Remove(i)
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be deleted")
-		}
-	}
-
-	l.Get(192) // expect 192 to be last key in l.Keys()
-
-	for i, k := range l.Keys() {
-		if (i < 63 && k != i+193) || (i == 63 && k != 192) {
-			t.Fatalf("out of order key: %v", k)
-		}
-	}
-
-	l.Purge()
-	if l.Len() != 0 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-	if _, ok := l.Get(200); ok {
-		t.Fatalf("should contain nothing")
-	}
-}
-
-// test that Add returns true/false if an eviction occured
-func TestLRUAdd(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		evictCounter += 1
-	}
-
-	l, err := NewWithEvict(1, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	if l.Add(1, 1) == true || evictCounter != 0 {
-		t.Errorf("should not have an eviction")
-	}
-	if l.Add(2, 2) == false || evictCounter != 1 {
-		t.Errorf("should have an eviction")
-	}
-}
-
-// test that Contains doesn't update recent-ness
-func TestLRUContains(t *testing.T) {
-	l, err := New(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if !l.Contains(1) {
-		t.Errorf("1 should be contained")
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("Contains should not have updated recent-ness of 1")
-	}
-}
-
-// test that Peek doesn't update recent-ness
-func TestLRUPeek(t *testing.T) {
-	l, err := New(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if v, ok := l.Peek(1); !ok || v != 1 {
-		t.Errorf("1 should be set to 1: %v, %v", v, ok)
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("should not have updated recent-ness of 1")
-	}
-}

Godeps/_workspace/src/github.com/huin/goupnp/README.md

@@ -1,14 +0,0 @@
-goupnp is a UPnP client library for Go
-
-Installation
-------------
-
-Run `go get -u github.com/huin/goupnp`.
-
-Regenerating dcps generated source code:
-----------------------------------------
-
-1. Install gotasks: `go get -u github.com/jingweno/gotask`
-2. Change to the gotasks directory: `cd gotasks`
-3. Download UPnP specification data (if not done already): `wget http://upnp.org/resources/upnpresources.zip`
-4. Regenerate source code: `gotask specgen -s upnpresources.zip -o ../dcps`

Godeps/_workspace/src/github.com/huin/goupnp/cmd/example_httpu_serving/example_httpu_serving.go

@@ -1,20 +0,0 @@
-package main
-
-import (
-	"log"
-	"net/http"
-
-	"github.com/huin/goupnp/httpu"
-)
-
-func main() {
-	srv := httpu.Server{
-		Addr:      "239.255.255.250:1900",
-		Multicast: true,
-		Handler: httpu.HandlerFunc(func(r *http.Request) {
-			log.Printf("Got %s %s message from %v: %v", r.Method, r.URL.Path, r.RemoteAddr, r.Header)
-		}),
-	}
-	err := srv.ListenAndServe()
-	log.Printf("Serving failed with error: %v", err)
-}