Release v2.0.0-alpha.3

Stop hterm spamming with errors to console after deactivate()

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,27 @@
+# When file a bug report (see below for feature requests)
+
+Please answer these quesions for a bug report. Thanks!
+
+### What version of GoTTY are you using (`gotty --version`)?
+
+
+### What operating system and browser are you using?
+
+
+### What did you do?
+
+If possible, please provide the command you ran.
+
+
+### What did you expect to see?
+
+
+### What did you see instead?
+
+If possible, please provide the output of the command and your browser's console output.
+
+
+
+# When file a new feature proposal
+
+Please provide an actual usecase that requires your new feature.

.gitignore

@@ -1,3 +1,4 @@
 gotty
 bindata
 builds
+js/node_modules/*

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "libapps"]
-	path = libapps
-	url = https://chromium.googlesource.com/apps/libapps

CONTRIBUTING.md

@@ -0,0 +1,44 @@
+# How to contribute
+
+GoTTY is MIT licensed and accepts contributions via GitHub pull requests. We also accepts feature requests on GitHub issues.
+
+## Reporting a bug
+
+Reporting a bug is always welcome and one of the best ways to contribute. A good bug report helps the developers to improve the product much easier. We therefore would like to ask you to fill out the quesions on the issue template as much as possible. That helps us to figure out what's happening and discover the root cause.
+
+
+## Requesting a new feature
+
+When you find that GoTTY cannot fullfill your requirements because of lack of ability, you may want to open a new feature request. In that case, please file a new issue with your usecase and requirements.
+
+
+## Opening a pull request
+
+### Code Style
+
+Please run `go fmt` on your Go code and make sure that your commits are organized for each logical change and your commit messages are in proper format (see below).
+
+[Go's official code style guide](https://github.com/golang/go/wiki/CodeReviewComments) is also helpful.
+
+### Format of the commit message
+
+When you write a commit message, we recommend include following information to make review easier and keep the history cleaerer.
+
+* What is the change
+* The reason for the change
+
+The following is an example:
+
+```
+Add something new to existing package
+
+Since the existing function lacks that mechanism for some purpose,
+this commit adds a new structure to provide it.
+```
+
+When your pull request is to add a new feature, we recommend add an actual usecase so that we can discuss the best way to achive your requirement. Opening a proposal issue in advance is another good way to start discussion of new features.
+
+
+## Contact
+
+If you have a trivial question about GoTTY for a bug or new feature, you can contact @i_yudai on Twitter (unfortunately, I cannot provide support on GoTTY though).

Godeps/Godeps.json

@@ -1,20 +1,16 @@
 {
 	"ImportPath": "github.com/yudai/gotty",
-	"GoVersion": "go1.7",
-	"GodepVersion": "v62",
-	"Packages": [
-		"./..."
-	],
+	"GoVersion": "go1.9",
+	"GodepVersion": "v79",
 	"Deps": [
 		{
-			"ImportPath": "github.com/braintree/manners",
-			"Comment": "0.4.0-6-g9e2a271",
-			"Rev": "9e2a2714de21eb092ead2ef56d8c7a60d7928819"
+			"ImportPath": "github.com/NYTimes/gziphandler",
+			"Rev": "967539e5e271a2bc9b3dcb1285078a1b1df105ae"
 		},
 		{
 			"ImportPath": "github.com/codegangsta/cli",
-			"Comment": "1.2.0-139-g142e6cd",
-			"Rev": "142e6cd241a4dfbf7f07a018f1f8225180018da4"
+			"Comment": "v1.19.1",
+			"Rev": "0bdeddeeb0f650497d603c4ad7b20cfe685682f6"
 		},
 		{
 			"ImportPath": "github.com/elazarl/go-bindata-assetfs",
@@ -37,6 +33,11 @@
 			"Comment": "release.r56-28-g5cf931e",
 			"Rev": "5cf931ef8f76dccd0910001d74a58a7fca84a83d"
 		},
+		{
+			"ImportPath": "github.com/pkg/errors",
+			"Comment": "v0.8.0-2-g248dadf",
+			"Rev": "248dadf4e9068a0b3e79f02ed0a610d935de5302"
+		},
 		{
 			"ImportPath": "github.com/yudai/hcl",
 			"Rev": "5fa2393b3552119bf33a69adb1402a1160cba23d"
@@ -48,10 +49,6 @@
 		{
 			"ImportPath": "github.com/yudai/hcl/json",
 			"Rev": "5fa2393b3552119bf33a69adb1402a1160cba23d"
-		},
-		{
-			"ImportPath": "github.com/yudai/umutex",
-			"Rev": "18216d265c6bc72c3bb0ad9c8103d47d530b7003"
 		}
 	]
 }

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Iwasaki Yudai
+Copyright (c) 2015-2017 Iwasaki Yudai
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,622 +19,3 @@ 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.
-
-=============================================================================
-
-This software is built with following third party open source software.
-
-
-# golng/go
-
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-# libapps/hterm
-
-Copyright (c) 2014, Google Inc.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice, this
-  list of conditions and the following disclaimer in the documentation and/or
-  other materials provided with the distribution.
-
-* Neither the name of Google Inc. nor the names of its contributors may be used
-  to endorse or promote products derived from this software without specific
-  prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-# odegangsta/cli
-
-Copyright (C) 2013 Jeremy Saenz
-All Rights Reserved.
-
-MIT LICENSE
-
-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.
-
-
-# jteeuwen/go-bindata
-
-This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
-license. Its contents can be found at:
-http://creativecommons.org/publicdomain/zero/1.0
-
-# elazarl/go-bindata-assetfs
-
-Copyright (c) 2014, Elazar Leibovich
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-# gorilla/websocket
-
-Copyright (c) 2013 The Gorilla WebSocket Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-  Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-  Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-# kr/pty
-
-Copyright (c) 2011 Keith Rarick
-
-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.
-
-
-# krishnasrinivas/wetty
-
-The MIT License (MIT)
-
-Copyright (c) 2014 Krishna Srinivas
-
-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.
-
-
-# braintree/manners
-
-Copyright (c) 2014 Braintree, a division of PayPal, Inc.
-
-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.
-
-
-# fatih/camelcase
-
-The MIT License (MIT)
-
-Copyright (c) 2015 Fatih Arslan
-
-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.
-
-
-# fatih/structs
-
-The MIT License (MIT)
-
-Copyright (c) 2014 Fatih Arslan
-
-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.
-
-
-# hashicorp/hcl
-
-Mozilla Public License, version 2.0
-
-1. Definitions
-
-1.1. “Contributor”
-
-     means each individual or legal entity that creates, contributes to the
-     creation of, or owns Covered Software.
-
-1.2. “Contributor Version”
-
-     means the combination of the Contributions of others (if any) used by a
-     Contributor and that particular Contributor’s Contribution.
-
-1.3. “Contribution”
-
-     means Covered Software of a particular Contributor.
-
-1.4. “Covered Software”
-
-     means Source Code Form to which the initial Contributor has attached the
-     notice in Exhibit A, the Executable Form of such Source Code Form, and
-     Modifications of such Source Code Form, in each case including portions
-     thereof.
-
-1.5. “Incompatible With Secondary Licenses”
-     means
-
-     a. that the initial Contributor has attached the notice described in
-        Exhibit B to the Covered Software; or
-
-     b. that the Covered Software was made available under the terms of version
-        1.1 or earlier of the License, but not also under the terms of a
-        Secondary License.
-
-1.6. “Executable Form”
-
-     means any form of the work other than Source Code Form.
-
-1.7. “Larger Work”
-
-     means a work that combines Covered Software with other material, in a separate
-     file or files, that is not Covered Software.
-
-1.8. “License”
-
-     means this document.
-
-1.9. “Licensable”
-
-     means having the right to grant, to the maximum extent possible, whether at the
-     time of the initial grant or subsequently, any and all of the rights conveyed by
-     this License.
-
-1.10. “Modifications”
-
-     means any of the following:
-
-     a. any file in Source Code Form that results from an addition to, deletion
-        from, or modification of the contents of Covered Software; or
-
-     b. any new file in Source Code Form that contains any Covered Software.
-
-1.11. “Patent Claims” of a Contributor
-
-      means any patent claim(s), including without limitation, method, process,
-      and apparatus claims, in any patent Licensable by such Contributor that
-      would be infringed, but for the grant of the License, by the making,
-      using, selling, offering for sale, having made, import, or transfer of
-      either its Contributions or its Contributor Version.
-
-1.12. “Secondary License”
-
-      means either the GNU General Public License, Version 2.0, the GNU Lesser
-      General Public License, Version 2.1, the GNU Affero General Public
-      License, Version 3.0, or any later versions of those licenses.
-
-1.13. “Source Code Form”
-
-      means the form of the work preferred for making modifications.
-
-1.14. “You” (or “Your”)
-
-      means an individual or a legal entity exercising rights under this
-      License. For legal entities, “You” includes any entity that controls, is
-      controlled by, or is under common control with You. For purposes of this
-      definition, “control” means (a) the power, direct or indirect, to cause
-      the direction or management of such entity, whether by contract or
-      otherwise, or (b) ownership of more than fifty percent (50%) of the
-      outstanding shares or beneficial ownership of such entity.
-
-
-2. License Grants and Conditions
-
-2.1. Grants
-
-     Each Contributor hereby grants You a world-wide, royalty-free,
-     non-exclusive license:
-
-     a. under intellectual property rights (other than patent or trademark)
-        Licensable by such Contributor to use, reproduce, make available,
-        modify, display, perform, distribute, and otherwise exploit its
-        Contributions, either on an unmodified basis, with Modifications, or as
-        part of a Larger Work; and
-
-     b. under Patent Claims of such Contributor to make, use, sell, offer for
-        sale, have made, import, and otherwise transfer either its Contributions
-        or its Contributor Version.
-
-2.2. Effective Date
-
-     The licenses granted in Section 2.1 with respect to any Contribution become
-     effective for each Contribution on the date the Contributor first distributes
-     such Contribution.
-
-2.3. Limitations on Grant Scope
-
-     The licenses granted in this Section 2 are the only rights granted under this
-     License. No additional rights or licenses will be implied from the distribution
-     or licensing of Covered Software under this License. Notwithstanding Section
-     2.1(b) above, no patent license is granted by a Contributor:
-
-     a. for any code that a Contributor has removed from Covered Software; or
-
-     b. for infringements caused by: (i) Your and any other third party’s
-        modifications of Covered Software, or (ii) the combination of its
-        Contributions with other software (except as part of its Contributor
-        Version); or
-
-     c. under Patent Claims infringed by Covered Software in the absence of its
-        Contributions.
-
-     This License does not grant any rights in the trademarks, service marks, or
-     logos of any Contributor (except as may be necessary to comply with the
-     notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-     No Contributor makes additional grants as a result of Your choice to
-     distribute the Covered Software under a subsequent version of this License
-     (see Section 10.2) or under the terms of a Secondary License (if permitted
-     under the terms of Section 3.3).
-
-2.5. Representation
-
-     Each Contributor represents that the Contributor believes its Contributions
-     are its original creation(s) or it has sufficient rights to grant the
-     rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-     This License is not intended to limit any rights You have under applicable
-     copyright doctrines of fair use, fair dealing, or other equivalents.
-
-2.7. Conditions
-
-     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
-     Section 2.1.
-
-
-3. Responsibilities
-
-3.1. Distribution of Source Form
-
-     All distribution of Covered Software in Source Code Form, including any
-     Modifications that You create or to which You contribute, must be under the
-     terms of this License. You must inform recipients that the Source Code Form
-     of the Covered Software is governed by the terms of this License, and how
-     they can obtain a copy of this License. You may not attempt to alter or
-     restrict the recipients’ rights in the Source Code Form.
-
-3.2. Distribution of Executable Form
-
-     If You distribute Covered Software in Executable Form then:
-
-     a. such Covered Software must also be made available in Source Code Form,
-        as described in Section 3.1, and You must inform recipients of the
-        Executable Form how they can obtain a copy of such Source Code Form by
-        reasonable means in a timely manner, at a charge no more than the cost
-        of distribution to the recipient; and
-
-     b. You may distribute such Executable Form under the terms of this License,
-        or sublicense it under different terms, provided that the license for
-        the Executable Form does not attempt to limit or alter the recipients’
-        rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-     You may create and distribute a Larger Work under terms of Your choice,
-     provided that You also comply with the requirements of this License for the
-     Covered Software. If the Larger Work is a combination of Covered Software
-     with a work governed by one or more Secondary Licenses, and the Covered
-     Software is not Incompatible With Secondary Licenses, this License permits
-     You to additionally distribute such Covered Software under the terms of
-     such Secondary License(s), so that the recipient of the Larger Work may, at
-     their option, further distribute the Covered Software under the terms of
-     either this License or such Secondary License(s).
-
-3.4. Notices
-
-     You may not remove or alter the substance of any license notices (including
-     copyright notices, patent notices, disclaimers of warranty, or limitations
-     of liability) contained within the Source Code Form of the Covered
-     Software, except that You may alter any license notices to the extent
-     required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-     You may choose to offer, and to charge a fee for, warranty, support,
-     indemnity or liability obligations to one or more recipients of Covered
-     Software. However, You may do so only on Your own behalf, and not on behalf
-     of any Contributor. You must make it absolutely clear that any such
-     warranty, support, indemnity, or liability obligation is offered by You
-     alone, and You hereby agree to indemnify every Contributor for any
-     liability incurred by such Contributor as a result of warranty, support,
-     indemnity or liability terms You offer. You may include additional
-     disclaimers of warranty and limitations of liability specific to any
-     jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
-
-   If it is impossible for You to comply with any of the terms of this License
-   with respect to some or all of the Covered Software due to statute, judicial
-   order, or regulation then You must: (a) comply with the terms of this License
-   to the maximum extent possible; and (b) describe the limitations and the code
-   they affect. Such description must be placed in a text file included with all
-   distributions of the Covered Software under this License. Except to the
-   extent prohibited by statute or regulation, such description must be
-   sufficiently detailed for a recipient of ordinary skill to be able to
-   understand it.
-
-5. Termination
-
-5.1. The rights granted under this License will terminate automatically if You
-     fail to comply with any of its terms. However, if You become compliant,
-     then the rights granted under this License from a particular Contributor
-     are reinstated (a) provisionally, unless and until such Contributor
-     explicitly and finally terminates Your grants, and (b) on an ongoing basis,
-     if such Contributor fails to notify You of the non-compliance by some
-     reasonable means prior to 60 days after You have come back into compliance.
-     Moreover, Your grants from a particular Contributor are reinstated on an
-     ongoing basis if such Contributor notifies You of the non-compliance by
-     some reasonable means, this is the first time You have received notice of
-     non-compliance with this License from such Contributor, and You become
-     compliant prior to 30 days after Your receipt of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-     infringement claim (excluding declaratory judgment actions, counter-claims,
-     and cross-claims) alleging that a Contributor Version directly or
-     indirectly infringes any patent, then the rights granted to You by any and
-     all Contributors for the Covered Software under Section 2.1 of this License
-     shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
-     license agreements (excluding distributors and resellers) which have been
-     validly granted by You or Your distributors under this License prior to
-     termination shall survive termination.
-
-6. Disclaimer of Warranty
-
-   Covered Software is provided under this License on an “as is” basis, without
-   warranty of any kind, either expressed, implied, or statutory, including,
-   without limitation, warranties that the Covered Software is free of defects,
-   merchantable, fit for a particular purpose or non-infringing. The entire
-   risk as to the quality and performance of the Covered Software is with You.
-   Should any Covered Software prove defective in any respect, You (not any
-   Contributor) assume the cost of any necessary servicing, repair, or
-   correction. This disclaimer of warranty constitutes an essential part of this
-   License. No use of  any Covered Software is authorized under this License
-   except under this disclaimer.
-
-7. Limitation of Liability
-
-   Under no circumstances and under no legal theory, whether tort (including
-   negligence), contract, or otherwise, shall any Contributor, or anyone who
-   distributes Covered Software as permitted above, be liable to You for any
-   direct, indirect, special, incidental, or consequential damages of any
-   character including, without limitation, damages for lost profits, loss of
-   goodwill, work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses, even if such party shall have been
-   informed of the possibility of such damages. This limitation of liability
-   shall not apply to liability for death or personal injury resulting from such
-   party’s negligence to the extent applicable law prohibits such limitation.
-   Some jurisdictions do not allow the exclusion or limitation of incidental or
-   consequential damages, so this exclusion and limitation may not apply to You.
-
-8. Litigation
-
-   Any litigation relating to this License may be brought only in the courts of
-   a jurisdiction where the defendant maintains its principal place of business
-   and such litigation shall be governed by laws of that jurisdiction, without
-   reference to its conflict-of-law provisions. Nothing in this Section shall
-   prevent a party’s ability to bring cross-claims or counter-claims.
-
-9. Miscellaneous
-
-   This License represents the complete agreement concerning the subject matter
-   hereof. If any provision of this License is held to be unenforceable, such
-   provision shall be reformed only to the extent necessary to make it
-   enforceable. Any law or regulation which provides that the language of a
-   contract shall be construed against the drafter shall not be used to construe
-   this License against a Contributor.
-
-
-10. Versions of the License
-
-10.1. New Versions
-
-      Mozilla Foundation is the license steward. Except as provided in Section
-      10.3, no one other than the license steward has the right to modify or
-      publish new versions of this License. Each version will be given a
-      distinguishing version number.
-
-10.2. Effect of New Versions
-
-      You may distribute the Covered Software under the terms of the version of
-      the License under which You originally received the Covered Software, or
-      under the terms of any subsequent version published by the license
-      steward.
-
-10.3. Modified Versions
-
-      If you create software not governed by this License, and you want to
-      create a new license for such software, you may create and use a modified
-      version of this License if you rename the license and remove any
-      references to the name of the license steward (except to note that such
-      modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses
-      If You choose to distribute Source Code Form that is Incompatible With
-      Secondary Licenses under the terms of this version of the License, the
-      notice described in Exhibit B of this License must be attached.
-
-Exhibit A - Source Code Form License Notice
-
-      This Source Code Form is subject to the
-      terms of the Mozilla Public License, v.
-      2.0. If a copy of the MPL was not
-      distributed with this file, You can
-      obtain one at
-      http://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular file, then
-You may include the notice in a location (such as a LICENSE file in a relevant
-directory) where a recipient would be likely to look for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - “Incompatible With Secondary Licenses” Notice
-
-      This Source Code Form is “Incompatible
-      With Secondary Licenses”, as defined by
-      the Mozilla Public License, v. 2.0.

Makefile

@@ -1,13 +1,18 @@
 OUTPUT_DIR = ./builds
+GIT_COMMIT = `git rev-parse HEAD | cut -c1-7`
+VERSION = 2.0.0-alpha.3
+BUILD_OPTIONS = -ldflags "-X main.Version=$(VERSION) -X main.CommitID=$(GIT_COMMIT)"
 
-gotty: app/resource.go main.go app/*.go
-	godep go build
+gotty: main.go server/*.go webtty/*.go backend/*.go Makefile
+	godep go build ${BUILD_OPTIONS}
 
-resource:  app/resource.go
+.PHONY: asset
+asset: bindata/static/js/gotty-bundle.js bindata/static/index.html bindata/static/favicon.png bindata/static/css/index.css bindata/static/css/xterm.css bindata/static/css/xterm_customize.css
+	go-bindata -prefix bindata -pkg server -ignore=\\.gitkeep -o server/asset.go bindata/...
+	gofmt -w server/asset.go
 
-app/resource.go: bindata/static/js/hterm.js bindata/static/js/gotty.js  bindata/static/index.html bindata/static/favicon.png
-	go-bindata -prefix bindata -pkg app -ignore=\\.gitkeep -o app/resource.go bindata/...
-	gofmt -w app/resource.go
+.PHONY: all
+all: asset gotty
 
 bindata:
 	mkdir bindata
@@ -24,12 +29,33 @@ bindata/static/favicon.png: bindata/static resources/favicon.png
 bindata/static/js: bindata/static
 	mkdir -p bindata/static/js
 
-bindata/static/js/hterm.js: bindata/static/js libapps/hterm/js/*.js
-	cd libapps && \
-	LIBDOT_SEARCH_PATH=`pwd` ./libdot/bin/concat.sh -i ./hterm/concat/hterm_all.concat -o ../bindata/static/js/hterm.js
 
-bindata/static/js/gotty.js: bindata/static/js resources/gotty.js
-	cp resources/gotty.js bindata/static/js/gotty.js
+bindata/static/js/gotty-bundle.js: bindata/static/js js/dist/gotty-bundle.js
+	cp js/dist/gotty-bundle.js bindata/static/js/gotty-bundle.js
+
+bindata/static/css: bindata/static
+	mkdir -p bindata/static/css
+
+bindata/static/css/index.css: bindata/static/css resources/index.css
+	cp resources/index.css bindata/static/css/index.css
+
+bindata/static/css/xterm_customize.css: bindata/static/css resources/xterm_customize.css
+	cp resources/xterm_customize.css bindata/static/css/xterm_customize.css
+
+bindata/static/css/xterm.css: bindata/static/css js/node_modules/xterm/dist/xterm.css
+	cp js/node_modules/xterm/dist/xterm.css bindata/static/css/xterm.css
+
+js/node_modules/xterm/dist/xterm.css:
+	cd js && \
+	npm install
+
+js/dist/gotty-bundle.js: js/src/* js/node_modules/webpack
+	cd js && \
+	`npm bin`/webpack
+
+js/node_modules/webpack:
+	cd js && \
+	npm install
 
 tools:
 	go get github.com/tools/godep
@@ -45,10 +71,10 @@ cross_compile:
 
 targz:
 	mkdir -p ${OUTPUT_DIR}/dist
-	cd ${OUTPUT_DIR}/pkg/; for osarch in *; do (cd $$osarch; tar zcvf ../../dist/gotty_$$osarch.tar.gz ./*); done;
+	cd ${OUTPUT_DIR}/pkg/; for osarch in *; do (cd $$osarch; tar zcvf ../../dist/gotty_${VERSION}_$$osarch.tar.gz ./*); done;
 
 shasums:
 	cd ${OUTPUT_DIR}/dist; sha256sum * > ./SHA256SUMS
 
 release:
-	ghr --delete --prerelease -u yudai -r gotty pre-release ${OUTPUT_DIR}/dist
+	ghr -c ${GIT_COMMIT} --delete --prerelease -u yudai -r gotty pre-release ${OUTPUT_DIR}/dist

README.md

@@ -3,12 +3,10 @@
 [![GitHub release](http://img.shields.io/github/release/yudai/gotty.svg?style=flat-square)][release]
 [![Wercker](http://img.shields.io/wercker/ci/55d0eeff7331453f0801982c.svg?style=flat-square)][wercker]
 [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)][license]
-[![Join the chat at https://gitter.im/yudai/gotty](http://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg?style=flat-square)][gitter]
 
 [release]: https://github.com/yudai/gotty/releases
 [wercker]: https://app.wercker.com/project/bykey/03b91f441bebeda34f80e09a9f14126f
 [license]: https://github.com/yudai/gotty/blob/master/LICENSE
-[gitter]: https://gitter.im/yudai/gotty?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
 
 GoTTY is a simple command line tool that turns your CLI tools into web applications.
 
@@ -16,9 +14,9 @@ GoTTY is a simple command line tool that turns your CLI tools into web applicati
 
 # Installation
 
-Download the latest binary file from the [Releases](https://github.com/yudai/gotty/releases) page.
+Download the latest stable binary file from the [Releases](https://github.com/yudai/gotty/releases) page. Note that the release marked `Pre-release` is built for testing purpose, which can include unstable or breaking changes. Download a release marked [Latest release](https://github.com/yudai/gotty/releases/latest) for a stabale build.
 
-(`darwin_amd64.tar.gz` is for Mac OS X users)
+(Files named with `darwin_amd64` are for Mac OS X users)
 
 ## Homebrew Installation
 
@@ -28,9 +26,9 @@ You can install GoTTY with [Homebrew](http://brew.sh/) as well.
 $ brew install yudai/gotty/gotty
 ```
 
-## `go get` Installation
+## `go get` Installation (Development)
 
-If you have a Go language environment, you can install GoTTY with the `go get` command.
+If you have a Go language environment, you can install GoTTY with the `go get` command. However, this command builds a binary file from the latest master branch, which can include unstable or breaking changes. GoTTY requires go1.9 or later.
 
 ```sh
 $ go get github.com/yudai/gotty
@@ -49,27 +47,32 @@ By default, GoTTY starts a web server at port 8080. Open the URL on your web bro
 ## Options
 
 ```
---address, -a                                                IP address to listen [$GOTTY_ADDRESS]
---port, -p "8080"                                            Port number to listen [$GOTTY_PORT]
---permit-write, -w                                           Permit clients to write to the TTY (BE CAREFUL) [$GOTTY_PERMIT_WRITE]
---credential, -c                                             Credential for Basic Authentication (ex: user:pass, default disabled) [$GOTTY_CREDENTIAL]
---random-url, -r                                             Add a random string to the URL [$GOTTY_RANDOM_URL]
---random-url-length "8"                                      Random URL length [$GOTTY_RANDOM_URL_LENGTH]
---tls, -t                                                    Enable TLS/SSL [$GOTTY_TLS]
---tls-crt "~/.gotty.crt"                                     TLS/SSL certificate file path [$GOTTY_TLS_CRT]
---tls-key "~/.gotty.key"                                     TLS/SSL key file path [$GOTTY_TLS_KEY]
---tls-ca-crt "~/.gotty.ca.crt"                               TLS/SSL CA certificate file for client certifications [$GOTTY_TLS_CA_CRT]
---index                                                      Custom index.html file [$GOTTY_INDEX]
---title-format "GoTTY - {{ .Command }} ({{ .Hostname }})"    Title format of browser window [$GOTTY_TITLE_FORMAT]
---reconnect                                                  Enable reconnection [$GOTTY_RECONNECT]
---reconnect-time "10"                                        Time to reconnect [$GOTTY_RECONNECT_TIME]
---timeout "0"                                                Timeout seconds for waiting a client (0 to disable) [$GOTTY_TIMEOUT]
---max-connection "0"                                         Set the maximum number of simultaneous connections (0 to disable)
---once                                                       Accept only one client and exit on disconnection [$GOTTY_ONCE]
---permit-arguments                                           Permit clients to send command line arguments in URL (e.g. http://example.com:8080/?arg=AAA&arg=BBB) [$GOTTY_PERMIT_ARGUMENTS]
---close-signal "1"                                           Signal sent to the command process when gotty close it (default: SIGHUP) [$GOTTY_CLOSE_SIGNAL]
---config "~/.gotty"                                          Config file path [$GOTTY_CONFIG]
---version, -v                                                print the version
+--address value, -a value     IP address to listen (default: "0.0.0.0") [$GOTTY_ADDRESS]
+--port value, -p value        Port number to liten (default: "8080") [$GOTTY_PORT]
+--permit-write, -w            Permit clients to write to the TTY (BE CAREFUL) [$GOTTY_PERMIT_WRITE]
+--credential value, -c value  Credential for Basic Authentication (ex: user:pass, default disabled) [$GOTTY_CREDENTIAL]
+--random-url, -r              Add a random string to the URL [$GOTTY_RANDOM_URL]
+--random-url-length value     Random URL length (default: 8) [$GOTTY_RANDOM_URL_LENGTH]
+--tls, -t                     Enable TLS/SSL [$GOTTY_TLS]
+--tls-crt value               TLS/SSL certificate file path (default: "~/.gotty.crt") [$GOTTY_TLS_CRT]
+--tls-key value               TLS/SSL key file path (default: "~/.gotty.key") [$GOTTY_TLS_KEY]
+--tls-ca-crt value            TLS/SSL CA certificate file for client certifications (default: "~/.gotty.ca.crt") [$GOTTY_TLS_CA_CRT]
+--index value                 Custom index.html file [$GOTTY_INDEX]
+--title-format value          Title format of browser window (default: "{{ .command }}@{{ .hostname }}") [$GOTTY_TITLE_FORMAT]
+--reconnect                   Enable reconnection [$GOTTY_RECONNECT]
+--reconnect-time value        Time to reconnect (default: 10) [$GOTTY_RECONNECT_TIME]
+--max-connection value        Maximum connection to gotty (default: 0) [$GOTTY_MAX_CONNECTION]
+--once                        Accept only one client and exit on disconnection [$GOTTY_ONCE]
+--timeout value               Timeout seconds for waiting a client(0 to disable) (default: 0) [$GOTTY_TIMEOUT]
+--permit-arguments            Permit clients to send command line arguments in URL (e.g. http://example.com:8080/?arg=AAA&arg=BBB) [$GOTTY_PERMIT_ARGUMENTS]
+--width value                 Static width of the screen, 0(default) means dynamically resize (default: 0) [$GOTTY_WIDTH]
+--height value                Static height of the screen, 0(default) means dynamically resize (default: 0) [$GOTTY_HEIGHT]
+--ws-origin value             A regular expression that matches origin URLs to be accepted by WebSocket. No cross origin requests are acceptable by default [$GOTTY_WS_ORIGIN]
+--term value                  Terminal name to use on the browser, one of xterm or hterm. (default: "xterm") [$GOTTY_TERM]
+--close-signal value          Signal sent to the command process when gotty close it (default: SIGHUP) (default: 1) [$GOTTY_CLOSE_SIGNAL]
+--close-timeout value         Time in seconds to force kill process after client is disconnected (default: -1) (default: -1) [$GOTTY_CLOSE_TIMEOUT]
+--config value                Config file path (default: "~/.gotty") [$GOTTY_CONFIG]
+--version, -v                 print the version
 ```
 
 ### Config File
@@ -148,26 +151,22 @@ $ gotty -w docker run -it --rm busybox
 
 ## Development
 
-You can build a binary using the following commands. Windows is not supported now.
+You can build a binary using the following commands. Windows is not supported now. go1.9 is required.
 
 ```sh
 # Install tools
 go get github.com/jteeuwen/go-bindata/...
 go get github.com/tools/godep
 
-# Checkout hterm
-git submodule sync && git submodule update --init --recursive
-
-# Restore libraries in Godeps
-godep restore
-
 # Build
 make
 ```
 
+To build the frontend part (JS files and other static files), you need `npm`.
+
 ## Architecture
 
-GoTTY uses [hterm](https://groups.google.com/a/chromium.org/forum/#!forum/chromium-hterm) to run a JavaScript based terminal on web browsers. GoTTY itself provides a websocket server that simply relays output from the TTY to clients and receives input from clients and forwards it to the TTY. This hterm + websocket idea is inspired by [Wetty](https://github.com/krishnasrinivas/wetty).
+GoTTY uses [xterm.js](https://xtermjs.org/) and [hterm](https://groups.google.com/a/chromium.org/forum/#!forum/chromium-hterm) to run a JavaScript based terminal on web browsers. GoTTY itself provides a websocket server that simply relays output from the TTY to clients and receives input from clients and forwards it to the TTY. This hterm + websocket idea is inspired by [Wetty](https://github.com/krishnasrinivas/wetty).
 
 ## Alternatives
 

app/app.go

@@ -1,511 +0,0 @@
-package app
-
-import (
-	"crypto/rand"
-	"crypto/tls"
-	"crypto/x509"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"io/ioutil"
-	"log"
-	"math/big"
-	"net"
-	"net/http"
-	"net/url"
-	"os"
-	"os/exec"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"text/template"
-	"time"
-
-	"github.com/braintree/manners"
-	"github.com/elazarl/go-bindata-assetfs"
-	"github.com/gorilla/websocket"
-	"github.com/kr/pty"
-	"github.com/yudai/hcl"
-	"github.com/yudai/umutex"
-)
-
-type InitMessage struct {
-	Arguments string `json:"Arguments,omitempty"`
-	AuthToken string `json:"AuthToken,omitempty"`
-}
-
-type App struct {
-	command []string
-	options *Options
-
-	upgrader *websocket.Upgrader
-	server   *manners.GracefulServer
-
-	titleTemplate *template.Template
-
-	onceMutex *umutex.UnblockingMutex
-	timer     *time.Timer
-
-	// clientContext writes concurrently
-	// Use atomic operations.
-	connections *int64
-}
-
-type Options struct {
-	Address             string                 `hcl:"address"`
-	Port                string                 `hcl:"port"`
-	PermitWrite         bool                   `hcl:"permit_write"`
-	EnableBasicAuth     bool                   `hcl:"enable_basic_auth"`
-	Credential          string                 `hcl:"credential"`
-	EnableRandomUrl     bool                   `hcl:"enable_random_url"`
-	RandomUrlLength     int                    `hcl:"random_url_length"`
-	IndexFile           string                 `hcl:"index_file"`
-	EnableTLS           bool                   `hcl:"enable_tls"`
-	TLSCrtFile          string                 `hcl:"tls_crt_file"`
-	TLSKeyFile          string                 `hcl:"tls_key_file"`
-	EnableTLSClientAuth bool                   `hcl:"enable_tls_client_auth"`
-	TLSCACrtFile        string                 `hcl:"tls_ca_crt_file"`
-	TitleFormat         string                 `hcl:"title_format"`
-	EnableReconnect     bool                   `hcl:"enable_reconnect"`
-	ReconnectTime       int                    `hcl:"reconnect_time"`
-	MaxConnection       int                    `hcl:"max_connection"`
-	Once                bool                   `hcl:"once"`
-	Timeout             int                    `hcl:"timeout"`
-	PermitArguments     bool                   `hcl:"permit_arguments"`
-	CloseSignal         int                    `hcl:"close_signal"`
-	Preferences         HtermPrefernces        `hcl:"preferences"`
-	RawPreferences      map[string]interface{} `hcl:"preferences"`
-	Width               int                    `hcl:"width"`
-	Height              int                    `hcl:"height"`
-}
-
-var Version = "1.0.0"
-
-var DefaultOptions = Options{
-	Address:             "",
-	Port:                "8080",
-	PermitWrite:         false,
-	EnableBasicAuth:     false,
-	Credential:          "",
-	EnableRandomUrl:     false,
-	RandomUrlLength:     8,
-	IndexFile:           "",
-	EnableTLS:           false,
-	TLSCrtFile:          "~/.gotty.crt",
-	TLSKeyFile:          "~/.gotty.key",
-	EnableTLSClientAuth: false,
-	TLSCACrtFile:        "~/.gotty.ca.crt",
-	TitleFormat:         "GoTTY - {{ .Command }} ({{ .Hostname }})",
-	EnableReconnect:     false,
-	ReconnectTime:       10,
-	MaxConnection:       0,
-	Once:                false,
-	CloseSignal:         1, // syscall.SIGHUP
-	Preferences:         HtermPrefernces{},
-	Width:               0,
-	Height:              0,
-}
-
-func New(command []string, options *Options) (*App, error) {
-	titleTemplate, err := template.New("title").Parse(options.TitleFormat)
-	if err != nil {
-		return nil, errors.New("Title format string syntax error")
-	}
-
-	connections := int64(0)
-
-	return &App{
-		command: command,
-		options: options,
-
-		upgrader: &websocket.Upgrader{
-			ReadBufferSize:  1024,
-			WriteBufferSize: 1024,
-			Subprotocols:    []string{"gotty"},
-		},
-
-		titleTemplate: titleTemplate,
-
-		onceMutex:   umutex.New(),
-		connections: &connections,
-	}, nil
-}
-
-func ApplyConfigFile(options *Options, filePath string) error {
-	filePath = ExpandHomeDir(filePath)
-	if _, err := os.Stat(filePath); os.IsNotExist(err) {
-		return err
-	}
-
-	fileString := []byte{}
-	log.Printf("Loading config file at: %s", filePath)
-	fileString, err := ioutil.ReadFile(filePath)
-	if err != nil {
-		return err
-	}
-
-	if err := hcl.Decode(options, string(fileString)); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func CheckConfig(options *Options) error {
-	if options.EnableTLSClientAuth && !options.EnableTLS {
-		return errors.New("TLS client authentication is enabled, but TLS is not enabled")
-	}
-	return nil
-}
-
-func (app *App) Run() error {
-	if app.options.PermitWrite {
-		log.Printf("Permitting clients to write input to the PTY.")
-	}
-
-	if app.options.Once {
-		log.Printf("Once option is provided, accepting only one client")
-	}
-
-	path := ""
-	if app.options.EnableRandomUrl {
-		path += "/" + generateRandomString(app.options.RandomUrlLength)
-	}
-
-	endpoint := net.JoinHostPort(app.options.Address, app.options.Port)
-
-	wsHandler := http.HandlerFunc(app.handleWS)
-	customIndexHandler := http.HandlerFunc(app.handleCustomIndex)
-	authTokenHandler := http.HandlerFunc(app.handleAuthToken)
-	staticHandler := http.FileServer(
-		&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "static"},
-	)
-
-	var siteMux = http.NewServeMux()
-
-	if app.options.IndexFile != "" {
-		log.Printf("Using index file at " + app.options.IndexFile)
-		siteMux.Handle(path+"/", customIndexHandler)
-	} else {
-		siteMux.Handle(path+"/", http.StripPrefix(path+"/", staticHandler))
-	}
-	siteMux.Handle(path+"/auth_token.js", authTokenHandler)
-	siteMux.Handle(path+"/js/", http.StripPrefix(path+"/", staticHandler))
-	siteMux.Handle(path+"/favicon.png", http.StripPrefix(path+"/", staticHandler))
-
-	siteHandler := http.Handler(siteMux)
-
-	if app.options.EnableBasicAuth {
-		log.Printf("Using Basic Authentication")
-		siteHandler = wrapBasicAuth(siteHandler, app.options.Credential)
-	}
-
-	siteHandler = wrapHeaders(siteHandler)
-
-	wsMux := http.NewServeMux()
-	wsMux.Handle("/", siteHandler)
-	wsMux.Handle(path+"/ws", wsHandler)
-	siteHandler = (http.Handler(wsMux))
-
-	siteHandler = wrapLogger(siteHandler)
-
-	scheme := "http"
-	if app.options.EnableTLS {
-		scheme = "https"
-	}
-	log.Printf(
-		"Server is starting with command: %s",
-		strings.Join(app.command, " "),
-	)
-	if app.options.Address != "" {
-		log.Printf(
-			"URL: %s",
-			(&url.URL{Scheme: scheme, Host: endpoint, Path: path + "/"}).String(),
-		)
-	} else {
-		for _, address := range listAddresses() {
-			log.Printf(
-				"URL: %s",
-				(&url.URL{
-					Scheme: scheme,
-					Host:   net.JoinHostPort(address, app.options.Port),
-					Path:   path + "/",
-				}).String(),
-			)
-		}
-	}
-
-	server, err := app.makeServer(endpoint, &siteHandler)
-	if err != nil {
-		return errors.New("Failed to build server: " + err.Error())
-	}
-	app.server = manners.NewWithServer(
-		server,
-	)
-
-	if app.options.Timeout > 0 {
-		app.timer = time.NewTimer(time.Duration(app.options.Timeout) * time.Second)
-		go func() {
-			<-app.timer.C
-			app.Exit()
-		}()
-	}
-
-	if app.options.EnableTLS {
-		crtFile := ExpandHomeDir(app.options.TLSCrtFile)
-		keyFile := ExpandHomeDir(app.options.TLSKeyFile)
-		log.Printf("TLS crt file: " + crtFile)
-		log.Printf("TLS key file: " + keyFile)
-
-		err = app.server.ListenAndServeTLS(crtFile, keyFile)
-	} else {
-		err = app.server.ListenAndServe()
-	}
-	if err != nil {
-		return err
-	}
-
-	log.Printf("Exiting...")
-
-	return nil
-}
-
-func (app *App) makeServer(addr string, handler *http.Handler) (*http.Server, error) {
-	server := &http.Server{
-		Addr:    addr,
-		Handler: *handler,
-	}
-
-	if app.options.EnableTLSClientAuth {
-		caFile := ExpandHomeDir(app.options.TLSCACrtFile)
-		log.Printf("CA file: " + caFile)
-		caCert, err := ioutil.ReadFile(caFile)
-		if err != nil {
-			return nil, errors.New("Could not open CA crt file " + caFile)
-		}
-		caCertPool := x509.NewCertPool()
-		if !caCertPool.AppendCertsFromPEM(caCert) {
-			return nil, errors.New("Could not parse CA crt file data in " + caFile)
-		}
-		tlsConfig := &tls.Config{
-			ClientCAs:  caCertPool,
-			ClientAuth: tls.RequireAndVerifyClientCert,
-		}
-		server.TLSConfig = tlsConfig
-	}
-
-	return server, nil
-}
-
-func (app *App) stopTimer() {
-	if app.options.Timeout > 0 {
-		app.timer.Stop()
-	}
-}
-
-func (app *App) restartTimer() {
-	if app.options.Timeout > 0 {
-		app.timer.Reset(time.Duration(app.options.Timeout) * time.Second)
-	}
-}
-
-func (app *App) handleWS(w http.ResponseWriter, r *http.Request) {
-	app.stopTimer()
-
-	connections := atomic.AddInt64(app.connections, 1)
-	if int64(app.options.MaxConnection) != 0 {
-		if connections >= int64(app.options.MaxConnection) {
-			log.Printf("Reached max connection: %d", app.options.MaxConnection)
-			return
-		}
-	}
-	log.Printf("New client connected: %s", r.RemoteAddr)
-
-	if r.Method != "GET" {
-		http.Error(w, "Method not allowed", 405)
-		return
-	}
-
-	conn, err := app.upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		log.Print("Failed to upgrade connection: " + err.Error())
-		return
-	}
-
-	_, stream, err := conn.ReadMessage()
-	if err != nil {
-		log.Print("Failed to authenticate websocket connection")
-		conn.Close()
-		return
-	}
-	var init InitMessage
-
-	err = json.Unmarshal(stream, &init)
-	if err != nil {
-		log.Printf("Failed to parse init message %v", err)
-		conn.Close()
-		return
-	}
-	if init.AuthToken != app.options.Credential {
-		log.Print("Failed to authenticate websocket connection")
-		conn.Close()
-		return
-	}
-	argv := app.command[1:]
-	if app.options.PermitArguments {
-		if init.Arguments == "" {
-			init.Arguments = "?"
-		}
-		query, err := url.Parse(init.Arguments)
-		if err != nil {
-			log.Print("Failed to parse arguments")
-			conn.Close()
-			return
-		}
-		params := query.Query()["arg"]
-		if len(params) != 0 {
-			argv = append(argv, params...)
-		}
-	}
-
-	app.server.StartRoutine()
-
-	if app.options.Once {
-		if app.onceMutex.TryLock() { // no unlock required, it will die soon
-			log.Printf("Last client accepted, closing the listener.")
-			app.server.Close()
-		} else {
-			log.Printf("Server is already closing.")
-			conn.Close()
-			return
-		}
-	}
-
-	cmd := exec.Command(app.command[0], argv...)
-	ptyIo, err := pty.Start(cmd)
-	if err != nil {
-		log.Print("Failed to execute command")
-		return
-	}
-
-	if app.options.MaxConnection != 0 {
-		log.Printf("Command is running for client %s with PID %d (args=%q), connections: %d/%d",
-			r.RemoteAddr, cmd.Process.Pid, strings.Join(argv, " "), connections, app.options.MaxConnection)
-	} else {
-		log.Printf("Command is running for client %s with PID %d (args=%q), connections: %d",
-			r.RemoteAddr, cmd.Process.Pid, strings.Join(argv, " "), connections)
-	}
-
-	context := &clientContext{
-		app:        app,
-		request:    r,
-		connection: conn,
-		command:    cmd,
-		pty:        ptyIo,
-		writeMutex: &sync.Mutex{},
-	}
-
-	context.goHandleClient()
-}
-
-func (app *App) handleCustomIndex(w http.ResponseWriter, r *http.Request) {
-	http.ServeFile(w, r, ExpandHomeDir(app.options.IndexFile))
-}
-
-func (app *App) handleAuthToken(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/javascript")
-	w.Write([]byte("var gotty_auth_token = '" + app.options.Credential + "';"))
-}
-
-func (app *App) Exit() (firstCall bool) {
-	if app.server != nil {
-		firstCall = app.server.Close()
-		if firstCall {
-			log.Printf("Received Exit command, waiting for all clients to close sessions...")
-		}
-		return firstCall
-	}
-	return true
-}
-
-func wrapLogger(handler http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		rw := &responseWrapper{w, 200}
-		handler.ServeHTTP(rw, r)
-		log.Printf("%s %d %s %s", r.RemoteAddr, rw.status, r.Method, r.URL.Path)
-	})
-}
-
-func wrapHeaders(handler http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Server", "GoTTY/"+Version)
-		handler.ServeHTTP(w, r)
-	})
-}
-
-func wrapBasicAuth(handler http.Handler, credential string) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		token := strings.SplitN(r.Header.Get("Authorization"), " ", 2)
-
-		if len(token) != 2 || strings.ToLower(token[0]) != "basic" {
-			w.Header().Set("WWW-Authenticate", `Basic realm="GoTTY"`)
-			http.Error(w, "Bad Request", http.StatusUnauthorized)
-			return
-		}
-
-		payload, err := base64.StdEncoding.DecodeString(token[1])
-		if err != nil {
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			return
-		}
-
-		if credential != string(payload) {
-			w.Header().Set("WWW-Authenticate", `Basic realm="GoTTY"`)
-			http.Error(w, "authorization failed", http.StatusUnauthorized)
-			return
-		}
-
-		log.Printf("Basic Authentication Succeeded: %s", r.RemoteAddr)
-		handler.ServeHTTP(w, r)
-	})
-}
-
-func generateRandomString(length int) string {
-	const base = 36
-	size := big.NewInt(base)
-	n := make([]byte, length)
-	for i, _ := range n {
-		c, _ := rand.Int(rand.Reader, size)
-		n[i] = strconv.FormatInt(c.Int64(), base)[0]
-	}
-	return string(n)
-}
-
-func listAddresses() (addresses []string) {
-	ifaces, _ := net.Interfaces()
-
-	addresses = make([]string, 0, len(ifaces))
-
-	for _, iface := range ifaces {
-		ifAddrs, _ := iface.Addrs()
-		for _, ifAddr := range ifAddrs {
-			switch v := ifAddr.(type) {
-			case *net.IPNet:
-				addresses = append(addresses, v.IP.String())
-			case *net.IPAddr:
-				addresses = append(addresses, v.IP.String())
-			}
-		}
-	}
-
-	return
-}
-
-func ExpandHomeDir(path string) string {
-	if path[0:2] == "~/" {
-		return os.Getenv("HOME") + path[1:]
-	} else {
-		return path
-	}
-}

app/client_context.go

@@ -1,241 +0,0 @@
-package app
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"log"
-	"net/http"
-	"os"
-	"os/exec"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"syscall"
-	"unsafe"
-
-	"github.com/fatih/structs"
-	"github.com/gorilla/websocket"
-)
-
-type clientContext struct {
-	app        *App
-	request    *http.Request
-	connection *websocket.Conn
-	command    *exec.Cmd
-	pty        *os.File
-	writeMutex *sync.Mutex
-}
-
-const (
-	Input          = '0'
-	Ping           = '1'
-	ResizeTerminal = '2'
-)
-
-const (
-	Output         = '0'
-	Pong           = '1'
-	SetWindowTitle = '2'
-	SetPreferences = '3'
-	SetReconnect   = '4'
-)
-
-type argResizeTerminal struct {
-	Columns float64
-	Rows    float64
-}
-
-type ContextVars struct {
-	Command    string
-	Pid        int
-	Hostname   string
-	RemoteAddr string
-}
-
-func (context *clientContext) goHandleClient() {
-	exit := make(chan bool, 2)
-
-	go func() {
-		defer func() { exit <- true }()
-
-		context.processSend()
-	}()
-
-	go func() {
-		defer func() { exit <- true }()
-
-		context.processReceive()
-	}()
-
-	go func() {
-		defer context.app.server.FinishRoutine()
-		defer func() {
-			connections := atomic.AddInt64(context.app.connections, -1)
-
-			if context.app.options.MaxConnection != 0 {
-				log.Printf("Connection closed: %s, connections: %d/%d",
-					context.request.RemoteAddr, connections, context.app.options.MaxConnection)
-			} else {
-				log.Printf("Connection closed: %s, connections: %d",
-					context.request.RemoteAddr, connections)
-			}
-
-			if connections == 0 {
-				context.app.restartTimer()
-			}
-		}()
-
-		<-exit
-		context.pty.Close()
-
-		// Even if the PTY has been closed,
-		// Read(0 in processSend() keeps blocking and the process doen't exit
-		context.command.Process.Signal(syscall.Signal(context.app.options.CloseSignal))
-
-		context.command.Wait()
-		context.connection.Close()
-	}()
-}
-
-func (context *clientContext) processSend() {
-	if err := context.sendInitialize(); err != nil {
-		log.Printf(err.Error())
-		return
-	}
-
-	buf := make([]byte, 1024)
-
-	for {
-		size, err := context.pty.Read(buf)
-		if err != nil {
-			log.Printf("Command exited for: %s", context.request.RemoteAddr)
-			return
-		}
-		safeMessage := base64.StdEncoding.EncodeToString([]byte(buf[:size]))
-		if err = context.write(append([]byte{Output}, []byte(safeMessage)...)); err != nil {
-			log.Printf(err.Error())
-			return
-		}
-	}
-}
-
-func (context *clientContext) write(data []byte) error {
-	context.writeMutex.Lock()
-	defer context.writeMutex.Unlock()
-	return context.connection.WriteMessage(websocket.TextMessage, data)
-}
-
-func (context *clientContext) sendInitialize() error {
-	hostname, _ := os.Hostname()
-	titleVars := ContextVars{
-		Command:    strings.Join(context.app.command, " "),
-		Pid:        context.command.Process.Pid,
-		Hostname:   hostname,
-		RemoteAddr: context.request.RemoteAddr,
-	}
-
-	titleBuffer := new(bytes.Buffer)
-	if err := context.app.titleTemplate.Execute(titleBuffer, titleVars); err != nil {
-		return err
-	}
-	if err := context.write(append([]byte{SetWindowTitle}, titleBuffer.Bytes()...)); err != nil {
-		return err
-	}
-
-	prefStruct := structs.New(context.app.options.Preferences)
-	prefMap := prefStruct.Map()
-	htermPrefs := make(map[string]interface{})
-	for key, value := range prefMap {
-		rawKey := prefStruct.Field(key).Tag("hcl")
-		if _, ok := context.app.options.RawPreferences[rawKey]; ok {
-			htermPrefs[strings.Replace(rawKey, "_", "-", -1)] = value
-		}
-	}
-	prefs, err := json.Marshal(htermPrefs)
-	if err != nil {
-		return err
-	}
-
-	if err := context.write(append([]byte{SetPreferences}, prefs...)); err != nil {
-		return err
-	}
-	if context.app.options.EnableReconnect {
-		reconnect, _ := json.Marshal(context.app.options.ReconnectTime)
-		if err := context.write(append([]byte{SetReconnect}, reconnect...)); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (context *clientContext) processReceive() {
-	for {
-		_, data, err := context.connection.ReadMessage()
-		if err != nil {
-			log.Print(err.Error())
-			return
-		}
-		if len(data) == 0 {
-			log.Print("An error has occured")
-			return
-		}
-
-		switch data[0] {
-		case Input:
-			if !context.app.options.PermitWrite {
-				break
-			}
-
-			_, err := context.pty.Write(data[1:])
-			if err != nil {
-				return
-			}
-
-		case Ping:
-			if err := context.write([]byte{Pong}); err != nil {
-				log.Print(err.Error())
-				return
-			}
-		case ResizeTerminal:
-			var args argResizeTerminal
-			err = json.Unmarshal(data[1:], &args)
-			if err != nil {
-				log.Print("Malformed remote command")
-				return
-			}
-
-			rows := uint16(context.app.options.Height)
-			if rows == 0 {
-				rows = uint16(args.Rows)
-			}
-
-			columns := uint16(context.app.options.Width)
-			if columns == 0 {
-				columns = uint16(args.Columns)
-			}
-
-			window := struct {
-				row uint16
-				col uint16
-				x   uint16
-				y   uint16
-			}{
-				rows,
-				columns,
-				0,
-				0,
-			}
-			syscall.Syscall(
-				syscall.SYS_IOCTL,
-				context.pty.Fd(),
-				syscall.TIOCSWINSZ,
-				uintptr(unsafe.Pointer(&window)),
-			)
-
-		default:
-			log.Print("Unknown message type")
-			return
-		}
-	}
-}

app/hterm_preferences.go

@@ -1,58 +0,0 @@
-package app
-
-type HtermPrefernces struct {
-	AltGrMode                     *string                      `hcl:"alt_gr_mode"`
-	AltBackspaceIsMetaBackspace   bool                         `hcl:"alt_backspace_is_meta_backspace"`
-	AltIsMeta                     bool                         `hcl:"alt_is_meta"`
-	AltSendsWhat                  string                       `hcl:"alt_sends_what"`
-	AudibleBellSound              string                       `hcl:"audible_bell_sound"`
-	DesktopNotificationBell       bool                         `hcl:"desktop_notification_bell"`
-	BackgroundColor               string                       `hcl:"background_color"`
-	BackgroundImage               string                       `hcl:"background_image"`
-	BackgroundSize                string                       `hcl:"background_size"`
-	BackgroundPosition            string                       `hcl:"background_position"`
-	BackspaceSendsBackspace       bool                         `hcl:"backspace_sends_backspace"`
-	CharacterMapOverrides         map[string]map[string]string `hcl:"character_map_overrides"`
-	CloseOnExit                   bool                         `hcl:"close_on_exit"`
-	CursorBlink                   bool                         `hcl:"cursor_blink"`
-	CursorBlinkCycle              [2]int                       `hcl:"cursor_blink_cycle"`
-	CursorColor                   string                       `hcl:"cursor_color"`
-	ColorPaletteOverrides         []*string                    `hcl:"color_palette_overrides"`
-	CopyOnSelect                  bool                         `hcl:"copy_on_select"`
-	UseDefaultWindowCopy          bool                         `hcl:"use_default_window_copy"`
-	ClearSelectionAfterCopy       bool                         `hcl:"clear_selection_after_copy"`
-	CtrlPlusMinusZeroZoom         bool                         `hcl:"ctrl_plus_minus_zero_zoom"`
-	CtrlCCopy                     bool                         `hcl:"ctrl_c_copy"`
-	CtrlVPaste                    bool                         `hcl:"ctrl_v_paste"`
-	EastAsianAmbiguousAsTwoColumn bool                         `hcl:"east_asian_ambiguous_as_two_column"`
-	Enable8BitControl             *bool                        `hcl:"enable_8_bit_control"`
-	EnableBold                    *bool                        `hcl:"enable_bold"`
-	EnableBoldAsBright            bool                         `hcl:"enable_bold_as_bright"`
-	EnableClipboardNotice         bool                         `hcl:"enable_clipboard_notice"`
-	EnableClipboardWrite          bool                         `hcl:"enable_clipboard_write"`
-	EnableDec12                   bool                         `hcl:"enable_dec12"`
-	Environment                   map[string]string            `hcl:"environment"`
-	FontFamily                    string                       `hcl:"font_family"`
-	FontSize                      int                          `hcl:"font_size"`
-	FontSmoothing                 string                       `hcl:"font_smoothing"`
-	ForegroundColor               string                       `hcl:"foreground_color"`
-	HomeKeysScroll                bool                         `hcl:"home_keys_scroll"`
-	Keybindings                   map[string]string            `hcl:"keybindings"`
-	MaxStringSequence             int                          `hcl:"max_string_sequence"`
-	MediaKeysAreFkeys             bool                         `hcl:"media_keys_are_fkeys"`
-	MetaSendsEscape               bool                         `hcl:"meta_sends_escape"`
-	MousePasteButton              *int                         `hcl:"mouse_paste_button"`
-	PageKeysScroll                bool                         `hcl:"page_keys_scroll"`
-	PassAltNumber                 *bool                        `hcl:"pass_alt_number"`
-	PassCtrlNumber                *bool                        `hcl:"pass_ctrl_number"`
-	PassMetaNumber                *bool                        `hcl:"pass_meta_number"`
-	PassMetaV                     bool                         `hcl:"pass_meta_v"`
-	ReceiveEncoding               string                       `hcl:"receive_encoding"`
-	ScrollOnKeystroke             bool                         `hcl:"scroll_on_keystroke"`
-	ScrollOnOutput                bool                         `hcl:"scroll_on_output"`
-	ScrollbarVisible              bool                         `hcl:"scrollbar_visible"`
-	ScrollWheelMoveMultiplier     int                          `hcl:"scroll_wheel_move_multiplier"`
-	SendEncoding                  string                       `hcl:"send_encoding"`
-	ShiftInsertPaste              bool                         `hcl:"shift_insert_paste"`
-	UserCss                       string                       `hcl:"user_css"`
-}

backend/doc.go

@@ -0,0 +1 @@
+package backend

backend/localcommand/doc.go

@@ -0,0 +1,3 @@
+// Package localcommand provides an implementation of webtty.Slave
+// that launches a local command with a PTY.
+package localcommand

backend/localcommand/factory.go

@@ -0,0 +1,48 @@
+package localcommand
+
+import (
+	"syscall"
+	"time"
+
+	"github.com/yudai/gotty/server"
+)
+
+type Options struct {
+	CloseSignal  int `hcl:"close_signal" flagName:"close-signal" flagSName:"" flagDescribe:"Signal sent to the command process when gotty close it (default: SIGHUP)" default:"1"`
+	CloseTimeout int `hcl:"close_timeout" flagName:"close-timeout" flagSName:"" flagDescribe:"Time in seconds to force kill process after client is disconnected (default: -1)" default:"-1"`
+}
+
+type Factory struct {
+	command string
+	argv    []string
+	options *Options
+	opts    []Option
+}
+
+func NewFactory(command string, argv []string, options *Options) (*Factory, error) {
+	opts := []Option{WithCloseSignal(syscall.Signal(options.CloseSignal))}
+	if options.CloseTimeout >= 0 {
+		opts = append(opts, WithCloseTimeout(time.Duration(options.CloseTimeout)*time.Second))
+	}
+
+	return &Factory{
+		command: command,
+		argv:    argv,
+		options: options,
+		opts:    opts,
+	}, nil
+}
+
+func (factory *Factory) Name() string {
+	return "local command"
+}
+
+func (factory *Factory) New(params map[string][]string) (server.Slave, error) {
+	argv := make([]string, len(factory.argv))
+	copy(argv, factory.argv)
+	if params["arg"] != nil && len(params["arg"]) > 0 {
+		argv = append(argv, params["arg"]...)
+	}
+
+	return New(factory.command, argv, factory.opts...)
+}

backend/localcommand/local_command.go

@@ -0,0 +1,132 @@
+package localcommand
+
+import (
+	"os"
+	"os/exec"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/kr/pty"
+	"github.com/pkg/errors"
+)
+
+const (
+	DefaultCloseSignal  = syscall.SIGINT
+	DefaultCloseTimeout = 10 * time.Second
+)
+
+type LocalCommand struct {
+	command string
+	argv    []string
+
+	closeSignal  syscall.Signal
+	closeTimeout time.Duration
+
+	cmd       *exec.Cmd
+	pty       *os.File
+	ptyClosed chan struct{}
+}
+
+func New(command string, argv []string, options ...Option) (*LocalCommand, error) {
+	cmd := exec.Command(command, argv...)
+
+	pty, err := pty.Start(cmd)
+	if err != nil {
+		// todo close cmd?
+		return nil, errors.Wrapf(err, "failed to start command `%s`", command)
+	}
+	ptyClosed := make(chan struct{})
+
+	lcmd := &LocalCommand{
+		command: command,
+		argv:    argv,
+
+		closeSignal:  DefaultCloseSignal,
+		closeTimeout: DefaultCloseTimeout,
+
+		cmd:       cmd,
+		pty:       pty,
+		ptyClosed: ptyClosed,
+	}
+
+	for _, option := range options {
+		option(lcmd)
+	}
+
+	// When the process is closed by the user,
+	// close pty so that Read() on the pty breaks with an EOF.
+	go func() {
+		defer func() {
+			lcmd.pty.Close()
+			close(lcmd.ptyClosed)
+		}()
+
+		lcmd.cmd.Wait()
+	}()
+
+	return lcmd, nil
+}
+
+func (lcmd *LocalCommand) Read(p []byte) (n int, err error) {
+	return lcmd.pty.Read(p)
+}
+
+func (lcmd *LocalCommand) Write(p []byte) (n int, err error) {
+	return lcmd.pty.Write(p)
+}
+
+func (lcmd *LocalCommand) Close() error {
+	if lcmd.cmd != nil && lcmd.cmd.Process != nil {
+		lcmd.cmd.Process.Signal(lcmd.closeSignal)
+	}
+	for {
+		select {
+		case <-lcmd.ptyClosed:
+			return nil
+		case <-lcmd.closeTimeoutC():
+			lcmd.cmd.Process.Signal(syscall.SIGKILL)
+		}
+	}
+}
+
+func (lcmd *LocalCommand) WindowTitleVariables() map[string]interface{} {
+	return map[string]interface{}{
+		"command": lcmd.command,
+		"argv":    lcmd.argv,
+		"pid":     lcmd.cmd.Process.Pid,
+	}
+}
+
+func (lcmd *LocalCommand) ResizeTerminal(width int, height int) error {
+	window := struct {
+		row uint16
+		col uint16
+		x   uint16
+		y   uint16
+	}{
+		uint16(height),
+		uint16(width),
+		0,
+		0,
+	}
+	_, _, errno := syscall.Syscall(
+		syscall.SYS_IOCTL,
+		lcmd.pty.Fd(),
+		syscall.TIOCSWINSZ,
+		uintptr(unsafe.Pointer(&window)),
+	)
+	if errno != 0 {
+		return errno
+	} else {
+		return nil
+	}
+}
+
+func (lcmd *LocalCommand) closeTimeoutC() <-chan time.Time {
+	if lcmd.closeTimeout >= 0 {
+		return time.After(lcmd.closeTimeout)
+	}
+
+	return make(chan time.Time)
+}

backend/localcommand/options.go

@@ -0,0 +1,20 @@
+package localcommand
+
+import (
+	"syscall"
+	"time"
+)
+
+type Option func(*LocalCommand)
+
+func WithCloseSignal(signal syscall.Signal) Option {
+	return func(lcmd *LocalCommand) {
+		lcmd.closeSignal = signal
+	}
+}
+
+func WithCloseTimeout(timeout time.Duration) Option {
+	return func(lcmd *LocalCommand) {
+		lcmd.closeTimeout = timeout
+	}
+}

flags.go

@@ -1,101 +0,0 @@
-package main
-
-import (
-	"errors"
-	"reflect"
-	"strings"
-
-	"github.com/codegangsta/cli"
-	"github.com/fatih/structs"
-
-	"github.com/yudai/gotty/app"
-)
-
-type flag struct {
-	name        string
-	shortName   string
-	description string
-}
-
-func generateFlags(flags []flag, hint map[string]string) ([]cli.Flag, error) {
-	o := structs.New(app.DefaultOptions)
-
-	results := make([]cli.Flag, len(flags))
-
-	for i, flag := range flags {
-		fieldName := fieldName(flag.name, hint)
-
-		field, ok := o.FieldOk(fieldName)
-		if !ok {
-			return nil, errors.New("No such field: " + fieldName)
-		}
-
-		flagName := flag.name
-		if flag.shortName != "" {
-			flagName += ", " + flag.shortName
-		}
-		envName := "GOTTY_" + strings.ToUpper(strings.Join(strings.Split(flag.name, "-"), "_"))
-
-		switch field.Kind() {
-		case reflect.String:
-			results[i] = cli.StringFlag{
-				Name:   flagName,
-				Value:  field.Value().(string),
-				Usage:  flag.description,
-				EnvVar: envName,
-			}
-		case reflect.Bool:
-			results[i] = cli.BoolFlag{
-				Name:   flagName,
-				Usage:  flag.description,
-				EnvVar: envName,
-			}
-		case reflect.Int:
-			results[i] = cli.IntFlag{
-				Name:   flagName,
-				Value:  field.Value().(int),
-				Usage:  flag.description,
-				EnvVar: envName,
-			}
-		default:
-			return nil, errors.New("Unsupported type: " + fieldName)
-		}
-	}
-
-	return results, nil
-}
-
-func applyFlags(
-	options *app.Options,
-	flags []flag,
-	mappingHint map[string]string,
-	c *cli.Context,
-) {
-	o := structs.New(options)
-	for _, flag := range flags {
-		if c.IsSet(flag.name) {
-			field := o.Field(fieldName(flag.name, mappingHint))
-			var val interface{}
-			switch field.Kind() {
-			case reflect.String:
-				val = c.String(flag.name)
-			case reflect.Bool:
-				val = c.Bool(flag.name)
-			case reflect.Int:
-				val = c.Int(flag.name)
-			}
-			field.Set(val)
-		}
-	}
-}
-
-func fieldName(name string, hint map[string]string) string {
-	if fieldName, ok := hint[name]; ok {
-		return fieldName
-	}
-	nameParts := strings.Split(name, "-")
-	for i, part := range nameParts {
-		nameParts[i] = strings.ToUpper(part[0:1]) + part[1:]
-	}
-	return strings.Join(nameParts, "")
-}

js/dist/hterm.d.ts

@@ -0,0 +1,24 @@
+import * as bare from "libapps";
+export declare class Hterm {
+    elem: HTMLElement;
+    term: bare.hterm.Terminal;
+    io: bare.hterm.IO;
+    columns: number;
+    rows: number;
+    message: string;
+    constructor(elem: HTMLElement);
+    info(): {
+        columns: number;
+        rows: number;
+    };
+    output(data: string): void;
+    showMessage(message: string, timeout: number): void;
+    removeMessage(): void;
+    setWindowTitle(title: string): void;
+    setPreferences(value: object): void;
+    onInput(callback: (input: string) => void): void;
+    onResize(callback: (colmuns: number, rows: number) => void): void;
+    deactivate(): void;
+    reset(): void;
+    close(): void;
+}

js/dist/websocket.d.ts

@@ -0,0 +1,17 @@
+export declare class ConnectionFactory {
+    url: string;
+    protocols: string[];
+    constructor(url: string, protocols: string[]);
+    create(): Connection;
+}
+export declare class Connection {
+    bare: WebSocket;
+    constructor(url: string, protocols: string[]);
+    open(): void;
+    close(): void;
+    send(data: string): void;
+    isOpen(): boolean;
+    onOpen(callback: () => void): void;
+    onReceive(callback: (data: string) => void): void;
+    onClose(callback: () => void): void;
+}

js/dist/webtty.d.ts

@@ -0,0 +1,48 @@
+export declare const protocols: string[];
+export declare const msgInputUnknown = "0";
+export declare const msgInput = "1";
+export declare const msgPing = "2";
+export declare const msgResizeTerminal = "3";
+export declare const msgUnknownOutput = "0";
+export declare const msgOutput = "1";
+export declare const msgPong = "2";
+export declare const msgSetWindowTitle = "3";
+export declare const msgSetPreferences = "4";
+export declare const msgSetReconnect = "5";
+export interface Terminal {
+    info(): {
+        columns: number;
+        rows: number;
+    };
+    output(data: string): void;
+    showMessage(message: string, timeout: number): void;
+    removeMessage(): void;
+    setWindowTitle(title: string): void;
+    setPreferences(value: object): void;
+    onInput(callback: (input: string) => void): void;
+    onResize(callback: (colmuns: number, rows: number) => void): void;
+    reset(): void;
+    deactivate(): void;
+    close(): void;
+}
+export interface Connection {
+    open(): void;
+    close(): void;
+    send(data: string): void;
+    isOpen(): boolean;
+    onOpen(callback: () => void): void;
+    onReceive(callback: (data: string) => void): void;
+    onClose(callback: () => void): void;
+}
+export interface ConnectionFactory {
+    create(): Connection;
+}
+export declare class WebTTY {
+    term: Terminal;
+    connectionFactory: ConnectionFactory;
+    args: string;
+    authToken: string;
+    reconnect: number;
+    constructor(term: Terminal, connectionFactory: ConnectionFactory, args: string, authToken: string);
+    open(): () => void;
+}

js/dist/xterm.d.ts

@@ -0,0 +1,26 @@
+import * as bare from "xterm";
+import { lib } from "libapps";
+export declare class Xterm {
+    elem: HTMLElement;
+    term: bare;
+    resizeListener: () => void;
+    decoder: lib.UTF8Decoder;
+    message: HTMLElement;
+    messageTimeout: number;
+    messageTimer: number;
+    constructor(elem: HTMLElement);
+    info(): {
+        columns: number;
+        rows: number;
+    };
+    output(data: string): void;
+    showMessage(message: string, timeout: number): void;
+    removeMessage(): void;
+    setWindowTitle(title: string): void;
+    setPreferences(value: object): void;
+    onInput(callback: (input: string) => void): void;
+    onResize(callback: (colmuns: number, rows: number) => void): void;
+    deactivate(): void;
+    reset(): void;
+    close(): void;
+}

js/package.json

@@ -0,0 +1,13 @@
+{
+    "devDependencies": {
+        "license-loader": "^0.5.0",
+        "ts-loader": "^2.0.3",
+        "typescript": "^2.3.2",
+        "uglifyjs-webpack-plugin": "^1.0.0-beta.2",
+        "webpack": "^2.5.1"
+    },
+    "dependencies": {
+        "libapps": "github:yudai/libapps#release-hterm-1.70",
+        "xterm": "^2.7.0"
+    }
+}

js/src/hterm.ts

@@ -0,0 +1,92 @@
+import * as bare from "libapps";
+
+export class Hterm {
+    elem: HTMLElement;
+
+    term: bare.hterm.Terminal;
+    io: bare.hterm.IO;
+
+    columns: number;
+    rows: number;
+
+    // to "show" the current message when removeMessage() is called
+    message: string;
+
+    constructor(elem: HTMLElement) {
+        this.elem = elem;
+        bare.hterm.defaultStorage = new bare.lib.Storage.Memory();
+        this.term = new bare.hterm.Terminal();
+        this.term.getPrefs().set("send-encoding", "raw");
+        this.term.decorate(this.elem);
+
+        this.io = this.term.io.push();
+        this.term.installKeyboard();
+    };
+
+    info(): { columns: number, rows: number } {
+        return { columns: this.columns, rows: this.rows };
+    };
+
+    output(data: string) {
+        if (this.term.io != null) {
+            this.term.io.writeUTF8(data);
+        }
+    };
+
+    showMessage(message: string, timeout: number) {
+        this.message = message;
+        if (timeout > 0) {
+            this.term.io.showOverlay(message, timeout);
+        } else {
+            this.term.io.showOverlay(message, null);
+        }
+    };
+
+    removeMessage(): void {
+        // there is no hideOverlay(), so show the same message with 0 sec
+        this.term.io.showOverlay(this.message, 0);
+    }
+
+    setWindowTitle(title: string) {
+        this.term.setWindowTitle(title);
+    };
+
+    setPreferences(value: object) {
+        Object.keys(value).forEach((key) => {
+            this.term.getPrefs().set(key, value[key]);
+        });
+    };
+
+    onInput(callback: (input: string) => void) {
+        this.io.onVTKeystroke = (data) => {
+            callback(data);
+        };
+        this.io.sendString = (data) => {
+            callback(data);
+        };
+    };
+
+    onResize(callback: (colmuns: number, rows: number) => void) {
+        this.io.onTerminalResize = (columns: number, rows: number) => {
+            this.columns = columns;
+            this.rows = rows;
+            callback(columns, rows);
+        };
+    };
+
+    deactivate(): void {
+        this.io.onVTKeystroke    = function(){};
+        this.io.sendString       = function(){};
+        this.io.onTerminalResize = function(){};
+        this.term.uninstallKeyboard();
+    }
+
+    reset(): void {
+        this.removeMessage();
+        this.term.installKeyboard();
+    }
+
+    close(): void {
+        this.term.uninstallKeyboard();
+    }
+}

js/src/main.ts

@@ -0,0 +1,30 @@
+import { Hterm } from "./hterm";
+import { Xterm } from "./xterm";
+import { Terminal, WebTTY, protocols } from "./webtty";
+import { ConnectionFactory } from "./websocket";
+
+// @TODO remove these
+declare var gotty_auth_token: string;
+declare var gotty_term: string;
+
+const elem = document.getElementById("terminal")
+
+if (elem !== null) {
+    var term: Terminal;
+    if (gotty_term == "hterm") {
+        term = new Hterm(elem);
+    } else {
+        term = new Xterm(elem);
+    }
+    const httpsEnabled = window.location.protocol == "https:";
+    const url = (httpsEnabled ? 'wss://' : 'ws://') + window.location.host + window.location.pathname + 'ws';
+    const args = window.location.search;
+    const factory = new ConnectionFactory(url, protocols);
+    const wt = new WebTTY(term, factory, args, gotty_auth_token);
+    const closer = wt.open();
+
+    window.addEventListener("unload", () => {
+        closer();
+        term.close();
+    });
+};

js/src/websocket.ts

@@ -0,0 +1,60 @@
+export class ConnectionFactory {
+    url: string;
+    protocols: string[];
+
+    constructor(url: string, protocols: string[]) {
+        this.url = url;
+        this.protocols = protocols;
+    };
+
+    create(): Connection {
+        return new Connection(this.url, this.protocols);
+    };
+}
+
+export class Connection {
+    bare: WebSocket;
+
+
+    constructor(url: string, protocols: string[]) {
+        this.bare = new WebSocket(url, protocols);
+    }
+
+    open() {
+        // nothing todo for websocket
+    };
+
+    close() {
+        this.bare.close();
+    };
+
+    send(data: string) {
+        this.bare.send(data);
+    };
+
+    isOpen(): boolean {
+        if (this.bare.readyState == WebSocket.CONNECTING ||
+            this.bare.readyState == WebSocket.OPEN) {
+            return true
+        }
+        return false
+    }
+
+    onOpen(callback: () => void) {
+        this.bare.onopen = (event) => {
+            callback();
+        }
+    };
+
+    onReceive(callback: (data: string) => void) {
+        this.bare.onmessage = (event) => {
+            callback(event.data);
+        }
+    };
+
+    onClose(callback: () => void) {
+        this.bare.onclose = (event) => {
+            callback();
+        };
+    };
+}

js/src/webtty.ts

@@ -0,0 +1,148 @@
+export const protocols = ["webtty"];
+
+export const msgInputUnknown = '0';
+export const msgInput = '1';
+export const msgPing = '2';
+export const msgResizeTerminal = '3';
+
+export const msgUnknownOutput = '0';
+export const msgOutput = '1';
+export const msgPong = '2';
+export const msgSetWindowTitle = '3';
+export const msgSetPreferences = '4';
+export const msgSetReconnect = '5';
+
+
+export interface Terminal {
+    info(): { columns: number, rows: number };
+    output(data: string): void;
+    showMessage(message: string, timeout: number): void;
+    removeMessage(): void;
+    setWindowTitle(title: string): void;
+    setPreferences(value: object): void;
+    onInput(callback: (input: string) => void): void;
+    onResize(callback: (colmuns: number, rows: number) => void): void;
+    reset(): void;
+    deactivate(): void;
+    close(): void;
+}
+
+export interface Connection {
+    open(): void;
+    close(): void;
+    send(data: string): void;
+    isOpen(): boolean;
+    onOpen(callback: () => void): void;
+    onReceive(callback: (data: string) => void): void;
+    onClose(callback: () => void): void;
+}
+
+export interface ConnectionFactory {
+    create(): Connection;
+}
+
+
+export class WebTTY {
+    term: Terminal;
+    connectionFactory: ConnectionFactory;
+    args: string;
+    authToken: string;
+    reconnect: number;
+
+    constructor(term: Terminal, connectionFactory: ConnectionFactory, args: string, authToken: string) {
+        this.term = term;
+        this.connectionFactory = connectionFactory;
+        this.args = args;
+        this.authToken = authToken;
+        this.reconnect = -1;
+    };
+
+    open() {
+        let connection = this.connectionFactory.create();
+        let pingTimer: number;
+        let reconnectTimeout: number;
+
+        const setup = () => {
+            connection.onOpen(() => {
+                const termInfo = this.term.info();
+
+                connection.send(JSON.stringify(
+                    {
+                        Arguments: this.args,
+                        AuthToken: this.authToken,
+                    }
+                ));
+
+
+                const resizeHandler = (colmuns: number, rows: number) => {
+                    connection.send(
+                        msgResizeTerminal + JSON.stringify(
+                            {
+                                columns: colmuns,
+                                rows: rows
+                            }
+                        )
+                    );
+                };
+
+                this.term.onResize(resizeHandler);
+                resizeHandler(termInfo.columns, termInfo.rows);
+
+                this.term.onInput(
+                    (input: string) => {
+                        connection.send(msgInput + input);
+                    }
+                );
+
+                pingTimer = setInterval(() => {
+                    connection.send(msgPing)
+                }, 30 * 1000);
+
+            });
+
+            connection.onReceive((data) => {
+                const payload = data.slice(1);
+                switch (data[0]) {
+                    case msgOutput:
+                        this.term.output(atob(payload));
+                        break;
+                    case msgPong:
+                        break;
+                    case msgSetWindowTitle:
+                        this.term.setWindowTitle(payload);
+                        break;
+                    case msgSetPreferences:
+                        const preferences = JSON.parse(payload);
+                        this.term.setPreferences(preferences);
+                        break;
+                    case msgSetReconnect:
+                        const autoReconnect = JSON.parse(payload);
+                        console.log("Enabling reconnect: " + autoReconnect + " seconds")
+                        this.reconnect = autoReconnect;
+                        break;
+                }
+            });
+
+            connection.onClose(() => {
+                clearInterval(pingTimer);
+                this.term.deactivate();
+                this.term.showMessage("Connection Closed", 0);
+                if (this.reconnect > 0) {
+                    reconnectTimeout = setTimeout(() => {
+                        connection = this.connectionFactory.create();
+                        this.term.reset();
+                        setup();
+                    }, this.reconnect * 1000);
+                }
+            });
+
+            connection.open();
+        }
+
+        setup();
+        return () => {
+            clearTimeout(reconnectTimeout);
+            connection.close();
+        }
+    };
+};

js/src/xterm.ts

@@ -0,0 +1,105 @@
+import * as bare from "xterm";
+import { lib } from "libapps"
+
+
+bare.loadAddon("fit");
+
+export class Xterm {
+    elem: HTMLElement;
+    term: bare;
+    resizeListener: () => void;
+    decoder: lib.UTF8Decoder;
+
+    message: HTMLElement;
+    messageTimeout: number;
+    messageTimer: number;
+
+
+    constructor(elem: HTMLElement) {
+        this.elem = elem;
+        this.term = new bare();
+
+        this.message = elem.ownerDocument.createElement("div");
+        this.message.className = "xterm-overlay";
+        this.messageTimeout = 2000;
+
+        this.resizeListener = () => {
+            this.term.fit();
+            this.term.scrollToBottom();
+            this.showMessage(String(this.term.cols) + "x" + String(this.term.rows), this.messageTimeout);
+        };
+
+        this.term.on("open", () => {
+            this.resizeListener();
+            window.addEventListener("resize", () => { this.resizeListener(); });
+        });
+
+        this.term.open(elem, true);
+
+        this.decoder = new lib.UTF8Decoder()
+    };
+
+    info(): { columns: number, rows: number } {
+        return { columns: this.term.cols, rows: this.term.rows };
+    };
+
+    output(data: string) {
+        this.term.write(this.decoder.decode(data));
+    };
+
+    showMessage(message: string, timeout: number) {
+        this.message.textContent = message;
+        this.elem.appendChild(this.message);
+
+        if (this.messageTimer) {
+            clearTimeout(this.messageTimer);
+        }
+        if (timeout > 0) {
+            this.messageTimer = setTimeout(() => {
+                this.elem.removeChild(this.message);
+            }, timeout);
+        }
+    };
+
+    removeMessage(): void {
+        if (this.message.parentNode == this.elem) {
+            this.elem.removeChild(this.message);
+        }
+    }
+
+    setWindowTitle(title: string) {
+        document.title = title;
+    };
+
+    setPreferences(value: object) {
+    };
+
+    onInput(callback: (input: string) => void) {
+        this.term.on("data", (data) => {
+            callback(data);
+        });
+
+    };
+
+    onResize(callback: (colmuns: number, rows: number) => void) {
+        this.term.on("resize", (data) => {
+            callback(data.cols, data.rows);
+        });
+    };
+
+    deactivate(): void {
+        this.term.off("data");
+        this.term.off("resize");
+        this.term.blur();
+    }
+
+    reset(): void {
+        this.removeMessage();
+        this.term.clear();
+    }
+
+    close(): void {
+        window.removeEventListener("resize", this.resizeListener);
+        this.term.destroy();
+    }
+}

js/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+      "strictNullChecks": true,
+      "noUnusedLocals" : true,
+      "noImplicitThis": true,
+      "alwaysStrict": true,
+      "outDir": "./dist/",
+      "declaration": true,
+      "sourceMap": true,
+      "target": "es5",
+      "module": "commonJS",
+      "baseUrl": ".",
+      "paths": {
+          "*": ["./typings/*"]
+      }
+  },
+    "exclude": [
+      "node_modules"
+    ]
+}

js/typings/libapps/index.d.ts

@@ -0,0 +1,51 @@
+export declare namespace hterm {
+    export class Terminal {
+        io: IO;
+        onTerminalReady: () => void;
+
+        constructor();
+        getPrefs(): Prefs;
+        decorate(HTMLElement);
+        installKeyboard(): void;
+        uninstallKeyboard(): void;
+        setWindowTitle(title: string): void;
+        reset(): void;
+        softReset(): void;
+    }
+
+    export class IO {
+        writeUTF8: ((data: string) => void);
+        writeUTF16: ((data: string) => void);
+        onVTKeystroke: ((data: string) => void) | null;
+        sendString: ((data: string) => void) | null;
+        onTerminalResize: ((columns: number, rows: number) => void) | null;
+
+        push(): IO;
+        writeUTF(data: string);
+        showOverlay(message: string, timeout: number | null);
+    }
+
+    export class Prefs {
+        set(key: string, value: string): void;
+    }
+
+    export var defaultStorage: lib.Storage;
+}
+
+export declare namespace lib {
+    export interface Storage {
+    }
+
+    export interface Memory {
+        new (): Storage;
+        Memory(): Storage
+    }
+
+    export var Storage: {
+        Memory: Memory
+    }
+
+    export class UTF8Decoder {
+        decode(str: string)
+    }
+}

js/webpack.config.js

@@ -0,0 +1,29 @@
+const UglifyJSPlugin = require('uglifyjs-webpack-plugin');
+
+module.exports = {
+    entry: "./src/main.ts",
+    output: {
+        filename: "./dist/gotty-bundle.js"
+    },
+    devtool: "source-map",
+    resolve: {
+        extensions: [".ts", ".tsx", ".js"],
+    },
+    module: {
+        rules: [
+            {
+                test: /\.tsx?$/,
+                loader: "ts-loader",
+                exclude: /node_modules/
+            },
+            {
+                test: /\.js$/,
+                include: /node_modules/,
+                loader: 'license-loader'
+            }
+        ]
+    },
+    plugins: [
+        new UglifyJSPlugin()
+    ]
+};

libapps

@@ -1 +0,0 @@
-Subproject commit 9dc111b58c7e5af86c1b3a0cb3b04a22a8dcf584

main.go

@@ -1,63 +1,45 @@
 package main
 
 import (
+	"context"
 	"fmt"
+	"log"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 
 	"github.com/codegangsta/cli"
 
-	"github.com/yudai/gotty/app"
+	"github.com/yudai/gotty/backend/localcommand"
+	"github.com/yudai/gotty/pkg/homedir"
+	"github.com/yudai/gotty/server"
+	"github.com/yudai/gotty/utils"
 )
 
 func main() {
-	cmd := cli.NewApp()
-	cmd.Version = app.Version
-	cmd.Name = "gotty"
-	cmd.Usage = "Share your terminal as a web application"
-	cmd.HideHelp = true
+	app := cli.NewApp()
+	app.Name = "gotty"
+	app.Version = Version + "+" + CommitID
+	app.Usage = "Share your terminal as a web application"
+	app.HideHelp = true
+	cli.AppHelpTemplate = helpTemplate
 
-	flags := []flag{
-		flag{"address", "a", "IP address to listen"},
-		flag{"port", "p", "Port number to listen"},
-		flag{"permit-write", "w", "Permit clients to write to the TTY (BE CAREFUL)"},
-		flag{"credential", "c", "Credential for Basic Authentication (ex: user:pass, default disabled)"},
-		flag{"random-url", "r", "Add a random string to the URL"},
-		flag{"random-url-length", "", "Random URL length"},
-		flag{"tls", "t", "Enable TLS/SSL"},
-		flag{"tls-crt", "", "TLS/SSL certificate file path"},
-		flag{"tls-key", "", "TLS/SSL key file path"},
-		flag{"tls-ca-crt", "", "TLS/SSL CA certificate file for client certifications"},
-		flag{"index", "", "Custom index.html file"},
-		flag{"title-format", "", "Title format of browser window"},
-		flag{"reconnect", "", "Enable reconnection"},
-		flag{"reconnect-time", "", "Time to reconnect"},
-		flag{"timeout", "", "Timeout seconds for waiting a client (0 to disable)"},
-		flag{"max-connection", "", "Maximum connection to gotty, 0(default) means no limit"},
-		flag{"once", "", "Accept only one client and exit on disconnection"},
-		flag{"permit-arguments", "", "Permit clients to send command line arguments in URL (e.g. http://example.com:8080/?arg=AAA&arg=BBB)"},
-		flag{"close-signal", "", "Signal sent to the command process when gotty close it (default: SIGHUP)"},
-		flag{"width", "", "Static width of the screen, 0(default) means dynamically resize"},
-		flag{"height", "", "Static height of the screen, 0(default) means dynamically resize"},
+	appOptions := &server.Options{}
+	if err := utils.ApplyDefaultValues(appOptions); err != nil {
+		exit(err, 1)
+	}
+	backendOptions := &localcommand.Options{}
+	if err := utils.ApplyDefaultValues(backendOptions); err != nil {
+		exit(err, 1)
 	}
 
-	mappingHint := map[string]string{
-		"index":      "IndexFile",
-		"tls":        "EnableTLS",
-		"tls-crt":    "TLSCrtFile",
-		"tls-key":    "TLSKeyFile",
-		"tls-ca-crt": "TLSCACrtFile",
-		"random-url": "EnableRandomUrl",
-		"reconnect":  "EnableReconnect",
-	}
-
-	cliFlags, err := generateFlags(flags, mappingHint)
+	cliFlags, flagMappings, err := utils.GenerateFlags(appOptions, backendOptions)
 	if err != nil {
 		exit(err, 3)
 	}
 
-	cmd.Flags = append(
+	app.Flags = append(
 		cliFlags,
 		cli.StringFlag{
 			Name:   "config",
@@ -67,52 +49,67 @@ func main() {
 		},
 	)
 
-	cmd.Action = func(c *cli.Context) {
+	app.Action = func(c *cli.Context) {
 		if len(c.Args()) == 0 {
-			fmt.Println("Error: No command given.\n")
+			msg := "Error: No command given."
 			cli.ShowAppHelp(c)
-			exit(err, 1)
+			exit(fmt.Errorf(msg), 1)
 		}
 
-		options := app.DefaultOptions
-
 		configFile := c.String("config")
-		_, err := os.Stat(app.ExpandHomeDir(configFile))
+		_, err := os.Stat(homedir.Expand(configFile))
 		if configFile != "~/.gotty" || !os.IsNotExist(err) {
-			if err := app.ApplyConfigFile(&options, configFile); err != nil {
+			if err := utils.ApplyConfigFile(configFile, appOptions, backendOptions); err != nil {
 				exit(err, 2)
 			}
 		}
 
-		applyFlags(&options, flags, mappingHint, c)
+		utils.ApplyFlags(cliFlags, flagMappings, c, appOptions, backendOptions)
 
-		if c.IsSet("credential") {
-			options.EnableBasicAuth = true
-		}
-		if c.IsSet("tls-ca-crt") {
-			options.EnableTLSClientAuth = true
-		}
+		appOptions.EnableBasicAuth = c.IsSet("credential")
+		appOptions.EnableTLSClientAuth = c.IsSet("tls-ca-crt")
 
-		if err := app.CheckConfig(&options); err != nil {
+		err = appOptions.Validate()
+		if err != nil {
 			exit(err, 6)
 		}
 
-		app, err := app.New(c.Args(), &options)
+		args := c.Args()
+		factory, err := localcommand.NewFactory(args[0], args[1:], backendOptions)
 		if err != nil {
 			exit(err, 3)
 		}
 
-		registerSignals(app)
-
-		err = app.Run()
-		if err != nil {
-			exit(err, 4)
+		hostname, _ := os.Hostname()
+		appOptions.TitleVariables = map[string]interface{}{
+			"command":  args[0],
+			"argv":     args[1:],
+			"hostname": hostname,
 		}
+
+		srv, err := server.New(factory, appOptions)
+		if err != nil {
+			exit(err, 3)
+		}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		gCtx, gCancel := context.WithCancel(context.Background())
+
+		log.Printf("GoTTY is starting with command: %s", strings.Join(args, " "))
+
+		errs := make(chan error, 1)
+		go func() {
+			errs <- srv.Run(ctx, server.WithGracefullContext(gCtx))
+		}()
+		err = waitSignals(errs, cancel, gCancel)
+
+		if err != nil && err != context.Canceled {
+			fmt.Printf("Error: %s\n", err)
+			exit(err, 8)
+		}
+
 	}
-
-	cli.AppHelpTemplate = helpTemplate
-
-	cmd.Run(os.Args)
+	app.Run(os.Args)
 }
 
 func exit(err error, code int) {
@@ -122,7 +119,7 @@ func exit(err error, code int) {
 	os.Exit(code)
 }
 
-func registerSignals(app *app.App) {
+func waitSignals(errs chan error, cancel context.CancelFunc, gracefullCancel context.CancelFunc) error {
 	sigChan := make(chan os.Signal, 1)
 	signal.Notify(
 		sigChan,
@@ -130,17 +127,26 @@ func registerSignals(app *app.App) {
 		syscall.SIGTERM,
 	)
 
-	go func() {
-		for {
-			s := <-sigChan
-			switch s {
-			case syscall.SIGINT, syscall.SIGTERM:
-				if app.Exit() {
-					fmt.Println("Send ^C to force exit.")
-				} else {
-					os.Exit(5)
-				}
+	select {
+	case err := <-errs:
+		return err
+
+	case s := <-sigChan:
+		switch s {
+		case syscall.SIGINT:
+			gracefullCancel()
+			fmt.Println("C-C to force close")
+			select {
+			case err := <-errs:
+				return err
+			case <-sigChan:
+				fmt.Println("Force closing...")
+				cancel()
+				return <-errs
 			}
+		default:
+			cancel()
+			return <-errs
 		}
-	}()
+	}
 }

pkg/homedir/expand.go

@@ -0,0 +1,13 @@
+package homedir
+
+import (
+	"os"
+)
+
+func Expand(path string) string {
+	if path[0:2] == "~/" {
+		return os.Getenv("HOME") + path[1:]
+	} else {
+		return path
+	}
+}

pkg/randomstring/generate.go

@@ -0,0 +1,18 @@
+package randomstring
+
+import (
+	"crypto/rand"
+	"math/big"
+	"strconv"
+)
+
+func Generate(length int) string {
+	const base = 36
+	size := big.NewInt(base)
+	n := make([]byte, length)
+	for i, _ := range n {
+		c, _ := rand.Int(rand.Reader, size)
+		n[i] = strconv.FormatInt(c.Int64(), base)[0]
+	}
+	return string(n)
+}

resources/gotty.js

@@ -1,96 +0,0 @@
-(function() {
-    var httpsEnabled = window.location.protocol == "https:";
-    var args = window.location.search;
-    var url = (httpsEnabled ? 'wss://' : 'ws://') + window.location.host + window.location.pathname + 'ws';
-    var protocols = ["gotty"];
-    var autoReconnect = -1;
-
-    var openWs = function() {
-        var ws = new WebSocket(url, protocols);
-
-        var term;
-
-        var pingTimer;
-
-        ws.onopen = function(event) {
-            ws.send(JSON.stringify({ Arguments: args, AuthToken: gotty_auth_token,}));
-            pingTimer = setInterval(sendPing, 30 * 1000, ws);
-
-            hterm.defaultStorage = new lib.Storage.Local();
-            hterm.defaultStorage.clear();
-
-            term = new hterm.Terminal();
-
-            term.getPrefs().set("send-encoding", "raw");
-
-            term.onTerminalReady = function() {
-                var io = term.io.push();
-
-                io.onVTKeystroke = function(str) {
-                    ws.send("0" + str);
-                };
-
-                io.sendString = io.onVTKeystroke;
-
-                io.onTerminalResize = function(columns, rows) {
-                    ws.send(
-                        "2" + JSON.stringify(
-                            {
-                                columns: columns,
-                                rows: rows,
-                            }
-                        )
-                    )
-                };
-
-                term.installKeyboard();
-            };
-
-            term.decorate(document.getElementById("terminal"));
-        };
-
-        ws.onmessage = function(event) {
-            data = event.data.slice(1);
-            switch(event.data[0]) {
-            case '0':
-                term.io.writeUTF8(window.atob(data));
-                break;
-            case '1':
-                // pong
-                break;
-            case '2':
-                term.setWindowTitle(data);
-                break;
-            case '3':
-                preferences = JSON.parse(data);
-                Object.keys(preferences).forEach(function(key) {
-                    console.log("Setting " + key + ": " +  preferences[key]);
-                    term.getPrefs().set(key, preferences[key]);
-                });
-                break;
-            case '4':
-                autoReconnect = JSON.parse(data);
-                console.log("Enabling reconnect: " + autoReconnect + " seconds")
-                break;
-            }
-        };
-
-        ws.onclose = function(event) {
-            if (term) {
-                term.uninstallKeyboard();
-                term.io.showOverlay("Connection Closed", null);
-            }
-            clearInterval(pingTimer);
-            if (autoReconnect > 0) {
-                setTimeout(openWs, autoReconnect * 1000);
-            }
-        };
-    }
-
-
-    var sendPing = function(ws) {
-        ws.send("1");
-    }
-
-    openWs();
-})()

resources/index.css

@@ -0,0 +1,7 @@
+html, body, #terminal {
+    background: black;
+    height: 100%;
+    width: 100%;
+    padding: 0%;
+    margin: 0%;
+}

resources/index.html

@@ -1,14 +1,16 @@
 <!doctype html>
 <html>
   <head>
-    <title>GoTTY</title>
-    <style>body, #terminal {position: absolute; height: 100%; width: 100%; margin: 0px;}</style>
+    <title>{{ .title }}</title>
     <link rel="icon" type="image/png" href="favicon.png">
+    <link rel="stylesheet" href="./css/index.css" />
+    <link rel="stylesheet" href="./css/xterm.css" />
+    <link rel="stylesheet" href="./css/xterm_customize.css" />
   </head>
   <body>
     <div id="terminal"></div>
-    <script src="./js/hterm.js"></script>
     <script src="./auth_token.js"></script>
-    <script src="./js/gotty.js"></script>
+    <script src="./config.js"></script>
+    <script src="./js/gotty-bundle.js"></script>
   </body>
 </html>

resources/xterm_customize.css

@@ -0,0 +1,19 @@
+.terminal {
+    font-family: "DejaVu Sans Mono", "Everson Mono", FreeMono, Menlo, Terminal, monospace, "Apple Symbols";
+}
+
+.xterm-overlay {
+    font-family: "DejaVu Sans Mono", "Everson Mono", FreeMono, Menlo, Terminal, monospace, "Apple Symbols";
+    border-radius: 15px;
+    font-size: xx-large;
+    color: black;
+    background: white;
+    opacity: 0.75;
+    padding: 0.2em 0.5em 0.2em 0.5em;
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    user-select: none;
+    transition: opacity 180ms ease-in;
+}

server/handler_atomic.go

@@ -0,0 +1,70 @@
+package server
+
+import (
+	"sync"
+	"time"
+)
+
+type counter struct {
+	duration    time.Duration
+	zeroTimer   *time.Timer
+	wg          sync.WaitGroup
+	connections int
+	mutex       sync.Mutex
+}
+
+func newCounter(duration time.Duration) *counter {
+	zeroTimer := time.NewTimer(duration)
+
+	// when duration is 0, drain the expire event here
+	// so that user will never get the event.
+	if duration == 0 {
+		<-zeroTimer.C
+	}
+
+	return &counter{
+		duration:  duration,
+		zeroTimer: zeroTimer,
+	}
+}
+
+func (counter *counter) add(n int) int {
+	counter.mutex.Lock()
+	defer counter.mutex.Unlock()
+
+	if counter.duration > 0 {
+		counter.zeroTimer.Stop()
+	}
+	counter.wg.Add(n)
+	counter.connections += n
+
+	return counter.connections
+}
+
+func (counter *counter) done() int {
+	counter.mutex.Lock()
+	defer counter.mutex.Unlock()
+
+	counter.connections--
+	counter.wg.Done()
+	if counter.connections == 0 && counter.duration > 0 {
+		counter.zeroTimer.Reset(counter.duration)
+	}
+
+	return counter.connections
+}
+
+func (counter *counter) count() int {
+	counter.mutex.Lock()
+	defer counter.mutex.Unlock()
+
+	return counter.connections
+}
+
+func (counter *counter) wait() {
+	counter.wg.Wait()
+}
+
+func (counter *counter) timer() *time.Timer {
+	return counter.zeroTimer
+}

server/handlers.go

@@ -0,0 +1,235 @@
+package server
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"sync/atomic"
+
+	"github.com/gorilla/websocket"
+	"github.com/pkg/errors"
+
+	"github.com/yudai/gotty/webtty"
+)
+
+func (server *Server) generateHandleWS(ctx context.Context, cancel context.CancelFunc, counter *counter) http.HandlerFunc {
+	once := new(int64)
+
+	go func() {
+		select {
+		case <-counter.timer().C:
+			cancel()
+		case <-ctx.Done():
+		}
+	}()
+
+	return func(w http.ResponseWriter, r *http.Request) {
+		if server.options.Once {
+			success := atomic.CompareAndSwapInt64(once, 0, 1)
+			if !success {
+				http.Error(w, "Server is shutting down", http.StatusServiceUnavailable)
+				return
+			}
+		}
+
+		num := counter.add(1)
+		closeReason := "unknown reason"
+
+		defer func() {
+			num := counter.done()
+			log.Printf(
+				"Connection closed by %s: %s, connections: %d/%d",
+				closeReason, r.RemoteAddr, num, server.options.MaxConnection,
+			)
+
+			if server.options.Once {
+				cancel()
+			}
+		}()
+
+		if int64(server.options.MaxConnection) != 0 {
+			if num > server.options.MaxConnection {
+				closeReason = "exceeding max number of connections"
+				return
+			}
+		}
+
+		log.Printf("New client connected: %s, connections: %d/%d", r.RemoteAddr, num, server.options.MaxConnection)
+
+		if r.Method != "GET" {
+			http.Error(w, "Method not allowed", 405)
+			return
+		}
+
+		conn, err := server.upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			closeReason = err.Error()
+			return
+		}
+		defer conn.Close()
+
+		err = server.processWSConn(ctx, conn)
+
+		switch err {
+		case ctx.Err():
+			closeReason = "cancelation"
+		case webtty.ErrSlaveClosed:
+			closeReason = server.factory.Name()
+		case webtty.ErrMasterClosed:
+			closeReason = "client"
+		default:
+			closeReason = fmt.Sprintf("an error: %s", err)
+		}
+	}
+}
+
+func (server *Server) processWSConn(ctx context.Context, conn *websocket.Conn) error {
+	typ, initLine, err := conn.ReadMessage()
+	if err != nil {
+		return errors.Wrapf(err, "failed to authenticate websocket connection")
+	}
+	if typ != websocket.TextMessage {
+		return errors.New("failed to authenticate websocket connection: invalid message type")
+	}
+
+	var init InitMessage
+	err = json.Unmarshal(initLine, &init)
+	if err != nil {
+		return errors.Wrapf(err, "failed to authenticate websocket connection")
+	}
+	if init.AuthToken != server.options.Credential {
+		return errors.New("failed to authenticate websocket connection")
+	}
+
+	queryPath := "?"
+	if server.options.PermitArguments && init.Arguments != "" {
+		queryPath = init.Arguments
+	}
+
+	query, err := url.Parse(queryPath)
+	if err != nil {
+		return errors.Wrapf(err, "failed to parse arguments")
+	}
+	params := query.Query()
+	var slave Slave
+	slave, err = server.factory.New(params)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create backend")
+	}
+	defer slave.Close()
+
+	titleVars := server.titleVariables(
+		[]string{"server", "master", "slave"},
+		map[string]map[string]interface{}{
+			"server": server.options.TitleVariables,
+			"master": map[string]interface{}{
+				"remote_addr": conn.RemoteAddr(),
+			},
+			"slave": slave.WindowTitleVariables(),
+		},
+	)
+
+	titleBuf := new(bytes.Buffer)
+	err = server.titleTemplate.Execute(titleBuf, titleVars)
+	if err != nil {
+		return errors.Wrapf(err, "failed to fill window title template")
+	}
+
+	opts := []webtty.Option{
+		webtty.WithWindowTitle(titleBuf.Bytes()),
+	}
+	if server.options.PermitWrite {
+		opts = append(opts, webtty.WithPermitWrite())
+	}
+	if server.options.EnableReconnect {
+		opts = append(opts, webtty.WithReconnect(server.options.ReconnectTime))
+	}
+	if server.options.Width > 0 {
+		opts = append(opts, webtty.WithFixedColumns(server.options.Width))
+	}
+	if server.options.Height > 0 {
+		opts = append(opts, webtty.WithFixedRows(server.options.Height))
+	}
+	if server.options.Preferences != nil {
+		opts = append(opts, webtty.WithMasterPreferences(server.options.Preferences))
+	}
+
+	tty, err := webtty.New(&wsWrapper{conn}, slave, opts...)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create webtty")
+	}
+
+	err = tty.Run(ctx)
+
+	return err
+}
+
+func (server *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
+	titleVars := server.titleVariables(
+		[]string{"server", "master"},
+		map[string]map[string]interface{}{
+			"server": server.options.TitleVariables,
+			"master": map[string]interface{}{
+				"remote_addr": r.RemoteAddr,
+			},
+		},
+	)
+
+	titleBuf := new(bytes.Buffer)
+	err := server.titleTemplate.Execute(titleBuf, titleVars)
+	if err != nil {
+		http.Error(w, "Internal Server Error", 500)
+		return
+	}
+
+	indexVars := map[string]interface{}{
+		"title": titleBuf.String(),
+	}
+
+	indexBuf := new(bytes.Buffer)
+	err = server.indexTemplate.Execute(indexBuf, indexVars)
+	if err != nil {
+		http.Error(w, "Internal Server Error", 500)
+		return
+	}
+
+	w.Write(indexBuf.Bytes())
+}
+
+func (server *Server) handleAuthToken(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/javascript")
+	// @TODO hashing?
+	w.Write([]byte("var gotty_auth_token = '" + server.options.Credential + "';"))
+}
+
+func (server *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/javascript")
+	w.Write([]byte("var gotty_term = '" + server.options.Term + "';"))
+}
+
+// titleVariables merges maps in a specified order.
+// varUnits are name-keyed maps, whose names will be iterated using order.
+func (server *Server) titleVariables(order []string, varUnits map[string]map[string]interface{}) map[string]interface{} {
+	titleVars := map[string]interface{}{}
+
+	for _, name := range order {
+		vars, ok := varUnits[name]
+		if !ok {
+			panic("title variable name error")
+		}
+		for key, val := range vars {
+			titleVars[key] = val
+		}
+	}
+
+	// safe net for conflicted keys
+	for _, name := range order {
+		titleVars[name] = varUnits[name]
+	}
+
+	return titleVars
+}

server/init_message.go

@@ -0,0 +1,6 @@
+package server
+
+type InitMessage struct {
+	Arguments string `json:"Arguments,omitempty"`
+	AuthToken string `json:"AuthToken,omitempty"`
+}

server/list_address.go

@@ -0,0 +1,28 @@
+package server
+
+import (
+	"net"
+)
+
+func listAddresses() (addresses []string) {
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return []string{}
+	}
+
+	addresses = make([]string, 0, len(ifaces))
+
+	for _, iface := range ifaces {
+		ifAddrs, _ := iface.Addrs()
+		for _, ifAddr := range ifAddrs {
+			switch v := ifAddr.(type) {
+			case *net.IPNet:
+				addresses = append(addresses, v.IP.String())
+			case *net.IPAddr:
+				addresses = append(addresses, v.IP.String())
+			}
+		}
+	}
+
+	return addresses
+}

server/log_response_writer.go

@@ -1,4 +1,4 @@
-package app
+package server
 
 import (
 	"bufio"
@@ -6,17 +6,17 @@ import (
 	"net/http"
 )
 
-type responseWrapper struct {
+type logResponseWriter struct {
 	http.ResponseWriter
 	status int
 }
 
-func (w *responseWrapper) WriteHeader(status int) {
+func (w *logResponseWriter) WriteHeader(status int) {
 	w.status = status
 	w.ResponseWriter.WriteHeader(status)
 }
 
-func (w *responseWrapper) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+func (w *logResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
 	hj, _ := w.ResponseWriter.(http.Hijacker)
 	w.status = http.StatusSwitchingProtocols
 	return hj.Hijack()

server/middleware.go

@@ -0,0 +1,51 @@
+package server
+
+import (
+	"encoding/base64"
+	"log"
+	"net/http"
+	"strings"
+)
+
+func (server *Server) wrapLogger(handler http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rw := &logResponseWriter{w, 200}
+		handler.ServeHTTP(rw, r)
+		log.Printf("%s %d %s %s", r.RemoteAddr, rw.status, r.Method, r.URL.Path)
+	})
+}
+
+func (server *Server) wrapHeaders(handler http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// todo add version
+		w.Header().Set("Server", "GoTTY")
+		handler.ServeHTTP(w, r)
+	})
+}
+
+func (server *Server) wrapBasicAuth(handler http.Handler, credential string) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		token := strings.SplitN(r.Header.Get("Authorization"), " ", 2)
+
+		if len(token) != 2 || strings.ToLower(token[0]) != "basic" {
+			w.Header().Set("WWW-Authenticate", `Basic realm="GoTTY"`)
+			http.Error(w, "Bad Request", http.StatusUnauthorized)
+			return
+		}
+
+		payload, err := base64.StdEncoding.DecodeString(token[1])
+		if err != nil {
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			return
+		}
+
+		if credential != string(payload) {
+			w.Header().Set("WWW-Authenticate", `Basic realm="GoTTY"`)
+			http.Error(w, "authorization failed", http.StatusUnauthorized)
+			return
+		}
+
+		log.Printf("Basic Authentication Succeeded: %s", r.RemoteAddr)
+		handler.ServeHTTP(w, r)
+	})
+}

server/options.go

@@ -0,0 +1,99 @@
+package server
+
+import (
+	"github.com/pkg/errors"
+)
+
+type Options struct {
+	Address             string           `hcl:"address" flagName:"address" flagSName:"a" flagDescribe:"IP address to listen" default:"0.0.0.0"`
+	Port                string           `hcl:"port" flagName:"port" flagSName:"p" flagDescribe:"Port number to liten" default:"8080"`
+	PermitWrite         bool             `hcl:"permit_write" flagName:"permit-write" flagSName:"w" flagDescribe:"Permit clients to write to the TTY (BE CAREFUL)" default:"false"`
+	EnableBasicAuth     bool             `hcl:"enable_basic_auth" default:"false"`
+	Credential          string           `hcl:"credential" flagName:"credential" flagSName:"c" flagDescribe:"Credential for Basic Authentication (ex: user:pass, default disabled)" default:""`
+	EnableRandomUrl     bool             `hcl:"enable_random_url" flagName:"random-url" flagSName:"r" flagDescribe:"Add a random string to the URL" default:"false"`
+	RandomUrlLength     int              `hcl:"random_url_length" flagName:"random-url-length" flagDescribe:"Random URL length" default:"8"`
+	EnableTLS           bool             `hcl:"enable_tls" flagName:"tls" flagSName:"t" flagDescribe:"Enable TLS/SSL" default:"false"`
+	TLSCrtFile          string           `hcl:"tls_crt_file" flagName:"tls-crt" flagDescribe:"TLS/SSL certificate file path" default:"~/.gotty.crt"`
+	TLSKeyFile          string           `hcl:"tls_key_file" flagName:"tls-key" flagDescribe:"TLS/SSL key file path" default:"~/.gotty.key"`
+	EnableTLSClientAuth bool             `hcl:"enable_tls_client_auth" default:"false"`
+	TLSCACrtFile        string           `hcl:"tls_ca_crt_file" flagName:"tls-ca-crt" flagDescribe:"TLS/SSL CA certificate file for client certifications" default:"~/.gotty.ca.crt"`
+	IndexFile           string           `hcl:"index_file" flagName:"index" flagDescribe:"Custom index.html file" default:""`
+	TitleFormat         string           `hcl:"title_format" flagName:"title-format" flagSName:"" flagDescribe:"Title format of browser window" default:"{{ .command }}@{{ .hostname }}"`
+	EnableReconnect     bool             `hcl:"enable_reconnect" flagName:"reconnect" flagDescribe:"Enable reconnection" default:"false"`
+	ReconnectTime       int              `hcl:"reconnect_time" flagName:"reconnect-time" flagDescribe:"Time to reconnect" default:"10"`
+	MaxConnection       int              `hcl:"max_connection" flagName:"max-connection" flagDescribe:"Maximum connection to gotty" default:"0"`
+	Once                bool             `hcl:"once" flagName:"once" flagDescribe:"Accept only one client and exit on disconnection" default:"false"`
+	Timeout             int              `hcl:"timeout" flagName:"timeout" flagDescribe:"Timeout seconds for waiting a client(0 to disable)" default:"0"`
+	PermitArguments     bool             `hcl:"permit_arguments" flagName:"permit-arguments" flagDescribe:"Permit clients to send command line arguments in URL (e.g. http://example.com:8080/?arg=AAA&arg=BBB)" default:"true"`
+	Preferences         *HtermPrefernces `hcl:"preferences"`
+	Width               int              `hcl:"width" flagName:"width" flagDescribe:"Static width of the screen, 0(default) means dynamically resize" default:"0"`
+	Height              int              `hcl:"height" flagName:"height" flagDescribe:"Static height of the screen, 0(default) means dynamically resize" default:"0"`
+	WSOrigin            string           `hcl:"ws_origin" flagName:"ws-origin" flagDescribe:"A regular expression that matches origin URLs to be accepted by WebSocket. No cross origin requests are acceptable by default" default:""`
+	Term                string           `hcl:"term" flagName:"term" flagDescribe:"Terminal name to use on the browser, one of xterm or hterm." default:"xterm"`
+
+	TitleVariables map[string]interface{}
+}
+
+func (options *Options) Validate() error {
+	if options.EnableTLSClientAuth && !options.EnableTLS {
+		return errors.New("TLS client authentication is enabled, but TLS is not enabled")
+	}
+	return nil
+}
+
+type HtermPrefernces struct {
+	AltGrMode                     *string                      `hcl:"alt_gr_mode" json:"alt-gr-mode,omitempty"`
+	AltBackspaceIsMetaBackspace   bool                         `hcl:"alt_backspace_is_meta_backspace" json:"alt-backspace-is-meta-backspace,omitempty"`
+	AltIsMeta                     bool                         `hcl:"alt_is_meta" json:"alt-is-meta,omitempty"`
+	AltSendsWhat                  string                       `hcl:"alt_sends_what" json:"alt-sends-what,omitempty"`
+	AudibleBellSound              string                       `hcl:"audible_bell_sound" json:"audible-bell-sound,omitempty"`
+	DesktopNotificationBell       bool                         `hcl:"desktop_notification_bell" json:"desktop-notification-bell,omitempty"`
+	BackgroundColor               string                       `hcl:"background_color" json:"background-color,omitempty"`
+	BackgroundImage               string                       `hcl:"background_image" json:"background-image,omitempty"`
+	BackgroundSize                string                       `hcl:"background_size" json:"background-size,omitempty"`
+	BackgroundPosition            string                       `hcl:"background_position" json:"background-position,omitempty"`
+	BackspaceSendsBackspace       bool                         `hcl:"backspace_sends_backspace" json:"backspace-sends-backspace,omitempty"`
+	CharacterMapOverrides         map[string]map[string]string `hcl:"character_map_overrides" json:"character-map-overrides,omitempty"`
+	CloseOnExit                   bool                         `hcl:"close_on_exit" json:"close-on-exit,omitempty"`
+	CursorBlink                   bool                         `hcl:"cursor_blink" json:"cursor-blink,omitempty"`
+	CursorBlinkCycle              [2]int                       `hcl:"cursor_blink_cycle" json:"cursor-blink-cycle,omitempty"`
+	CursorColor                   string                       `hcl:"cursor_color" json:"cursor-color,omitempty"`
+	ColorPaletteOverrides         []*string                    `hcl:"color_palette_overrides" json:"color-palette-overrides,omitempty"`
+	CopyOnSelect                  bool                         `hcl:"copy_on_select" json:"copy-on-select,omitempty"`
+	UseDefaultWindowCopy          bool                         `hcl:"use_default_window_copy" json:"use-default-window-copy,omitempty"`
+	ClearSelectionAfterCopy       bool                         `hcl:"clear_selection_after_copy" json:"clear-selection-after-copy,omitempty"`
+	CtrlPlusMinusZeroZoom         bool                         `hcl:"ctrl_plus_minus_zero_zoom" json:"ctrl-plus-minus-zero-zoom,omitempty"`
+	CtrlCCopy                     bool                         `hcl:"ctrl_c_copy" json:"ctrl-c-copy,omitempty"`
+	CtrlVPaste                    bool                         `hcl:"ctrl_v_paste" json:"ctrl-v-paste,omitempty"`
+	EastAsianAmbiguousAsTwoColumn bool                         `hcl:"east_asian_ambiguous_as_two_column" json:"east-asian-ambiguous-as-two-column,omitempty"`
+	Enable8BitControl             *bool                        `hcl:"enable_8_bit_control" json:"enable-8-bit-control,omitempty"`
+	EnableBold                    *bool                        `hcl:"enable_bold" json:"enable-bold,omitempty"`
+	EnableBoldAsBright            bool                         `hcl:"enable_bold_as_bright" json:"enable-bold-as-bright,omitempty"`
+	EnableClipboardNotice         bool                         `hcl:"enable_clipboard_notice" json:"enable-clipboard-notice,omitempty"`
+	EnableClipboardWrite          bool                         `hcl:"enable_clipboard_write" json:"enable-clipboard-write,omitempty"`
+	EnableDec12                   bool                         `hcl:"enable_dec12" json:"enable-dec12,omitempty"`
+	Environment                   map[string]string            `hcl:"environment" json:"environment,omitempty"`
+	FontFamily                    string                       `hcl:"font_family" json:"font-family,omitempty"`
+	FontSize                      int                          `hcl:"font_size" json:"font-size,omitempty"`
+	FontSmoothing                 string                       `hcl:"font_smoothing" json:"font-smoothing,omitempty"`
+	ForegroundColor               string                       `hcl:"foreground_color" json:"foreground-color,omitempty"`
+	HomeKeysScroll                bool                         `hcl:"home_keys_scroll" json:"home-keys-scroll,omitempty"`
+	Keybindings                   map[string]string            `hcl:"keybindings" json:"keybindings,omitempty"`
+	MaxStringSequence             int                          `hcl:"max_string_sequence" json:"max-string-sequence,omitempty"`
+	MediaKeysAreFkeys             bool                         `hcl:"media_keys_are_fkeys" json:"media-keys-are-fkeys,omitempty"`
+	MetaSendsEscape               bool                         `hcl:"meta_sends_escape" json:"meta-sends-escape,omitempty"`
+	MousePasteButton              *int                         `hcl:"mouse_paste_button" json:"mouse-paste-button,omitempty"`
+	PageKeysScroll                bool                         `hcl:"page_keys_scroll" json:"page-keys-scroll,omitempty"`
+	PassAltNumber                 *bool                        `hcl:"pass_alt_number" json:"pass-alt-number,omitempty"`
+	PassCtrlNumber                *bool                        `hcl:"pass_ctrl_number" json:"pass-ctrl-number,omitempty"`
+	PassMetaNumber                *bool                        `hcl:"pass_meta_number" json:"pass-meta-number,omitempty"`
+	PassMetaV                     bool                         `hcl:"pass_meta_v" json:"pass-meta-v,omitempty"`
+	ReceiveEncoding               string                       `hcl:"receive_encoding" json:"receive-encoding,omitempty"`
+	ScrollOnKeystroke             bool                         `hcl:"scroll_on_keystroke" json:"scroll-on-keystroke,omitempty"`
+	ScrollOnOutput                bool                         `hcl:"scroll_on_output" json:"scroll-on-output,omitempty"`
+	ScrollbarVisible              bool                         `hcl:"scrollbar_visible" json:"scrollbar-visible,omitempty"`
+	ScrollWheelMoveMultiplier     int                          `hcl:"scroll_wheel_move_multiplier" json:"scroll-wheel-move-multiplier,omitempty"`
+	SendEncoding                  string                       `hcl:"send_encoding" json:"send-encoding,omitempty"`
+	ShiftInsertPaste              bool                         `hcl:"shift_insert_paste" json:"shift-insert-paste,omitempty"`
+	UserCss                       string                       `hcl:"user_css" json:"user-css,omitempty"`
+}

server/run_option.go

@@ -0,0 +1,21 @@
+package server
+
+import (
+	"context"
+)
+
+// RunOptions holds a set of configurations for Server.Run().
+type RunOptions struct {
+	gracefullCtx context.Context
+}
+
+// RunOption is an option of Server.Run().
+type RunOption func(*RunOptions)
+
+// WithGracefullContext accepts a context to shutdown a Server
+// with care for existing client connections.
+func WithGracefullContext(ctx context.Context) RunOption {
+	return func(options *RunOptions) {
+		options.gracefullCtx = ctx
+	}
+}

server/server.go

@@ -0,0 +1,246 @@
+package server
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"html/template"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+	"regexp"
+	noesctmpl "text/template"
+	"time"
+
+	"github.com/NYTimes/gziphandler"
+	"github.com/elazarl/go-bindata-assetfs"
+	"github.com/gorilla/websocket"
+	"github.com/pkg/errors"
+
+	"github.com/yudai/gotty/pkg/homedir"
+	"github.com/yudai/gotty/pkg/randomstring"
+	"github.com/yudai/gotty/webtty"
+)
+
+// Server provides a webtty HTTP endpoint.
+type Server struct {
+	factory Factory
+	options *Options
+
+	upgrader      *websocket.Upgrader
+	indexTemplate *template.Template
+	titleTemplate *noesctmpl.Template
+}
+
+// New creates a new instance of Server.
+// Server will use the New() of the factory provided to handle each request.
+func New(factory Factory, options *Options) (*Server, error) {
+	indexData, err := Asset("static/index.html")
+	if err != nil {
+		panic("index not found") // must be in bindata
+	}
+	if options.IndexFile != "" {
+		path := homedir.Expand(options.IndexFile)
+		indexData, err = ioutil.ReadFile(path)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to read custom index file at `%s`", path)
+		}
+	}
+	indexTemplate, err := template.New("index").Parse(string(indexData))
+	if err != nil {
+		panic("index template parse failed") // must be valid
+	}
+
+	titleTemplate, err := noesctmpl.New("title").Parse(options.TitleFormat)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to parse window title format `%s`", options.TitleFormat)
+	}
+
+	var originChekcer func(r *http.Request) bool
+	if options.WSOrigin != "" {
+		matcher, err := regexp.Compile(options.WSOrigin)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to compile regular expression of Websocket Origin: %s", options.WSOrigin)
+		}
+		originChekcer = func(r *http.Request) bool {
+			return matcher.MatchString(r.Header.Get("Origin"))
+		}
+	}
+
+	return &Server{
+		factory: factory,
+		options: options,
+
+		upgrader: &websocket.Upgrader{
+			ReadBufferSize:  1024,
+			WriteBufferSize: 1024,
+			Subprotocols:    webtty.Protocols,
+			CheckOrigin:     originChekcer,
+		},
+		indexTemplate: indexTemplate,
+		titleTemplate: titleTemplate,
+	}, nil
+}
+
+// Run starts the main process of the Server.
+// The cancelation of ctx will shutdown the server immediately with aborting
+// existing connections. Use WithGracefullContext() to support gracefull shutdown.
+func (server *Server) Run(ctx context.Context, options ...RunOption) error {
+	cctx, cancel := context.WithCancel(ctx)
+	opts := &RunOptions{gracefullCtx: context.Background()}
+	for _, opt := range options {
+		opt(opts)
+	}
+
+	counter := newCounter(time.Duration(server.options.Timeout) * time.Second)
+
+	path := "/"
+	if server.options.EnableRandomUrl {
+		path = "/" + randomstring.Generate(server.options.RandomUrlLength) + "/"
+	}
+
+	handlers := server.setupHandlers(cctx, cancel, path, counter)
+	srv, err := server.setupHTTPServer(handlers)
+	if err != nil {
+		return errors.Wrapf(err, "failed to setup an HTTP server")
+	}
+
+	if server.options.PermitWrite {
+		log.Printf("Permitting clients to write input to the PTY.")
+	}
+	if server.options.Once {
+		log.Printf("Once option is provided, accepting only one client")
+	}
+
+	if server.options.Port == "0" {
+		log.Printf("Port number configured to `0`, choosing a random port")
+	}
+	hostPort := net.JoinHostPort(server.options.Address, server.options.Port)
+	listener, err := net.Listen("tcp", hostPort)
+	if err != nil {
+		return errors.Wrapf(err, "failed to listen at `%s`", hostPort)
+	}
+
+	scheme := "http"
+	if server.options.EnableTLS {
+		scheme = "https"
+	}
+	host, port, _ := net.SplitHostPort(listener.Addr().String())
+	log.Printf("HTTP server is listening at: %s", scheme+"://"+host+":"+port+path)
+	if server.options.Address == "0.0.0.0" {
+		for _, address := range listAddresses() {
+			log.Printf("Alternative URL: %s", scheme+"://"+address+":"+port+path)
+		}
+	}
+
+	srvErr := make(chan error, 1)
+	go func() {
+		if server.options.EnableTLS {
+			crtFile := homedir.Expand(server.options.TLSCrtFile)
+			keyFile := homedir.Expand(server.options.TLSKeyFile)
+			log.Printf("TLS crt file: " + crtFile)
+			log.Printf("TLS key file: " + keyFile)
+
+			err = srv.ServeTLS(listener, crtFile, keyFile)
+		} else {
+			err = srv.Serve(listener)
+		}
+		if err != nil {
+			srvErr <- err
+		}
+	}()
+
+	go func() {
+		select {
+		case <-opts.gracefullCtx.Done():
+			srv.Shutdown(context.Background())
+		case <-cctx.Done():
+		}
+	}()
+
+	select {
+	case err = <-srvErr:
+		if err == http.ErrServerClosed { // by gracefull ctx
+			err = nil
+		} else {
+			cancel()
+		}
+	case <-cctx.Done():
+		srv.Close()
+		err = cctx.Err()
+	}
+
+	conn := counter.count()
+	if conn > 0 {
+		log.Printf("Waiting for %d connections to be closed", conn)
+	}
+	counter.wait()
+
+	return err
+}
+
+func (server *Server) setupHandlers(ctx context.Context, cancel context.CancelFunc, pathPrefix string, counter *counter) http.Handler {
+	staticFileHandler := http.FileServer(
+		&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "static"},
+	)
+
+	var siteMux = http.NewServeMux()
+	siteMux.HandleFunc(pathPrefix, server.handleIndex)
+	siteMux.Handle(pathPrefix+"js/", http.StripPrefix(pathPrefix, staticFileHandler))
+	siteMux.Handle(pathPrefix+"favicon.png", http.StripPrefix(pathPrefix, staticFileHandler))
+	siteMux.Handle(pathPrefix+"css/", http.StripPrefix(pathPrefix, staticFileHandler))
+
+	siteMux.HandleFunc(pathPrefix+"auth_token.js", server.handleAuthToken)
+	siteMux.HandleFunc(pathPrefix+"config.js", server.handleConfig)
+
+	siteHandler := http.Handler(siteMux)
+
+	if server.options.EnableBasicAuth {
+		log.Printf("Using Basic Authentication")
+		siteHandler = server.wrapBasicAuth(siteHandler, server.options.Credential)
+	}
+
+	withGz := gziphandler.GzipHandler(server.wrapHeaders(siteHandler))
+	siteHandler = server.wrapLogger(withGz)
+
+	wsMux := http.NewServeMux()
+	wsMux.Handle("/", siteHandler)
+	wsMux.HandleFunc(pathPrefix+"ws", server.generateHandleWS(ctx, cancel, counter))
+	siteHandler = http.Handler(wsMux)
+
+	return siteHandler
+}
+
+func (server *Server) setupHTTPServer(handler http.Handler) (*http.Server, error) {
+	srv := &http.Server{
+		Handler: handler,
+	}
+
+	if server.options.EnableTLSClientAuth {
+		tlsConfig, err := server.tlsConfig()
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to setup TLS configuration")
+		}
+		srv.TLSConfig = tlsConfig
+	}
+
+	return srv, nil
+}
+
+func (server *Server) tlsConfig() (*tls.Config, error) {
+	caFile := homedir.Expand(server.options.TLSCACrtFile)
+	caCert, err := ioutil.ReadFile(caFile)
+	if err != nil {
+		return nil, errors.New("could not open CA crt file " + caFile)
+	}
+	caCertPool := x509.NewCertPool()
+	if !caCertPool.AppendCertsFromPEM(caCert) {
+		return nil, errors.New("could not parse CA crt file data in " + caFile)
+	}
+	tlsConfig := &tls.Config{
+		ClientCAs:  caCertPool,
+		ClientAuth: tls.RequireAndVerifyClientCert,
+	}
+	return tlsConfig, nil
+}

server/slave.go

@@ -0,0 +1,17 @@
+package server
+
+import (
+	"github.com/yudai/gotty/webtty"
+)
+
+// Slave is webtty.Slave with some additional methods.
+type Slave interface {
+	webtty.Slave
+
+	Close() error
+}
+
+type Factory interface {
+	Name() string
+	New(params map[string][]string) (Slave, error)
+}

server/ws_wrapper.go

@@ -0,0 +1,33 @@
+package server
+
+import (
+	"github.com/gorilla/websocket"
+)
+
+type wsWrapper struct {
+	*websocket.Conn
+}
+
+func (wsw *wsWrapper) Write(p []byte) (n int, err error) {
+	writer, err := wsw.Conn.NextWriter(websocket.TextMessage)
+	if err != nil {
+		return 0, err
+	}
+	defer writer.Close()
+	return writer.Write(p)
+}
+
+func (wsw *wsWrapper) Read(p []byte) (n int, err error) {
+	for {
+		msgType, reader, err := wsw.Conn.NextReader()
+		if err != nil {
+			return 0, err
+		}
+
+		if msgType != websocket.TextMessage {
+			continue
+		}
+
+		return reader.Read(p)
+	}
+}

utils/default.go

@@ -0,0 +1,41 @@
+package utils
+
+import (
+	"fmt"
+	"github.com/fatih/structs"
+	"reflect"
+	"strconv"
+)
+
+func ApplyDefaultValues(struct_ interface{}) (err error) {
+	o := structs.New(struct_)
+
+	for _, field := range o.Fields() {
+		defaultValue := field.Tag("default")
+		if defaultValue == "" {
+			continue
+		}
+		var val interface{}
+		switch field.Kind() {
+		case reflect.String:
+			val = defaultValue
+		case reflect.Bool:
+			if defaultValue == "true" {
+				val = true
+			} else if defaultValue == "false" {
+				val = false
+			} else {
+				return fmt.Errorf("invalid bool expression: %v, use true/false", defaultValue)
+			}
+		case reflect.Int:
+			val, err = strconv.Atoi(defaultValue)
+			if err != nil {
+				return err
+			}
+		default:
+			val = field.Value()
+		}
+		field.Set(val)
+	}
+	return nil
+}

utils/flags.go

@@ -0,0 +1,124 @@
+package utils
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"strings"
+
+	"github.com/codegangsta/cli"
+	"github.com/fatih/structs"
+	"github.com/yudai/hcl"
+
+	"github.com/yudai/gotty/pkg/homedir"
+)
+
+func GenerateFlags(options ...interface{}) (flags []cli.Flag, mappings map[string]string, err error) {
+	mappings = make(map[string]string)
+
+	for _, struct_ := range options {
+		o := structs.New(struct_)
+		for _, field := range o.Fields() {
+			flagName := field.Tag("flagName")
+			if flagName == "" {
+				continue
+			}
+			envName := "GOTTY_" + strings.ToUpper(strings.Join(strings.Split(flagName, "-"), "_"))
+			mappings[flagName] = field.Name()
+
+			flagShortName := field.Tag("flagSName")
+			if flagShortName != "" {
+				flagName += ", " + flagShortName
+			}
+
+			flagDescription := field.Tag("flagDescribe")
+
+			switch field.Kind() {
+			case reflect.String:
+				flags = append(flags, cli.StringFlag{
+					Name:   flagName,
+					Value:  field.Value().(string),
+					Usage:  flagDescription,
+					EnvVar: envName,
+				})
+			case reflect.Bool:
+				flags = append(flags, cli.BoolFlag{
+					Name:   flagName,
+					Usage:  flagDescription,
+					EnvVar: envName,
+				})
+			case reflect.Int:
+				flags = append(flags, cli.IntFlag{
+					Name:   flagName,
+					Value:  field.Value().(int),
+					Usage:  flagDescription,
+					EnvVar: envName,
+				})
+			}
+		}
+	}
+
+	return
+}
+
+func ApplyFlags(
+	flags []cli.Flag,
+	mappingHint map[string]string,
+	c *cli.Context,
+	options ...interface{},
+) {
+	objects := make([]*structs.Struct, len(options))
+	for i, struct_ := range options {
+		objects[i] = structs.New(struct_)
+	}
+
+	for flagName, fieldName := range mappingHint {
+		if !c.IsSet(flagName) {
+			continue
+		}
+		var field *structs.Field
+		var ok bool
+		for _, o := range objects {
+			field, ok = o.FieldOk(fieldName)
+			if ok {
+				break
+			}
+		}
+		if field == nil {
+			continue
+		}
+		var val interface{}
+		switch field.Kind() {
+		case reflect.String:
+			val = c.String(flagName)
+		case reflect.Bool:
+			val = c.Bool(flagName)
+		case reflect.Int:
+			val = c.Int(flagName)
+		}
+		field.Set(val)
+	}
+}
+
+func ApplyConfigFile(filePath string, options ...interface{}) error {
+	filePath = homedir.Expand(filePath)
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		return err
+	}
+
+	fileString := []byte{}
+	log.Printf("Loading config file at: %s", filePath)
+	fileString, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return err
+	}
+
+	for _, object := range options {
+		if err := hcl.Decode(object, string(fileString)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

vendor/github.com/NYTimes/gziphandler/.gitignore

@@ -0,0 +1 @@
+*.swp

vendor/github.com/NYTimes/gziphandler/.travis.yml

@@ -0,0 +1,6 @@
+language: go
+
+go:
+  - 1.7
+  - 1.8
+  - tip

vendor/github.com/NYTimes/gziphandler/CODE_OF_CONDUCT.md

@@ -0,0 +1,75 @@
+---
+layout: code-of-conduct
+version: v1.0
+---
+
+This code of conduct outlines our expectations for participants within the **NYTimes/gziphandler** community, as well as steps to reporting unacceptable behavior. We are committed to providing a welcoming and inspiring community for all and expect our code of conduct to be honored. Anyone who violates this code of conduct may be banned from the community.
+
+Our open source community strives to:
+
+* **Be friendly and patient.**
+* **Be welcoming**: We strive to be a community that welcomes and supports people of all backgrounds and identities. This includes, but is not limited to members of any race, ethnicity, culture, national origin, colour, immigration status, social and economic class, educational level, sex, sexual orientation, gender identity and expression, age, size, family status, political belief, religion, and mental and physical ability.
+* **Be considerate**: Your work will be used by other people, and you in turn will depend on the work of others. Any decision you take will affect users and colleagues, and you should take those consequences into account when making decisions. Remember that we're a world-wide community, so you might not be communicating in someone else's primary language.
+* **Be respectful**:  Not all of us will agree all the time, but disagreement is no excuse for poor behavior and poor manners. We might all experience some frustration now and then, but we cannot allow that frustration to turn into a personal attack. It’s important to remember that a community where people feel uncomfortable or threatened is not a productive one.
+* **Be careful in the words that we choose**: we are a community of professionals, and we conduct ourselves professionally. Be kind to others. Do not insult or put down other participants. Harassment and other exclusionary behavior aren't acceptable.
+* **Try to understand why we disagree**: Disagreements, both social and technical, happen all the time. It is important that we resolve disagreements and differing views constructively. Remember that we’re different. The strength of our community comes from its diversity, people from a wide range of backgrounds. Different people have different perspectives on issues. Being unable to understand why someone holds a viewpoint doesn’t mean that they’re wrong. Don’t forget that it is human to err and blaming each other doesn’t get us anywhere. Instead, focus on helping to resolve issues and learning from mistakes.
+
+## Definitions
+
+Harassment includes, but is not limited to:
+
+- Offensive comments related to gender, gender identity and expression, sexual orientation, disability, mental illness, neuro(a)typicality, physical appearance, body size, race, age, regional discrimination, political or religious affiliation
+- Unwelcome comments regarding a person’s lifestyle choices and practices, including those related to food, health, parenting, drugs, and employment
+- Deliberate misgendering. This includes deadnaming or persistently using a pronoun that does not correctly reflect a person's gender identity. You must address people by the name they give you when not addressing them by their username or handle
+- Physical contact and simulated physical contact (eg, textual descriptions like “*hug*” or “*backrub*”) without consent or after a request to stop
+- Threats of violence, both physical and psychological
+- Incitement of violence towards any individual, including encouraging a person to commit suicide or to engage in self-harm
+- Deliberate intimidation
+- Stalking or following
+- Harassing photography or recording, including logging online activity for harassment purposes
+- Sustained disruption of discussion
+- Unwelcome sexual attention, including gratuitous or off-topic sexual images or behaviour
+- Pattern of inappropriate social contact, such as requesting/assuming inappropriate levels of intimacy with others
+- Continued one-on-one communication after requests to cease
+- Deliberate “outing” of any aspect of a person’s identity without their consent except as necessary to protect others from intentional abuse
+- Publication of non-harassing private communication
+
+Our open source community prioritizes marginalized people’s safety over privileged people’s comfort. We will not act on complaints regarding:
+
+- ‘Reverse’ -isms, including ‘reverse racism,’ ‘reverse sexism,’ and ‘cisphobia’
+- Reasonable communication of boundaries, such as “leave me alone,” “go away,” or “I’m not discussing this with you”
+- Refusal to explain or debate social justice concepts
+- Communicating in a ‘tone’ you don’t find congenial
+- Criticizing racist, sexist, cissexist, or otherwise oppressive behavior or assumptions
+
+
+### Diversity Statement
+
+We encourage everyone to participate and are committed to building a community for all. Although we will fail at times, we seek to treat everyone both as fairly and equally as possible. Whenever a participant has made a mistake, we expect them to take responsibility for it. If someone has been harmed or offended, it is our responsibility to listen carefully and respectfully, and do our best to right the wrong.
+
+Although this list cannot be exhaustive, we explicitly honor diversity in age, gender, gender identity or expression, culture, ethnicity, language, national origin, political beliefs, profession, race, religion, sexual orientation, socioeconomic status, and technical ability. We will not tolerate discrimination based on any of the protected
+characteristics above, including participants with disabilities.
+
+### Reporting Issues
+
+If you experience or witness unacceptable behavior—or have any other concerns—please report it by contacting us via **code@nytimes.com**. All reports will be handled with discretion. In your report please include:
+
+- Your contact information.
+- Names (real, nicknames, or pseudonyms) of any individuals involved. If there are additional witnesses, please
+include them as well. Your account of what occurred, and if you believe the incident is ongoing. If there is a publicly available record (e.g. a mailing list archive or a public IRC logger), please include a link.
+- Any additional information that may be helpful.
+
+After filing a report, a representative will contact you personally, review the incident, follow up with any additional questions, and make a decision as to how to respond. If the person who is harassing you is part of the response team, they will recuse themselves from handling your incident. If the complaint originates from a member of the response team, it will be handled by a different member of the response team. We will respect confidentiality requests for the purpose of protecting victims of abuse.
+
+### Attribution & Acknowledgements
+
+We all stand on the shoulders of giants across many open source communities.  We'd like to thank the communities and projects that established code of conducts and diversity statements as our inspiration:
+
+* [Django](https://www.djangoproject.com/conduct/reporting/)
+* [Python](https://www.python.org/community/diversity/)
+* [Ubuntu](http://www.ubuntu.com/about/about-ubuntu/conduct)
+* [Contributor Covenant](http://contributor-covenant.org/)
+* [Geek Feminism](http://geekfeminism.org/about/code-of-conduct/)
+* [Citizen Code of Conduct](http://citizencodeofconduct.org/)
+
+This Code of Conduct was based on https://github.com/todogroup/opencodeofconduct

vendor/github.com/NYTimes/gziphandler/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+# Contributing to NYTimes/gziphandler
+
+This is an open source project started by handful of developers at The New York Times and open to the entire Go community.
+
+We really appreciate your help!
+
+## Filing issues
+
+When filing an issue, make sure to answer these five questions:
+
+1. What version of Go are you using (`go version`)?
+2. What operating system and processor architecture are you using?
+3. What did you do?
+4. What did you expect to see?
+5. What did you see instead?
+
+## Contributing code
+
+Before submitting changes, please follow these guidelines:
+
+1. Check the open issues and pull requests for existing discussions.
+2. Open an issue to discuss a new feature.
+3. Write tests.
+4. Make sure code follows the ['Go Code Review Comments'](https://github.com/golang/go/wiki/CodeReviewComments).
+5. Make sure your changes pass `go test`.
+6. Make sure the entire test suite passes locally and on Travis CI.
+7. Open a Pull Request.
+8. [Squash your commits](http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html) after receiving feedback and add a [great commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+
+Unless otherwise noted, the gziphandler source files are distributed under the Apache 2.0-style license found in the LICENSE.md file.

vendor/github.com/NYTimes/gziphandler/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright (c) 2015 The New York Times Company
+ 
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this library except in compliance with the License.
+You may obtain a copy of the License at
+ 
+    http://www.apache.org/licenses/LICENSE-2.0
+ 
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/github.com/NYTimes/gziphandler/README.md

@@ -0,0 +1,52 @@
+Gzip Handler
+============
+
+This is a tiny Go package which wraps HTTP handlers to transparently gzip the
+response body, for clients which support it. Although it's usually simpler to
+leave that to a reverse proxy (like nginx or Varnish), this package is useful
+when that's undesirable.
+
+
+## Usage
+
+Call `GzipHandler` with any handler (an object which implements the
+`http.Handler` interface), and it'll return a new handler which gzips the
+response. For example:
+
+```go
+package main
+
+import (
+	"io"
+	"net/http"
+	"github.com/NYTimes/gziphandler"
+)
+
+func main() {
+	withoutGz := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain")
+		io.WriteString(w, "Hello, World")
+	})
+
+	withGz := gziphandler.GzipHandler(withoutGz)
+
+	http.Handle("/", withGz)
+	http.ListenAndServe("0.0.0.0:8000", nil)
+}
+```
+
+
+## Documentation
+
+The docs can be found at [godoc.org][docs], as usual.
+
+
+## License
+
+[Apache 2.0][license].
+
+
+
+
+[docs]:     https://godoc.org/github.com/nytimes/gziphandler
+[license]:  https://github.com/nytimes/gziphandler/blob/master/LICENSE.md

vendor/github.com/NYTimes/gziphandler/gzip.go

@@ -0,0 +1,407 @@
+package gziphandler
+
+import (
+	"bufio"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+const (
+	vary            = "Vary"
+	acceptEncoding  = "Accept-Encoding"
+	contentEncoding = "Content-Encoding"
+	contentType     = "Content-Type"
+	contentLength   = "Content-Length"
+)
+
+type codings map[string]float64
+
+const (
+	// DefaultQValue is the default qvalue to assign to an encoding if no explicit qvalue is set.
+	// This is actually kind of ambiguous in RFC 2616, so hopefully it's correct.
+	// The examples seem to indicate that it is.
+	DefaultQValue = 1.0
+
+	// DefaultMinSize defines the minimum size to reach to enable compression.
+	// It's 512 bytes.
+	DefaultMinSize = 512
+)
+
+// gzipWriterPools stores a sync.Pool for each compression level for reuse of
+// gzip.Writers. Use poolIndex to covert a compression level to an index into
+// gzipWriterPools.
+var gzipWriterPools [gzip.BestCompression - gzip.BestSpeed + 2]*sync.Pool
+
+func init() {
+	for i := gzip.BestSpeed; i <= gzip.BestCompression; i++ {
+		addLevelPool(i)
+	}
+	addLevelPool(gzip.DefaultCompression)
+}
+
+// poolIndex maps a compression level to its index into gzipWriterPools. It
+// assumes that level is a valid gzip compression level.
+func poolIndex(level int) int {
+	// gzip.DefaultCompression == -1, so we need to treat it special.
+	if level == gzip.DefaultCompression {
+		return gzip.BestCompression - gzip.BestSpeed + 1
+	}
+	return level - gzip.BestSpeed
+}
+
+func addLevelPool(level int) {
+	gzipWriterPools[poolIndex(level)] = &sync.Pool{
+		New: func() interface{} {
+			// NewWriterLevel only returns error on a bad level, we are guaranteeing
+			// that this will be a valid level so it is okay to ignore the returned
+			// error.
+			w, _ := gzip.NewWriterLevel(nil, level)
+			return w
+		},
+	}
+}
+
+// GzipResponseWriter provides an http.ResponseWriter interface, which gzips
+// bytes before writing them to the underlying response. This doesn't close the
+// writers, so don't forget to do that.
+// It can be configured to skip response smaller than minSize.
+type GzipResponseWriter struct {
+	http.ResponseWriter
+	index int // Index for gzipWriterPools.
+	gw    *gzip.Writer
+
+	code int // Saves the WriteHeader value.
+
+	minSize int    // Specifed the minimum response size to gzip. If the response length is bigger than this value, it is compressed.
+	buf     []byte // Holds the first part of the write before reaching the minSize or the end of the write.
+
+	contentTypes []string // Only compress if the response is one of these content-types. All are accepted if empty.
+}
+
+// Write appends data to the gzip writer.
+func (w *GzipResponseWriter) Write(b []byte) (int, error) {
+	// If content type is not set.
+	if _, ok := w.Header()[contentType]; !ok {
+		// It infer it from the uncompressed body.
+		w.Header().Set(contentType, http.DetectContentType(b))
+	}
+
+	// GZIP responseWriter is initialized. Use the GZIP responseWriter.
+	if w.gw != nil {
+		n, err := w.gw.Write(b)
+		return n, err
+	}
+
+	// Save the write into a buffer for later use in GZIP responseWriter (if content is long enough) or at close with regular responseWriter.
+	// On the first write, w.buf changes from nil to a valid slice
+	w.buf = append(w.buf, b...)
+
+	// If the global writes are bigger than the minSize and we're about to write
+	// a response containing a content type we want to handle, enable
+	// compression.
+	if len(w.buf) >= w.minSize && handleContentType(w.contentTypes, w) {
+		err := w.startGzip()
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	return len(b), nil
+}
+
+// startGzip initialize any GZIP specific informations.
+func (w *GzipResponseWriter) startGzip() error {
+
+	// Set the GZIP header.
+	w.Header().Set(contentEncoding, "gzip")
+
+	// if the Content-Length is already set, then calls to Write on gzip
+	// will fail to set the Content-Length header since its already set
+	// See: https://github.com/golang/go/issues/14975.
+	w.Header().Del(contentLength)
+
+	// Write the header to gzip response.
+	if w.code != 0 {
+		w.ResponseWriter.WriteHeader(w.code)
+	}
+
+	// Initialize the GZIP response.
+	w.init()
+
+	// Flush the buffer into the gzip reponse.
+	n, err := w.gw.Write(w.buf)
+
+	// This should never happen (per io.Writer docs), but if the write didn't
+	// accept the entire buffer but returned no specific error, we have no clue
+	// what's going on, so abort just to be safe.
+	if err == nil && n < len(w.buf) {
+		return io.ErrShortWrite
+	}
+
+	w.buf = nil
+	return err
+}
+
+// WriteHeader just saves the response code until close or GZIP effective writes.
+func (w *GzipResponseWriter) WriteHeader(code int) {
+	w.code = code
+}
+
+// init graps a new gzip writer from the gzipWriterPool and writes the correct
+// content encoding header.
+func (w *GzipResponseWriter) init() {
+	// Bytes written during ServeHTTP are redirected to this gzip writer
+	// before being written to the underlying response.
+	gzw := gzipWriterPools[w.index].Get().(*gzip.Writer)
+	gzw.Reset(w.ResponseWriter)
+	w.gw = gzw
+}
+
+// Close will close the gzip.Writer and will put it back in the gzipWriterPool.
+func (w *GzipResponseWriter) Close() error {
+	if w.gw == nil {
+		// Gzip not trigged yet, write out regular response.
+		if w.code != 0 {
+			w.ResponseWriter.WriteHeader(w.code)
+		}
+		if w.buf != nil {
+			_, writeErr := w.ResponseWriter.Write(w.buf)
+			// Returns the error if any at write.
+			if writeErr != nil {
+				return fmt.Errorf("gziphandler: write to regular responseWriter at close gets error: %q", writeErr.Error())
+			}
+		}
+		return nil
+	}
+
+	err := w.gw.Close()
+	gzipWriterPools[w.index].Put(w.gw)
+	w.gw = nil
+	return err
+}
+
+// Flush flushes the underlying *gzip.Writer and then the underlying
+// http.ResponseWriter if it is an http.Flusher. This makes GzipResponseWriter
+// an http.Flusher.
+func (w *GzipResponseWriter) Flush() {
+	if w.gw != nil {
+		w.gw.Flush()
+	}
+
+	if fw, ok := w.ResponseWriter.(http.Flusher); ok {
+		fw.Flush()
+	}
+}
+
+// Hijack implements http.Hijacker. If the underlying ResponseWriter is a
+// Hijacker, its Hijack method is returned. Otherwise an error is returned.
+func (w *GzipResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	if hj, ok := w.ResponseWriter.(http.Hijacker); ok {
+		return hj.Hijack()
+	}
+	return nil, nil, fmt.Errorf("http.Hijacker interface is not supported")
+}
+
+// verify Hijacker interface implementation
+var _ http.Hijacker = &GzipResponseWriter{}
+
+// MustNewGzipLevelHandler behaves just like NewGzipLevelHandler except that in
+// an error case it panics rather than returning an error.
+func MustNewGzipLevelHandler(level int) func(http.Handler) http.Handler {
+	wrap, err := NewGzipLevelHandler(level)
+	if err != nil {
+		panic(err)
+	}
+	return wrap
+}
+
+// NewGzipLevelHandler returns a wrapper function (often known as middleware)
+// which can be used to wrap an HTTP handler to transparently gzip the response
+// body if the client supports it (via the Accept-Encoding header). Responses will
+// be encoded at the given gzip compression level. An error will be returned only
+// if an invalid gzip compression level is given, so if one can ensure the level
+// is valid, the returned error can be safely ignored.
+func NewGzipLevelHandler(level int) (func(http.Handler) http.Handler, error) {
+	return NewGzipLevelAndMinSize(level, DefaultMinSize)
+}
+
+// NewGzipLevelAndMinSize behave as NewGzipLevelHandler except it let the caller
+// specify the minimum size before compression.
+func NewGzipLevelAndMinSize(level, minSize int) (func(http.Handler) http.Handler, error) {
+	return GzipHandlerWithOpts(CompressionLevel(level), MinSize(minSize))
+}
+
+func GzipHandlerWithOpts(opts ...option) (func(http.Handler) http.Handler, error) {
+	c := &config{
+		level:   gzip.DefaultCompression,
+		minSize: DefaultMinSize,
+	}
+
+	for _, o := range opts {
+		o(c)
+	}
+
+	if err := c.validate(); err != nil {
+		return nil, err
+	}
+
+	return func(h http.Handler) http.Handler {
+		index := poolIndex(c.level)
+
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Add(vary, acceptEncoding)
+
+			if acceptsGzip(r) {
+				gw := &GzipResponseWriter{
+					ResponseWriter: w,
+					index:          index,
+					minSize:        c.minSize,
+					contentTypes:   c.contentTypes,
+				}
+				defer gw.Close()
+
+				h.ServeHTTP(gw, r)
+			} else {
+				h.ServeHTTP(w, r)
+			}
+		})
+	}, nil
+}
+
+// Used for functional configuration.
+type config struct {
+	minSize      int
+	level        int
+	contentTypes []string
+}
+
+func (c *config) validate() error {
+	if c.level != gzip.DefaultCompression && (c.level < gzip.BestSpeed || c.level > gzip.BestCompression) {
+		return fmt.Errorf("invalid compression level requested: %d", c.level)
+	}
+
+	if c.minSize < 0 {
+		return fmt.Errorf("minimum size must be more than zero")
+	}
+
+	return nil
+}
+
+type option func(c *config)
+
+func MinSize(size int) option {
+	return func(c *config) {
+		c.minSize = size
+	}
+}
+
+func CompressionLevel(level int) option {
+	return func(c *config) {
+		c.level = level
+	}
+}
+
+func ContentTypes(types []string) option {
+	return func(c *config) {
+		c.contentTypes = []string{}
+		for _, v := range types {
+			c.contentTypes = append(c.contentTypes, strings.ToLower(v))
+		}
+	}
+}
+
+// GzipHandler wraps an HTTP handler, to transparently gzip the response body if
+// the client supports it (via the Accept-Encoding header). This will compress at
+// the default compression level.
+func GzipHandler(h http.Handler) http.Handler {
+	wrapper, _ := NewGzipLevelHandler(gzip.DefaultCompression)
+	return wrapper(h)
+}
+
+// acceptsGzip returns true if the given HTTP request indicates that it will
+// accept a gzipped response.
+func acceptsGzip(r *http.Request) bool {
+	acceptedEncodings, _ := parseEncodings(r.Header.Get(acceptEncoding))
+	return acceptedEncodings["gzip"] > 0.0
+}
+
+// returns true if we've been configured to compress the specific content type.
+func handleContentType(contentTypes []string, w http.ResponseWriter) bool {
+	// If contentTypes is empty we handle all content types.
+	if len(contentTypes) == 0 {
+		return true
+	}
+
+	ct := strings.ToLower(w.Header().Get(contentType))
+	for _, c := range contentTypes {
+		if c == ct {
+			return true
+		}
+	}
+
+	return false
+}
+
+// parseEncodings attempts to parse a list of codings, per RFC 2616, as might
+// appear in an Accept-Encoding header. It returns a map of content-codings to
+// quality values, and an error containing the errors encountered. It's probably
+// safe to ignore those, because silently ignoring errors is how the internet
+// works.
+//
+// See: http://tools.ietf.org/html/rfc2616#section-14.3.
+func parseEncodings(s string) (codings, error) {
+	c := make(codings)
+	var e []string
+
+	for _, ss := range strings.Split(s, ",") {
+		coding, qvalue, err := parseCoding(ss)
+
+		if err != nil {
+			e = append(e, err.Error())
+		} else {
+			c[coding] = qvalue
+		}
+	}
+
+	// TODO (adammck): Use a proper multi-error struct, so the individual errors
+	//                 can be extracted if anyone cares.
+	if len(e) > 0 {
+		return c, fmt.Errorf("errors while parsing encodings: %s", strings.Join(e, ", "))
+	}
+
+	return c, nil
+}
+
+// parseCoding parses a single conding (content-coding with an optional qvalue),
+// as might appear in an Accept-Encoding header. It attempts to forgive minor
+// formatting errors.
+func parseCoding(s string) (coding string, qvalue float64, err error) {
+	for n, part := range strings.Split(s, ";") {
+		part = strings.TrimSpace(part)
+		qvalue = DefaultQValue
+
+		if n == 0 {
+			coding = strings.ToLower(part)
+		} else if strings.HasPrefix(part, "q=") {
+			qvalue, err = strconv.ParseFloat(strings.TrimPrefix(part, "q="), 64)
+
+			if qvalue < 0.0 {
+				qvalue = 0.0
+			} else if qvalue > 1.0 {
+				qvalue = 1.0
+			}
+		}
+	}
+
+	if coding == "" {
+		err = fmt.Errorf("empty content-coding")
+	}
+
+	return
+}

vendor/github.com/NYTimes/gziphandler/gzip_go18.go

@@ -0,0 +1,43 @@
+// +build go1.8
+
+package gziphandler
+
+import "net/http"
+
+// Push initiates an HTTP/2 server push.
+// Push returns ErrNotSupported if the client has disabled push or if push
+// is not supported on the underlying connection.
+func (w *GzipResponseWriter) Push(target string, opts *http.PushOptions) error {
+	pusher, ok := w.ResponseWriter.(http.Pusher)
+	if ok && pusher != nil {
+		return pusher.Push(target, setAcceptEncodingForPushOptions(opts))
+	}
+	return http.ErrNotSupported
+}
+
+// setAcceptEncodingForPushOptions sets "Accept-Encoding" : "gzip" for PushOptions without overriding existing headers.
+func setAcceptEncodingForPushOptions(opts *http.PushOptions) *http.PushOptions {
+
+	if opts == nil {
+		opts = &http.PushOptions{
+			Header: http.Header{
+				acceptEncoding: []string{"gzip"},
+			},
+		}
+		return opts
+	}
+
+	if opts.Header == nil {
+		opts.Header = http.Header{
+			acceptEncoding: []string{"gzip"},
+		}
+		return opts
+	}
+
+	if encoding := opts.Header.Get(acceptEncoding); encoding == "" {
+		opts.Header.Add(acceptEncoding, "gzip")
+		return opts
+	}
+
+	return opts
+}

vendor/github.com/braintree/manners/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2014 Braintree, a division of PayPal, Inc.
-
-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.

vendor/github.com/braintree/manners/README.md

@@ -1,36 +0,0 @@
-# Manners
-
-A *polite* webserver for Go.
-
-Manners allows you to shut your Go webserver down gracefully, without dropping any requests. It can act as a drop-in replacement for the standard library's http.ListenAndServe function:
-
-```go
-func main() {
-  handler := MyHTTPHandler()
-  manners.ListenAndServe(":7000", handler)
-}
-```
-
-Then, when you want to shut the server down:
-
-```go
-manners.Close()
-```
-
-(Note that this does not block until all the requests are finished. Rather, the call to manners.ListenAndServe will stop blocking when all the requests are finished.)
-
-Manners ensures that all requests are served by incrementing a WaitGroup when a request comes in and decrementing it when the request finishes.
-
-If your request handler spawns Goroutines that are not guaranteed to finish with the request, you can ensure they are also completed with the `StartRoutine` and `FinishRoutine` functions on the server.
-
-### Known Issues
-
-Manners does not correctly shut down long-lived keepalive connections when issued a shutdown command. Clients on an idle keepalive connection may see a connection reset error rather than a close. See https://github.com/braintree/manners/issues/13 for details.
-
-### Compatability
-
-Manners 0.3.0 and above uses standard library functionality introduced in Go 1.3.
-
-### Installation
-
-`go get github.com/braintree/manners`

vendor/github.com/braintree/manners/interfaces.go

@@ -1,7 +0,0 @@
-package manners
-
-type waitGroup interface {
-	Add(int)
-	Done()
-	Wait()
-}

vendor/github.com/braintree/manners/server.go

@@ -1,228 +0,0 @@
-/*
-Package manners provides a wrapper for a standard net/http server that
-ensures all active HTTP client have completed their current request
-before the server shuts down.
-
-It can be used a drop-in replacement for the standard http package,
-or can wrap a pre-configured Server.
-
-eg.
-
-	http.Handle("/hello", func(w http.ResponseWriter, r *http.Request) {
-	  w.Write([]byte("Hello\n"))
-	})
-
-	log.Fatal(manners.ListenAndServe(":8080", nil))
-
-or for a customized server:
-
-	s := manners.NewWithServer(&http.Server{
-		Addr:           ":8080",
-		Handler:        myHandler,
-		ReadTimeout:    10 * time.Second,
-		WriteTimeout:   10 * time.Second,
-		MaxHeaderBytes: 1 << 20,
-	})
-	log.Fatal(s.ListenAndServe())
-
-The server will shut down cleanly when the Close() method is called:
-
-	go func() {
-		sigchan := make(chan os.Signal, 1)
-		signal.Notify(sigchan, os.Interrupt, os.Kill)
-		<-sigchan
-		log.Info("Shutting down...")
-		manners.Close()
-	}()
-
-	http.Handle("/hello", myHandler)
-	log.Fatal(manners.ListenAndServe(":8080", nil))
-*/
-package manners
-
-import (
-	"crypto/tls"
-	"net"
-	"net/http"
-	"sync"
-	"sync/atomic"
-)
-
-// A GracefulServer maintains a WaitGroup that counts how many in-flight
-// requests the server is handling. When it receives a shutdown signal,
-// it stops accepting new requests but does not actually shut down until
-// all in-flight requests terminate.
-//
-// GracefulServer embeds the underlying net/http.Server making its non-override
-// methods and properties avaiable.
-//
-// It must be initialized by calling NewWithServer.
-type GracefulServer struct {
-	*http.Server
-
-	shutdown chan bool
-	wg       waitGroup
-
-	lcsmu         sync.RWMutex
-	lastConnState map[net.Conn]http.ConnState
-
-	up chan net.Listener // Only used by test code.
-}
-
-// NewWithServer wraps an existing http.Server object and returns a
-// GracefulServer that supports all of the original Server operations.
-func NewWithServer(s *http.Server) *GracefulServer {
-	return &GracefulServer{
-		Server:        s,
-		shutdown:      make(chan bool),
-		wg:            new(sync.WaitGroup),
-		lastConnState: make(map[net.Conn]http.ConnState),
-	}
-}
-
-// Close stops the server from accepting new requets and begins shutting down.
-// It returns true if it's the first time Close is called.
-func (s *GracefulServer) Close() bool {
-	return <-s.shutdown
-}
-
-// ListenAndServe provides a graceful equivalent of net/http.Serve.ListenAndServe.
-func (s *GracefulServer) ListenAndServe() error {
-	addr := s.Addr
-	if addr == "" {
-		addr = ":http"
-	}
-	listener, err := net.Listen("tcp", addr)
-	if err != nil {
-		return err
-	}
-
-	return s.Serve(listener)
-}
-
-// ListenAndServeTLS provides a graceful equivalent of net/http.Serve.ListenAndServeTLS.
-func (s *GracefulServer) ListenAndServeTLS(certFile, keyFile string) error {
-	// direct lift from net/http/server.go
-	addr := s.Addr
-	if addr == "" {
-		addr = ":https"
-	}
-	config := &tls.Config{}
-	if s.TLSConfig != nil {
-		*config = *s.TLSConfig
-	}
-	if config.NextProtos == nil {
-		config.NextProtos = []string{"http/1.1"}
-	}
-
-	var err error
-	config.Certificates = make([]tls.Certificate, 1)
-	config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
-	if err != nil {
-		return err
-	}
-
-	ln, err := net.Listen("tcp", addr)
-	if err != nil {
-		return err
-	}
-
-	return s.Serve(tls.NewListener(ln, config))
-}
-
-// Serve provides a graceful equivalent net/http.Server.Serve.
-func (s *GracefulServer) Serve(listener net.Listener) error {
-	var closing int32
-
-	go func() {
-		s.shutdown <- true
-		close(s.shutdown)
-		atomic.StoreInt32(&closing, 1)
-		s.Server.SetKeepAlivesEnabled(false)
-		listener.Close()
-	}()
-
-	originalConnState := s.Server.ConnState
-
-	// s.ConnState is invoked by the net/http.Server every time a connectiion
-	// changes state. It keeps track of each connection's state over time,
-	// enabling manners to handle persisted connections correctly.
-	s.ConnState = func(conn net.Conn, newState http.ConnState) {
-		s.lcsmu.RLock()
-		lastConnState := s.lastConnState[conn]
-		s.lcsmu.RUnlock()
-
-		switch newState {
-
-		// New connection -> StateNew
-		case http.StateNew:
-			s.StartRoutine()
-
-			// (StateNew, StateIdle) -> StateActive
-		case http.StateActive:
-			// The connection transitioned from idle back to active
-			if lastConnState == http.StateIdle {
-				s.StartRoutine()
-			}
-
-			// StateActive -> StateIdle
-			// Immediately close newly idle connections; if not they may make
-			// one more request before SetKeepAliveEnabled(false) takes effect.
-		case http.StateIdle:
-			if atomic.LoadInt32(&closing) == 1 {
-				conn.Close()
-			}
-			s.FinishRoutine()
-
-			// (StateNew, StateActive, StateIdle) -> (StateClosed, StateHiJacked)
-			// If the connection was idle we do not need to decrement the counter.
-		case http.StateClosed, http.StateHijacked:
-			if lastConnState != http.StateIdle {
-				s.FinishRoutine()
-			}
-
-		}
-
-		s.lcsmu.Lock()
-		if newState == http.StateClosed || newState == http.StateHijacked {
-			delete(s.lastConnState, conn)
-		} else {
-			s.lastConnState[conn] = newState
-		}
-		s.lcsmu.Unlock()
-
-		if originalConnState != nil {
-			originalConnState(conn, newState)
-		}
-	}
-
-	// A hook to allow the server to notify others when it is ready to receive
-	// requests; only used by tests.
-	if s.up != nil {
-		s.up <- listener
-	}
-
-	err := s.Server.Serve(listener)
-
-	// This block is reached when the server has received a shut down command
-	// or a real error happened.
-	if err == nil || atomic.LoadInt32(&closing) == 1 {
-		s.wg.Wait()
-		return nil
-	}
-
-	return err
-}
-
-// StartRoutine increments the server's WaitGroup. Use this if a web request
-// starts more goroutines and these goroutines are not guaranteed to finish
-// before the request.
-func (s *GracefulServer) StartRoutine() {
-	s.wg.Add(1)
-}
-
-// FinishRoutine decrements the server's WaitGroup. Use this to complement
-// StartRoutine().
-func (s *GracefulServer) FinishRoutine() {
-	s.wg.Done()
-}

vendor/github.com/braintree/manners/static.go

@@ -1,35 +0,0 @@
-package manners
-
-import (
-	"net"
-	"net/http"
-)
-
-var defaultServer *GracefulServer
-
-// ListenAndServe provides a graceful version of the function provided by the
-// net/http package. Call Close() to stop the server.
-func ListenAndServe(addr string, handler http.Handler) error {
-	defaultServer = NewWithServer(&http.Server{Addr: addr, Handler: handler})
-	return defaultServer.ListenAndServe()
-}
-
-// ListenAndServeTLS provides a graceful version of the function provided by the
-// net/http package. Call Close() to stop the server.
-func ListenAndServeTLS(addr string, certFile string, keyFile string, handler http.Handler) error {
-	defaultServer = NewWithServer(&http.Server{Addr: addr, Handler: handler})
-	return defaultServer.ListenAndServeTLS(certFile, keyFile)
-}
-
-// Serve provides a graceful version of the function provided by the net/http
-// package. Call Close() to stop the server.
-func Serve(l net.Listener, handler http.Handler) error {
-	defaultServer = NewWithServer(&http.Server{Handler: handler})
-	return defaultServer.Serve(l)
-}
-
-// Shuts down the default server used by ListenAndServe, ListenAndServeTLS and
-// Serve. It returns true if it's the first time Close is called.
-func Close() bool {
-	return defaultServer.Close()
-}

vendor/github.com/codegangsta/cli/.gitignore

@@ -0,0 +1,2 @@
+*.coverprofile
+node_modules/

vendor/github.com/codegangsta/cli/.travis.yml

@@ -1,13 +1,39 @@
 language: go
+
 sudo: false
 
+cache:
+  directories:
+  - node_modules
+
 go:
-- 1.0.3
-- 1.1.2
-- 1.2.2
-- 1.3.3
+- 1.2.x
+- 1.3.x
 - 1.4.2
+- 1.5.x
+- 1.6.x
+- 1.7.x
+- master
+
+matrix:
+  allow_failures:
+  - go: master
+  include:
+  - go: 1.6.x
+    os: osx
+  - go: 1.7.x
+    os: osx
+
+before_script:
+- go get github.com/urfave/gfmrun/... || true
+- go get golang.org/x/tools/... || true
+- if [ ! -f node_modules/.bin/markdown-toc ] ; then
+    npm install markdown-toc ;
+  fi
 
 script:
-- go vet ./...
-- go test -v ./...
+- ./runtests gen
+- ./runtests vet
+- ./runtests test
+- ./runtests gfmrun
+- ./runtests toc

vendor/github.com/codegangsta/cli/CHANGELOG.md

@@ -0,0 +1,392 @@
+# Change Log
+
+**ATTN**: This project uses [semantic versioning](http://semver.org/).
+
+## [Unreleased]
+
+## [1.19.1] - 2016-11-21
+
+### Fixed
+
+- Fixes regression introduced in 1.19.0 where using an `ActionFunc` as
+  the `Action` for a command would cause it to error rather than calling the
+  function. Should not have a affected declarative cases using `func(c
+  *cli.Context) err)`.
+- Shell completion now handles the case where the user specifies
+  `--generate-bash-completion` immediately after a flag that takes an argument.
+  Previously it call the application with `--generate-bash-completion` as the
+  flag value.
+
+## [1.19.0] - 2016-11-19
+### Added
+- `FlagsByName` was added to make it easy to sort flags (e.g. `sort.Sort(cli.FlagsByName(app.Flags))`)
+- A `Description` field was added to `App` for a more detailed description of
+  the application (similar to the existing `Description` field on `Command`)
+- Flag type code generation via `go generate`
+- Write to stderr and exit 1 if action returns non-nil error
+- Added support for TOML to the `altsrc` loader
+- `SkipArgReorder` was added to allow users to skip the argument reordering.
+  This is useful if you want to consider all "flags" after an argument as
+  arguments rather than flags (the default behavior of the stdlib `flag`
+  library). This is backported functionality from the [removal of the flag
+  reordering](https://github.com/urfave/cli/pull/398) in the unreleased version
+  2
+- For formatted errors (those implementing `ErrorFormatter`), the errors will
+  be formatted during output. Compatible with `pkg/errors`.
+
+### Changed
+- Raise minimum tested/supported Go version to 1.2+
+
+### Fixed
+- Consider empty environment variables as set (previously environment variables
+  with the equivalent of `""` would be skipped rather than their value used).
+- Return an error if the value in a given environment variable cannot be parsed
+  as the flag type. Previously these errors were silently swallowed.
+- Print full error when an invalid flag is specified (which includes the invalid flag)
+- `App.Writer` defaults to `stdout` when `nil`
+- If no action is specified on a command or app, the help is now printed instead of `panic`ing
+- `App.Metadata` is initialized automatically now (previously was `nil` unless initialized)
+- Correctly show help message if `-h` is provided to a subcommand
+- `context.(Global)IsSet` now respects environment variables. Previously it
+  would return `false` if a flag was specified in the environment rather than
+  as an argument
+- Removed deprecation warnings to STDERR to avoid them leaking to the end-user
+- `altsrc`s import paths were updated to use `gopkg.in/urfave/cli.v1`. This
+  fixes issues that occurred when `gopkg.in/urfave/cli.v1` was imported as well
+  as `altsrc` where Go would complain that the types didn't match
+
+## [1.18.1] - 2016-08-28
+### Fixed
+- Removed deprecation warnings to STDERR to avoid them leaking to the end-user (backported)
+
+## [1.18.0] - 2016-06-27
+### Added
+- `./runtests` test runner with coverage tracking by default
+- testing on OS X
+- testing on Windows
+- `UintFlag`, `Uint64Flag`, and `Int64Flag` types and supporting code
+
+### Changed
+- Use spaces for alignment in help/usage output instead of tabs, making the
+  output alignment consistent regardless of tab width
+
+### Fixed
+- Printing of command aliases in help text
+- Printing of visible flags for both struct and struct pointer flags
+- Display the `help` subcommand when using `CommandCategories`
+- No longer swallows `panic`s that occur within the `Action`s themselves when
+  detecting the signature of the `Action` field
+
+## [1.17.1] - 2016-08-28
+### Fixed
+- Removed deprecation warnings to STDERR to avoid them leaking to the end-user
+
+## [1.17.0] - 2016-05-09
+### Added
+- Pluggable flag-level help text rendering via `cli.DefaultFlagStringFunc`
+- `context.GlobalBoolT` was added as an analogue to `context.GlobalBool`
+- Support for hiding commands by setting `Hidden: true` -- this will hide the
+  commands in help output
+
+### Changed
+- `Float64Flag`, `IntFlag`, and `DurationFlag` default values are no longer
+  quoted in help text output.
+- All flag types now include `(default: {value})` strings following usage when a
+  default value can be (reasonably) detected.
+- `IntSliceFlag` and `StringSliceFlag` usage strings are now more consistent
+  with non-slice flag types
+- Apps now exit with a code of 3 if an unknown subcommand is specified
+  (previously they printed "No help topic for...", but still exited 0. This
+  makes it easier to script around apps built using `cli` since they can trust
+  that a 0 exit code indicated a successful execution.
+- cleanups based on [Go Report Card
+  feedback](https://goreportcard.com/report/github.com/urfave/cli)
+
+## [1.16.1] - 2016-08-28
+### Fixed
+- Removed deprecation warnings to STDERR to avoid them leaking to the end-user
+
+## [1.16.0] - 2016-05-02
+### Added
+- `Hidden` field on all flag struct types to omit from generated help text
+
+### Changed
+- `BashCompletionFlag` (`--enable-bash-completion`) is now omitted from
+generated help text via the `Hidden` field
+
+### Fixed
+- handling of error values in `HandleAction` and `HandleExitCoder`
+
+## [1.15.0] - 2016-04-30
+### Added
+- This file!
+- Support for placeholders in flag usage strings
+- `App.Metadata` map for arbitrary data/state management
+- `Set` and `GlobalSet` methods on `*cli.Context` for altering values after
+parsing.
+- Support for nested lookup of dot-delimited keys in structures loaded from
+YAML.
+
+### Changed
+- The `App.Action` and `Command.Action` now prefer a return signature of
+`func(*cli.Context) error`, as defined by `cli.ActionFunc`.  If a non-nil
+`error` is returned, there may be two outcomes:
+    - If the error fulfills `cli.ExitCoder`, then `os.Exit` will be called
+    automatically
+    - Else the error is bubbled up and returned from `App.Run`
+- Specifying an `Action` with the legacy return signature of
+`func(*cli.Context)` will produce a deprecation message to stderr
+- Specifying an `Action` that is not a `func` type will produce a non-zero exit
+from `App.Run`
+- Specifying an `Action` func that has an invalid (input) signature will
+produce a non-zero exit from `App.Run`
+
+### Deprecated
+- <a name="deprecated-cli-app-runandexitonerror"></a>
+`cli.App.RunAndExitOnError`, which should now be done by returning an error
+that fulfills `cli.ExitCoder` to `cli.App.Run`.
+- <a name="deprecated-cli-app-action-signature"></a> the legacy signature for
+`cli.App.Action` of `func(*cli.Context)`, which should now have a return
+signature of `func(*cli.Context) error`, as defined by `cli.ActionFunc`.
+
+### Fixed
+- Added missing `*cli.Context.GlobalFloat64` method
+
+## [1.14.0] - 2016-04-03 (backfilled 2016-04-25)
+### Added
+- Codebeat badge
+- Support for categorization via `CategorizedHelp` and `Categories` on app.
+
+### Changed
+- Use `filepath.Base` instead of `path.Base` in `Name` and `HelpName`.
+
+### Fixed
+- Ensure version is not shown in help text when `HideVersion` set.
+
+## [1.13.0] - 2016-03-06 (backfilled 2016-04-25)
+### Added
+- YAML file input support.
+- `NArg` method on context.
+
+## [1.12.0] - 2016-02-17 (backfilled 2016-04-25)
+### Added
+- Custom usage error handling.
+- Custom text support in `USAGE` section of help output.
+- Improved help messages for empty strings.
+- AppVeyor CI configuration.
+
+### Changed
+- Removed `panic` from default help printer func.
+- De-duping and optimizations.
+
+### Fixed
+- Correctly handle `Before`/`After` at command level when no subcommands.
+- Case of literal `-` argument causing flag reordering.
+- Environment variable hints on Windows.
+- Docs updates.
+
+## [1.11.1] - 2015-12-21 (backfilled 2016-04-25)
+### Changed
+- Use `path.Base` in `Name` and `HelpName`
+- Export `GetName` on flag types.
+
+### Fixed
+- Flag parsing when skipping is enabled.
+- Test output cleanup.
+- Move completion check to account for empty input case.
+
+## [1.11.0] - 2015-11-15 (backfilled 2016-04-25)
+### Added
+- Destination scan support for flags.
+- Testing against `tip` in Travis CI config.
+
+### Changed
+- Go version in Travis CI config.
+
+### Fixed
+- Removed redundant tests.
+- Use correct example naming in tests.
+
+## [1.10.2] - 2015-10-29 (backfilled 2016-04-25)
+### Fixed
+- Remove unused var in bash completion.
+
+## [1.10.1] - 2015-10-21 (backfilled 2016-04-25)
+### Added
+- Coverage and reference logos in README.
+
+### Fixed
+- Use specified values in help and version parsing.
+- Only display app version and help message once.
+
+## [1.10.0] - 2015-10-06 (backfilled 2016-04-25)
+### Added
+- More tests for existing functionality.
+- `ArgsUsage` at app and command level for help text flexibility.
+
+### Fixed
+- Honor `HideHelp` and `HideVersion` in `App.Run`.
+- Remove juvenile word from README.
+
+## [1.9.0] - 2015-09-08 (backfilled 2016-04-25)
+### Added
+- `FullName` on command with accompanying help output update.
+- Set default `$PROG` in bash completion.
+
+### Changed
+- Docs formatting.
+
+### Fixed
+- Removed self-referential imports in tests.
+
+## [1.8.0] - 2015-06-30 (backfilled 2016-04-25)
+### Added
+- Support for `Copyright` at app level.
+- `Parent` func at context level to walk up context lineage.
+
+### Fixed
+- Global flag processing at top level.
+
+## [1.7.1] - 2015-06-11 (backfilled 2016-04-25)
+### Added
+- Aggregate errors from `Before`/`After` funcs.
+- Doc comments on flag structs.
+- Include non-global flags when checking version and help.
+- Travis CI config updates.
+
+### Fixed
+- Ensure slice type flags have non-nil values.
+- Collect global flags from the full command hierarchy.
+- Docs prose.
+
+## [1.7.0] - 2015-05-03 (backfilled 2016-04-25)
+### Changed
+- `HelpPrinter` signature includes output writer.
+
+### Fixed
+- Specify go 1.1+ in docs.
+- Set `Writer` when running command as app.
+
+## [1.6.0] - 2015-03-23 (backfilled 2016-04-25)
+### Added
+- Multiple author support.
+- `NumFlags` at context level.
+- `Aliases` at command level.
+
+### Deprecated
+- `ShortName` at command level.
+
+### Fixed
+- Subcommand help output.
+- Backward compatible support for deprecated `Author` and `Email` fields.
+- Docs regarding `Names`/`Aliases`.
+
+## [1.5.0] - 2015-02-20 (backfilled 2016-04-25)
+### Added
+- `After` hook func support at app and command level.
+
+### Fixed
+- Use parsed context when running command as subcommand.
+- Docs prose.
+
+## [1.4.1] - 2015-01-09 (backfilled 2016-04-25)
+### Added
+- Support for hiding `-h / --help` flags, but not `help` subcommand.
+- Stop flag parsing after `--`.
+
+### Fixed
+- Help text for generic flags to specify single value.
+- Use double quotes in output for defaults.
+- Use `ParseInt` instead of `ParseUint` for int environment var values.
+- Use `0` as base when parsing int environment var values.
+
+## [1.4.0] - 2014-12-12 (backfilled 2016-04-25)
+### Added
+- Support for environment variable lookup "cascade".
+- Support for `Stdout` on app for output redirection.
+
+### Fixed
+- Print command help instead of app help in `ShowCommandHelp`.
+
+## [1.3.1] - 2014-11-13 (backfilled 2016-04-25)
+### Added
+- Docs and example code updates.
+
+### Changed
+- Default `-v / --version` flag made optional.
+
+## [1.3.0] - 2014-08-10 (backfilled 2016-04-25)
+### Added
+- `FlagNames` at context level.
+- Exposed `VersionPrinter` var for more control over version output.
+- Zsh completion hook.
+- `AUTHOR` section in default app help template.
+- Contribution guidelines.
+- `DurationFlag` type.
+
+## [1.2.0] - 2014-08-02
+### Added
+- Support for environment variable defaults on flags plus tests.
+
+## [1.1.0] - 2014-07-15
+### Added
+- Bash completion.
+- Optional hiding of built-in help command.
+- Optional skipping of flag parsing at command level.
+- `Author`, `Email`, and `Compiled` metadata on app.
+- `Before` hook func support at app and command level.
+- `CommandNotFound` func support at app level.
+- Command reference available on context.
+- `GenericFlag` type.
+- `Float64Flag` type.
+- `BoolTFlag` type.
+- `IsSet` flag helper on context.
+- More flag lookup funcs at context level.
+- More tests &amp; docs.
+
+### Changed
+- Help template updates to account for presence/absence of flags.
+- Separated subcommand help template.
+- Exposed `HelpPrinter` var for more control over help output.
+
+## [1.0.0] - 2013-11-01
+### Added
+- `help` flag in default app flag set and each command flag set.
+- Custom handling of argument parsing errors.
+- Command lookup by name at app level.
+- `StringSliceFlag` type and supporting `StringSlice` type.
+- `IntSliceFlag` type and supporting `IntSlice` type.
+- Slice type flag lookups by name at context level.
+- Export of app and command help functions.
+- More tests &amp; docs.
+
+## 0.1.0 - 2013-07-22
+### Added
+- Initial implementation.
+
+[Unreleased]: https://github.com/urfave/cli/compare/v1.18.0...HEAD
+[1.18.0]: https://github.com/urfave/cli/compare/v1.17.0...v1.18.0
+[1.17.0]: https://github.com/urfave/cli/compare/v1.16.0...v1.17.0
+[1.16.0]: https://github.com/urfave/cli/compare/v1.15.0...v1.16.0
+[1.15.0]: https://github.com/urfave/cli/compare/v1.14.0...v1.15.0
+[1.14.0]: https://github.com/urfave/cli/compare/v1.13.0...v1.14.0
+[1.13.0]: https://github.com/urfave/cli/compare/v1.12.0...v1.13.0
+[1.12.0]: https://github.com/urfave/cli/compare/v1.11.1...v1.12.0
+[1.11.1]: https://github.com/urfave/cli/compare/v1.11.0...v1.11.1
+[1.11.0]: https://github.com/urfave/cli/compare/v1.10.2...v1.11.0
+[1.10.2]: https://github.com/urfave/cli/compare/v1.10.1...v1.10.2
+[1.10.1]: https://github.com/urfave/cli/compare/v1.10.0...v1.10.1
+[1.10.0]: https://github.com/urfave/cli/compare/v1.9.0...v1.10.0
+[1.9.0]: https://github.com/urfave/cli/compare/v1.8.0...v1.9.0
+[1.8.0]: https://github.com/urfave/cli/compare/v1.7.1...v1.8.0
+[1.7.1]: https://github.com/urfave/cli/compare/v1.7.0...v1.7.1
+[1.7.0]: https://github.com/urfave/cli/compare/v1.6.0...v1.7.0
+[1.6.0]: https://github.com/urfave/cli/compare/v1.5.0...v1.6.0
+[1.5.0]: https://github.com/urfave/cli/compare/v1.4.1...v1.5.0
+[1.4.1]: https://github.com/urfave/cli/compare/v1.4.0...v1.4.1
+[1.4.0]: https://github.com/urfave/cli/compare/v1.3.1...v1.4.0
+[1.3.1]: https://github.com/urfave/cli/compare/v1.3.0...v1.3.1
+[1.3.0]: https://github.com/urfave/cli/compare/v1.2.0...v1.3.0
+[1.2.0]: https://github.com/urfave/cli/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/urfave/cli/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/urfave/cli/compare/v0.1.0...v1.0.0

vendor/github.com/codegangsta/cli/LICENSE

@@ -1,21 +1,21 @@
-Copyright (C) 2013 Jeremy Saenz
-All Rights Reserved.
+MIT License
 
-MIT LICENSE
+Copyright (c) 2016 Jeremy Saenz & Contributors
 
-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:
+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.
+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.

vendor/github.com/codegangsta/cli/app.go

@@ -5,18 +5,40 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
+	"path/filepath"
+	"sort"
 	"time"
 )
 
-// App is the main structure of a cli application. It is recomended that
+var (
+	changeLogURL                    = "https://github.com/urfave/cli/blob/master/CHANGELOG.md"
+	appActionDeprecationURL         = fmt.Sprintf("%s#deprecated-cli-app-action-signature", changeLogURL)
+	runAndExitOnErrorDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-runandexitonerror", changeLogURL)
+
+	contactSysadmin = "This is an error in the application.  Please contact the distributor of this application if this is not you."
+
+	errInvalidActionType = NewExitError("ERROR invalid Action type. "+
+		fmt.Sprintf("Must be `func(*Context`)` or `func(*Context) error).  %s", contactSysadmin)+
+		fmt.Sprintf("See %s", appActionDeprecationURL), 2)
+)
+
+// App is the main structure of a cli application. It is recommended that
 // an app be created with the cli.NewApp() function
 type App struct {
-	// The name of the program. Defaults to os.Args[0]
+	// The name of the program. Defaults to path.Base(os.Args[0])
 	Name string
+	// Full name of command for help, defaults to Name
+	HelpName string
 	// Description of the program.
 	Usage string
+	// Text to override the USAGE section of help
+	UsageText string
+	// Description of the program argument format.
+	ArgsUsage string
 	// Version of the program
 	Version string
+	// Description of the program
+	Description string
 	// List of commands to execute
 	Commands []Command
 	// List of flags to parse
@@ -25,20 +47,28 @@ type App struct {
 	EnableBashCompletion bool
 	// Boolean to hide built-in help command
 	HideHelp bool
-	// Boolean to hide built-in version flag
+	// Boolean to hide built-in version flag and the VERSION section of help
 	HideVersion bool
+	// Populate on app startup, only gettable through method Categories()
+	categories CommandCategories
 	// An action to execute when the bash-completion flag is set
-	BashComplete func(context *Context)
+	BashComplete BashCompleteFunc
 	// 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
+	Before BeforeFunc
 	// 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
+	After AfterFunc
+
 	// The action to execute when no subcommands are specified
-	Action func(context *Context)
+	// Expects a `cli.ActionFunc` but will accept the *deprecated* signature of `func(*cli.Context) {}`
+	// *Note*: support for the deprecated `Action` signature will be removed in a future version
+	Action interface{}
+
 	// Execute this function if the proper command cannot be found
-	CommandNotFound func(context *Context, command string)
+	CommandNotFound CommandNotFoundFunc
+	// Execute this function if an usage error occurs
+	OnUsageError OnUsageErrorFunc
 	// Compilation date
 	Compiled time.Time
 	// List of all authors who contributed
@@ -51,6 +81,12 @@ type App struct {
 	Email string
 	// Writer writer to write output to
 	Writer io.Writer
+	// ErrWriter writes error output
+	ErrWriter io.Writer
+	// Other custom info
+	Metadata map[string]interface{}
+
+	didSetup bool
 }
 
 // Tries to find out when this binary was compiled.
@@ -63,11 +99,14 @@ func compileTime() time.Time {
 	return info.ModTime()
 }
 
-// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
+// NewApp creates a new cli Application with some reasonable defaults for Name,
+// Usage, Version and Action.
 func NewApp() *App {
 	return &App{
-		Name:         os.Args[0],
+		Name:         filepath.Base(os.Args[0]),
+		HelpName:     filepath.Base(os.Args[0]),
 		Usage:        "A new cli application",
+		UsageText:    "",
 		Version:      "0.0.0",
 		BashComplete: DefaultAppComplete,
 		Action:       helpCommand.Action,
@@ -76,13 +115,29 @@ func NewApp() *App {
 	}
 }
 
-// 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) {
+// Setup runs initialization code to ensure all data structures are ready for
+// `Run` or inspection prior to `Run`.  It is internally called by `Run`, but
+// will return early if setup has already happened.
+func (a *App) Setup() {
+	if a.didSetup {
+		return
+	}
+
+	a.didSetup = true
+
 	if a.Author != "" || a.Email != "" {
 		a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email})
 	}
 
-	// append help to commands
+	newCmds := []Command{}
+	for _, c := range a.Commands {
+		if c.HelpName == "" {
+			c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
+		}
+		newCmds = append(newCmds, c)
+	}
+	a.Commands = newCmds
+
 	if a.Command(helpCommand.Name) == nil && !a.HideHelp {
 		a.Commands = append(a.Commands, helpCommand)
 		if (HelpFlag != BoolFlag{}) {
@@ -90,51 +145,83 @@ func (a *App) Run(arguments []string) (err error) {
 		}
 	}
 
-	//append version/help flags
-	if a.EnableBashCompletion {
-		a.appendFlag(BashCompletionFlag)
-	}
-
 	if !a.HideVersion {
 		a.appendFlag(VersionFlag)
 	}
 
+	a.categories = CommandCategories{}
+	for _, command := range a.Commands {
+		a.categories = a.categories.AddCommand(command.Category, command)
+	}
+	sort.Sort(a.categories)
+
+	if a.Metadata == nil {
+		a.Metadata = make(map[string]interface{})
+	}
+
+	if a.Writer == nil {
+		a.Writer = os.Stdout
+	}
+}
+
+// Run is the 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) {
+	a.Setup()
+
+	// handle the completion flag separately from the flagset since
+	// completion could be attempted after a flag, but before its value was put
+	// on the command line. this causes the flagset to interpret the completion
+	// flag name as the value of the flag before it which is undesirable
+	// note that we can only do this because the shell autocomplete function
+	// always appends the completion flag at the end of the command
+	shellComplete, arguments := checkShellCompleteFlag(a, arguments)
+
 	// parse flags
-	set := flagSet(a.Name, a.Flags)
+	set, err := flagSet(a.Name, a.Flags)
+	if err != nil {
+		return err
+	}
+
 	set.SetOutput(ioutil.Discard)
 	err = set.Parse(arguments[1:])
 	nerr := normalizeFlags(a.Flags, set)
+	context := NewContext(a, set, nil)
 	if nerr != nil {
 		fmt.Fprintln(a.Writer, nerr)
-		context := NewContext(a, set, nil)
 		ShowAppHelp(context)
 		return nerr
 	}
-	context := NewContext(a, set, nil)
-
-	if err != nil {
-		fmt.Fprintln(a.Writer, "Incorrect Usage.")
-		fmt.Fprintln(a.Writer)
-		ShowAppHelp(context)
-		return err
-	}
+	context.shellComplete = shellComplete
 
 	if checkCompletions(context) {
 		return nil
 	}
 
-	if checkHelp(context) {
+	if err != nil {
+		if a.OnUsageError != nil {
+			err := a.OnUsageError(context, err, false)
+			HandleExitCoder(err)
+			return err
+		}
+		fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
+		ShowAppHelp(context)
+		return err
+	}
+
+	if !a.HideHelp && checkHelp(context) {
+		ShowAppHelp(context)
 		return nil
 	}
 
-	if checkVersion(context) {
+	if !a.HideVersion && checkVersion(context) {
+		ShowVersion(context)
 		return nil
 	}
 
 	if a.After != nil {
 		defer func() {
-			afterErr := a.After(context)
-			if afterErr != nil {
+			if afterErr := a.After(context); afterErr != nil {
 				if err != nil {
 					err = NewMultiError(err, afterErr)
 				} else {
@@ -145,8 +232,12 @@ func (a *App) Run(arguments []string) (err error) {
 	}
 
 	if a.Before != nil {
-		err := a.Before(context)
-		if err != nil {
+		beforeErr := a.Before(context)
+		if beforeErr != nil {
+			fmt.Fprintf(a.Writer, "%v\n\n", beforeErr)
+			ShowAppHelp(context)
+			HandleExitCoder(beforeErr)
+			err = beforeErr
 			return err
 		}
 	}
@@ -160,20 +251,31 @@ func (a *App) Run(arguments []string) (err error) {
 		}
 	}
 
+	if a.Action == nil {
+		a.Action = helpCommand.Action
+	}
+
 	// Run default Action
-	a.Action(context)
-	return nil
+	err = HandleAction(a.Action, context)
+
+	HandleExitCoder(err)
+	return err
 }
 
-// Another entry point to the cli app, takes care of passing arguments and error handling
+// RunAndExitOnError calls .Run() and exits non-zero if an error was returned
+//
+// Deprecated: instead you should return an error that fulfills cli.ExitCoder
+// to cli.App.Run. This will cause the application to exit with the given eror
+// code in the cli.ExitCoder
 func (a *App) RunAndExitOnError() {
 	if err := a.Run(os.Args); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
+		fmt.Fprintln(a.errWriter(), err)
+		OsExiter(1)
 	}
 }
 
-// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
+// RunAsSubcommand 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 {
@@ -185,13 +287,21 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 		}
 	}
 
-	// append flags
-	if a.EnableBashCompletion {
-		a.appendFlag(BashCompletionFlag)
+	newCmds := []Command{}
+	for _, c := range a.Commands {
+		if c.HelpName == "" {
+			c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
+		}
+		newCmds = append(newCmds, c)
 	}
+	a.Commands = newCmds
 
 	// parse flags
-	set := flagSet(a.Name, a.Flags)
+	set, err := flagSet(a.Name, a.Flags)
+	if err != nil {
+		return err
+	}
+
 	set.SetOutput(ioutil.Discard)
 	err = set.Parse(ctx.Args().Tail())
 	nerr := normalizeFlags(a.Flags, set)
@@ -208,17 +318,21 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 		return nerr
 	}
 
-	if err != nil {
-		fmt.Fprintln(a.Writer, "Incorrect Usage.")
-		fmt.Fprintln(a.Writer)
-		ShowSubcommandHelp(context)
-		return err
-	}
-
 	if checkCompletions(context) {
 		return nil
 	}
 
+	if err != nil {
+		if a.OnUsageError != nil {
+			err = a.OnUsageError(context, err, true)
+			HandleExitCoder(err)
+			return err
+		}
+		fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
+		ShowSubcommandHelp(context)
+		return err
+	}
+
 	if len(a.Commands) > 0 {
 		if checkSubcommandHelp(context) {
 			return nil
@@ -233,6 +347,7 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 		defer func() {
 			afterErr := a.After(context)
 			if afterErr != nil {
+				HandleExitCoder(err)
 				if err != nil {
 					err = NewMultiError(err, afterErr)
 				} else {
@@ -243,8 +358,10 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 	}
 
 	if a.Before != nil {
-		err := a.Before(context)
-		if err != nil {
+		beforeErr := a.Before(context)
+		if beforeErr != nil {
+			HandleExitCoder(beforeErr)
+			err = beforeErr
 			return err
 		}
 	}
@@ -259,12 +376,13 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 	}
 
 	// Run default Action
-	a.Action(context)
+	err = HandleAction(a.Action, context)
 
-	return nil
+	HandleExitCoder(err)
+	return err
 }
 
-// Returns the named command on App. Returns nil if the command does not exist
+// Command 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) {
@@ -275,6 +393,46 @@ func (a *App) Command(name string) *Command {
 	return nil
 }
 
+// Categories returns a slice containing all the categories with the commands they contain
+func (a *App) Categories() CommandCategories {
+	return a.categories
+}
+
+// VisibleCategories returns a slice of categories and commands that are
+// Hidden=false
+func (a *App) VisibleCategories() []*CommandCategory {
+	ret := []*CommandCategory{}
+	for _, category := range a.categories {
+		if visible := func() *CommandCategory {
+			for _, command := range category.Commands {
+				if !command.Hidden {
+					return category
+				}
+			}
+			return nil
+		}(); visible != nil {
+			ret = append(ret, visible)
+		}
+	}
+	return ret
+}
+
+// VisibleCommands returns a slice of the Commands with Hidden=false
+func (a *App) VisibleCommands() []Command {
+	ret := []Command{}
+	for _, command := range a.Commands {
+		if !command.Hidden {
+			ret = append(ret, command)
+		}
+	}
+	return ret
+}
+
+// VisibleFlags returns a slice of the Flags with Hidden=false
+func (a *App) VisibleFlags() []Flag {
+	return visibleFlags(a.Flags)
+}
+
 func (a *App) hasFlag(flag Flag) bool {
 	for _, f := range a.Flags {
 		if flag == f {
@@ -285,6 +443,16 @@ func (a *App) hasFlag(flag Flag) bool {
 	return false
 }
 
+func (a *App) errWriter() io.Writer {
+
+	// When the app ErrWriter is nil use the package level one.
+	if a.ErrWriter == nil {
+		return ErrWriter
+	}
+
+	return a.ErrWriter
+}
+
 func (a *App) appendFlag(flag Flag) {
 	if !a.hasFlag(flag) {
 		a.Flags = append(a.Flags, flag)
@@ -301,8 +469,24 @@ type Author struct {
 func (a Author) String() string {
 	e := ""
 	if a.Email != "" {
-		e = "<" + a.Email + "> "
+		e = " <" + a.Email + ">"
 	}
 
-	return fmt.Sprintf("%v %v", a.Name, e)
+	return fmt.Sprintf("%v%v", a.Name, e)
+}
+
+// HandleAction attempts to figure out which Action signature was used.  If
+// it's an ActionFunc or a func with the legacy signature for Action, the func
+// is run!
+func HandleAction(action interface{}, context *Context) (err error) {
+	if a, ok := action.(ActionFunc); ok {
+		return a(context)
+	} else if a, ok := action.(func(*Context) error); ok {
+		return a(context)
+	} else if a, ok := action.(func(*Context)); ok { // deprecated function signature
+		a(context)
+		return nil
+	} else {
+		return errInvalidActionType
+	}
 }

vendor/github.com/codegangsta/cli/appveyor.yml

@@ -0,0 +1,24 @@
+version: "{build}"
+
+os: Windows Server 2012 R2
+
+clone_folder: c:\gopath\src\github.com\urfave\cli
+
+environment:
+  GOPATH: C:\gopath
+  GOVERSION: 1.6
+  PYTHON: C:\Python27-x64
+  PYTHON_VERSION: 2.7.x
+  PYTHON_ARCH: 64
+
+install:
+- set PATH=%GOPATH%\bin;C:\go\bin;%PATH%
+- go version
+- go env
+- go get github.com/urfave/gfmrun/...
+- go get -v -t ./...
+
+build_script:
+- python runtests vet
+- python runtests test
+- python runtests gfmrun

vendor/github.com/codegangsta/cli/category.go

@@ -0,0 +1,44 @@
+package cli
+
+// CommandCategories is a slice of *CommandCategory.
+type CommandCategories []*CommandCategory
+
+// CommandCategory is a category containing commands.
+type CommandCategory struct {
+	Name     string
+	Commands Commands
+}
+
+func (c CommandCategories) Less(i, j int) bool {
+	return c[i].Name < c[j].Name
+}
+
+func (c CommandCategories) Len() int {
+	return len(c)
+}
+
+func (c CommandCategories) Swap(i, j int) {
+	c[i], c[j] = c[j], c[i]
+}
+
+// AddCommand adds a command to a category.
+func (c CommandCategories) AddCommand(category string, command Command) CommandCategories {
+	for _, commandCategory := range c {
+		if commandCategory.Name == category {
+			commandCategory.Commands = append(commandCategory.Commands, command)
+			return c
+		}
+	}
+	return append(c, &CommandCategory{Name: category, Commands: []Command{command}})
+}
+
+// VisibleCommands returns a slice of the Commands with Hidden=false
+func (c *CommandCategory) VisibleCommands() []Command {
+	ret := []Command{}
+	for _, command := range c.Commands {
+		if !command.Hidden {
+			ret = append(ret, command)
+		}
+	}
+	return ret
+}

vendor/github.com/codegangsta/cli/cli.go

@@ -10,7 +10,7 @@
 //     app := cli.NewApp()
 //     app.Name = "greet"
 //     app.Usage = "say a greeting"
-//     app.Action = func(c *cli.Context) {
+//     app.Action = func(c *cli.Context) error {
 //       println("Greetings")
 //     }
 //
@@ -18,23 +18,4 @@
 //   }
 package cli
 
-import (
-	"strings"
-)
-
-type MultiError struct {
-	Errors []error
-}
-
-func NewMultiError(err ...error) MultiError {
-	return MultiError{Errors: err}
-}
-
-func (m MultiError) Error() string {
-	errs := make([]string, len(m.Errors))
-	for i, err := range m.Errors {
-		errs[i] = err.Error()
-	}
-
-	return strings.Join(errs, "\n")
-}
+//go:generate python ./generate-flag-types cli -i flag-types.json -o flag_generated.go

vendor/github.com/codegangsta/cli/command.go

@@ -3,6 +3,7 @@ package cli
 import (
 	"fmt"
 	"io/ioutil"
+	"sort"
 	"strings"
 )
 
@@ -16,31 +17,51 @@ type Command struct {
 	Aliases []string
 	// A short description of the usage of this command
 	Usage string
+	// Custom text to show on USAGE section of help
+	UsageText string
 	// A longer explanation of how the command works
 	Description string
+	// A short description of the arguments of this command
+	ArgsUsage string
+	// The category the command is part of
+	Category string
 	// The function to call when checking for bash command completions
-	BashComplete func(context *Context)
+	BashComplete BashCompleteFunc
 	// 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
+	Before BeforeFunc
 	// 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
+	After AfterFunc
 	// The function to call when this command is invoked
-	Action func(context *Context)
+	Action interface{}
+	// TODO: replace `Action: interface{}` with `Action: ActionFunc` once some kind
+	// of deprecation period has passed, maybe?
+
+	// Execute this function if a usage error occurs.
+	OnUsageError OnUsageErrorFunc
 	// List of child commands
-	Subcommands []Command
+	Subcommands Commands
 	// List of flags to parse
 	Flags []Flag
 	// Treat all flags as normal arguments if true
 	SkipFlagParsing bool
+	// Skip argument reordering which attempts to move flags before arguments,
+	// but only works if all flags appear after all arguments. This behavior was
+	// removed n version 2 since it only works under specific conditions so we
+	// backport here by exposing it as an option for compatibility.
+	SkipArgReorder bool
 	// Boolean to hide built-in help command
 	HideHelp bool
+	// Boolean to hide this command from help or completion
+	Hidden bool
 
+	// Full name of command for help, defaults to full command name, including parent commands.
+	HelpName        string
 	commandNamePath []string
 }
 
-// Returns the full name of the command.
+// FullName returns the full name of the command.
 // For subcommands this ensures that parent commands are part of the command path
 func (c Command) FullName() string {
 	if c.commandNamePath == nil {
@@ -49,9 +70,12 @@ func (c Command) FullName() string {
 	return strings.Join(c.commandNamePath, " ")
 }
 
-// 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 {
+// Commands is a slice of Command
+type Commands []Command
+
+// Run invokes the command given the context, parses ctx.Args() to generate command-specific flags
+func (c Command) Run(ctx *Context) (err error) {
+	if len(c.Subcommands) > 0 {
 		return c.startApp(ctx)
 	}
 
@@ -63,50 +87,50 @@ func (c Command) Run(ctx *Context) error {
 		)
 	}
 
-	if ctx.App.EnableBashCompletion {
-		c.Flags = append(c.Flags, BashCompletionFlag)
+	set, err := flagSet(c.Name, c.Flags)
+	if err != nil {
+		return err
 	}
-
-	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
+	if c.SkipFlagParsing {
+		err = set.Parse(append([]string{"--"}, ctx.Args().Tail()...))
+	} else if !c.SkipArgReorder {
+		firstFlagIndex := -1
+		terminatorIndex := -1
+		for index, arg := range ctx.Args() {
+			if arg == "--" {
+				terminatorIndex = index
+				break
+			} else if arg == "-" {
+				// Do nothing. A dash alone is not really a flag.
+				continue
+			} 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])
+		if firstFlagIndex > -1 {
+			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:]...)
+			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 {
-			flagArgs = args[firstFlagIndex:]
+			err = set.Parse(ctx.Args().Tail())
 		}
-
-		err = set.Parse(append(flagArgs, regularArgs...))
 	} else {
 		err = set.Parse(ctx.Args().Tail())
 	}
 
-	if err != nil {
-		fmt.Fprintln(ctx.App.Writer, "Incorrect Usage.")
-		fmt.Fprintln(ctx.App.Writer)
-		ShowCommandHelp(ctx, c.Name)
-		return err
-	}
-
 	nerr := normalizeFlags(c.Flags, set)
 	if nerr != nil {
 		fmt.Fprintln(ctx.App.Writer, nerr)
@@ -114,20 +138,67 @@ func (c Command) Run(ctx *Context) error {
 		ShowCommandHelp(ctx, c.Name)
 		return nerr
 	}
-	context := NewContext(ctx.App, set, ctx)
 
+	context := NewContext(ctx.App, set, ctx)
 	if checkCommandCompletions(context, c.Name) {
 		return nil
 	}
 
+	if err != nil {
+		if c.OnUsageError != nil {
+			err := c.OnUsageError(ctx, err, false)
+			HandleExitCoder(err)
+			return err
+		}
+		fmt.Fprintln(ctx.App.Writer, "Incorrect Usage:", err.Error())
+		fmt.Fprintln(ctx.App.Writer)
+		ShowCommandHelp(ctx, c.Name)
+		return err
+	}
+
 	if checkCommandHelp(context, c.Name) {
 		return nil
 	}
+
+	if c.After != nil {
+		defer func() {
+			afterErr := c.After(context)
+			if afterErr != nil {
+				HandleExitCoder(err)
+				if err != nil {
+					err = NewMultiError(err, afterErr)
+				} else {
+					err = afterErr
+				}
+			}
+		}()
+	}
+
+	if c.Before != nil {
+		err = c.Before(context)
+		if err != nil {
+			fmt.Fprintln(ctx.App.Writer, err)
+			fmt.Fprintln(ctx.App.Writer)
+			ShowCommandHelp(ctx, c.Name)
+			HandleExitCoder(err)
+			return err
+		}
+	}
+
+	if c.Action == nil {
+		c.Action = helpSubcommand.Action
+	}
+
 	context.Command = c
-	c.Action(context)
-	return nil
+	err = HandleAction(c.Action, context)
+
+	if err != nil {
+		HandleExitCoder(err)
+	}
+	return err
 }
 
+// Names returns the names including short names and aliases.
 func (c Command) Names() []string {
 	names := []string{c.Name}
 
@@ -138,7 +209,7 @@ func (c Command) Names() []string {
 	return append(names, c.Aliases...)
 }
 
-// Returns true if Command.Name or Command.ShortName matches given name
+// HasName 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 {
@@ -150,9 +221,15 @@ func (c Command) HasName(name string) bool {
 
 func (c Command) startApp(ctx *Context) error {
 	app := NewApp()
-
+	app.Metadata = ctx.App.Metadata
 	// set the name and usage
 	app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
+	if c.HelpName == "" {
+		app.HelpName = c.HelpName
+	} else {
+		app.HelpName = app.Name
+	}
+
 	if c.Description != "" {
 		app.Usage = c.Description
 	} else {
@@ -174,6 +251,13 @@ func (c Command) startApp(ctx *Context) error {
 	app.Email = ctx.App.Email
 	app.Writer = ctx.App.Writer
 
+	app.categories = CommandCategories{}
+	for _, command := range c.Subcommands {
+		app.categories = app.categories.AddCommand(command.Category, command)
+	}
+
+	sort.Sort(app.categories)
+
 	// bash completion
 	app.EnableBashCompletion = ctx.App.EnableBashCompletion
 	if c.BashComplete != nil {
@@ -189,12 +273,14 @@ func (c Command) startApp(ctx *Context) error {
 		app.Action = helpSubcommand.Action
 	}
 
-	var newCmds []Command
-	for _, cc := range app.Commands {
-		cc.commandNamePath = []string{c.Name, cc.Name}
-		newCmds = append(newCmds, cc)
+	for index, cc := range app.Commands {
+		app.Commands[index].commandNamePath = []string{c.Name, cc.Name}
 	}
-	app.Commands = newCmds
 
 	return app.RunAsSubcommand(ctx)
 }
+
+// VisibleFlags returns a slice of the Flags with Hidden=false
+func (c Command) VisibleFlags() []Flag {
+	return visibleFlags(c.Flags)
+}

vendor/github.com/codegangsta/cli/context.go

@@ -3,9 +3,9 @@ package cli
 import (
 	"errors"
 	"flag"
-	"strconv"
+	"reflect"
 	"strings"
-	"time"
+	"syscall"
 )
 
 // Context is a type that is passed through to
@@ -13,157 +13,122 @@ import (
 // can be used to retrieve context-specific Args and
 // parsed command-line options.
 type Context struct {
-	App            *App
-	Command        Command
-	flagSet        *flag.FlagSet
-	setFlags       map[string]bool
-	globalSetFlags map[string]bool
-	parentContext  *Context
+	App           *App
+	Command       Command
+	shellComplete bool
+	flagSet       *flag.FlagSet
+	setFlags      map[string]bool
+	parentContext *Context
 }
 
-// Creates a new context. For use in when invoking an App or Command action.
+// NewContext creates a new context. For use in when invoking an App or Command action.
 func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
-	return &Context{App: app, flagSet: set, parentContext: parentCtx}
-}
+	c := &Context{App: app, flagSet: set, parentContext: parentCtx}
 
-// 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 {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupInt(name, fs)
+	if parentCtx != nil {
+		c.shellComplete = parentCtx.shellComplete
 	}
-	return 0
+
+	return c
 }
 
-// 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 {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupDuration(name, fs)
-	}
-	return 0
-}
-
-// Looks up the value of a global bool flag, returns false if no bool flag exists
-func (c *Context) GlobalBool(name string) bool {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupBool(name, fs)
-	}
-	return false
-}
-
-// Looks up the value of a global string flag, returns "" if no string flag exists
-func (c *Context) GlobalString(name string) string {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupString(name, fs)
-	}
-	return ""
-}
-
-// 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 {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupStringSlice(name, fs)
-	}
-	return nil
-}
-
-// 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 {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupIntSlice(name, fs)
-	}
-	return nil
-}
-
-// Looks up the value of a global generic flag, returns nil if no generic flag exists
-func (c *Context) GlobalGeneric(name string) interface{} {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupGeneric(name, fs)
-	}
-	return nil
-}
-
-// Returns the number of flags set
+// NumFlags returns the number of flags set
 func (c *Context) NumFlags() int {
 	return c.flagSet.NFlag()
 }
 
-// Determines if the flag was actually set
+// Set sets a context flag to a value.
+func (c *Context) Set(name, value string) error {
+	return c.flagSet.Set(name, value)
+}
+
+// GlobalSet sets a context flag to a value on the global flagset
+func (c *Context) GlobalSet(name, value string) error {
+	return globalContext(c).flagSet.Set(name, value)
+}
+
+// IsSet 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)
-		ctx := c
-		if ctx.parentContext != nil {
-			ctx = ctx.parentContext
+		c.flagSet.VisitAll(func(f *flag.Flag) {
+			if _, ok := c.setFlags[f.Name]; ok {
+				return
+			}
+			c.setFlags[f.Name] = false
+		})
+
+		// XXX hack to support IsSet for flags with EnvVar
+		//
+		// There isn't an easy way to do this with the current implementation since
+		// whether a flag was set via an environment variable is very difficult to
+		// determine here. Instead, we intend to introduce a backwards incompatible
+		// change in version 2 to add `IsSet` to the Flag interface to push the
+		// responsibility closer to where the information required to determine
+		// whether a flag is set by non-standard means such as environment
+		// variables is avaliable.
+		//
+		// See https://github.com/urfave/cli/issues/294 for additional discussion
+		flags := c.Command.Flags
+		if c.Command.Name == "" { // cannot == Command{} since it contains slice types
+			if c.App != nil {
+				flags = c.App.Flags
+			}
 		}
-		for ; ctx != nil && c.globalSetFlags[name] == false; ctx = ctx.parentContext {
-			ctx.flagSet.Visit(func(f *flag.Flag) {
-				c.globalSetFlags[f.Name] = true
+		for _, f := range flags {
+			eachName(f.GetName(), func(name string) {
+				if isSet, ok := c.setFlags[name]; isSet || !ok {
+					return
+				}
+
+				val := reflect.ValueOf(f)
+				if val.Kind() == reflect.Ptr {
+					val = val.Elem()
+				}
+
+				envVarValue := val.FieldByName("EnvVar")
+				if !envVarValue.IsValid() {
+					return
+				}
+
+				eachName(envVarValue.String(), func(envVar string) {
+					envVar = strings.TrimSpace(envVar)
+					if _, ok := syscall.Getenv(envVar); ok {
+						c.setFlags[name] = true
+						return
+					}
+				})
 			})
 		}
 	}
-	return c.globalSetFlags[name]
+
+	return c.setFlags[name]
 }
 
-// Returns a slice of flag names used in this context.
+// GlobalIsSet determines if the global flag was actually set
+func (c *Context) GlobalIsSet(name string) bool {
+	ctx := c
+	if ctx.parentContext != nil {
+		ctx = ctx.parentContext
+	}
+
+	for ; ctx != nil; ctx = ctx.parentContext {
+		if ctx.IsSet(name) {
+			return true
+		}
+	}
+	return false
+}
+
+// FlagNames 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]
+		name := strings.Split(flag.GetName(), ",")[0]
 		if name == "help" {
 			continue
 		}
@@ -172,10 +137,10 @@ func (c *Context) FlagNames() (names []string) {
 	return
 }
 
-// Returns a slice of global flag names used by the app.
+// GlobalFlagNames 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]
+		name := strings.Split(flag.GetName(), ",")[0]
 		if name == "help" || name == "version" {
 			continue
 		}
@@ -184,20 +149,31 @@ func (c *Context) GlobalFlagNames() (names []string) {
 	return
 }
 
-// Returns the parent context, if any
+// Parent returns the parent context, if any
 func (c *Context) Parent() *Context {
 	return c.parentContext
 }
 
+// value returns the value of the flag coressponding to `name`
+func (c *Context) value(name string) interface{} {
+	return c.flagSet.Lookup(name).Value.(flag.Getter).Get()
+}
+
+// Args contains apps console arguments
 type Args []string
 
-// Returns the command line arguments associated with the context.
+// Args 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
+// NArg returns the number of the command line arguments.
+func (c *Context) NArg() int {
+	return len(c.Args())
+}
+
+// Get returns the nth argument, or else a blank string
 func (a Args) Get(n int) string {
 	if len(a) > n {
 		return a[n]
@@ -205,12 +181,12 @@ func (a Args) Get(n int) string {
 	return ""
 }
 
-// Returns the first argument, or else a blank string
+// First 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)
+// Tail returns the rest of the arguments (not the first one)
 // or else an empty string slice
 func (a Args) Tail() []string {
 	if len(a) >= 2 {
@@ -219,12 +195,12 @@ func (a Args) Tail() []string {
 	return []string{}
 }
 
-// Checks if there are any arguments present
+// Present checks if there are any arguments present
 func (a Args) Present() bool {
 	return len(a) != 0
 }
 
-// Swaps arguments at the given indexes
+// Swap 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")
@@ -233,6 +209,19 @@ func (a Args) Swap(from, to int) error {
 	return nil
 }
 
+func globalContext(ctx *Context) *Context {
+	if ctx == nil {
+		return nil
+	}
+
+	for {
+		if ctx.parentContext == nil {
+			return ctx
+		}
+		ctx = ctx.parentContext
+	}
+}
+
 func lookupGlobalFlagSet(name string, ctx *Context) *flag.FlagSet {
 	if ctx.parentContext != nil {
 		ctx = ctx.parentContext
@@ -245,107 +234,6 @@ func lookupGlobalFlagSet(name string, ctx *Context) *flag.FlagSet {
 	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:
@@ -360,7 +248,7 @@ func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
 		visited[f.Name] = true
 	})
 	for _, f := range flags {
-		parts := strings.Split(f.getName(), ",")
+		parts := strings.Split(f.GetName(), ",")
 		if len(parts) == 1 {
 			continue
 		}

vendor/github.com/codegangsta/cli/errors.go

@@ -0,0 +1,110 @@
+package cli
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+)
+
+// OsExiter is the function used when the app exits. If not set defaults to os.Exit.
+var OsExiter = os.Exit
+
+// ErrWriter is used to write errors to the user. This can be anything
+// implementing the io.Writer interface and defaults to os.Stderr.
+var ErrWriter io.Writer = os.Stderr
+
+// MultiError is an error that wraps multiple errors.
+type MultiError struct {
+	Errors []error
+}
+
+// NewMultiError creates a new MultiError. Pass in one or more errors.
+func NewMultiError(err ...error) MultiError {
+	return MultiError{Errors: err}
+}
+
+// Error implements the error interface.
+func (m MultiError) Error() string {
+	errs := make([]string, len(m.Errors))
+	for i, err := range m.Errors {
+		errs[i] = err.Error()
+	}
+
+	return strings.Join(errs, "\n")
+}
+
+type ErrorFormatter interface {
+	Format(s fmt.State, verb rune)
+}
+
+// ExitCoder is the interface checked by `App` and `Command` for a custom exit
+// code
+type ExitCoder interface {
+	error
+	ExitCode() int
+}
+
+// ExitError fulfills both the builtin `error` interface and `ExitCoder`
+type ExitError struct {
+	exitCode int
+	message  interface{}
+}
+
+// NewExitError makes a new *ExitError
+func NewExitError(message interface{}, exitCode int) *ExitError {
+	return &ExitError{
+		exitCode: exitCode,
+		message:  message,
+	}
+}
+
+// Error returns the string message, fulfilling the interface required by
+// `error`
+func (ee *ExitError) Error() string {
+	return fmt.Sprintf("%v", ee.message)
+}
+
+// ExitCode returns the exit code, fulfilling the interface required by
+// `ExitCoder`
+func (ee *ExitError) ExitCode() int {
+	return ee.exitCode
+}
+
+// HandleExitCoder checks if the error fulfills the ExitCoder interface, and if
+// so prints the error to stderr (if it is non-empty) and calls OsExiter with the
+// given exit code.  If the given error is a MultiError, then this func is
+// called on all members of the Errors slice.
+func HandleExitCoder(err error) {
+	if err == nil {
+		return
+	}
+
+	if exitErr, ok := err.(ExitCoder); ok {
+		if err.Error() != "" {
+			if _, ok := exitErr.(ErrorFormatter); ok {
+				fmt.Fprintf(ErrWriter, "%+v\n", err)
+			} else {
+				fmt.Fprintln(ErrWriter, err)
+			}
+		}
+		OsExiter(exitErr.ExitCode())
+		return
+	}
+
+	if multiErr, ok := err.(MultiError); ok {
+		for _, merr := range multiErr.Errors {
+			HandleExitCoder(merr)
+		}
+		return
+	}
+
+	if err.Error() != "" {
+		if _, ok := err.(ErrorFormatter); ok {
+			fmt.Fprintf(ErrWriter, "%+v\n", err)
+		} else {
+			fmt.Fprintln(ErrWriter, err)
+		}
+	}
+	OsExiter(1)
+}

vendor/github.com/codegangsta/cli/flag-types.json

@@ -0,0 +1,93 @@
+[
+  {
+    "name": "Bool",
+    "type": "bool",
+    "value": false,
+    "context_default": "false",
+    "parser": "strconv.ParseBool(f.Value.String())"
+  },
+  {
+    "name": "BoolT",
+    "type": "bool",
+    "value": false,
+    "doctail": " that is true by default",
+    "context_default": "false",
+    "parser": "strconv.ParseBool(f.Value.String())"
+  },
+  {
+    "name": "Duration",
+    "type": "time.Duration",
+    "doctail": " (see https://golang.org/pkg/time/#ParseDuration)",
+    "context_default": "0",
+    "parser": "time.ParseDuration(f.Value.String())"
+  },
+  {
+    "name": "Float64",
+    "type": "float64",
+    "context_default": "0",
+    "parser": "strconv.ParseFloat(f.Value.String(), 64)"
+  },
+  {
+    "name": "Generic",
+    "type": "Generic",
+    "dest": false,
+    "context_default": "nil",
+    "context_type": "interface{}"
+  },
+  {
+    "name": "Int64",
+    "type": "int64",
+    "context_default": "0",
+    "parser": "strconv.ParseInt(f.Value.String(), 0, 64)"
+  },
+  {
+    "name": "Int",
+    "type": "int",
+    "context_default": "0",
+    "parser": "strconv.ParseInt(f.Value.String(), 0, 64)",
+    "parser_cast": "int(parsed)"
+  },
+  {
+    "name": "IntSlice",
+    "type": "*IntSlice",
+    "dest": false,
+    "context_default": "nil",
+    "context_type": "[]int",
+    "parser": "(f.Value.(*IntSlice)).Value(), error(nil)"
+  },
+  {
+    "name": "Int64Slice",
+    "type": "*Int64Slice",
+    "dest": false,
+    "context_default": "nil",
+    "context_type": "[]int64",
+    "parser": "(f.Value.(*Int64Slice)).Value(), error(nil)"
+  },
+  {
+    "name": "String",
+    "type": "string",
+    "context_default": "\"\"",
+    "parser": "f.Value.String(), error(nil)"
+  },
+  {
+    "name": "StringSlice",
+    "type": "*StringSlice",
+    "dest": false,
+    "context_default": "nil",
+    "context_type": "[]string",
+    "parser": "(f.Value.(*StringSlice)).Value(), error(nil)"
+  },
+  {
+    "name": "Uint64",
+    "type": "uint64",
+    "context_default": "0",
+    "parser": "strconv.ParseUint(f.Value.String(), 0, 64)"
+  },
+  {
+    "name": "Uint",
+    "type": "uint",
+    "context_default": "0",
+    "parser": "strconv.ParseUint(f.Value.String(), 0, 64)",
+    "parser_cast": "uint(parsed)"
+  }
+]

vendor/github.com/codegangsta/cli/flag.go

@@ -3,24 +3,29 @@ package cli
 import (
 	"flag"
 	"fmt"
-	"os"
+	"reflect"
+	"runtime"
 	"strconv"
 	"strings"
+	"syscall"
 	"time"
 )
 
-// This flag enables bash-completion for all commands and subcommands
+const defaultPlaceholder = "value"
+
+// BashCompletionFlag enables bash-completion for all commands and subcommands
 var BashCompletionFlag = BoolFlag{
-	Name: "generate-bash-completion",
+	Name:   "generate-bash-completion",
+	Hidden: true,
 }
 
-// This flag prints the version for the application
+// VersionFlag 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
+// HelpFlag 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{
@@ -28,23 +33,58 @@ var HelpFlag = BoolFlag{
 	Usage: "show help",
 }
 
+// FlagStringer converts a flag definition to a string. This is used by help
+// to display a flag.
+var FlagStringer FlagStringFunc = stringifyFlag
+
+// FlagsByName is a slice of Flag.
+type FlagsByName []Flag
+
+func (f FlagsByName) Len() int {
+	return len(f)
+}
+
+func (f FlagsByName) Less(i, j int) bool {
+	return f[i].GetName() < f[j].GetName()
+}
+
+func (f FlagsByName) Swap(i, j int) {
+	f[i], f[j] = f[j], f[i]
+}
+
 // Flag is a common interface related to parsing flags in cli.
-// For more advanced flag parsing techniques, it is recomended that
+// For more advanced flag parsing techniques, it is recommended that
 // this interface be implemented.
 type Flag interface {
 	fmt.Stringer
 	// Apply Flag settings to the given flag set
 	Apply(*flag.FlagSet)
-	getName() string
+	GetName() string
 }
 
-func flagSet(name string, flags []Flag) *flag.FlagSet {
+// errorableFlag is an interface that allows us to return errors during apply
+// it allows flags defined in this library to return errors in a fashion backwards compatible
+// TODO remove in v2 and modify the existing Flag interface to return errors
+type errorableFlag interface {
+	Flag
+
+	ApplyWithError(*flag.FlagSet) error
+}
+
+func flagSet(name string, flags []Flag) (*flag.FlagSet, error) {
 	set := flag.NewFlagSet(name, flag.ContinueOnError)
 
 	for _, f := range flags {
-		f.Apply(set)
+		//TODO remove in v2 when errorableFlag is removed
+		if ef, ok := f.(errorableFlag); ok {
+			if err := ef.ApplyWithError(set); err != nil {
+				return nil, err
+			}
+		} else {
+			f.Apply(set)
+		}
 	}
-	return set
+	return set, nil
 }
 
 func eachName(longName string, fn func(string)) {
@@ -61,30 +101,24 @@ type Generic interface {
 	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
+// Ignores parsing errors
 func (f GenericFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError 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) ApplyWithError(set *flag.FlagSet) error {
 	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)
+			if envVal, ok := syscall.Getenv(envVar); ok {
+				if err := val.Set(envVal); err != nil {
+					return fmt.Errorf("could not parse %s as value for flag %s: %s", envVal, f.Name, err)
+				}
 				break
 			}
 		}
@@ -93,13 +127,11 @@ func (f GenericFlag) Apply(set *flag.FlagSet) {
 	eachName(f.Name, func(name string) {
 		set.Var(f.Value, name, f.Usage)
 	})
+
+	return nil
 }
 
-func (f GenericFlag) getName() string {
-	return f.Name
-}
-
-// StringSlice is an opaque type for []string to satisfy flag.Value
+// StringSlice is an opaque type for []string to satisfy flag.Value and flag.Getter
 type StringSlice []string
 
 // Set appends the string value to the list of values
@@ -118,32 +150,29 @@ func (f *StringSlice) Value() []string {
 	return *f
 }
 
-// StringSlice is a string flag that can be specified multiple times on the
-// command-line
-type StringSliceFlag struct {
-	Name   string
-	Value  *StringSlice
-	Usage  string
-	EnvVar string
-}
-
-// String returns the usage
-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))
+// Get returns the slice of strings set by this flag
+func (f *StringSlice) Get() interface{} {
+	return *f
 }
 
 // Apply populates the flag given the flag set and environment
+// Ignores errors
 func (f StringSliceFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f StringSliceFlag) ApplyWithError(set *flag.FlagSet) error {
 	if f.EnvVar != "" {
 		for _, envVar := range strings.Split(f.EnvVar, ",") {
 			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+			if envVal, ok := syscall.Getenv(envVar); ok {
 				newVal := &StringSlice{}
 				for _, s := range strings.Split(envVal, ",") {
 					s = strings.TrimSpace(s)
-					newVal.Set(s)
+					if err := newVal.Set(s); err != nil {
+						return fmt.Errorf("could not parse %s as string value for flag %s: %s", envVal, f.Name, err)
+					}
 				}
 				f.Value = newVal
 				break
@@ -157,13 +186,11 @@ func (f StringSliceFlag) Apply(set *flag.FlagSet) {
 		}
 		set.Var(f.Value, name, f.Usage)
 	})
+
+	return nil
 }
 
-func (f StringSliceFlag) getName() string {
-	return f.Name
-}
-
-// StringSlice is an opaque type for []int to satisfy flag.Value
+// IntSlice is an opaque type for []int to satisfy flag.Value and flag.Getter
 type IntSlice []int
 
 // Set parses the value into an integer and appends it to the list of values
@@ -171,15 +198,14 @@ func (f *IntSlice) Set(value string) error {
 	tmp, err := strconv.Atoi(value)
 	if err != nil {
 		return err
-	} else {
-		*f = append(*f, tmp)
 	}
+	*f = append(*f, tmp)
 	return nil
 }
 
 // String returns a readable representation of this value (for usage defaults)
 func (f *IntSlice) String() string {
-	return fmt.Sprintf("%d", *f)
+	return fmt.Sprintf("%#v", *f)
 }
 
 // Value returns the slice of ints set by this flag
@@ -187,34 +213,28 @@ func (f *IntSlice) Value() []int {
 	return *f
 }
 
-// IntSliceFlag is an int flag that can be specified multiple times on the
-// command-line
-type IntSliceFlag struct {
-	Name   string
-	Value  *IntSlice
-	Usage  string
-	EnvVar string
-}
-
-// String returns the usage
-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))
+// Get returns the slice of ints set by this flag
+func (f *IntSlice) Get() interface{} {
+	return *f
 }
 
 // Apply populates the flag given the flag set and environment
+// Ignores errors
 func (f IntSliceFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f IntSliceFlag) ApplyWithError(set *flag.FlagSet) error {
 	if f.EnvVar != "" {
 		for _, envVar := range strings.Split(f.EnvVar, ",") {
 			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+			if envVal, ok := syscall.Getenv(envVar); ok {
 				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())
+					if err := newVal.Set(s); err != nil {
+						return fmt.Errorf("could not parse %s as int slice value for flag %s: %s", envVal, f.Name, err)
 					}
 				}
 				f.Value = newVal
@@ -229,115 +249,164 @@ func (f IntSliceFlag) Apply(set *flag.FlagSet) {
 		}
 		set.Var(f.Value, name, f.Usage)
 	})
+
+	return nil
 }
 
-func (f IntSliceFlag) getName() string {
-	return f.Name
-}
+// Int64Slice is an opaque type for []int to satisfy flag.Value and flag.Getter
+type Int64Slice []int64
 
-// BoolFlag is a switch that defaults to false
-type BoolFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
+// Set parses the value into an integer and appends it to the list of values
+func (f *Int64Slice) Set(value string) error {
+	tmp, err := strconv.ParseInt(value, 10, 64)
+	if err != nil {
+		return err
+	}
+	*f = append(*f, tmp)
+	return nil
 }
 
 // String returns a readable representation of this value (for usage defaults)
-func (f BoolFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+func (f *Int64Slice) String() string {
+	return fmt.Sprintf("%#v", *f)
+}
+
+// Value returns the slice of ints set by this flag
+func (f *Int64Slice) Value() []int64 {
+	return *f
+}
+
+// Get returns the slice of ints set by this flag
+func (f *Int64Slice) Get() interface{} {
+	return *f
 }
 
 // Apply populates the flag given the flag set and environment
-func (f BoolFlag) Apply(set *flag.FlagSet) {
-	val := false
+// Ignores errors
+func (f Int64SliceFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f Int64SliceFlag) ApplyWithError(set *flag.FlagSet) error {
 	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
+			if envVal, ok := syscall.Getenv(envVar); ok {
+				newVal := &Int64Slice{}
+				for _, s := range strings.Split(envVal, ",") {
+					s = strings.TrimSpace(s)
+					if err := newVal.Set(s); err != nil {
+						return fmt.Errorf("could not parse %s as int64 slice value for flag %s: %s", envVal, f.Name, err)
+					}
 				}
+				f.Value = newVal
 				break
 			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
-		set.Bool(name, val, f.Usage)
+		if f.Value == nil {
+			f.Value = &Int64Slice{}
+		}
+		set.Var(f.Value, name, f.Usage)
 	})
-}
-
-func (f BoolFlag) getName() string {
-	return f.Name
-}
-
-// BoolTFlag this represents a boolean flag that is true by default, but can
-// still be set to false by --some-flag=false
-type BoolTFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f BoolTFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+	return nil
 }
 
 // Apply populates the flag given the flag set and environment
-func (f BoolTFlag) Apply(set *flag.FlagSet) {
-	val := true
+// Ignores errors
+func (f BoolFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f BoolFlag) ApplyWithError(set *flag.FlagSet) error {
+	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
+			if envVal, ok := syscall.Getenv(envVar); ok {
+				if envVal == "" {
+					val = false
 					break
 				}
+
+				envValBool, err := strconv.ParseBool(envVal)
+				if err != nil {
+					return fmt.Errorf("could not parse %s as bool value for flag %s: %s", envVal, f.Name, err)
+				}
+
+				val = envValBool
+				break
 			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
+		if f.Destination != nil {
+			set.BoolVar(f.Destination, name, val, f.Usage)
+			return
+		}
 		set.Bool(name, val, f.Usage)
 	})
-}
 
-func (f BoolTFlag) getName() string {
-	return f.Name
-}
-
-// StringFlag represents a flag that takes as string value
-type StringFlag struct {
-	Name   string
-	Value  string
-	Usage  string
-	EnvVar string
-}
-
-// String returns the usage
-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))
+	return nil
 }
 
 // Apply populates the flag given the flag set and environment
-func (f StringFlag) Apply(set *flag.FlagSet) {
+// Ignores errors
+func (f BoolTFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f BoolTFlag) ApplyWithError(set *flag.FlagSet) error {
+	val := true
 	if f.EnvVar != "" {
 		for _, envVar := range strings.Split(f.EnvVar, ",") {
 			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+			if envVal, ok := syscall.Getenv(envVar); ok {
+				if envVal == "" {
+					val = false
+					break
+				}
+
+				envValBool, err := strconv.ParseBool(envVal)
+				if err != nil {
+					return fmt.Errorf("could not parse %s as bool value for flag %s: %s", envVal, f.Name, err)
+				}
+
+				val = envValBool
+				break
+			}
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		if f.Destination != nil {
+			set.BoolVar(f.Destination, name, val, f.Usage)
+			return
+		}
+		set.Bool(name, val, f.Usage)
+	})
+
+	return nil
+}
+
+// Apply populates the flag given the flag set and environment
+// Ignores errors
+func (f StringFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f StringFlag) ApplyWithError(set *flag.FlagSet) error {
+	if f.EnvVar != "" {
+		for _, envVar := range strings.Split(f.EnvVar, ",") {
+			envVar = strings.TrimSpace(envVar)
+			if envVal, ok := syscall.Getenv(envVar); ok {
 				f.Value = envVal
 				break
 			}
@@ -345,125 +414,227 @@ func (f StringFlag) Apply(set *flag.FlagSet) {
 	}
 
 	eachName(f.Name, func(name string) {
+		if f.Destination != nil {
+			set.StringVar(f.Destination, name, f.Value, f.Usage)
+			return
+		}
 		set.String(name, f.Value, f.Usage)
 	})
-}
 
-func (f StringFlag) getName() string {
-	return f.Name
-}
-
-// IntFlag is a flag that takes an integer
-// Errors if the value provided cannot be parsed
-type IntFlag struct {
-	Name   string
-	Value  int
-	Usage  string
-	EnvVar string
-}
-
-// String returns the usage
-func (f IntFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+	return nil
 }
 
 // Apply populates the flag given the flag set and environment
+// Ignores errors
 func (f IntFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f IntFlag) ApplyWithError(set *flag.FlagSet) error {
 	if f.EnvVar != "" {
 		for _, envVar := range strings.Split(f.EnvVar, ",") {
 			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+			if envVal, ok := syscall.Getenv(envVar); ok {
 				envValInt, err := strconv.ParseInt(envVal, 0, 64)
-				if err == nil {
-					f.Value = int(envValInt)
-					break
+				if err != nil {
+					return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err)
 				}
+				f.Value = int(envValInt)
+				break
 			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
+		if f.Destination != nil {
+			set.IntVar(f.Destination, name, f.Value, f.Usage)
+			return
+		}
 		set.Int(name, f.Value, f.Usage)
 	})
-}
 
-func (f IntFlag) getName() string {
-	return f.Name
-}
-
-// DurationFlag is a flag that takes a duration specified in Go's duration
-// format: https://golang.org/pkg/time/#ParseDuration
-type DurationFlag struct {
-	Name   string
-	Value  time.Duration
-	Usage  string
-	EnvVar string
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f DurationFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+	return nil
 }
 
 // Apply populates the flag given the flag set and environment
-func (f DurationFlag) Apply(set *flag.FlagSet) {
+// Ignores errors
+func (f Int64Flag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f Int64Flag) ApplyWithError(set *flag.FlagSet) error {
 	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
+			if envVal, ok := syscall.Getenv(envVar); ok {
+				envValInt, err := strconv.ParseInt(envVal, 0, 64)
+				if err != nil {
+					return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err)
 				}
+
+				f.Value = envValInt
+				break
 			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
+		if f.Destination != nil {
+			set.Int64Var(f.Destination, name, f.Value, f.Usage)
+			return
+		}
+		set.Int64(name, f.Value, f.Usage)
+	})
+
+	return nil
+}
+
+// Apply populates the flag given the flag set and environment
+// Ignores errors
+func (f UintFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f UintFlag) ApplyWithError(set *flag.FlagSet) error {
+	if f.EnvVar != "" {
+		for _, envVar := range strings.Split(f.EnvVar, ",") {
+			envVar = strings.TrimSpace(envVar)
+			if envVal, ok := syscall.Getenv(envVar); ok {
+				envValInt, err := strconv.ParseUint(envVal, 0, 64)
+				if err != nil {
+					return fmt.Errorf("could not parse %s as uint value for flag %s: %s", envVal, f.Name, err)
+				}
+
+				f.Value = uint(envValInt)
+				break
+			}
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		if f.Destination != nil {
+			set.UintVar(f.Destination, name, f.Value, f.Usage)
+			return
+		}
+		set.Uint(name, f.Value, f.Usage)
+	})
+
+	return nil
+}
+
+// Apply populates the flag given the flag set and environment
+// Ignores errors
+func (f Uint64Flag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f Uint64Flag) ApplyWithError(set *flag.FlagSet) error {
+	if f.EnvVar != "" {
+		for _, envVar := range strings.Split(f.EnvVar, ",") {
+			envVar = strings.TrimSpace(envVar)
+			if envVal, ok := syscall.Getenv(envVar); ok {
+				envValInt, err := strconv.ParseUint(envVal, 0, 64)
+				if err != nil {
+					return fmt.Errorf("could not parse %s as uint64 value for flag %s: %s", envVal, f.Name, err)
+				}
+
+				f.Value = uint64(envValInt)
+				break
+			}
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		if f.Destination != nil {
+			set.Uint64Var(f.Destination, name, f.Value, f.Usage)
+			return
+		}
+		set.Uint64(name, f.Value, f.Usage)
+	})
+
+	return nil
+}
+
+// Apply populates the flag given the flag set and environment
+// Ignores errors
+func (f DurationFlag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f DurationFlag) ApplyWithError(set *flag.FlagSet) error {
+	if f.EnvVar != "" {
+		for _, envVar := range strings.Split(f.EnvVar, ",") {
+			envVar = strings.TrimSpace(envVar)
+			if envVal, ok := syscall.Getenv(envVar); ok {
+				envValDuration, err := time.ParseDuration(envVal)
+				if err != nil {
+					return fmt.Errorf("could not parse %s as duration for flag %s: %s", envVal, f.Name, err)
+				}
+
+				f.Value = envValDuration
+				break
+			}
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		if f.Destination != nil {
+			set.DurationVar(f.Destination, name, f.Value, f.Usage)
+			return
+		}
 		set.Duration(name, f.Value, f.Usage)
 	})
-}
 
-func (f DurationFlag) getName() string {
-	return f.Name
-}
-
-// Float64Flag is a flag that takes an float value
-// Errors if the value provided cannot be parsed
-type Float64Flag struct {
-	Name   string
-	Value  float64
-	Usage  string
-	EnvVar string
-}
-
-// String returns the usage
-func (f Float64Flag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+	return nil
 }
 
 // Apply populates the flag given the flag set and environment
+// Ignores errors
 func (f Float64Flag) Apply(set *flag.FlagSet) {
+	f.ApplyWithError(set)
+}
+
+// ApplyWithError populates the flag given the flag set and environment
+func (f Float64Flag) ApplyWithError(set *flag.FlagSet) error {
 	if f.EnvVar != "" {
 		for _, envVar := range strings.Split(f.EnvVar, ",") {
 			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+			if envVal, ok := syscall.Getenv(envVar); ok {
 				envValFloat, err := strconv.ParseFloat(envVal, 10)
-				if err == nil {
-					f.Value = float64(envValFloat)
+				if err != nil {
+					return fmt.Errorf("could not parse %s as float64 value for flag %s: %s", envVal, f.Name, err)
 				}
+
+				f.Value = float64(envValFloat)
+				break
 			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
+		if f.Destination != nil {
+			set.Float64Var(f.Destination, name, f.Value, f.Usage)
+			return
+		}
 		set.Float64(name, f.Value, f.Usage)
 	})
+
+	return nil
 }
 
-func (f Float64Flag) getName() string {
-	return f.Name
+func visibleFlags(fl []Flag) []Flag {
+	visible := []Flag{}
+	for _, flag := range fl {
+		if !flagValue(flag).FieldByName("Hidden").Bool() {
+			visible = append(visible, flag)
+		}
+	}
+	return visible
 }
 
 func prefixFor(name string) (prefix string) {
@@ -476,22 +647,153 @@ func prefixFor(name string) (prefix string) {
 	return
 }
 
-func prefixedNames(fullName string) (prefixed string) {
+// Returns the placeholder, if any, and the unquoted usage string.
+func unquoteUsage(usage string) (string, string) {
+	for i := 0; i < len(usage); i++ {
+		if usage[i] == '`' {
+			for j := i + 1; j < len(usage); j++ {
+				if usage[j] == '`' {
+					name := usage[i+1 : j]
+					usage = usage[:i] + name + usage[j+1:]
+					return name, usage
+				}
+			}
+			break
+		}
+	}
+	return "", usage
+}
+
+func prefixedNames(fullName, placeholder string) string {
+	var prefixed string
 	parts := strings.Split(fullName, ",")
 	for i, name := range parts {
 		name = strings.Trim(name, " ")
 		prefixed += prefixFor(name) + name
+		if placeholder != "" {
+			prefixed += " " + placeholder
+		}
 		if i < len(parts)-1 {
 			prefixed += ", "
 		}
 	}
-	return
+	return prefixed
 }
 
 func withEnvHint(envVar, str string) string {
 	envText := ""
 	if envVar != "" {
-		envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
+		prefix := "$"
+		suffix := ""
+		sep := ", $"
+		if runtime.GOOS == "windows" {
+			prefix = "%"
+			suffix = "%"
+			sep = "%, %"
+		}
+		envText = fmt.Sprintf(" [%s%s%s]", prefix, strings.Join(strings.Split(envVar, ","), sep), suffix)
 	}
 	return str + envText
 }
+
+func flagValue(f Flag) reflect.Value {
+	fv := reflect.ValueOf(f)
+	for fv.Kind() == reflect.Ptr {
+		fv = reflect.Indirect(fv)
+	}
+	return fv
+}
+
+func stringifyFlag(f Flag) string {
+	fv := flagValue(f)
+
+	switch f.(type) {
+	case IntSliceFlag:
+		return withEnvHint(fv.FieldByName("EnvVar").String(),
+			stringifyIntSliceFlag(f.(IntSliceFlag)))
+	case Int64SliceFlag:
+		return withEnvHint(fv.FieldByName("EnvVar").String(),
+			stringifyInt64SliceFlag(f.(Int64SliceFlag)))
+	case StringSliceFlag:
+		return withEnvHint(fv.FieldByName("EnvVar").String(),
+			stringifyStringSliceFlag(f.(StringSliceFlag)))
+	}
+
+	placeholder, usage := unquoteUsage(fv.FieldByName("Usage").String())
+
+	needsPlaceholder := false
+	defaultValueString := ""
+	val := fv.FieldByName("Value")
+
+	if val.IsValid() {
+		needsPlaceholder = true
+		defaultValueString = fmt.Sprintf(" (default: %v)", val.Interface())
+
+		if val.Kind() == reflect.String && val.String() != "" {
+			defaultValueString = fmt.Sprintf(" (default: %q)", val.String())
+		}
+	}
+
+	if defaultValueString == " (default: )" {
+		defaultValueString = ""
+	}
+
+	if needsPlaceholder && placeholder == "" {
+		placeholder = defaultPlaceholder
+	}
+
+	usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultValueString))
+
+	return withEnvHint(fv.FieldByName("EnvVar").String(),
+		fmt.Sprintf("%s\t%s", prefixedNames(fv.FieldByName("Name").String(), placeholder), usageWithDefault))
+}
+
+func stringifyIntSliceFlag(f IntSliceFlag) string {
+	defaultVals := []string{}
+	if f.Value != nil && len(f.Value.Value()) > 0 {
+		for _, i := range f.Value.Value() {
+			defaultVals = append(defaultVals, fmt.Sprintf("%d", i))
+		}
+	}
+
+	return stringifySliceFlag(f.Usage, f.Name, defaultVals)
+}
+
+func stringifyInt64SliceFlag(f Int64SliceFlag) string {
+	defaultVals := []string{}
+	if f.Value != nil && len(f.Value.Value()) > 0 {
+		for _, i := range f.Value.Value() {
+			defaultVals = append(defaultVals, fmt.Sprintf("%d", i))
+		}
+	}
+
+	return stringifySliceFlag(f.Usage, f.Name, defaultVals)
+}
+
+func stringifyStringSliceFlag(f StringSliceFlag) string {
+	defaultVals := []string{}
+	if f.Value != nil && len(f.Value.Value()) > 0 {
+		for _, s := range f.Value.Value() {
+			if len(s) > 0 {
+				defaultVals = append(defaultVals, fmt.Sprintf("%q", s))
+			}
+		}
+	}
+
+	return stringifySliceFlag(f.Usage, f.Name, defaultVals)
+}
+
+func stringifySliceFlag(usage, name string, defaultVals []string) string {
+	placeholder, usage := unquoteUsage(usage)
+	if placeholder == "" {
+		placeholder = defaultPlaceholder
+	}
+
+	defaultVal := ""
+	if len(defaultVals) > 0 {
+		defaultVal = fmt.Sprintf(" (default: %s)", strings.Join(defaultVals, ", "))
+	}
+
+	usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultVal))
+	return fmt.Sprintf("%s\t%s", prefixedNames(name, placeholder), usageWithDefault)
+}

vendor/github.com/codegangsta/cli/flag_generated.go

@@ -0,0 +1,627 @@
+package cli
+
+import (
+	"flag"
+	"strconv"
+	"time"
+)
+
+// WARNING: This file is generated!
+
+// BoolFlag is a flag with type bool
+type BoolFlag struct {
+	Name        string
+	Usage       string
+	EnvVar      string
+	Hidden      bool
+	Destination *bool
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f BoolFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f BoolFlag) GetName() string {
+	return f.Name
+}
+
+// Bool looks up the value of a local BoolFlag, returns
+// false if not found
+func (c *Context) Bool(name string) bool {
+	return lookupBool(name, c.flagSet)
+}
+
+// GlobalBool looks up the value of a global BoolFlag, returns
+// false if not found
+func (c *Context) GlobalBool(name string) bool {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupBool(name, fs)
+	}
+	return false
+}
+
+func lookupBool(name string, set *flag.FlagSet) bool {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseBool(f.Value.String())
+		if err != nil {
+			return false
+		}
+		return parsed
+	}
+	return false
+}
+
+// BoolTFlag is a flag with type bool that is true by default
+type BoolTFlag struct {
+	Name        string
+	Usage       string
+	EnvVar      string
+	Hidden      bool
+	Destination *bool
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f BoolTFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f BoolTFlag) GetName() string {
+	return f.Name
+}
+
+// BoolT looks up the value of a local BoolTFlag, returns
+// false if not found
+func (c *Context) BoolT(name string) bool {
+	return lookupBoolT(name, c.flagSet)
+}
+
+// GlobalBoolT looks up the value of a global BoolTFlag, returns
+// false if not found
+func (c *Context) GlobalBoolT(name string) bool {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupBoolT(name, fs)
+	}
+	return false
+}
+
+func lookupBoolT(name string, set *flag.FlagSet) bool {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseBool(f.Value.String())
+		if err != nil {
+			return false
+		}
+		return parsed
+	}
+	return false
+}
+
+// DurationFlag is a flag with type time.Duration (see https://golang.org/pkg/time/#ParseDuration)
+type DurationFlag struct {
+	Name        string
+	Usage       string
+	EnvVar      string
+	Hidden      bool
+	Value       time.Duration
+	Destination *time.Duration
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f DurationFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f DurationFlag) GetName() string {
+	return f.Name
+}
+
+// Duration looks up the value of a local DurationFlag, returns
+// 0 if not found
+func (c *Context) Duration(name string) time.Duration {
+	return lookupDuration(name, c.flagSet)
+}
+
+// GlobalDuration looks up the value of a global DurationFlag, returns
+// 0 if not found
+func (c *Context) GlobalDuration(name string) time.Duration {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupDuration(name, fs)
+	}
+	return 0
+}
+
+func lookupDuration(name string, set *flag.FlagSet) time.Duration {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := time.ParseDuration(f.Value.String())
+		if err != nil {
+			return 0
+		}
+		return parsed
+	}
+	return 0
+}
+
+// Float64Flag is a flag with type float64
+type Float64Flag struct {
+	Name        string
+	Usage       string
+	EnvVar      string
+	Hidden      bool
+	Value       float64
+	Destination *float64
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f Float64Flag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f Float64Flag) GetName() string {
+	return f.Name
+}
+
+// Float64 looks up the value of a local Float64Flag, returns
+// 0 if not found
+func (c *Context) Float64(name string) float64 {
+	return lookupFloat64(name, c.flagSet)
+}
+
+// GlobalFloat64 looks up the value of a global Float64Flag, returns
+// 0 if not found
+func (c *Context) GlobalFloat64(name string) float64 {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupFloat64(name, fs)
+	}
+	return 0
+}
+
+func lookupFloat64(name string, set *flag.FlagSet) float64 {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseFloat(f.Value.String(), 64)
+		if err != nil {
+			return 0
+		}
+		return parsed
+	}
+	return 0
+}
+
+// GenericFlag is a flag with type Generic
+type GenericFlag struct {
+	Name   string
+	Usage  string
+	EnvVar string
+	Hidden bool
+	Value  Generic
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f GenericFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f GenericFlag) GetName() string {
+	return f.Name
+}
+
+// Generic looks up the value of a local GenericFlag, returns
+// nil if not found
+func (c *Context) Generic(name string) interface{} {
+	return lookupGeneric(name, c.flagSet)
+}
+
+// GlobalGeneric looks up the value of a global GenericFlag, returns
+// nil if not found
+func (c *Context) GlobalGeneric(name string) interface{} {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupGeneric(name, fs)
+	}
+	return nil
+}
+
+func lookupGeneric(name string, set *flag.FlagSet) interface{} {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := f.Value, error(nil)
+		if err != nil {
+			return nil
+		}
+		return parsed
+	}
+	return nil
+}
+
+// Int64Flag is a flag with type int64
+type Int64Flag struct {
+	Name        string
+	Usage       string
+	EnvVar      string
+	Hidden      bool
+	Value       int64
+	Destination *int64
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f Int64Flag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f Int64Flag) GetName() string {
+	return f.Name
+}
+
+// Int64 looks up the value of a local Int64Flag, returns
+// 0 if not found
+func (c *Context) Int64(name string) int64 {
+	return lookupInt64(name, c.flagSet)
+}
+
+// GlobalInt64 looks up the value of a global Int64Flag, returns
+// 0 if not found
+func (c *Context) GlobalInt64(name string) int64 {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupInt64(name, fs)
+	}
+	return 0
+}
+
+func lookupInt64(name string, set *flag.FlagSet) int64 {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
+		if err != nil {
+			return 0
+		}
+		return parsed
+	}
+	return 0
+}
+
+// IntFlag is a flag with type int
+type IntFlag struct {
+	Name        string
+	Usage       string
+	EnvVar      string
+	Hidden      bool
+	Value       int
+	Destination *int
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f IntFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f IntFlag) GetName() string {
+	return f.Name
+}
+
+// Int looks up the value of a local IntFlag, returns
+// 0 if not found
+func (c *Context) Int(name string) int {
+	return lookupInt(name, c.flagSet)
+}
+
+// GlobalInt looks up the value of a global IntFlag, returns
+// 0 if not found
+func (c *Context) GlobalInt(name string) int {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupInt(name, fs)
+	}
+	return 0
+}
+
+func lookupInt(name string, set *flag.FlagSet) int {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
+		if err != nil {
+			return 0
+		}
+		return int(parsed)
+	}
+	return 0
+}
+
+// IntSliceFlag is a flag with type *IntSlice
+type IntSliceFlag struct {
+	Name   string
+	Usage  string
+	EnvVar string
+	Hidden bool
+	Value  *IntSlice
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f IntSliceFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f IntSliceFlag) GetName() string {
+	return f.Name
+}
+
+// IntSlice looks up the value of a local IntSliceFlag, returns
+// nil if not found
+func (c *Context) IntSlice(name string) []int {
+	return lookupIntSlice(name, c.flagSet)
+}
+
+// GlobalIntSlice looks up the value of a global IntSliceFlag, returns
+// nil if not found
+func (c *Context) GlobalIntSlice(name string) []int {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupIntSlice(name, fs)
+	}
+	return nil
+}
+
+func lookupIntSlice(name string, set *flag.FlagSet) []int {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := (f.Value.(*IntSlice)).Value(), error(nil)
+		if err != nil {
+			return nil
+		}
+		return parsed
+	}
+	return nil
+}
+
+// Int64SliceFlag is a flag with type *Int64Slice
+type Int64SliceFlag struct {
+	Name   string
+	Usage  string
+	EnvVar string
+	Hidden bool
+	Value  *Int64Slice
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f Int64SliceFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f Int64SliceFlag) GetName() string {
+	return f.Name
+}
+
+// Int64Slice looks up the value of a local Int64SliceFlag, returns
+// nil if not found
+func (c *Context) Int64Slice(name string) []int64 {
+	return lookupInt64Slice(name, c.flagSet)
+}
+
+// GlobalInt64Slice looks up the value of a global Int64SliceFlag, returns
+// nil if not found
+func (c *Context) GlobalInt64Slice(name string) []int64 {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupInt64Slice(name, fs)
+	}
+	return nil
+}
+
+func lookupInt64Slice(name string, set *flag.FlagSet) []int64 {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := (f.Value.(*Int64Slice)).Value(), error(nil)
+		if err != nil {
+			return nil
+		}
+		return parsed
+	}
+	return nil
+}
+
+// StringFlag is a flag with type string
+type StringFlag struct {
+	Name        string
+	Usage       string
+	EnvVar      string
+	Hidden      bool
+	Value       string
+	Destination *string
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f StringFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f StringFlag) GetName() string {
+	return f.Name
+}
+
+// String looks up the value of a local StringFlag, returns
+// "" if not found
+func (c *Context) String(name string) string {
+	return lookupString(name, c.flagSet)
+}
+
+// GlobalString looks up the value of a global StringFlag, returns
+// "" if not found
+func (c *Context) GlobalString(name string) string {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupString(name, fs)
+	}
+	return ""
+}
+
+func lookupString(name string, set *flag.FlagSet) string {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := f.Value.String(), error(nil)
+		if err != nil {
+			return ""
+		}
+		return parsed
+	}
+	return ""
+}
+
+// StringSliceFlag is a flag with type *StringSlice
+type StringSliceFlag struct {
+	Name   string
+	Usage  string
+	EnvVar string
+	Hidden bool
+	Value  *StringSlice
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f StringSliceFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f StringSliceFlag) GetName() string {
+	return f.Name
+}
+
+// StringSlice looks up the value of a local StringSliceFlag, returns
+// nil if not found
+func (c *Context) StringSlice(name string) []string {
+	return lookupStringSlice(name, c.flagSet)
+}
+
+// GlobalStringSlice looks up the value of a global StringSliceFlag, returns
+// nil if not found
+func (c *Context) GlobalStringSlice(name string) []string {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupStringSlice(name, fs)
+	}
+	return nil
+}
+
+func lookupStringSlice(name string, set *flag.FlagSet) []string {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := (f.Value.(*StringSlice)).Value(), error(nil)
+		if err != nil {
+			return nil
+		}
+		return parsed
+	}
+	return nil
+}
+
+// Uint64Flag is a flag with type uint64
+type Uint64Flag struct {
+	Name        string
+	Usage       string
+	EnvVar      string
+	Hidden      bool
+	Value       uint64
+	Destination *uint64
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f Uint64Flag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f Uint64Flag) GetName() string {
+	return f.Name
+}
+
+// Uint64 looks up the value of a local Uint64Flag, returns
+// 0 if not found
+func (c *Context) Uint64(name string) uint64 {
+	return lookupUint64(name, c.flagSet)
+}
+
+// GlobalUint64 looks up the value of a global Uint64Flag, returns
+// 0 if not found
+func (c *Context) GlobalUint64(name string) uint64 {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupUint64(name, fs)
+	}
+	return 0
+}
+
+func lookupUint64(name string, set *flag.FlagSet) uint64 {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
+		if err != nil {
+			return 0
+		}
+		return parsed
+	}
+	return 0
+}
+
+// UintFlag is a flag with type uint
+type UintFlag struct {
+	Name        string
+	Usage       string
+	EnvVar      string
+	Hidden      bool
+	Value       uint
+	Destination *uint
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f UintFlag) String() string {
+	return FlagStringer(f)
+}
+
+// GetName returns the name of the flag
+func (f UintFlag) GetName() string {
+	return f.Name
+}
+
+// Uint looks up the value of a local UintFlag, returns
+// 0 if not found
+func (c *Context) Uint(name string) uint {
+	return lookupUint(name, c.flagSet)
+}
+
+// GlobalUint looks up the value of a global UintFlag, returns
+// 0 if not found
+func (c *Context) GlobalUint(name string) uint {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupUint(name, fs)
+	}
+	return 0
+}
+
+func lookupUint(name string, set *flag.FlagSet) uint {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
+		if err != nil {
+			return 0
+		}
+		return uint(parsed)
+	}
+	return 0
+}

vendor/github.com/codegangsta/cli/funcs.go

@@ -0,0 +1,28 @@
+package cli
+
+// BashCompleteFunc is an action to execute when the bash-completion flag is set
+type BashCompleteFunc func(*Context)
+
+// BeforeFunc is 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
+type BeforeFunc func(*Context) error
+
+// AfterFunc is an action to execute after any subcommands are run, but after the
+// subcommand has finished it is run even if Action() panics
+type AfterFunc func(*Context) error
+
+// ActionFunc is the action to execute when no subcommands are specified
+type ActionFunc func(*Context) error
+
+// CommandNotFoundFunc is executed if the proper command cannot be found
+type CommandNotFoundFunc func(*Context, string)
+
+// OnUsageErrorFunc is executed if an usage error occurs. This is useful for displaying
+// customized usage error messages.  This function is able to replace the
+// original error messages.  If this function is not set, the "Incorrect usage"
+// is displayed and the execution is interrupted.
+type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error
+
+// FlagStringFunc is used by the help generation to display a flag, which is
+// expected to be a single line.
+type FlagStringFunc func(Flag) string

vendor/github.com/codegangsta/cli/generate-flag-types

@@ -0,0 +1,255 @@
+#!/usr/bin/env python
+"""
+The flag types that ship with the cli library have many things in common, and
+so we can take advantage of the `go generate` command to create much of the
+source code from a list of definitions.  These definitions attempt to cover
+the parts that vary between flag types, and should evolve as needed.
+
+An example of the minimum definition needed is:
+
+    {
+      "name": "SomeType",
+      "type": "sometype",
+      "context_default": "nil"
+    }
+
+In this example, the code generated for the `cli` package will include a type
+named `SomeTypeFlag` that is expected to wrap a value of type `sometype`.
+Fetching values by name via `*cli.Context` will default to a value of `nil`.
+
+A more complete, albeit somewhat redundant, example showing all available
+definition keys is:
+
+    {
+      "name": "VeryMuchType",
+      "type": "*VeryMuchType",
+      "value": true,
+      "dest": false,
+      "doctail": " which really only wraps a []float64, oh well!",
+      "context_type": "[]float64",
+      "context_default": "nil",
+      "parser": "parseVeryMuchType(f.Value.String())",
+      "parser_cast": "[]float64(parsed)"
+    }
+
+The meaning of each field is as follows:
+
+               name (string) - The type "name", which will be suffixed with
+                               `Flag` when generating the type definition
+                               for `cli` and the wrapper type for `altsrc`
+               type (string) - The type that the generated `Flag` type for `cli`
+                               is expected to "contain" as its `.Value` member
+                value (bool) - Should the generated `cli` type have a `Value`
+                               member?
+                 dest (bool) - Should the generated `cli` type support a
+                               destination pointer?
+            doctail (string) - Additional docs for the `cli` flag type comment
+       context_type (string) - The literal type used in the `*cli.Context`
+                               reader func signature
+    context_default (string) - The literal value used as the default by the
+                               `*cli.Context` reader funcs when no value is
+                               present
+             parser (string) - Literal code used to parse the flag `f`,
+                               expected to have a return signature of
+                               (value, error)
+        parser_cast (string) - Literal code used to cast the `parsed` value
+                               returned from the `parser` code
+"""
+
+from __future__ import print_function, unicode_literals
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import textwrap
+
+
+class _FancyFormatter(argparse.ArgumentDefaultsHelpFormatter,
+                      argparse.RawDescriptionHelpFormatter):
+    pass
+
+
+def main(sysargs=sys.argv[:]):
+    parser = argparse.ArgumentParser(
+        description='Generate flag type code!',
+        formatter_class=_FancyFormatter)
+    parser.add_argument(
+        'package',
+        type=str, default='cli', choices=_WRITEFUNCS.keys(),
+        help='Package for which flag types will be generated'
+    )
+    parser.add_argument(
+        '-i', '--in-json',
+        type=argparse.FileType('r'),
+        default=sys.stdin,
+        help='Input JSON file which defines each type to be generated'
+    )
+    parser.add_argument(
+        '-o', '--out-go',
+        type=argparse.FileType('w'),
+        default=sys.stdout,
+        help='Output file/stream to which generated source will be written'
+    )
+    parser.epilog = __doc__
+
+    args = parser.parse_args(sysargs[1:])
+    _generate_flag_types(_WRITEFUNCS[args.package], args.out_go, args.in_json)
+    return 0
+
+
+def _generate_flag_types(writefunc, output_go, input_json):
+    types = json.load(input_json)
+
+    tmp = tempfile.NamedTemporaryFile(suffix='.go', delete=False)
+    writefunc(tmp, types)
+    tmp.close()
+
+    new_content = subprocess.check_output(
+        ['goimports', tmp.name]
+    ).decode('utf-8')
+
+    print(new_content, file=output_go, end='')
+    output_go.flush()
+    os.remove(tmp.name)
+
+
+def _set_typedef_defaults(typedef):
+    typedef.setdefault('doctail', '')
+    typedef.setdefault('context_type', typedef['type'])
+    typedef.setdefault('dest', True)
+    typedef.setdefault('value', True)
+    typedef.setdefault('parser', 'f.Value, error(nil)')
+    typedef.setdefault('parser_cast', 'parsed')
+
+
+def _write_cli_flag_types(outfile, types):
+    _fwrite(outfile, """\
+        package cli
+
+        // WARNING: This file is generated!
+
+        """)
+
+    for typedef in types:
+        _set_typedef_defaults(typedef)
+
+        _fwrite(outfile, """\
+        // {name}Flag is a flag with type {type}{doctail}
+        type {name}Flag struct {{
+            Name string
+            Usage string
+            EnvVar string
+            Hidden bool
+        """.format(**typedef))
+
+        if typedef['value']:
+            _fwrite(outfile, """\
+            Value {type}
+            """.format(**typedef))
+
+        if typedef['dest']:
+            _fwrite(outfile, """\
+            Destination *{type}
+            """.format(**typedef))
+
+        _fwrite(outfile, "\n}\n\n")
+
+        _fwrite(outfile, """\
+            // String returns a readable representation of this value
+            // (for usage defaults)
+            func (f {name}Flag) String() string {{
+                return FlagStringer(f)
+            }}
+
+            // GetName returns the name of the flag
+            func (f {name}Flag) GetName() string {{
+                return f.Name
+            }}
+
+            // {name} looks up the value of a local {name}Flag, returns
+            // {context_default} if not found
+            func (c *Context) {name}(name string) {context_type} {{
+                return lookup{name}(name, c.flagSet)
+            }}
+
+            // Global{name} looks up the value of a global {name}Flag, returns
+            // {context_default} if not found
+            func (c *Context) Global{name}(name string) {context_type} {{
+                if fs := lookupGlobalFlagSet(name, c); fs != nil {{
+                    return lookup{name}(name, fs)
+                }}
+                return {context_default}
+            }}
+
+            func lookup{name}(name string, set *flag.FlagSet) {context_type} {{
+                f := set.Lookup(name)
+                if f != nil {{
+                    parsed, err := {parser}
+                    if err != nil {{
+                        return {context_default}
+                    }}
+                    return {parser_cast}
+                }}
+                return {context_default}
+            }}
+            """.format(**typedef))
+
+
+def _write_altsrc_flag_types(outfile, types):
+    _fwrite(outfile, """\
+        package altsrc
+
+        import (
+            "gopkg.in/urfave/cli.v1"
+        )
+
+        // WARNING: This file is generated!
+
+        """)
+
+    for typedef in types:
+        _set_typedef_defaults(typedef)
+
+        _fwrite(outfile, """\
+        // {name}Flag is the flag type that wraps cli.{name}Flag to allow
+        // for other values to be specified
+        type {name}Flag struct {{
+            cli.{name}Flag
+            set *flag.FlagSet
+        }}
+
+        // New{name}Flag creates a new {name}Flag
+        func New{name}Flag(fl cli.{name}Flag) *{name}Flag {{
+            return &{name}Flag{{{name}Flag: fl, set: nil}}
+        }}
+
+        // Apply saves the flagSet for later usage calls, then calls the
+        // wrapped {name}Flag.Apply
+        func (f *{name}Flag) Apply(set *flag.FlagSet) {{
+            f.set = set
+            f.{name}Flag.Apply(set)
+        }}
+
+        // ApplyWithError saves the flagSet for later usage calls, then calls the
+        // wrapped {name}Flag.ApplyWithError
+        func (f *{name}Flag) ApplyWithError(set *flag.FlagSet) error {{
+            f.set = set
+            return f.{name}Flag.ApplyWithError(set)
+        }}
+        """.format(**typedef))
+
+
+def _fwrite(outfile, text):
+    print(textwrap.dedent(text), end='', file=outfile)
+
+
+_WRITEFUNCS = {
+    'cli': _write_cli_flag_types,
+    'altsrc': _write_altsrc_flag_types
+}
+
+if __name__ == '__main__':
+    sys.exit(main())

vendor/github.com/codegangsta/cli/help.go

@@ -3,148 +3,170 @@ package cli
 import (
 	"fmt"
 	"io"
+	"os"
 	"strings"
 	"text/tabwriter"
 	"text/template"
 )
 
-// The text template for the Default help topic.
+// AppHelpTemplate is 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}}
+   {{.Name}}{{if .Usage}} - {{.Usage}}{{end}}
 
 USAGE:
-   {{.Name}} {{if .Flags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} [arguments...]
-   {{if .Version}}
+   {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}{{if .Version}}{{if not .HideVersion}}
+
 VERSION:
-   {{.Version}}
-   {{end}}{{if len .Authors}}
-AUTHOR(S):
-   {{range .Authors}}{{ . }}{{end}}
-   {{end}}{{if .Commands}}
-COMMANDS:
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-   {{end}}{{end}}{{if .Flags}}
+   {{.Version}}{{end}}{{end}}{{if .Description}}
+
+DESCRIPTION:
+   {{.Description}}{{end}}{{if len .Authors}}
+
+AUTHOR{{with $length := len .Authors}}{{if ne 1 $length}}S{{end}}{{end}}:
+   {{range $index, $author := .Authors}}{{if $index}}
+   {{end}}{{$author}}{{end}}{{end}}{{if .VisibleCommands}}
+
+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
+   {{.Name}}:{{end}}{{range .VisibleCommands}}
+     {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
+
 GLOBAL OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{end}}{{if .Copyright }}
+   {{range $index, $option := .VisibleFlags}}{{if $index}}
+   {{end}}{{$option}}{{end}}{{end}}{{if .Copyright}}
+
 COPYRIGHT:
-   {{.Copyright}}
-   {{end}}
+   {{.Copyright}}{{end}}
 `
 
-// The text template for the command help topic.
+// CommandHelpTemplate is 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:
-   {{.FullName}} - {{.Usage}}
+   {{.HelpName}} - {{.Usage}}
 
 USAGE:
-   command {{.FullName}}{{if .Flags}} [command options]{{end}} [arguments...]{{if .Description}}
+   {{.HelpName}}{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Category}}
+
+CATEGORY:
+   {{.Category}}{{end}}{{if .Description}}
 
 DESCRIPTION:
-   {{.Description}}{{end}}{{if .Flags}}
+   {{.Description}}{{end}}{{if .VisibleFlags}}
 
 OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{ end }}
+   {{range .VisibleFlags}}{{.}}
+   {{end}}{{end}}
 `
 
-// The text template for the subcommand help topic.
+// SubcommandHelpTemplate is 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}}
+   {{.HelpName}} - {{.Usage}}
 
 USAGE:
-   {{.Name}} command{{if .Flags}} [command options]{{end}} [arguments...]
+   {{.HelpName}} command{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
 
-COMMANDS:
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-   {{end}}{{if .Flags}}
+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
+   {{.Name}}:{{end}}{{range .VisibleCommands}}
+     {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}
+{{end}}{{if .VisibleFlags}}
 OPTIONS:
-   {{range .Flags}}{{.}}
+   {{range .VisibleFlags}}{{.}}
    {{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) {
+	Name:      "help",
+	Aliases:   []string{"h"},
+	Usage:     "Shows a list of commands or help for one command",
+	ArgsUsage: "[command]",
+	Action: func(c *Context) error {
 		args := c.Args()
 		if args.Present() {
-			ShowCommandHelp(c, args.First())
-		} else {
-			ShowAppHelp(c)
+			return ShowCommandHelp(c, args.First())
 		}
+
+		ShowAppHelp(c)
+		return nil
 	},
 }
 
 var helpSubcommand = Command{
-	Name:    "help",
-	Aliases: []string{"h"},
-	Usage:   "Shows a list of commands or help for one command",
-	Action: func(c *Context) {
+	Name:      "help",
+	Aliases:   []string{"h"},
+	Usage:     "Shows a list of commands or help for one command",
+	ArgsUsage: "[command]",
+	Action: func(c *Context) error {
 		args := c.Args()
 		if args.Present() {
-			ShowCommandHelp(c, args.First())
-		} else {
-			ShowSubcommandHelp(c)
+			return ShowCommandHelp(c, args.First())
 		}
+
+		return ShowSubcommandHelp(c)
 	},
 }
 
 // Prints help for the App or Command
 type helpPrinter func(w io.Writer, templ string, data interface{})
 
+// HelpPrinter is a function that writes the help output. If not set a default
+// is used. The function signature is:
+// func(w io.Writer, templ string, data interface{})
 var HelpPrinter helpPrinter = printHelp
 
-// Prints version for the App
+// VersionPrinter prints the version for the App
 var VersionPrinter = printVersion
 
-func ShowAppHelp(c *Context) {
+// ShowAppHelp is an action that displays the help.
+func ShowAppHelp(c *Context) error {
 	HelpPrinter(c.App.Writer, AppHelpTemplate, c.App)
+	return nil
 }
 
-// Prints the list of subcommands as the default app completion method
+// DefaultAppComplete prints the list of subcommands as the default app completion method
 func DefaultAppComplete(c *Context) {
 	for _, command := range c.App.Commands {
+		if command.Hidden {
+			continue
+		}
 		for _, name := range command.Names() {
 			fmt.Fprintln(c.App.Writer, name)
 		}
 	}
 }
 
-// Prints help for the given command
-func ShowCommandHelp(ctx *Context, command string) {
+// ShowCommandHelp prints help for the given command
+func ShowCommandHelp(ctx *Context, command string) error {
 	// show the subcommand help for a command with subcommands
 	if command == "" {
 		HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App)
-		return
+		return nil
 	}
 
 	for _, c := range ctx.App.Commands {
 		if c.HasName(command) {
 			HelpPrinter(ctx.App.Writer, CommandHelpTemplate, c)
-			return
+			return nil
 		}
 	}
 
-	if ctx.App.CommandNotFound != nil {
-		ctx.App.CommandNotFound(ctx, command)
-	} else {
-		fmt.Fprintf(ctx.App.Writer, "No help topic for '%v'\n", command)
+	if ctx.App.CommandNotFound == nil {
+		return NewExitError(fmt.Sprintf("No help topic for '%v'", command), 3)
 	}
+
+	ctx.App.CommandNotFound(ctx, command)
+	return nil
 }
 
-// Prints help for the given subcommand
-func ShowSubcommandHelp(c *Context) {
-	ShowCommandHelp(c, c.Command.Name)
+// ShowSubcommandHelp prints help for the given subcommand
+func ShowSubcommandHelp(c *Context) error {
+	return ShowCommandHelp(c, c.Command.Name)
 }
 
-// Prints the version number of the App
+// ShowVersion prints the version number of the App
 func ShowVersion(c *Context) {
 	VersionPrinter(c)
 }
@@ -153,7 +175,7 @@ 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
+// ShowCompletions prints the lists of commands within a given context
 func ShowCompletions(c *Context) {
 	a := c.App
 	if a != nil && a.BashComplete != nil {
@@ -161,7 +183,7 @@ func ShowCompletions(c *Context) {
 	}
 }
 
-// Prints the custom completions for a given command
+// ShowCommandCompletions 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 {
@@ -174,31 +196,42 @@ func printHelp(out io.Writer, templ string, data interface{}) {
 		"join": strings.Join,
 	}
 
-	w := tabwriter.NewWriter(out, 0, 8, 1, '\t', 0)
+	w := tabwriter.NewWriter(out, 1, 8, 2, ' ', 0)
 	t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
 	err := t.Execute(w, data)
 	if err != nil {
-		panic(err)
+		// If the writer is closed, t.Execute will fail, and there's nothing
+		// we can do to recover.
+		if os.Getenv("CLI_TEMPLATE_ERROR_DEBUG") != "" {
+			fmt.Fprintf(ErrWriter, "CLI TEMPLATE ERROR: %#v\n", err)
+		}
+		return
 	}
 	w.Flush()
 }
 
 func checkVersion(c *Context) bool {
-	if c.GlobalBool("version") || c.GlobalBool("v") || c.Bool("version") || c.Bool("v") {
-		ShowVersion(c)
-		return true
+	found := false
+	if VersionFlag.Name != "" {
+		eachName(VersionFlag.Name, func(name string) {
+			if c.GlobalBool(name) || c.Bool(name) {
+				found = true
+			}
+		})
 	}
-
-	return false
+	return found
 }
 
 func checkHelp(c *Context) bool {
-	if c.GlobalBool("h") || c.GlobalBool("help") || c.Bool("h") || c.Bool("help") {
-		ShowAppHelp(c)
-		return true
+	found := false
+	if HelpFlag.Name != "" {
+		eachName(HelpFlag.Name, func(name string) {
+			if c.GlobalBool(name) || c.Bool(name) {
+				found = true
+			}
+		})
 	}
-
-	return false
+	return found
 }
 
 func checkCommandHelp(c *Context, name string) bool {
@@ -211,7 +244,7 @@ func checkCommandHelp(c *Context, name string) bool {
 }
 
 func checkSubcommandHelp(c *Context) bool {
-	if c.GlobalBool("h") || c.GlobalBool("help") {
+	if c.Bool("h") || c.Bool("help") {
 		ShowSubcommandHelp(c)
 		return true
 	}
@@ -219,20 +252,43 @@ func checkSubcommandHelp(c *Context) bool {
 	return false
 }
 
-func checkCompletions(c *Context) bool {
-	if (c.GlobalBool(BashCompletionFlag.Name) || c.Bool(BashCompletionFlag.Name)) && c.App.EnableBashCompletion {
-		ShowCompletions(c)
-		return true
+func checkShellCompleteFlag(a *App, arguments []string) (bool, []string) {
+	if !a.EnableBashCompletion {
+		return false, arguments
 	}
 
-	return false
+	pos := len(arguments) - 1
+	lastArg := arguments[pos]
+
+	if lastArg != "--"+BashCompletionFlag.Name {
+		return false, arguments
+	}
+
+	return true, arguments[:pos]
+}
+
+func checkCompletions(c *Context) bool {
+	if !c.shellComplete {
+		return false
+	}
+
+	if args := c.Args(); args.Present() {
+		name := args.First()
+		if cmd := c.App.Command(name); cmd != nil {
+			// let the command handle the completion
+			return false
+		}
+	}
+
+	ShowCompletions(c)
+	return true
 }
 
 func checkCommandCompletions(c *Context, name string) bool {
-	if c.Bool(BashCompletionFlag.Name) && c.App.EnableBashCompletion {
-		ShowCommandCompletions(c, name)
-		return true
+	if !c.shellComplete {
+		return false
 	}
 
-	return false
+	ShowCommandCompletions(c, name)
+	return true
 }

vendor/github.com/codegangsta/cli/runtests

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+from __future__ import print_function
+
+import argparse
+import os
+import sys
+import tempfile
+
+from subprocess import check_call, check_output
+
+
+PACKAGE_NAME = os.environ.get(
+    'CLI_PACKAGE_NAME', 'github.com/urfave/cli'
+)
+
+
+def main(sysargs=sys.argv[:]):
+    targets = {
+        'vet': _vet,
+        'test': _test,
+        'gfmrun': _gfmrun,
+        'toc': _toc,
+        'gen': _gen,
+    }
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        'target', nargs='?', choices=tuple(targets.keys()), default='test'
+    )
+    args = parser.parse_args(sysargs[1:])
+
+    targets[args.target]()
+    return 0
+
+
+def _test():
+    if check_output('go version'.split()).split()[2] < 'go1.2':
+        _run('go test -v .')
+        return
+
+    coverprofiles = []
+    for subpackage in ['', 'altsrc']:
+        coverprofile = 'cli.coverprofile'
+        if subpackage != '':
+            coverprofile = '{}.coverprofile'.format(subpackage)
+
+        coverprofiles.append(coverprofile)
+
+        _run('go test -v'.split() + [
+            '-coverprofile={}'.format(coverprofile),
+            ('{}/{}'.format(PACKAGE_NAME, subpackage)).rstrip('/')
+        ])
+
+    combined_name = _combine_coverprofiles(coverprofiles)
+    _run('go tool cover -func={}'.format(combined_name))
+    os.remove(combined_name)
+
+
+def _gfmrun():
+    go_version = check_output('go version'.split()).split()[2]
+    if go_version < 'go1.3':
+        print('runtests: skip on {}'.format(go_version), file=sys.stderr)
+        return
+    _run(['gfmrun', '-c', str(_gfmrun_count()), '-s', 'README.md'])
+
+
+def _vet():
+    _run('go vet ./...')
+
+
+def _toc():
+    _run('node_modules/.bin/markdown-toc -i README.md')
+    _run('git diff --exit-code')
+
+
+def _gen():
+    go_version = check_output('go version'.split()).split()[2]
+    if go_version < 'go1.5':
+        print('runtests: skip on {}'.format(go_version), file=sys.stderr)
+        return
+
+    _run('go generate ./...')
+    _run('git diff --exit-code')
+
+
+def _run(command):
+    if hasattr(command, 'split'):
+        command = command.split()
+    print('runtests: {}'.format(' '.join(command)), file=sys.stderr)
+    check_call(command)
+
+
+def _gfmrun_count():
+    with open('README.md') as infile:
+        lines = infile.read().splitlines()
+        return len(filter(_is_go_runnable, lines))
+
+
+def _is_go_runnable(line):
+    return line.startswith('package main')
+
+
+def _combine_coverprofiles(coverprofiles):
+    combined = tempfile.NamedTemporaryFile(
+        suffix='.coverprofile', delete=False
+    )
+    combined.write('mode: set\n')
+
+    for coverprofile in coverprofiles:
+        with open(coverprofile, 'r') as infile:
+            for line in infile.readlines():
+                if not line.startswith('mode: '):
+                    combined.write(line)
+
+    combined.flush()
+    name = combined.name
+    combined.close()
+    return name
+
+
+if __name__ == '__main__':
+    sys.exit(main())

vendor/github.com/pkg/errors/.gitignore

@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof

vendor/github.com/pkg/errors/.travis.yml

@@ -0,0 +1,11 @@
+language: go
+go_import_path: github.com/pkg/errors
+go:
+  - 1.4.3
+  - 1.5.4
+  - 1.6.3
+  - 1.7.3
+  - tip
+
+script:
+  - go test -v ./...

vendor/github.com/pkg/errors/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2015, Dave Cheney <dave@cheney.net>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/pkg/errors/README.md

@@ -0,0 +1,52 @@
+# errors [![Travis-CI](https://travis-ci.org/pkg/errors.svg)](https://travis-ci.org/pkg/errors) [![AppVeyor](https://ci.appveyor.com/api/projects/status/b98mptawhudj53ep/branch/master?svg=true)](https://ci.appveyor.com/project/davecheney/errors/branch/master) [![GoDoc](https://godoc.org/github.com/pkg/errors?status.svg)](http://godoc.org/github.com/pkg/errors) [![Report card](https://goreportcard.com/badge/github.com/pkg/errors)](https://goreportcard.com/report/github.com/pkg/errors)
+
+Package errors provides simple error handling primitives.
+
+`go get github.com/pkg/errors`
+
+The traditional error handling idiom in Go is roughly akin to
+```go
+if err != nil {
+        return err
+}
+```
+which applied recursively up the call stack results in error reports without context or debugging information. The errors package allows programmers to add context to the failure path in their code in a way that does not destroy the original value of the error.
+
+## Adding context to an error
+
+The errors.Wrap function returns a new error that adds context to the original error. For example
+```go
+_, err := ioutil.ReadAll(r)
+if err != nil {
+        return errors.Wrap(err, "read failed")
+}
+```
+## Retrieving the cause of an error
+
+Using `errors.Wrap` constructs a stack of errors, adding context to the preceding error. Depending on the nature of the error it may be necessary to reverse the operation of errors.Wrap to retrieve the original error for inspection. Any error value which implements this interface can be inspected by `errors.Cause`.
+```go
+type causer interface {
+        Cause() error
+}
+```
+`errors.Cause` will recursively retrieve the topmost error which does not implement `causer`, which is assumed to be the original cause. For example:
+```go
+switch err := errors.Cause(err).(type) {
+case *MyError:
+        // handle specifically
+default:
+        // unknown error
+}
+```
+
+[Read the package documentation for more information](https://godoc.org/github.com/pkg/errors).
+
+## Contributing
+
+We welcome pull requests, bug fixes and issue reports. With that said, the bar for adding new symbols to this package is intentionally set high.
+
+Before proposing a change, please discuss your change by raising an issue.
+
+## Licence
+
+BSD-2-Clause

vendor/github.com/pkg/errors/appveyor.yml

@@ -0,0 +1,32 @@
+version: build-{build}.{branch}
+
+clone_folder: C:\gopath\src\github.com\pkg\errors
+shallow_clone: true # for startup speed
+
+environment:
+  GOPATH: C:\gopath
+
+platform:
+  - x64
+
+# http://www.appveyor.com/docs/installed-software
+install:
+  # some helpful output for debugging builds
+  - go version
+  - go env
+  # pre-installed MinGW at C:\MinGW is 32bit only
+  # but MSYS2 at C:\msys64 has mingw64
+  - set PATH=C:\msys64\mingw64\bin;%PATH%
+  - gcc --version
+  - g++ --version
+
+build_script:
+  - go install -v ./...
+
+test_script:
+  - set PATH=C:\gopath\bin;%PATH%
+  - go test -v ./...
+
+#artifacts:
+#  - path: '%GOPATH%\bin\*.exe'
+deploy: off

vendor/github.com/pkg/errors/errors.go

@@ -0,0 +1,269 @@
+// Package errors provides simple error handling primitives.
+//
+// The traditional error handling idiom in Go is roughly akin to
+//
+//     if err != nil {
+//             return err
+//     }
+//
+// which applied recursively up the call stack results in error reports
+// without context or debugging information. The errors package allows
+// programmers to add context to the failure path in their code in a way
+// that does not destroy the original value of the error.
+//
+// Adding context to an error
+//
+// The errors.Wrap function returns a new error that adds context to the
+// original error by recording a stack trace at the point Wrap is called,
+// and the supplied message. For example
+//
+//     _, err := ioutil.ReadAll(r)
+//     if err != nil {
+//             return errors.Wrap(err, "read failed")
+//     }
+//
+// If additional control is required the errors.WithStack and errors.WithMessage
+// functions destructure errors.Wrap into its component operations of annotating
+// an error with a stack trace and an a message, respectively.
+//
+// Retrieving the cause of an error
+//
+// Using errors.Wrap constructs a stack of errors, adding context to the
+// preceding error. Depending on the nature of the error it may be necessary
+// to reverse the operation of errors.Wrap to retrieve the original error
+// for inspection. Any error value which implements this interface
+//
+//     type causer interface {
+//             Cause() error
+//     }
+//
+// can be inspected by errors.Cause. errors.Cause will recursively retrieve
+// the topmost error which does not implement causer, which is assumed to be
+// the original cause. For example:
+//
+//     switch err := errors.Cause(err).(type) {
+//     case *MyError:
+//             // handle specifically
+//     default:
+//             // unknown error
+//     }
+//
+// causer interface is not exported by this package, but is considered a part
+// of stable public API.
+//
+// Formatted printing of errors
+//
+// All error values returned from this package implement fmt.Formatter and can
+// be formatted by the fmt package. The following verbs are supported
+//
+//     %s    print the error. If the error has a Cause it will be
+//           printed recursively
+//     %v    see %s
+//     %+v   extended format. Each Frame of the error's StackTrace will
+//           be printed in detail.
+//
+// Retrieving the stack trace of an error or wrapper
+//
+// New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
+// invoked. This information can be retrieved with the following interface.
+//
+//     type stackTracer interface {
+//             StackTrace() errors.StackTrace
+//     }
+//
+// Where errors.StackTrace is defined as
+//
+//     type StackTrace []Frame
+//
+// The Frame type represents a call site in the stack trace. Frame supports
+// the fmt.Formatter interface that can be used for printing information about
+// the stack trace of this error. For example:
+//
+//     if err, ok := err.(stackTracer); ok {
+//             for _, f := range err.StackTrace() {
+//                     fmt.Printf("%+s:%d", f)
+//             }
+//     }
+//
+// stackTracer interface is not exported by this package, but is considered a part
+// of stable public API.
+//
+// See the documentation for Frame.Format for more details.
+package errors
+
+import (
+	"fmt"
+	"io"
+)
+
+// New returns an error with the supplied message.
+// New also records the stack trace at the point it was called.
+func New(message string) error {
+	return &fundamental{
+		msg:   message,
+		stack: callers(),
+	}
+}
+
+// Errorf formats according to a format specifier and returns the string
+// as a value that satisfies error.
+// Errorf also records the stack trace at the point it was called.
+func Errorf(format string, args ...interface{}) error {
+	return &fundamental{
+		msg:   fmt.Sprintf(format, args...),
+		stack: callers(),
+	}
+}
+
+// fundamental is an error that has a message and a stack, but no caller.
+type fundamental struct {
+	msg string
+	*stack
+}
+
+func (f *fundamental) Error() string { return f.msg }
+
+func (f *fundamental) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') {
+			io.WriteString(s, f.msg)
+			f.stack.Format(s, verb)
+			return
+		}
+		fallthrough
+	case 's':
+		io.WriteString(s, f.msg)
+	case 'q':
+		fmt.Fprintf(s, "%q", f.msg)
+	}
+}
+
+// WithStack annotates err with a stack trace at the point WithStack was called.
+// If err is nil, WithStack returns nil.
+func WithStack(err error) error {
+	if err == nil {
+		return nil
+	}
+	return &withStack{
+		err,
+		callers(),
+	}
+}
+
+type withStack struct {
+	error
+	*stack
+}
+
+func (w *withStack) Cause() error { return w.error }
+
+func (w *withStack) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') {
+			fmt.Fprintf(s, "%+v", w.Cause())
+			w.stack.Format(s, verb)
+			return
+		}
+		fallthrough
+	case 's':
+		io.WriteString(s, w.Error())
+	case 'q':
+		fmt.Fprintf(s, "%q", w.Error())
+	}
+}
+
+// Wrap returns an error annotating err with a stack trace
+// at the point Wrap is called, and the supplied message.
+// If err is nil, Wrap returns nil.
+func Wrap(err error, message string) error {
+	if err == nil {
+		return nil
+	}
+	err = &withMessage{
+		cause: err,
+		msg:   message,
+	}
+	return &withStack{
+		err,
+		callers(),
+	}
+}
+
+// Wrapf returns an error annotating err with a stack trace
+// at the point Wrapf is call, and the format specifier.
+// If err is nil, Wrapf returns nil.
+func Wrapf(err error, format string, args ...interface{}) error {
+	if err == nil {
+		return nil
+	}
+	err = &withMessage{
+		cause: err,
+		msg:   fmt.Sprintf(format, args...),
+	}
+	return &withStack{
+		err,
+		callers(),
+	}
+}
+
+// WithMessage annotates err with a new message.
+// If err is nil, WithMessage returns nil.
+func WithMessage(err error, message string) error {
+	if err == nil {
+		return nil
+	}
+	return &withMessage{
+		cause: err,
+		msg:   message,
+	}
+}
+
+type withMessage struct {
+	cause error
+	msg   string
+}
+
+func (w *withMessage) Error() string { return w.msg + ": " + w.cause.Error() }
+func (w *withMessage) Cause() error  { return w.cause }
+
+func (w *withMessage) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') {
+			fmt.Fprintf(s, "%+v\n", w.Cause())
+			io.WriteString(s, w.msg)
+			return
+		}
+		fallthrough
+	case 's', 'q':
+		io.WriteString(s, w.Error())
+	}
+}
+
+// Cause returns the underlying cause of the error, if possible.
+// An error value has a cause if it implements the following
+// interface:
+//
+//     type causer interface {
+//            Cause() error
+//     }
+//
+// If the error does not implement Cause, the original error will
+// be returned. If the error is nil, nil will be returned without further
+// investigation.
+func Cause(err error) error {
+	type causer interface {
+		Cause() error
+	}
+
+	for err != nil {
+		cause, ok := err.(causer)
+		if !ok {
+			break
+		}
+		err = cause.Cause()
+	}
+	return err
+}

vendor/github.com/pkg/errors/stack.go

@@ -0,0 +1,178 @@
+package errors
+
+import (
+	"fmt"
+	"io"
+	"path"
+	"runtime"
+	"strings"
+)
+
+// Frame represents a program counter inside a stack frame.
+type Frame uintptr
+
+// pc returns the program counter for this frame;
+// multiple frames may have the same PC value.
+func (f Frame) pc() uintptr { return uintptr(f) - 1 }
+
+// file returns the full path to the file that contains the
+// function for this Frame's pc.
+func (f Frame) file() string {
+	fn := runtime.FuncForPC(f.pc())
+	if fn == nil {
+		return "unknown"
+	}
+	file, _ := fn.FileLine(f.pc())
+	return file
+}
+
+// line returns the line number of source code of the
+// function for this Frame's pc.
+func (f Frame) line() int {
+	fn := runtime.FuncForPC(f.pc())
+	if fn == nil {
+		return 0
+	}
+	_, line := fn.FileLine(f.pc())
+	return line
+}
+
+// Format formats the frame according to the fmt.Formatter interface.
+//
+//    %s    source file
+//    %d    source line
+//    %n    function name
+//    %v    equivalent to %s:%d
+//
+// Format accepts flags that alter the printing of some verbs, as follows:
+//
+//    %+s   path of source file relative to the compile time GOPATH
+//    %+v   equivalent to %+s:%d
+func (f Frame) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 's':
+		switch {
+		case s.Flag('+'):
+			pc := f.pc()
+			fn := runtime.FuncForPC(pc)
+			if fn == nil {
+				io.WriteString(s, "unknown")
+			} else {
+				file, _ := fn.FileLine(pc)
+				fmt.Fprintf(s, "%s\n\t%s", fn.Name(), file)
+			}
+		default:
+			io.WriteString(s, path.Base(f.file()))
+		}
+	case 'd':
+		fmt.Fprintf(s, "%d", f.line())
+	case 'n':
+		name := runtime.FuncForPC(f.pc()).Name()
+		io.WriteString(s, funcname(name))
+	case 'v':
+		f.Format(s, 's')
+		io.WriteString(s, ":")
+		f.Format(s, 'd')
+	}
+}
+
+// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
+type StackTrace []Frame
+
+func (st StackTrace) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		switch {
+		case s.Flag('+'):
+			for _, f := range st {
+				fmt.Fprintf(s, "\n%+v", f)
+			}
+		case s.Flag('#'):
+			fmt.Fprintf(s, "%#v", []Frame(st))
+		default:
+			fmt.Fprintf(s, "%v", []Frame(st))
+		}
+	case 's':
+		fmt.Fprintf(s, "%s", []Frame(st))
+	}
+}
+
+// stack represents a stack of program counters.
+type stack []uintptr
+
+func (s *stack) Format(st fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		switch {
+		case st.Flag('+'):
+			for _, pc := range *s {
+				f := Frame(pc)
+				fmt.Fprintf(st, "\n%+v", f)
+			}
+		}
+	}
+}
+
+func (s *stack) StackTrace() StackTrace {
+	f := make([]Frame, len(*s))
+	for i := 0; i < len(f); i++ {
+		f[i] = Frame((*s)[i])
+	}
+	return f
+}
+
+func callers() *stack {
+	const depth = 32
+	var pcs [depth]uintptr
+	n := runtime.Callers(3, pcs[:])
+	var st stack = pcs[0:n]
+	return &st
+}
+
+// funcname removes the path prefix component of a function's name reported by func.Name().
+func funcname(name string) string {
+	i := strings.LastIndex(name, "/")
+	name = name[i+1:]
+	i = strings.Index(name, ".")
+	return name[i+1:]
+}
+
+func trimGOPATH(name, file string) string {
+	// Here we want to get the source file path relative to the compile time
+	// GOPATH. As of Go 1.6.x there is no direct way to know the compiled
+	// GOPATH at runtime, but we can infer the number of path segments in the
+	// GOPATH. We note that fn.Name() returns the function name qualified by
+	// the import path, which does not include the GOPATH. Thus we can trim
+	// segments from the beginning of the file path until the number of path
+	// separators remaining is one more than the number of path separators in
+	// the function name. For example, given:
+	//
+	//    GOPATH     /home/user
+	//    file       /home/user/src/pkg/sub/file.go
+	//    fn.Name()  pkg/sub.Type.Method
+	//
+	// We want to produce:
+	//
+	//    pkg/sub/file.go
+	//
+	// From this we can easily see that fn.Name() has one less path separator
+	// than our desired output. We count separators from the end of the file
+	// path until it finds two more than in the function name and then move
+	// one character forward to preserve the initial path segment without a
+	// leading separator.
+	const sep = "/"
+	goal := strings.Count(name, sep) + 2
+	i := len(file)
+	for n := 0; n < goal; n++ {
+		i = strings.LastIndex(file[:i], sep)
+		if i == -1 {
+			// not enough separators found, set i so that the slice expression
+			// below leaves file unmodified
+			i = -len(sep)
+			break
+		}
+	}
+	// get back to 0 or trim the leading separator
+	file = file[i+len(sep):]
+	return file
+}

vendor/github.com/yudai/umutex/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Iwasaki Yudai
-
-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.

vendor/github.com/yudai/umutex/README.md

@@ -1,53 +0,0 @@
-# Unblocking Mutex
-
-This simple package provides unblocking mutexes for those who don't want to write many `select` clauses or get confused by numerous channels.
-
-## Usage Example
-
-```go
-package main
-
-import (
-	"fmt"
-	"github.com/yudai/umutex"
-)
-
-func main() {
-	// Create mutex
-	mutex := umutex.New()
-
-	// First time, try should succeed
-	if mutex.TryLock() {
-		fmt.Println("SUCCESS")
-	} else {
-		fmt.Println("FAILURE")
-	}
-
-	// Second time, try should fail as it's locked
-	if mutex.TryLock() {
-		fmt.Println("SUCCESS")
-	} else {
-		fmt.Println("FAILURE")
-	}
-
-	// Unclock mutex
-	mutex.Unlock()
-
-	// Third time, try should succeed again
-	if mutex.TryLock() {
-		fmt.Println("SUCCESS")
-	} else {
-		fmt.Println("FAILURE")
-	}
-}
-```
-
-The output is;
-
-```sh
-SUCCESS
-FAILURE
-SUCCESS
-```
-
-`ForceLock()` method is also availale for normal blocking lock.

vendor/github.com/yudai/umutex/umutex.go

@@ -1,38 +0,0 @@
-// Package umutex provides unblocking mutex
-package umutex
-
-// UnblockingMutex represents an unblocking mutex.
-type UnblockingMutex struct {
-	// Raw channel
-	C chan bool
-}
-
-// New returnes a new unblocking mutex instance.
-func New() *UnblockingMutex {
-	return &UnblockingMutex{
-		C: make(chan bool, 1),
-	}
-}
-
-// TryLock tries to lock the mutex.
-// When the mutex is free at the time, the function locks the mutex and return
-// true. Otherwise false will be returned. In the both cases, this function
-// doens't block and return the result immediately.
-func (m UnblockingMutex) TryLock() (result bool) {
-	select {
-	case m.C <- true:
-		return true
-	default:
-		return false
-	}
-}
-
-// Unlock unclocks the mutex.
-func (m UnblockingMutex) Unlock() {
-	<-m.C
-}
-
-// ForceLock surely locks the mutex, however, this function blocks when the mutex is locked at the time.
-func (m UnblockingMutex) ForceLock() {
-	m.C <- false
-}

version.go

@@ -0,0 +1,4 @@
+package main
+
+var Version = "unknown_version"
+var CommitID = "unknown_commit"

webtty/doc.go

@@ -0,0 +1,3 @@
+// Package webtty provides a protocl and an implementation to
+// controll terminals thorough networks.
+package webtty