You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by ma...@apache.org on 2016/04/28 06:52:18 UTC
[51/51] [abbrv] [partial] incubator-mynewt-newt git commit: newt;
add updated vendor packages.
newt; add updated vendor packages.
Project: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/commit/f6ae9636
Tree: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/tree/f6ae9636
Diff: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/diff/f6ae9636
Branch: refs/heads/develop
Commit: f6ae9636f285e01436bb20a208e95ad850c7bda9
Parents: 7e05641
Author: Marko Kiiskila <ma...@runtime.io>
Authored: Wed Apr 27 21:45:22 2016 -0700
Committer: Marko Kiiskila <ma...@runtime.io>
Committed: Wed Apr 27 21:45:22 2016 -0700
----------------------------------------------------------------------
newt/Godeps/Godeps.json | 69 +
newt/Godeps/Readme | 5 +
.../github.com/Sirupsen/logrus/.gitignore | 1 +
.../github.com/Sirupsen/logrus/.travis.yml | 9 +
.../github.com/Sirupsen/logrus/CHANGELOG.md | 59 +
newt/vendor/github.com/Sirupsen/logrus/LICENSE | 21 +
.../vendor/github.com/Sirupsen/logrus/README.md | 386 +++
newt/vendor/github.com/Sirupsen/logrus/doc.go | 26 +
newt/vendor/github.com/Sirupsen/logrus/entry.go | 264 ++
.../github.com/Sirupsen/logrus/exported.go | 193 ++
.../github.com/Sirupsen/logrus/formatter.go | 48 +
newt/vendor/github.com/Sirupsen/logrus/hooks.go | 34 +
.../Sirupsen/logrus/json_formatter.go | 41 +
.../vendor/github.com/Sirupsen/logrus/logger.go | 212 ++
.../vendor/github.com/Sirupsen/logrus/logrus.go | 109 +
.../github.com/Sirupsen/logrus/terminal_bsd.go | 9 +
.../Sirupsen/logrus/terminal_linux.go | 12 +
.../Sirupsen/logrus/terminal_notwindows.go | 21 +
.../Sirupsen/logrus/terminal_solaris.go | 15 +
.../Sirupsen/logrus/terminal_windows.go | 27 +
.../Sirupsen/logrus/text_formatter.go | 161 ++
.../vendor/github.com/Sirupsen/logrus/writer.go | 31 +
.../inconshreveable/mousetrap/LICENSE | 13 +
.../inconshreveable/mousetrap/README.md | 23 +
.../inconshreveable/mousetrap/trap_others.go | 15 +
.../inconshreveable/mousetrap/trap_windows.go | 98 +
.../mousetrap/trap_windows_1.4.go | 46 +
newt/vendor/github.com/kr/pretty/.gitignore | 4 +
newt/vendor/github.com/kr/pretty/License | 21 +
newt/vendor/github.com/kr/pretty/Readme | 9 +
newt/vendor/github.com/kr/pretty/diff.go | 158 +
newt/vendor/github.com/kr/pretty/formatter.go | 337 +++
newt/vendor/github.com/kr/pretty/pretty.go | 98 +
newt/vendor/github.com/kr/pretty/zero.go | 41 +
newt/vendor/github.com/kr/text/License | 19 +
newt/vendor/github.com/kr/text/Readme | 3 +
newt/vendor/github.com/kr/text/doc.go | 3 +
newt/vendor/github.com/kr/text/indent.go | 74 +
newt/vendor/github.com/kr/text/wrap.go | 86 +
.../mitchellh/mapstructure/.travis.yml | 7 +
.../github.com/mitchellh/mapstructure/LICENSE | 21 +
.../github.com/mitchellh/mapstructure/README.md | 46 +
.../mitchellh/mapstructure/decode_hooks.go | 151 +
.../github.com/mitchellh/mapstructure/error.go | 50 +
.../mitchellh/mapstructure/mapstructure.go | 767 +++++
newt/vendor/github.com/spf13/cast/.gitignore | 23 +
newt/vendor/github.com/spf13/cast/LICENSE | 21 +
newt/vendor/github.com/spf13/cast/README.md | 72 +
newt/vendor/github.com/spf13/cast/cast.go | 73 +
newt/vendor/github.com/spf13/cast/caste.go | 456 +++
newt/vendor/github.com/spf13/cobra/.gitignore | 24 +
newt/vendor/github.com/spf13/cobra/.mailmap | 3 +
newt/vendor/github.com/spf13/cobra/.travis.yml | 9 +
newt/vendor/github.com/spf13/cobra/LICENSE.txt | 174 ++
newt/vendor/github.com/spf13/cobra/README.md | 872 ++++++
.../github.com/spf13/cobra/bash_completions.go | 532 ++++
.../github.com/spf13/cobra/bash_completions.md | 149 +
newt/vendor/github.com/spf13/cobra/cobra.go | 162 ++
newt/vendor/github.com/spf13/cobra/command.go | 1197 ++++++++
.../github.com/spf13/cobra/command_notwin.go | 5 +
.../github.com/spf13/cobra/command_win.go | 26 +
.../spf13/jwalterweatherman/.gitignore | 22 +
.../github.com/spf13/jwalterweatherman/LICENSE | 21 +
.../spf13/jwalterweatherman/README.md | 161 ++
.../thatswhyyoualwaysleaveanote.go | 198 ++
newt/vendor/github.com/spf13/pflag/.travis.yml | 18 +
newt/vendor/github.com/spf13/pflag/LICENSE | 28 +
newt/vendor/github.com/spf13/pflag/README.md | 256 ++
newt/vendor/github.com/spf13/pflag/bool.go | 97 +
newt/vendor/github.com/spf13/pflag/count.go | 97 +
newt/vendor/github.com/spf13/pflag/duration.go | 86 +
newt/vendor/github.com/spf13/pflag/flag.go | 920 ++++++
newt/vendor/github.com/spf13/pflag/float32.go | 91 +
newt/vendor/github.com/spf13/pflag/float64.go | 87 +
.../vendor/github.com/spf13/pflag/golangflag.go | 104 +
newt/vendor/github.com/spf13/pflag/int.go | 87 +
newt/vendor/github.com/spf13/pflag/int32.go | 91 +
newt/vendor/github.com/spf13/pflag/int64.go | 87 +
newt/vendor/github.com/spf13/pflag/int8.go | 91 +
newt/vendor/github.com/spf13/pflag/int_slice.go | 128 +
newt/vendor/github.com/spf13/pflag/ip.go | 96 +
newt/vendor/github.com/spf13/pflag/ipmask.go | 122 +
newt/vendor/github.com/spf13/pflag/ipnet.go | 100 +
newt/vendor/github.com/spf13/pflag/string.go | 82 +
.../github.com/spf13/pflag/string_slice.go | 111 +
newt/vendor/github.com/spf13/pflag/uint.go | 91 +
newt/vendor/github.com/spf13/pflag/uint16.go | 89 +
newt/vendor/github.com/spf13/pflag/uint32.go | 89 +
newt/vendor/github.com/spf13/pflag/uint64.go | 91 +
newt/vendor/github.com/spf13/pflag/uint8.go | 91 +
newt/vendor/golang.org/x/sys/LICENSE | 27 +
newt/vendor/golang.org/x/sys/PATENTS | 22 +
newt/vendor/golang.org/x/sys/unix/.gitignore | 1 +
newt/vendor/golang.org/x/sys/unix/asm.s | 10 +
.../golang.org/x/sys/unix/asm_darwin_386.s | 29 +
.../golang.org/x/sys/unix/asm_darwin_amd64.s | 29 +
.../golang.org/x/sys/unix/asm_darwin_arm.s | 30 +
.../golang.org/x/sys/unix/asm_darwin_arm64.s | 30 +
.../golang.org/x/sys/unix/asm_dragonfly_386.s | 29 +
.../golang.org/x/sys/unix/asm_dragonfly_amd64.s | 29 +
.../golang.org/x/sys/unix/asm_freebsd_386.s | 29 +
.../golang.org/x/sys/unix/asm_freebsd_amd64.s | 29 +
.../golang.org/x/sys/unix/asm_freebsd_arm.s | 29 +
.../golang.org/x/sys/unix/asm_linux_386.s | 35 +
.../golang.org/x/sys/unix/asm_linux_amd64.s | 29 +
.../golang.org/x/sys/unix/asm_linux_arm.s | 29 +
.../golang.org/x/sys/unix/asm_linux_arm64.s | 24 +
.../golang.org/x/sys/unix/asm_linux_mips64x.s | 28 +
.../golang.org/x/sys/unix/asm_linux_ppc64x.s | 28 +
.../golang.org/x/sys/unix/asm_netbsd_386.s | 29 +
.../golang.org/x/sys/unix/asm_netbsd_amd64.s | 29 +
.../golang.org/x/sys/unix/asm_netbsd_arm.s | 29 +
.../golang.org/x/sys/unix/asm_openbsd_386.s | 29 +
.../golang.org/x/sys/unix/asm_openbsd_amd64.s | 29 +
.../golang.org/x/sys/unix/asm_solaris_amd64.s | 17 +
.../golang.org/x/sys/unix/bluetooth_linux.go | 35 +
newt/vendor/golang.org/x/sys/unix/constants.go | 13 +
newt/vendor/golang.org/x/sys/unix/env_unix.go | 27 +
newt/vendor/golang.org/x/sys/unix/env_unset.go | 14 +
newt/vendor/golang.org/x/sys/unix/flock.go | 24 +
.../golang.org/x/sys/unix/flock_linux_32bit.go | 13 +
newt/vendor/golang.org/x/sys/unix/gccgo.go | 46 +
newt/vendor/golang.org/x/sys/unix/gccgo_c.c | 41 +
.../golang.org/x/sys/unix/gccgo_linux_amd64.go | 20 +
newt/vendor/golang.org/x/sys/unix/mkall.sh | 274 ++
newt/vendor/golang.org/x/sys/unix/mkerrors.sh | 476 +++
newt/vendor/golang.org/x/sys/unix/mksyscall.pl | 323 +++
.../golang.org/x/sys/unix/mksyscall_solaris.pl | 294 ++
.../golang.org/x/sys/unix/mksysctl_openbsd.pl | 264 ++
.../golang.org/x/sys/unix/mksysnum_darwin.pl | 39 +
.../golang.org/x/sys/unix/mksysnum_dragonfly.pl | 50 +
.../golang.org/x/sys/unix/mksysnum_freebsd.pl | 63 +
.../golang.org/x/sys/unix/mksysnum_linux.pl | 58 +
.../golang.org/x/sys/unix/mksysnum_netbsd.pl | 58 +
.../golang.org/x/sys/unix/mksysnum_openbsd.pl | 50 +
newt/vendor/golang.org/x/sys/unix/race.go | 30 +
newt/vendor/golang.org/x/sys/unix/race0.go | 25 +
.../golang.org/x/sys/unix/sockcmsg_linux.go | 36 +
.../golang.org/x/sys/unix/sockcmsg_unix.go | 103 +
newt/vendor/golang.org/x/sys/unix/str.go | 26 +
newt/vendor/golang.org/x/sys/unix/syscall.go | 76 +
.../vendor/golang.org/x/sys/unix/syscall_bsd.go | 628 ++++
.../golang.org/x/sys/unix/syscall_darwin.go | 509 ++++
.../golang.org/x/sys/unix/syscall_darwin_386.go | 77 +
.../x/sys/unix/syscall_darwin_amd64.go | 79 +
.../golang.org/x/sys/unix/syscall_darwin_arm.go | 71 +
.../x/sys/unix/syscall_darwin_arm64.go | 77 +
.../golang.org/x/sys/unix/syscall_dragonfly.go | 411 +++
.../x/sys/unix/syscall_dragonfly_386.go | 61 +
.../x/sys/unix/syscall_dragonfly_amd64.go | 61 +
.../golang.org/x/sys/unix/syscall_freebsd.go | 682 +++++
.../x/sys/unix/syscall_freebsd_386.go | 61 +
.../x/sys/unix/syscall_freebsd_amd64.go | 61 +
.../x/sys/unix/syscall_freebsd_arm.go | 61 +
.../golang.org/x/sys/unix/syscall_linux.go | 1108 +++++++
.../golang.org/x/sys/unix/syscall_linux_386.go | 390 +++
.../x/sys/unix/syscall_linux_amd64.go | 148 +
.../golang.org/x/sys/unix/syscall_linux_arm.go | 254 ++
.../x/sys/unix/syscall_linux_arm64.go | 180 ++
.../x/sys/unix/syscall_linux_mips64x.go | 206 ++
.../x/sys/unix/syscall_linux_ppc64x.go | 99 +
.../golang.org/x/sys/unix/syscall_netbsd.go | 492 ++++
.../golang.org/x/sys/unix/syscall_netbsd_386.go | 42 +
.../x/sys/unix/syscall_netbsd_amd64.go | 42 +
.../golang.org/x/sys/unix/syscall_netbsd_arm.go | 42 +
.../golang.org/x/sys/unix/syscall_no_getwd.go | 11 +
.../golang.org/x/sys/unix/syscall_openbsd.go | 303 ++
.../x/sys/unix/syscall_openbsd_386.go | 42 +
.../x/sys/unix/syscall_openbsd_amd64.go | 42 +
.../golang.org/x/sys/unix/syscall_solaris.go | 713 +++++
.../x/sys/unix/syscall_solaris_amd64.go | 35 +
.../golang.org/x/sys/unix/syscall_unix.go | 297 ++
.../golang.org/x/sys/unix/types_darwin.go | 250 ++
.../golang.org/x/sys/unix/types_dragonfly.go | 242 ++
.../golang.org/x/sys/unix/types_freebsd.go | 353 +++
.../vendor/golang.org/x/sys/unix/types_linux.go | 414 +++
.../golang.org/x/sys/unix/types_netbsd.go | 232 ++
.../golang.org/x/sys/unix/types_openbsd.go | 244 ++
.../golang.org/x/sys/unix/types_solaris.go | 260 ++
.../golang.org/x/sys/unix/zerrors_darwin_386.go | 1576 ++++++++++
.../x/sys/unix/zerrors_darwin_amd64.go | 1576 ++++++++++
.../golang.org/x/sys/unix/zerrors_darwin_arm.go | 1293 +++++++++
.../x/sys/unix/zerrors_darwin_arm64.go | 1576 ++++++++++
.../x/sys/unix/zerrors_dragonfly_386.go | 1530 ++++++++++
.../x/sys/unix/zerrors_dragonfly_amd64.go | 1530 ++++++++++
.../x/sys/unix/zerrors_freebsd_386.go | 1743 +++++++++++
.../x/sys/unix/zerrors_freebsd_amd64.go | 1748 +++++++++++
.../x/sys/unix/zerrors_freebsd_arm.go | 1729 +++++++++++
.../golang.org/x/sys/unix/zerrors_linux_386.go | 1818 ++++++++++++
.../x/sys/unix/zerrors_linux_amd64.go | 1819 ++++++++++++
.../golang.org/x/sys/unix/zerrors_linux_arm.go | 1742 +++++++++++
.../x/sys/unix/zerrors_linux_arm64.go | 1896 ++++++++++++
.../x/sys/unix/zerrors_linux_mips64.go | 1916 ++++++++++++
.../x/sys/unix/zerrors_linux_mips64le.go | 1916 ++++++++++++
.../x/sys/unix/zerrors_linux_ppc64.go | 1969 +++++++++++++
.../x/sys/unix/zerrors_linux_ppc64le.go | 1968 +++++++++++++
.../golang.org/x/sys/unix/zerrors_netbsd_386.go | 1712 +++++++++++
.../x/sys/unix/zerrors_netbsd_amd64.go | 1702 +++++++++++
.../golang.org/x/sys/unix/zerrors_netbsd_arm.go | 1688 +++++++++++
.../x/sys/unix/zerrors_openbsd_386.go | 1584 ++++++++++
.../x/sys/unix/zerrors_openbsd_amd64.go | 1583 ++++++++++
.../x/sys/unix/zerrors_solaris_amd64.go | 1436 +++++++++
.../x/sys/unix/zsyscall_darwin_386.go | 1426 +++++++++
.../x/sys/unix/zsyscall_darwin_amd64.go | 1442 +++++++++
.../x/sys/unix/zsyscall_darwin_arm.go | 1426 +++++++++
.../x/sys/unix/zsyscall_darwin_arm64.go | 1426 +++++++++
.../x/sys/unix/zsyscall_dragonfly_386.go | 1412 +++++++++
.../x/sys/unix/zsyscall_dragonfly_amd64.go | 1412 +++++++++
.../x/sys/unix/zsyscall_freebsd_386.go | 1664 +++++++++++
.../x/sys/unix/zsyscall_freebsd_amd64.go | 1664 +++++++++++
.../x/sys/unix/zsyscall_freebsd_arm.go | 1664 +++++++++++
.../golang.org/x/sys/unix/zsyscall_linux_386.go | 1638 +++++++++++
.../x/sys/unix/zsyscall_linux_amd64.go | 1832 ++++++++++++
.../golang.org/x/sys/unix/zsyscall_linux_arm.go | 1739 +++++++++++
.../x/sys/unix/zsyscall_linux_arm64.go | 1723 +++++++++++
.../x/sys/unix/zsyscall_linux_mips64.go | 1781 ++++++++++++
.../x/sys/unix/zsyscall_linux_mips64le.go | 1781 ++++++++++++
.../x/sys/unix/zsyscall_linux_ppc64.go | 1812 ++++++++++++
.../x/sys/unix/zsyscall_linux_ppc64le.go | 1812 ++++++++++++
.../x/sys/unix/zsyscall_netbsd_386.go | 1326 +++++++++
.../x/sys/unix/zsyscall_netbsd_amd64.go | 1326 +++++++++
.../x/sys/unix/zsyscall_netbsd_arm.go | 1326 +++++++++
.../x/sys/unix/zsyscall_openbsd_386.go | 1386 +++++++++
.../x/sys/unix/zsyscall_openbsd_amd64.go | 1386 +++++++++
.../x/sys/unix/zsyscall_solaris_amd64.go | 1559 ++++++++++
.../golang.org/x/sys/unix/zsysctl_openbsd.go | 270 ++
.../golang.org/x/sys/unix/zsysnum_darwin_386.go | 398 +++
.../x/sys/unix/zsysnum_darwin_amd64.go | 398 +++
.../golang.org/x/sys/unix/zsysnum_darwin_arm.go | 358 +++
.../x/sys/unix/zsysnum_darwin_arm64.go | 398 +++
.../x/sys/unix/zsysnum_dragonfly_386.go | 304 ++
.../x/sys/unix/zsysnum_dragonfly_amd64.go | 304 ++
.../x/sys/unix/zsysnum_freebsd_386.go | 351 +++
.../x/sys/unix/zsysnum_freebsd_amd64.go | 351 +++
.../x/sys/unix/zsysnum_freebsd_arm.go | 351 +++
.../golang.org/x/sys/unix/zsysnum_linux_386.go | 355 +++
.../x/sys/unix/zsysnum_linux_amd64.go | 321 ++
.../golang.org/x/sys/unix/zsysnum_linux_arm.go | 356 +++
.../x/sys/unix/zsysnum_linux_arm64.go | 272 ++
.../x/sys/unix/zsysnum_linux_mips64.go | 327 +++
.../x/sys/unix/zsysnum_linux_mips64le.go | 327 +++
.../x/sys/unix/zsysnum_linux_ppc64.go | 360 +++
.../x/sys/unix/zsysnum_linux_ppc64le.go | 353 +++
.../golang.org/x/sys/unix/zsysnum_netbsd_386.go | 273 ++
.../x/sys/unix/zsysnum_netbsd_amd64.go | 273 ++
.../golang.org/x/sys/unix/zsysnum_netbsd_arm.go | 273 ++
.../x/sys/unix/zsysnum_openbsd_386.go | 207 ++
.../x/sys/unix/zsysnum_openbsd_amd64.go | 207 ++
.../x/sys/unix/zsysnum_solaris_amd64.go | 13 +
.../golang.org/x/sys/unix/ztypes_darwin_386.go | 447 +++
.../x/sys/unix/ztypes_darwin_amd64.go | 462 +++
.../golang.org/x/sys/unix/ztypes_darwin_arm.go | 449 +++
.../x/sys/unix/ztypes_darwin_arm64.go | 457 +++
.../x/sys/unix/ztypes_dragonfly_386.go | 437 +++
.../x/sys/unix/ztypes_dragonfly_amd64.go | 443 +++
.../golang.org/x/sys/unix/ztypes_freebsd_386.go | 502 ++++
.../x/sys/unix/ztypes_freebsd_amd64.go | 505 ++++
.../golang.org/x/sys/unix/ztypes_freebsd_arm.go | 497 ++++
.../golang.org/x/sys/unix/ztypes_linux_386.go | 607 ++++
.../golang.org/x/sys/unix/ztypes_linux_amd64.go | 625 ++++
.../golang.org/x/sys/unix/ztypes_linux_arm.go | 587 ++++
.../golang.org/x/sys/unix/ztypes_linux_arm64.go | 604 ++++
.../x/sys/unix/ztypes_linux_mips64.go | 607 ++++
.../x/sys/unix/ztypes_linux_mips64le.go | 607 ++++
.../golang.org/x/sys/unix/ztypes_linux_ppc64.go | 613 ++++
.../x/sys/unix/ztypes_linux_ppc64le.go | 613 ++++
.../golang.org/x/sys/unix/ztypes_netbsd_386.go | 396 +++
.../x/sys/unix/ztypes_netbsd_amd64.go | 403 +++
.../golang.org/x/sys/unix/ztypes_netbsd_arm.go | 401 +++
.../golang.org/x/sys/unix/ztypes_openbsd_386.go | 441 +++
.../x/sys/unix/ztypes_openbsd_amd64.go | 448 +++
.../x/sys/unix/ztypes_solaris_amd64.go | 422 +++
newt/vendor/gopkg.in/fsnotify.v1/.gitignore | 6 +
newt/vendor/gopkg.in/fsnotify.v1/.travis.yml | 23 +
newt/vendor/gopkg.in/fsnotify.v1/AUTHORS | 40 +
newt/vendor/gopkg.in/fsnotify.v1/CHANGELOG.md | 287 ++
.../vendor/gopkg.in/fsnotify.v1/CONTRIBUTING.md | 77 +
newt/vendor/gopkg.in/fsnotify.v1/LICENSE | 28 +
newt/vendor/gopkg.in/fsnotify.v1/README.md | 46 +
newt/vendor/gopkg.in/fsnotify.v1/fsnotify.go | 62 +
newt/vendor/gopkg.in/fsnotify.v1/inotify.go | 324 +++
.../gopkg.in/fsnotify.v1/inotify_poller.go | 186 ++
newt/vendor/gopkg.in/fsnotify.v1/kqueue.go | 502 ++++
.../gopkg.in/fsnotify.v1/open_mode_bsd.go | 11 +
.../gopkg.in/fsnotify.v1/open_mode_darwin.go | 12 +
newt/vendor/gopkg.in/fsnotify.v1/windows.go | 561 ++++
newt/vendor/mynewt.apache.org/newt/DISCLAIMER | 8 +
newt/vendor/mynewt.apache.org/newt/LICENSE | 247 ++
newt/vendor/mynewt.apache.org/newt/NOTICE | 8 +
newt/vendor/mynewt.apache.org/newt/util/util.go | 421 +++
.../vendor/mynewt.apache.org/newt/viper/LICENSE | 21 +
.../mynewt.apache.org/newt/viper/README.md | 620 ++++
.../mynewt.apache.org/newt/viper/flags.go | 57 +
.../vendor/mynewt.apache.org/newt/viper/util.go | 195 ++
.../mynewt.apache.org/newt/viper/viper.go | 1300 +++++++++
newt/vendor/mynewt.apache.org/newt/yaml/apic.go | 767 +++++
.../mynewt.apache.org/newt/yaml/decode.go | 308 ++
.../mynewt.apache.org/newt/yaml/emitterc.go | 1710 +++++++++++
newt/vendor/mynewt.apache.org/newt/yaml/misc.go | 32 +
.../mynewt.apache.org/newt/yaml/parserc.go | 1121 +++++++
.../mynewt.apache.org/newt/yaml/readerc.go | 419 +++
.../mynewt.apache.org/newt/yaml/scannerc.go | 2735 ++++++++++++++++++
newt/vendor/mynewt.apache.org/newt/yaml/shim.go | 42 +
.../mynewt.apache.org/newt/yaml/writerc.go | 114 +
.../vendor/mynewt.apache.org/newt/yaml/yamlh.go | 754 +++++
.../mynewt.apache.org/newt/yaml/yamlprivateh.go | 198 ++
306 files changed, 130917 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/Godeps/Godeps.json
----------------------------------------------------------------------
diff --git a/newt/Godeps/Godeps.json b/newt/Godeps/Godeps.json
new file mode 100644
index 0000000..6f5bfdd
--- /dev/null
+++ b/newt/Godeps/Godeps.json
@@ -0,0 +1,69 @@
+{
+ "ImportPath": "mynewt.apache.org/newt/newt",
+ "GoVersion": "go1.5",
+ "GodepVersion": "v62",
+ "Deps": [
+ {
+ "ImportPath": "github.com/Sirupsen/logrus",
+ "Comment": "v0.9.0-17-ga26f435",
+ "Rev": "a26f43589d737684363ff856c5a0f9f24b946510"
+ },
+ {
+ "ImportPath": "github.com/inconshreveable/mousetrap",
+ "Rev": "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
+ },
+ {
+ "ImportPath": "github.com/kr/pretty",
+ "Comment": "go.weekly.2011-12-22-27-ge6ac2fc",
+ "Rev": "e6ac2fc51e89a3249e82157fa0bb7a18ef9dd5bb"
+ },
+ {
+ "ImportPath": "github.com/kr/text",
+ "Rev": "bb797dc4fb8320488f47bf11de07a733d7233e1f"
+ },
+ {
+ "ImportPath": "github.com/mitchellh/mapstructure",
+ "Rev": "d2dd0262208475919e1a362f675cfc0e7c10e905"
+ },
+ {
+ "ImportPath": "github.com/spf13/cast",
+ "Rev": "ee7b3e0353166ab1f3a605294ac8cd2b77953778"
+ },
+ {
+ "ImportPath": "github.com/spf13/cobra",
+ "Rev": "65a708cee0a4424f4e353d031ce440643e312f92"
+ },
+ {
+ "ImportPath": "github.com/spf13/jwalterweatherman",
+ "Rev": "d00654080cddbd2b082acaa74007cb94a2b40866"
+ },
+ {
+ "ImportPath": "github.com/spf13/pflag",
+ "Rev": "7f60f83a2c81bc3c3c0d5297f61ddfa68da9d3b7"
+ },
+ {
+ "ImportPath": "golang.org/x/sys/unix",
+ "Rev": "c8bc69bc2db9c57ccf979550bc69655df5039a8a"
+ },
+ {
+ "ImportPath": "gopkg.in/fsnotify.v1",
+ "Comment": "v1.2.10",
+ "Rev": "875cf421b32f8f1b31bd43776297876d01542279"
+ },
+ {
+ "ImportPath": "mynewt.apache.org/newt/util",
+ "Comment": "mynewt_0_8_0_b2_tag-31-g7e05641",
+ "Rev": "7e05641d3a0569ac223f5040540442252c24c397"
+ },
+ {
+ "ImportPath": "mynewt.apache.org/newt/viper",
+ "Comment": "mynewt_0_8_0_b2_tag-31-g7e05641",
+ "Rev": "7e05641d3a0569ac223f5040540442252c24c397"
+ },
+ {
+ "ImportPath": "mynewt.apache.org/newt/yaml",
+ "Comment": "mynewt_0_8_0_b2_tag-31-g7e05641",
+ "Rev": "7e05641d3a0569ac223f5040540442252c24c397"
+ }
+ ]
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/Godeps/Readme
----------------------------------------------------------------------
diff --git a/newt/Godeps/Readme b/newt/Godeps/Readme
new file mode 100644
index 0000000..4cdaa53
--- /dev/null
+++ b/newt/Godeps/Readme
@@ -0,0 +1,5 @@
+This directory tree is generated automatically by godep.
+
+Please do not edit.
+
+See https://github.com/tools/godep for more information.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/.gitignore
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/.gitignore b/newt/vendor/github.com/Sirupsen/logrus/.gitignore
new file mode 100644
index 0000000..66be63a
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/.gitignore
@@ -0,0 +1 @@
+logrus
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/.travis.yml
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/.travis.yml b/newt/vendor/github.com/Sirupsen/logrus/.travis.yml
new file mode 100644
index 0000000..ff23150
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/.travis.yml
@@ -0,0 +1,9 @@
+language: go
+go:
+ - 1.3
+ - 1.4
+ - 1.5
+ - tip
+install:
+ - go get -t ./...
+script: GOMAXPROCS=4 GORACE="halt_on_error=1" go test -race -v ./...
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/CHANGELOG.md
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/CHANGELOG.md b/newt/vendor/github.com/Sirupsen/logrus/CHANGELOG.md
new file mode 100644
index 0000000..9e9e600
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/CHANGELOG.md
@@ -0,0 +1,59 @@
+# 0.9.0
+
+* logrus/text_formatter: don't emit empty msg
+* logrus/hooks/airbrake: move out of main repository
+* logrus/hooks/sentry: move out of main repository
+* logrus/hooks/papertrail: move out of main repository
+* logrus/hooks/bugsnag: move out of main repository
+* logrus/core: run tests with `-race`
+* logrus/core: detect TTY based on `stderr`
+* logrus/core: support `WithError` on logger
+* logrus/core: Solaris support
+
+# 0.8.7
+
+* logrus/core: fix possible race (#216)
+* logrus/doc: small typo fixes and doc improvements
+
+
+# 0.8.6
+
+* hooks/raven: allow passing an initialized client
+
+# 0.8.5
+
+* logrus/core: revert #208
+
+# 0.8.4
+
+* formatter/text: fix data race (#218)
+
+# 0.8.3
+
+* logrus/core: fix entry log level (#208)
+* logrus/core: improve performance of text formatter by 40%
+* logrus/core: expose `LevelHooks` type
+* logrus/core: add support for DragonflyBSD and NetBSD
+* formatter/text: print structs more verbosely
+
+# 0.8.2
+
+* logrus: fix more Fatal family functions
+
+# 0.8.1
+
+* logrus: fix not exiting on `Fatalf` and `Fatalln`
+
+# 0.8.0
+
+* logrus: defaults to stderr instead of stdout
+* hooks/sentry: add special field for `*http.Request`
+* formatter/text: ignore Windows for colors
+
+# 0.7.3
+
+* formatter/\*: allow configuration of timestamp layout
+
+# 0.7.2
+
+* formatter/text: Add configuration option for time format (#158)
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/LICENSE
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/LICENSE b/newt/vendor/github.com/Sirupsen/logrus/LICENSE
new file mode 100644
index 0000000..f090cb4
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Simon Eskildsen
+
+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.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/README.md
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/README.md b/newt/vendor/github.com/Sirupsen/logrus/README.md
new file mode 100644
index 0000000..49f7f07
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/README.md
@@ -0,0 +1,386 @@
+# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/> [](https://travis-ci.org/Sirupsen/logrus) [](https://godoc.org/github.com/Sirupsen/logrus)
+
+Logrus is a structured logger for Go (golang), completely API compatible with
+the standard library logger. [Godoc][godoc]. **Please note the Logrus API is not
+yet stable (pre 1.0). Logrus itself is completely stable and has been used in
+many large deployments. The core API is unlikely to change much but please
+version control your Logrus to make sure you aren't fetching latest `master` on
+every build.**
+
+Nicely color-coded in development (when a TTY is attached, otherwise just
+plain text):
+
+
+
+With `log.Formatter = new(logrus.JSONFormatter)`, for easy parsing by logstash
+or Splunk:
+
+```json
+{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
+ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
+
+{"level":"warning","msg":"The group's number increased tremendously!",
+"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"}
+
+{"animal":"walrus","level":"info","msg":"A giant walrus appears!",
+"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"}
+
+{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.",
+"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"}
+
+{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true,
+"time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
+```
+
+With the default `log.Formatter = new(&log.TextFormatter{})` when a TTY is not
+attached, the output is compatible with the
+[logfmt](http://godoc.org/github.com/kr/logfmt) format:
+
+```text
+time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8
+time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10
+time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true
+time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4
+time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009
+time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true
+exit status 1
+```
+
+#### Example
+
+The simplest way to use Logrus is simply the package-level exported logger:
+
+```go
+package main
+
+import (
+ log "github.com/Sirupsen/logrus"
+)
+
+func main() {
+ log.WithFields(log.Fields{
+ "animal": "walrus",
+ }).Info("A walrus appears")
+}
+```
+
+Note that it's completely api-compatible with the stdlib logger, so you can
+replace your `log` imports everywhere with `log "github.com/Sirupsen/logrus"`
+and you'll now have the flexibility of Logrus. You can customize it all you
+want:
+
+```go
+package main
+
+import (
+ "os"
+ log "github.com/Sirupsen/logrus"
+)
+
+func init() {
+ // Log as JSON instead of the default ASCII formatter.
+ log.SetFormatter(&log.JSONFormatter{})
+
+ // Output to stderr instead of stdout, could also be a file.
+ log.SetOutput(os.Stderr)
+
+ // Only log the warning severity or above.
+ log.SetLevel(log.WarnLevel)
+}
+
+func main() {
+ log.WithFields(log.Fields{
+ "animal": "walrus",
+ "size": 10,
+ }).Info("A group of walrus emerges from the ocean")
+
+ log.WithFields(log.Fields{
+ "omg": true,
+ "number": 122,
+ }).Warn("The group's number increased tremendously!")
+
+ log.WithFields(log.Fields{
+ "omg": true,
+ "number": 100,
+ }).Fatal("The ice breaks!")
+
+ // A common pattern is to re-use fields between logging statements by re-using
+ // the logrus.Entry returned from WithFields()
+ contextLogger := log.WithFields(log.Fields{
+ "common": "this is a common field",
+ "other": "I also should be logged always",
+ })
+
+ contextLogger.Info("I'll be logged with common and other field")
+ contextLogger.Info("Me too")
+}
+```
+
+For more advanced usage such as logging to multiple locations from the same
+application, you can also create an instance of the `logrus` Logger:
+
+```go
+package main
+
+import (
+ "github.com/Sirupsen/logrus"
+)
+
+// Create a new instance of the logger. You can have any number of instances.
+var log = logrus.New()
+
+func main() {
+ // The API for setting attributes is a little different than the package level
+ // exported logger. See Godoc.
+ log.Out = os.Stderr
+
+ log.WithFields(logrus.Fields{
+ "animal": "walrus",
+ "size": 10,
+ }).Info("A group of walrus emerges from the ocean")
+}
+```
+
+#### Fields
+
+Logrus encourages careful, structured logging though logging fields instead of
+long, unparseable error messages. For example, instead of: `log.Fatalf("Failed
+to send event %s to topic %s with key %d")`, you should log the much more
+discoverable:
+
+```go
+log.WithFields(log.Fields{
+ "event": event,
+ "topic": topic,
+ "key": key,
+}).Fatal("Failed to send event")
+```
+
+We've found this API forces you to think about logging in a way that produces
+much more useful logging messages. We've been in countless situations where just
+a single added field to a log statement that was already there would've saved us
+hours. The `WithFields` call is optional.
+
+In general, with Logrus using any of the `printf`-family functions should be
+seen as a hint you should add a field, however, you can still use the
+`printf`-family functions with Logrus.
+
+#### Hooks
+
+You can add hooks for logging levels. For example to send errors to an exception
+tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to
+multiple places simultaneously, e.g. syslog.
+
+Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in
+`init`:
+
+```go
+import (
+ log "github.com/Sirupsen/logrus"
+ "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "aibrake"
+ logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
+ "log/syslog"
+)
+
+func init() {
+
+ // Use the Airbrake hook to report errors that have Error severity or above to
+ // an exception tracker. You can create custom hooks, see the Hooks section.
+ log.AddHook(airbrake.NewHook(123, "xyz", "production"))
+
+ hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
+ if err != nil {
+ log.Error("Unable to connect to local syslog daemon")
+ } else {
+ log.AddHook(hook)
+ }
+}
+```
+Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md).
+
+| Hook | Description |
+| ----- | ----------- |
+| [Airbrake](https://github.com/gemnasium/logrus-airbrake-hook) | Send errors to the Airbrake API V3. Uses the official [`gobrake`](https://github.com/airbrake/gobrake) behind the scenes. |
+| [Airbrake "legacy"](https://github.com/gemnasium/logrus-airbrake-legacy-hook) | Send errors to an exception tracking service compatible with the Airbrake API V2. Uses [`airbrake-go`](https://github.com/tobi/airbrake-go) behind the scenes. |
+| [Papertrail](https://github.com/polds/logrus-papertrail-hook) | Send errors to the [Papertrail](https://papertrailapp.com) hosted logging service via UDP. |
+| [Syslog](https://github.com/Sirupsen/logrus/blob/master/hooks/syslog/syslog.go) | Send errors to remote syslog server. Uses standard library `log/syslog` behind the scenes. |
+| [Bugsnag](https://github.com/Shopify/logrus-bugsnag/blob/master/bugsnag.go) | Send errors to the Bugsnag exception tracking service. |
+| [Sentry](https://github.com/evalphobia/logrus_sentry) | Send errors to the Sentry error logging and aggregation service. |
+| [Hiprus](https://github.com/nubo/hiprus) | Send errors to a channel in hipchat. |
+| [Logrusly](https://github.com/sebest/logrusly) | Send logs to [Loggly](https://www.loggly.com/) |
+| [Slackrus](https://github.com/johntdyer/slackrus) | Hook for Slack chat. |
+| [Journalhook](https://github.com/wercker/journalhook) | Hook for logging to `systemd-journald` |
+| [Graylog](https://github.com/gemnasium/logrus-graylog-hook) | Hook for logging to [Graylog](http://graylog2.org/) |
+| [Raygun](https://github.com/squirkle/logrus-raygun-hook) | Hook for logging to [Raygun.io](http://raygun.io/) |
+| [LFShook](https://github.com/rifflock/lfshook) | Hook for logging to the local filesystem |
+| [Honeybadger](https://github.com/agonzalezro/logrus_honeybadger) | Hook for sending exceptions to Honeybadger |
+| [Mail](https://github.com/zbindenren/logrus_mail) | Hook for sending exceptions via mail |
+| [Rollrus](https://github.com/heroku/rollrus) | Hook for sending errors to rollbar |
+| [Fluentd](https://github.com/evalphobia/logrus_fluent) | Hook for logging to fluentd |
+| [Mongodb](https://github.com/weekface/mgorus) | Hook for logging to mongodb |
+| [InfluxDB](https://github.com/Abramovic/logrus_influxdb) | Hook for logging to influxdb |
+| [Octokit](https://github.com/dorajistyle/logrus-octokit-hook) | Hook for logging to github via octokit |
+| [DeferPanic](https://github.com/deferpanic/dp-logrus) | Hook for logging to DeferPanic |
+| [Redis-Hook](https://github.com/rogierlommers/logrus-redis-hook) | Hook for logging to a ELK stack (through Redis) |
+| [Amqp-Hook](https://github.com/vladoatanasov/logrus_amqp) | Hook for logging to Amqp broker (Like RabbitMQ) |
+| [KafkaLogrus](https://github.com/goibibo/KafkaLogrus) | Hook for logging to kafka |
+| [Typetalk](https://github.com/dragon3/logrus-typetalk-hook) | Hook for logging to [Typetalk](https://www.typetalk.in/) |
+
+#### Level logging
+
+Logrus has six logging levels: Debug, Info, Warning, Error, Fatal and Panic.
+
+```go
+log.Debug("Useful debugging information.")
+log.Info("Something noteworthy happened!")
+log.Warn("You should probably take a look at this.")
+log.Error("Something failed but I'm not quitting.")
+// Calls os.Exit(1) after logging
+log.Fatal("Bye.")
+// Calls panic() after logging
+log.Panic("I'm bailing.")
+```
+
+You can set the logging level on a `Logger`, then it will only log entries with
+that severity or anything above it:
+
+```go
+// Will log anything that is info or above (warn, error, fatal, panic). Default.
+log.SetLevel(log.InfoLevel)
+```
+
+It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
+environment if your application has that.
+
+#### Entries
+
+Besides the fields added with `WithField` or `WithFields` some fields are
+automatically added to all logging events:
+
+1. `time`. The timestamp when the entry was created.
+2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after
+ the `AddFields` call. E.g. `Failed to send event.`
+3. `level`. The logging level. E.g. `info`.
+
+#### Environments
+
+Logrus has no notion of environment.
+
+If you wish for hooks and formatters to only be used in specific environments,
+you should handle that yourself. For example, if your application has a global
+variable `Environment`, which is a string representation of the environment you
+could do:
+
+```go
+import (
+ log "github.com/Sirupsen/logrus"
+)
+
+init() {
+ // do something here to set environment depending on an environment variable
+ // or command-line flag
+ if Environment == "production" {
+ log.SetFormatter(&log.JSONFormatter{})
+ } else {
+ // The TextFormatter is default, you don't actually have to do this.
+ log.SetFormatter(&log.TextFormatter{})
+ }
+}
+```
+
+This configuration is how `logrus` was intended to be used, but JSON in
+production is mostly only useful if you do log aggregation with tools like
+Splunk or Logstash.
+
+#### Formatters
+
+The built-in logging formatters are:
+
+* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise
+ without colors.
+ * *Note:* to force colored output when there is no TTY, set the `ForceColors`
+ field to `true`. To force no colored output even if there is a TTY set the
+ `DisableColors` field to `true`
+* `logrus.JSONFormatter`. Logs fields as JSON.
+* `logrus/formatters/logstash.LogstashFormatter`. Logs fields as [Logstash](http://logstash.net) Events.
+
+ ```go
+ logrus.SetFormatter(&logstash.LogstashFormatter{Type: "application_name"})
+ ```
+
+Third party logging formatters:
+
+* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout.
+* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
+
+You can define your formatter by implementing the `Formatter` interface,
+requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
+`Fields` type (`map[string]interface{}`) with all your fields as well as the
+default ones (see Entries section above):
+
+```go
+type MyJSONFormatter struct {
+}
+
+log.SetFormatter(new(MyJSONFormatter))
+
+func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) {
+ // Note this doesn't include Time, Level and Message which are available on
+ // the Entry. Consult `godoc` on information about those fields or read the
+ // source of the official loggers.
+ serialized, err := json.Marshal(entry.Data)
+ if err != nil {
+ return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
+ }
+ return append(serialized, '\n'), nil
+}
+```
+
+#### Logger as an `io.Writer`
+
+Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.
+
+```go
+w := logger.Writer()
+defer w.Close()
+
+srv := http.Server{
+ // create a stdlib log.Logger that writes to
+ // logrus.Logger.
+ ErrorLog: log.New(w, "", 0),
+}
+```
+
+Each line written to that writer will be printed the usual way, using formatters
+and hooks. The level for those entries is `info`.
+
+#### Rotation
+
+Log rotation is not provided with Logrus. Log rotation should be done by an
+external program (like `logrotate(8)`) that can compress and delete old log
+entries. It should not be a feature of the application-level logger.
+
+#### Tools
+
+| Tool | Description |
+| ---- | ----------- |
+|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will generated with different config at different environment.|
+
+#### Testing
+
+Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides:
+
+* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just add the `test` hook
+* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any):
+
+```go
+logger, hook := NewNullLogger()
+logger.Error("Hello error")
+
+assert.Equal(1, len(hook.Entries))
+assert.Equal(logrus.ErrorLevel, hook.LastEntry().Level)
+assert.Equal("Hello error", hook.LastEntry().Message)
+
+hook.Reset()
+assert.Nil(hook.LastEntry())
+```
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/doc.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/doc.go b/newt/vendor/github.com/Sirupsen/logrus/doc.go
new file mode 100644
index 0000000..dddd5f8
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/doc.go
@@ -0,0 +1,26 @@
+/*
+Package logrus is a structured logger for Go, completely API compatible with the standard library logger.
+
+
+The simplest way to use Logrus is simply the package-level exported logger:
+
+ package main
+
+ import (
+ log "github.com/Sirupsen/logrus"
+ )
+
+ func main() {
+ log.WithFields(log.Fields{
+ "animal": "walrus",
+ "number": 1,
+ "size": 10,
+ }).Info("A walrus appears")
+ }
+
+Output:
+ time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10
+
+For a full guide visit https://github.com/Sirupsen/logrus
+*/
+package logrus
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/entry.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/entry.go b/newt/vendor/github.com/Sirupsen/logrus/entry.go
new file mode 100644
index 0000000..9ae900b
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/entry.go
@@ -0,0 +1,264 @@
+package logrus
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "time"
+)
+
+// Defines the key when adding errors using WithError.
+var ErrorKey = "error"
+
+// An entry is the final or intermediate Logrus logging entry. It contains all
+// the fields passed with WithField{,s}. It's finally logged when Debug, Info,
+// Warn, Error, Fatal or Panic is called on it. These objects can be reused and
+// passed around as much as you wish to avoid field duplication.
+type Entry struct {
+ Logger *Logger
+
+ // Contains all the fields set by the user.
+ Data Fields
+
+ // Time at which the log entry was created
+ Time time.Time
+
+ // Level the log entry was logged at: Debug, Info, Warn, Error, Fatal or Panic
+ Level Level
+
+ // Message passed to Debug, Info, Warn, Error, Fatal or Panic
+ Message string
+}
+
+func NewEntry(logger *Logger) *Entry {
+ return &Entry{
+ Logger: logger,
+ // Default is three fields, give a little extra room
+ Data: make(Fields, 5),
+ }
+}
+
+// Returns a reader for the entry, which is a proxy to the formatter.
+func (entry *Entry) Reader() (*bytes.Buffer, error) {
+ serialized, err := entry.Logger.Formatter.Format(entry)
+ return bytes.NewBuffer(serialized), err
+}
+
+// Returns the string representation from the reader and ultimately the
+// formatter.
+func (entry *Entry) String() (string, error) {
+ reader, err := entry.Reader()
+ if err != nil {
+ return "", err
+ }
+
+ return reader.String(), err
+}
+
+// Add an error as single field (using the key defined in ErrorKey) to the Entry.
+func (entry *Entry) WithError(err error) *Entry {
+ return entry.WithField(ErrorKey, err)
+}
+
+// Add a single field to the Entry.
+func (entry *Entry) WithField(key string, value interface{}) *Entry {
+ return entry.WithFields(Fields{key: value})
+}
+
+// Add a map of fields to the Entry.
+func (entry *Entry) WithFields(fields Fields) *Entry {
+ data := Fields{}
+ for k, v := range entry.Data {
+ data[k] = v
+ }
+ for k, v := range fields {
+ data[k] = v
+ }
+ return &Entry{Logger: entry.Logger, Data: data}
+}
+
+// This function is not declared with a pointer value because otherwise
+// race conditions will occur when using multiple goroutines
+func (entry Entry) log(level Level, msg string) {
+ entry.Time = time.Now()
+ entry.Level = level
+ entry.Message = msg
+
+ if err := entry.Logger.Hooks.Fire(level, &entry); err != nil {
+ entry.Logger.mu.Lock()
+ fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)
+ entry.Logger.mu.Unlock()
+ }
+
+ reader, err := entry.Reader()
+ if err != nil {
+ entry.Logger.mu.Lock()
+ fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
+ entry.Logger.mu.Unlock()
+ }
+
+ entry.Logger.mu.Lock()
+ defer entry.Logger.mu.Unlock()
+
+ _, err = io.Copy(entry.Logger.Out, reader)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
+ }
+
+ // To avoid Entry#log() returning a value that only would make sense for
+ // panic() to use in Entry#Panic(), we avoid the allocation by checking
+ // directly here.
+ if level <= PanicLevel {
+ panic(&entry)
+ }
+}
+
+func (entry *Entry) Debug(args ...interface{}) {
+ if entry.Logger.Level >= DebugLevel {
+ entry.log(DebugLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Print(args ...interface{}) {
+ entry.Info(args...)
+}
+
+func (entry *Entry) Info(args ...interface{}) {
+ if entry.Logger.Level >= InfoLevel {
+ entry.log(InfoLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Warn(args ...interface{}) {
+ if entry.Logger.Level >= WarnLevel {
+ entry.log(WarnLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Warning(args ...interface{}) {
+ entry.Warn(args...)
+}
+
+func (entry *Entry) Error(args ...interface{}) {
+ if entry.Logger.Level >= ErrorLevel {
+ entry.log(ErrorLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Fatal(args ...interface{}) {
+ if entry.Logger.Level >= FatalLevel {
+ entry.log(FatalLevel, fmt.Sprint(args...))
+ }
+ os.Exit(1)
+}
+
+func (entry *Entry) Panic(args ...interface{}) {
+ if entry.Logger.Level >= PanicLevel {
+ entry.log(PanicLevel, fmt.Sprint(args...))
+ }
+ panic(fmt.Sprint(args...))
+}
+
+// Entry Printf family functions
+
+func (entry *Entry) Debugf(format string, args ...interface{}) {
+ if entry.Logger.Level >= DebugLevel {
+ entry.Debug(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Infof(format string, args ...interface{}) {
+ if entry.Logger.Level >= InfoLevel {
+ entry.Info(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Printf(format string, args ...interface{}) {
+ entry.Infof(format, args...)
+}
+
+func (entry *Entry) Warnf(format string, args ...interface{}) {
+ if entry.Logger.Level >= WarnLevel {
+ entry.Warn(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Warningf(format string, args ...interface{}) {
+ entry.Warnf(format, args...)
+}
+
+func (entry *Entry) Errorf(format string, args ...interface{}) {
+ if entry.Logger.Level >= ErrorLevel {
+ entry.Error(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Fatalf(format string, args ...interface{}) {
+ if entry.Logger.Level >= FatalLevel {
+ entry.Fatal(fmt.Sprintf(format, args...))
+ }
+ os.Exit(1)
+}
+
+func (entry *Entry) Panicf(format string, args ...interface{}) {
+ if entry.Logger.Level >= PanicLevel {
+ entry.Panic(fmt.Sprintf(format, args...))
+ }
+}
+
+// Entry Println family functions
+
+func (entry *Entry) Debugln(args ...interface{}) {
+ if entry.Logger.Level >= DebugLevel {
+ entry.Debug(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Infoln(args ...interface{}) {
+ if entry.Logger.Level >= InfoLevel {
+ entry.Info(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Println(args ...interface{}) {
+ entry.Infoln(args...)
+}
+
+func (entry *Entry) Warnln(args ...interface{}) {
+ if entry.Logger.Level >= WarnLevel {
+ entry.Warn(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Warningln(args ...interface{}) {
+ entry.Warnln(args...)
+}
+
+func (entry *Entry) Errorln(args ...interface{}) {
+ if entry.Logger.Level >= ErrorLevel {
+ entry.Error(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Fatalln(args ...interface{}) {
+ if entry.Logger.Level >= FatalLevel {
+ entry.Fatal(entry.sprintlnn(args...))
+ }
+ os.Exit(1)
+}
+
+func (entry *Entry) Panicln(args ...interface{}) {
+ if entry.Logger.Level >= PanicLevel {
+ entry.Panic(entry.sprintlnn(args...))
+ }
+}
+
+// Sprintlnn => Sprint no newline. This is to get the behavior of how
+// fmt.Sprintln where spaces are always added between operands, regardless of
+// their type. Instead of vendoring the Sprintln implementation to spare a
+// string allocation, we do the simplest thing.
+func (entry *Entry) sprintlnn(args ...interface{}) string {
+ msg := fmt.Sprintln(args...)
+ return msg[:len(msg)-1]
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/exported.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/exported.go b/newt/vendor/github.com/Sirupsen/logrus/exported.go
new file mode 100644
index 0000000..9a0120a
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/exported.go
@@ -0,0 +1,193 @@
+package logrus
+
+import (
+ "io"
+)
+
+var (
+ // std is the name of the standard logger in stdlib `log`
+ std = New()
+)
+
+func StandardLogger() *Logger {
+ return std
+}
+
+// SetOutput sets the standard logger output.
+func SetOutput(out io.Writer) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Out = out
+}
+
+// SetFormatter sets the standard logger formatter.
+func SetFormatter(formatter Formatter) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Formatter = formatter
+}
+
+// SetLevel sets the standard logger level.
+func SetLevel(level Level) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Level = level
+}
+
+// GetLevel returns the standard logger level.
+func GetLevel() Level {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ return std.Level
+}
+
+// AddHook adds a hook to the standard logger hooks.
+func AddHook(hook Hook) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Hooks.Add(hook)
+}
+
+// WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key.
+func WithError(err error) *Entry {
+ return std.WithField(ErrorKey, err)
+}
+
+// WithField creates an entry from the standard logger and adds a field to
+// it. If you want multiple fields, use `WithFields`.
+//
+// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
+// or Panic on the Entry it returns.
+func WithField(key string, value interface{}) *Entry {
+ return std.WithField(key, value)
+}
+
+// WithFields creates an entry from the standard logger and adds multiple
+// fields to it. This is simply a helper for `WithField`, invoking it
+// once for each field.
+//
+// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
+// or Panic on the Entry it returns.
+func WithFields(fields Fields) *Entry {
+ return std.WithFields(fields)
+}
+
+// Debug logs a message at level Debug on the standard logger.
+func Debug(args ...interface{}) {
+ std.Debug(args...)
+}
+
+// Print logs a message at level Info on the standard logger.
+func Print(args ...interface{}) {
+ std.Print(args...)
+}
+
+// Info logs a message at level Info on the standard logger.
+func Info(args ...interface{}) {
+ std.Info(args...)
+}
+
+// Warn logs a message at level Warn on the standard logger.
+func Warn(args ...interface{}) {
+ std.Warn(args...)
+}
+
+// Warning logs a message at level Warn on the standard logger.
+func Warning(args ...interface{}) {
+ std.Warning(args...)
+}
+
+// Error logs a message at level Error on the standard logger.
+func Error(args ...interface{}) {
+ std.Error(args...)
+}
+
+// Panic logs a message at level Panic on the standard logger.
+func Panic(args ...interface{}) {
+ std.Panic(args...)
+}
+
+// Fatal logs a message at level Fatal on the standard logger.
+func Fatal(args ...interface{}) {
+ std.Fatal(args...)
+}
+
+// Debugf logs a message at level Debug on the standard logger.
+func Debugf(format string, args ...interface{}) {
+ std.Debugf(format, args...)
+}
+
+// Printf logs a message at level Info on the standard logger.
+func Printf(format string, args ...interface{}) {
+ std.Printf(format, args...)
+}
+
+// Infof logs a message at level Info on the standard logger.
+func Infof(format string, args ...interface{}) {
+ std.Infof(format, args...)
+}
+
+// Warnf logs a message at level Warn on the standard logger.
+func Warnf(format string, args ...interface{}) {
+ std.Warnf(format, args...)
+}
+
+// Warningf logs a message at level Warn on the standard logger.
+func Warningf(format string, args ...interface{}) {
+ std.Warningf(format, args...)
+}
+
+// Errorf logs a message at level Error on the standard logger.
+func Errorf(format string, args ...interface{}) {
+ std.Errorf(format, args...)
+}
+
+// Panicf logs a message at level Panic on the standard logger.
+func Panicf(format string, args ...interface{}) {
+ std.Panicf(format, args...)
+}
+
+// Fatalf logs a message at level Fatal on the standard logger.
+func Fatalf(format string, args ...interface{}) {
+ std.Fatalf(format, args...)
+}
+
+// Debugln logs a message at level Debug on the standard logger.
+func Debugln(args ...interface{}) {
+ std.Debugln(args...)
+}
+
+// Println logs a message at level Info on the standard logger.
+func Println(args ...interface{}) {
+ std.Println(args...)
+}
+
+// Infoln logs a message at level Info on the standard logger.
+func Infoln(args ...interface{}) {
+ std.Infoln(args...)
+}
+
+// Warnln logs a message at level Warn on the standard logger.
+func Warnln(args ...interface{}) {
+ std.Warnln(args...)
+}
+
+// Warningln logs a message at level Warn on the standard logger.
+func Warningln(args ...interface{}) {
+ std.Warningln(args...)
+}
+
+// Errorln logs a message at level Error on the standard logger.
+func Errorln(args ...interface{}) {
+ std.Errorln(args...)
+}
+
+// Panicln logs a message at level Panic on the standard logger.
+func Panicln(args ...interface{}) {
+ std.Panicln(args...)
+}
+
+// Fatalln logs a message at level Fatal on the standard logger.
+func Fatalln(args ...interface{}) {
+ std.Fatalln(args...)
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/formatter.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/formatter.go b/newt/vendor/github.com/Sirupsen/logrus/formatter.go
new file mode 100644
index 0000000..104d689
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/formatter.go
@@ -0,0 +1,48 @@
+package logrus
+
+import "time"
+
+const DefaultTimestampFormat = time.RFC3339
+
+// The Formatter interface is used to implement a custom Formatter. It takes an
+// `Entry`. It exposes all the fields, including the default ones:
+//
+// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
+// * `entry.Data["time"]`. The timestamp.
+// * `entry.Data["level"]. The level the entry was logged at.
+//
+// Any additional fields added with `WithField` or `WithFields` are also in
+// `entry.Data`. Format is expected to return an array of bytes which are then
+// logged to `logger.Out`.
+type Formatter interface {
+ Format(*Entry) ([]byte, error)
+}
+
+// This is to not silently overwrite `time`, `msg` and `level` fields when
+// dumping it. If this code wasn't there doing:
+//
+// logrus.WithField("level", 1).Info("hello")
+//
+// Would just silently drop the user provided level. Instead with this code
+// it'll logged as:
+//
+// {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
+//
+// It's not exported because it's still using Data in an opinionated way. It's to
+// avoid code duplication between the two default formatters.
+func prefixFieldClashes(data Fields) {
+ _, ok := data["time"]
+ if ok {
+ data["fields.time"] = data["time"]
+ }
+
+ _, ok = data["msg"]
+ if ok {
+ data["fields.msg"] = data["msg"]
+ }
+
+ _, ok = data["level"]
+ if ok {
+ data["fields.level"] = data["level"]
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/hooks.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/hooks.go b/newt/vendor/github.com/Sirupsen/logrus/hooks.go
new file mode 100644
index 0000000..3f151cd
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/hooks.go
@@ -0,0 +1,34 @@
+package logrus
+
+// A hook to be fired when logging on the logging levels returned from
+// `Levels()` on your implementation of the interface. Note that this is not
+// fired in a goroutine or a channel with workers, you should handle such
+// functionality yourself if your call is non-blocking and you don't wish for
+// the logging calls for levels returned from `Levels()` to block.
+type Hook interface {
+ Levels() []Level
+ Fire(*Entry) error
+}
+
+// Internal type for storing the hooks on a logger instance.
+type LevelHooks map[Level][]Hook
+
+// Add a hook to an instance of logger. This is called with
+// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.
+func (hooks LevelHooks) Add(hook Hook) {
+ for _, level := range hook.Levels() {
+ hooks[level] = append(hooks[level], hook)
+ }
+}
+
+// Fire all the hooks for the passed level. Used by `entry.log` to fire
+// appropriate hooks for a log entry.
+func (hooks LevelHooks) Fire(level Level, entry *Entry) error {
+ for _, hook := range hooks[level] {
+ if err := hook.Fire(entry); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/json_formatter.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/json_formatter.go b/newt/vendor/github.com/Sirupsen/logrus/json_formatter.go
new file mode 100644
index 0000000..2ad6dc5
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/json_formatter.go
@@ -0,0 +1,41 @@
+package logrus
+
+import (
+ "encoding/json"
+ "fmt"
+)
+
+type JSONFormatter struct {
+ // TimestampFormat sets the format used for marshaling timestamps.
+ TimestampFormat string
+}
+
+func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
+ data := make(Fields, len(entry.Data)+3)
+ for k, v := range entry.Data {
+ switch v := v.(type) {
+ case error:
+ // Otherwise errors are ignored by `encoding/json`
+ // https://github.com/Sirupsen/logrus/issues/137
+ data[k] = v.Error()
+ default:
+ data[k] = v
+ }
+ }
+ prefixFieldClashes(data)
+
+ timestampFormat := f.TimestampFormat
+ if timestampFormat == "" {
+ timestampFormat = DefaultTimestampFormat
+ }
+
+ data["time"] = entry.Time.Format(timestampFormat)
+ data["msg"] = entry.Message
+ data["level"] = entry.Level.String()
+
+ serialized, err := json.Marshal(data)
+ if err != nil {
+ return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
+ }
+ return append(serialized, '\n'), nil
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/logger.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/logger.go b/newt/vendor/github.com/Sirupsen/logrus/logger.go
new file mode 100644
index 0000000..2fdb231
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/logger.go
@@ -0,0 +1,212 @@
+package logrus
+
+import (
+ "io"
+ "os"
+ "sync"
+)
+
+type Logger struct {
+ // The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
+ // file, or leave it default which is `os.Stderr`. You can also set this to
+ // something more adventorous, such as logging to Kafka.
+ Out io.Writer
+ // Hooks for the logger instance. These allow firing events based on logging
+ // levels and log entries. For example, to send errors to an error tracking
+ // service, log to StatsD or dump the core on fatal errors.
+ Hooks LevelHooks
+ // All log entries pass through the formatter before logged to Out. The
+ // included formatters are `TextFormatter` and `JSONFormatter` for which
+ // TextFormatter is the default. In development (when a TTY is attached) it
+ // logs with colors, but to a file it wouldn't. You can easily implement your
+ // own that implements the `Formatter` interface, see the `README` or included
+ // formatters for examples.
+ Formatter Formatter
+ // The logging level the logger should log at. This is typically (and defaults
+ // to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
+ // logged. `logrus.Debug` is useful in
+ Level Level
+ // Used to sync writing to the log.
+ mu sync.Mutex
+}
+
+// Creates a new logger. Configuration should be set by changing `Formatter`,
+// `Out` and `Hooks` directly on the default logger instance. You can also just
+// instantiate your own:
+//
+// var log = &Logger{
+// Out: os.Stderr,
+// Formatter: new(JSONFormatter),
+// Hooks: make(LevelHooks),
+// Level: logrus.DebugLevel,
+// }
+//
+// It's recommended to make this a global instance called `log`.
+func New() *Logger {
+ return &Logger{
+ Out: os.Stderr,
+ Formatter: new(TextFormatter),
+ Hooks: make(LevelHooks),
+ Level: InfoLevel,
+ }
+}
+
+// Adds a field to the log entry, note that you it doesn't log until you call
+// Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry.
+// If you want multiple fields, use `WithFields`.
+func (logger *Logger) WithField(key string, value interface{}) *Entry {
+ return NewEntry(logger).WithField(key, value)
+}
+
+// Adds a struct of fields to the log entry. All it does is call `WithField` for
+// each `Field`.
+func (logger *Logger) WithFields(fields Fields) *Entry {
+ return NewEntry(logger).WithFields(fields)
+}
+
+// Add an error as single field to the log entry. All it does is call
+// `WithError` for the given `error`.
+func (logger *Logger) WithError(err error) *Entry {
+ return NewEntry(logger).WithError(err)
+}
+
+func (logger *Logger) Debugf(format string, args ...interface{}) {
+ if logger.Level >= DebugLevel {
+ NewEntry(logger).Debugf(format, args...)
+ }
+}
+
+func (logger *Logger) Infof(format string, args ...interface{}) {
+ if logger.Level >= InfoLevel {
+ NewEntry(logger).Infof(format, args...)
+ }
+}
+
+func (logger *Logger) Printf(format string, args ...interface{}) {
+ NewEntry(logger).Printf(format, args...)
+}
+
+func (logger *Logger) Warnf(format string, args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnf(format, args...)
+ }
+}
+
+func (logger *Logger) Warningf(format string, args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnf(format, args...)
+ }
+}
+
+func (logger *Logger) Errorf(format string, args ...interface{}) {
+ if logger.Level >= ErrorLevel {
+ NewEntry(logger).Errorf(format, args...)
+ }
+}
+
+func (logger *Logger) Fatalf(format string, args ...interface{}) {
+ if logger.Level >= FatalLevel {
+ NewEntry(logger).Fatalf(format, args...)
+ }
+ os.Exit(1)
+}
+
+func (logger *Logger) Panicf(format string, args ...interface{}) {
+ if logger.Level >= PanicLevel {
+ NewEntry(logger).Panicf(format, args...)
+ }
+}
+
+func (logger *Logger) Debug(args ...interface{}) {
+ if logger.Level >= DebugLevel {
+ NewEntry(logger).Debug(args...)
+ }
+}
+
+func (logger *Logger) Info(args ...interface{}) {
+ if logger.Level >= InfoLevel {
+ NewEntry(logger).Info(args...)
+ }
+}
+
+func (logger *Logger) Print(args ...interface{}) {
+ NewEntry(logger).Info(args...)
+}
+
+func (logger *Logger) Warn(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warn(args...)
+ }
+}
+
+func (logger *Logger) Warning(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warn(args...)
+ }
+}
+
+func (logger *Logger) Error(args ...interface{}) {
+ if logger.Level >= ErrorLevel {
+ NewEntry(logger).Error(args...)
+ }
+}
+
+func (logger *Logger) Fatal(args ...interface{}) {
+ if logger.Level >= FatalLevel {
+ NewEntry(logger).Fatal(args...)
+ }
+ os.Exit(1)
+}
+
+func (logger *Logger) Panic(args ...interface{}) {
+ if logger.Level >= PanicLevel {
+ NewEntry(logger).Panic(args...)
+ }
+}
+
+func (logger *Logger) Debugln(args ...interface{}) {
+ if logger.Level >= DebugLevel {
+ NewEntry(logger).Debugln(args...)
+ }
+}
+
+func (logger *Logger) Infoln(args ...interface{}) {
+ if logger.Level >= InfoLevel {
+ NewEntry(logger).Infoln(args...)
+ }
+}
+
+func (logger *Logger) Println(args ...interface{}) {
+ NewEntry(logger).Println(args...)
+}
+
+func (logger *Logger) Warnln(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnln(args...)
+ }
+}
+
+func (logger *Logger) Warningln(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnln(args...)
+ }
+}
+
+func (logger *Logger) Errorln(args ...interface{}) {
+ if logger.Level >= ErrorLevel {
+ NewEntry(logger).Errorln(args...)
+ }
+}
+
+func (logger *Logger) Fatalln(args ...interface{}) {
+ if logger.Level >= FatalLevel {
+ NewEntry(logger).Fatalln(args...)
+ }
+ os.Exit(1)
+}
+
+func (logger *Logger) Panicln(args ...interface{}) {
+ if logger.Level >= PanicLevel {
+ NewEntry(logger).Panicln(args...)
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/logrus.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/logrus.go b/newt/vendor/github.com/Sirupsen/logrus/logrus.go
new file mode 100644
index 0000000..1e9670d
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/logrus.go
@@ -0,0 +1,109 @@
+package logrus
+
+import (
+ "fmt"
+ "log"
+ "strings"
+)
+
+// Fields type, used to pass to `WithFields`.
+type Fields map[string]interface{}
+
+// Level type
+type Level uint8
+
+// Convert the Level to a string. E.g. PanicLevel becomes "panic".
+func (level Level) String() string {
+ switch level {
+ case DebugLevel:
+ return "debug"
+ case InfoLevel:
+ return "info"
+ case WarnLevel:
+ return "warning"
+ case ErrorLevel:
+ return "error"
+ case FatalLevel:
+ return "fatal"
+ case PanicLevel:
+ return "panic"
+ }
+
+ return "unknown"
+}
+
+// ParseLevel takes a string level and returns the Logrus log level constant.
+func ParseLevel(lvl string) (Level, error) {
+ switch strings.ToLower(lvl) {
+ case "panic":
+ return PanicLevel, nil
+ case "fatal":
+ return FatalLevel, nil
+ case "error":
+ return ErrorLevel, nil
+ case "warn", "warning":
+ return WarnLevel, nil
+ case "info":
+ return InfoLevel, nil
+ case "debug":
+ return DebugLevel, nil
+ }
+
+ var l Level
+ return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
+}
+
+// A constant exposing all logging levels
+var AllLevels = []Level{
+ PanicLevel,
+ FatalLevel,
+ ErrorLevel,
+ WarnLevel,
+ InfoLevel,
+ DebugLevel,
+}
+
+// These are the different logging levels. You can set the logging level to log
+// on your instance of logger, obtained with `logrus.New()`.
+const (
+ // PanicLevel level, highest level of severity. Logs and then calls panic with the
+ // message passed to Debug, Info, ...
+ PanicLevel Level = iota
+ // FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the
+ // logging level is set to Panic.
+ FatalLevel
+ // ErrorLevel level. Logs. Used for errors that should definitely be noted.
+ // Commonly used for hooks to send errors to an error tracking service.
+ ErrorLevel
+ // WarnLevel level. Non-critical entries that deserve eyes.
+ WarnLevel
+ // InfoLevel level. General operational entries about what's going on inside the
+ // application.
+ InfoLevel
+ // DebugLevel level. Usually only enabled when debugging. Very verbose logging.
+ DebugLevel
+)
+
+// Won't compile if StdLogger can't be realized by a log.Logger
+var (
+ _ StdLogger = &log.Logger{}
+ _ StdLogger = &Entry{}
+ _ StdLogger = &Logger{}
+)
+
+// StdLogger is what your logrus-enabled library should take, that way
+// it'll accept a stdlib logger and a logrus logger. There's no standard
+// interface, this is the closest we get, unfortunately.
+type StdLogger interface {
+ Print(...interface{})
+ Printf(string, ...interface{})
+ Println(...interface{})
+
+ Fatal(...interface{})
+ Fatalf(string, ...interface{})
+ Fatalln(...interface{})
+
+ Panic(...interface{})
+ Panicf(string, ...interface{})
+ Panicln(...interface{})
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/terminal_bsd.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/terminal_bsd.go b/newt/vendor/github.com/Sirupsen/logrus/terminal_bsd.go
new file mode 100644
index 0000000..71f8d67
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/terminal_bsd.go
@@ -0,0 +1,9 @@
+// +build darwin freebsd openbsd netbsd dragonfly
+
+package logrus
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TIOCGETA
+
+type Termios syscall.Termios
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/terminal_linux.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/terminal_linux.go b/newt/vendor/github.com/Sirupsen/logrus/terminal_linux.go
new file mode 100644
index 0000000..a2c0b40
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/terminal_linux.go
@@ -0,0 +1,12 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logrus
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TCGETS
+
+type Termios syscall.Termios
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go b/newt/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go
new file mode 100644
index 0000000..b343b3a
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go
@@ -0,0 +1,21 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux darwin freebsd openbsd netbsd dragonfly
+
+package logrus
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+// IsTerminal returns true if stderr's file descriptor is a terminal.
+func IsTerminal() bool {
+ fd := syscall.Stderr
+ var termios Termios
+ _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
+ return err == 0
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/terminal_solaris.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/terminal_solaris.go b/newt/vendor/github.com/Sirupsen/logrus/terminal_solaris.go
new file mode 100644
index 0000000..3e70bf7
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/terminal_solaris.go
@@ -0,0 +1,15 @@
+// +build solaris
+
+package logrus
+
+import (
+ "os"
+
+ "golang.org/x/sys/unix"
+)
+
+// IsTerminal returns true if the given file descriptor is a terminal.
+func IsTerminal() bool {
+ _, err := unix.IoctlGetTermios(int(os.Stdout.Fd()), unix.TCGETA)
+ return err == nil
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/terminal_windows.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/terminal_windows.go b/newt/vendor/github.com/Sirupsen/logrus/terminal_windows.go
new file mode 100644
index 0000000..0146845
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/terminal_windows.go
@@ -0,0 +1,27 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package logrus
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+var kernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+var (
+ procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
+)
+
+// IsTerminal returns true if stderr's file descriptor is a terminal.
+func IsTerminal() bool {
+ fd := syscall.Stderr
+ var st uint32
+ r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0)
+ return r != 0 && e == 0
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/text_formatter.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/text_formatter.go b/newt/vendor/github.com/Sirupsen/logrus/text_formatter.go
new file mode 100644
index 0000000..06ef202
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/text_formatter.go
@@ -0,0 +1,161 @@
+package logrus
+
+import (
+ "bytes"
+ "fmt"
+ "runtime"
+ "sort"
+ "strings"
+ "time"
+)
+
+const (
+ nocolor = 0
+ red = 31
+ green = 32
+ yellow = 33
+ blue = 34
+ gray = 37
+)
+
+var (
+ baseTimestamp time.Time
+ isTerminal bool
+)
+
+func init() {
+ baseTimestamp = time.Now()
+ isTerminal = IsTerminal()
+}
+
+func miniTS() int {
+ return int(time.Since(baseTimestamp) / time.Second)
+}
+
+type TextFormatter struct {
+ // Set to true to bypass checking for a TTY before outputting colors.
+ ForceColors bool
+
+ // Force disabling colors.
+ DisableColors bool
+
+ // Disable timestamp logging. useful when output is redirected to logging
+ // system that already adds timestamps.
+ DisableTimestamp bool
+
+ // Enable logging the full timestamp when a TTY is attached instead of just
+ // the time passed since beginning of execution.
+ FullTimestamp bool
+
+ // TimestampFormat to use for display when a full timestamp is printed
+ TimestampFormat string
+
+ // The fields are sorted by default for a consistent output. For applications
+ // that log extremely frequently and don't use the JSON formatter this may not
+ // be desired.
+ DisableSorting bool
+}
+
+func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
+ var keys []string = make([]string, 0, len(entry.Data))
+ for k := range entry.Data {
+ keys = append(keys, k)
+ }
+
+ if !f.DisableSorting {
+ sort.Strings(keys)
+ }
+
+ b := &bytes.Buffer{}
+
+ prefixFieldClashes(entry.Data)
+
+ isColorTerminal := isTerminal && (runtime.GOOS != "windows")
+ isColored := (f.ForceColors || isColorTerminal) && !f.DisableColors
+
+ timestampFormat := f.TimestampFormat
+ if timestampFormat == "" {
+ timestampFormat = DefaultTimestampFormat
+ }
+ if isColored {
+ f.printColored(b, entry, keys, timestampFormat)
+ } else {
+ if !f.DisableTimestamp {
+ f.appendKeyValue(b, "time", entry.Time.Format(timestampFormat))
+ }
+ f.appendKeyValue(b, "level", entry.Level.String())
+ if entry.Message != "" {
+ f.appendKeyValue(b, "msg", entry.Message)
+ }
+ for _, key := range keys {
+ f.appendKeyValue(b, key, entry.Data[key])
+ }
+ }
+
+ b.WriteByte('\n')
+ return b.Bytes(), nil
+}
+
+func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, timestampFormat string) {
+ var levelColor int
+ switch entry.Level {
+ case DebugLevel:
+ levelColor = gray
+ case WarnLevel:
+ levelColor = yellow
+ case ErrorLevel, FatalLevel, PanicLevel:
+ levelColor = red
+ default:
+ levelColor = blue
+ }
+
+ levelText := strings.ToUpper(entry.Level.String())[0:4]
+
+ if !f.FullTimestamp {
+ fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d] %-44s ", levelColor, levelText, miniTS(), entry.Message)
+ } else {
+ fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), entry.Message)
+ }
+ for _, k := range keys {
+ v := entry.Data[k]
+ fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=%+v", levelColor, k, v)
+ }
+}
+
+func needsQuoting(text string) bool {
+ for _, ch := range text {
+ if !((ch >= 'a' && ch <= 'z') ||
+ (ch >= 'A' && ch <= 'Z') ||
+ (ch >= '0' && ch <= '9') ||
+ ch == '-' || ch == '.') {
+ return false
+ }
+ }
+ return true
+}
+
+func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
+
+ b.WriteString(key)
+ b.WriteByte('=')
+
+ switch value := value.(type) {
+ case string:
+ if needsQuoting(value) {
+ b.WriteString(value)
+ } else {
+ fmt.Fprintf(b, "%q", value)
+ }
+ case error:
+ errmsg := value.Error()
+ if needsQuoting(errmsg) {
+ b.WriteString(errmsg)
+ } else {
+ fmt.Fprintf(b, "%q", value)
+ }
+ default:
+ fmt.Fprint(b, value)
+ }
+
+ b.WriteByte(' ')
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/Sirupsen/logrus/writer.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/Sirupsen/logrus/writer.go b/newt/vendor/github.com/Sirupsen/logrus/writer.go
new file mode 100644
index 0000000..1e30b1c
--- /dev/null
+++ b/newt/vendor/github.com/Sirupsen/logrus/writer.go
@@ -0,0 +1,31 @@
+package logrus
+
+import (
+ "bufio"
+ "io"
+ "runtime"
+)
+
+func (logger *Logger) Writer() *io.PipeWriter {
+ reader, writer := io.Pipe()
+
+ go logger.writerScanner(reader)
+ runtime.SetFinalizer(writer, writerFinalizer)
+
+ return writer
+}
+
+func (logger *Logger) writerScanner(reader *io.PipeReader) {
+ scanner := bufio.NewScanner(reader)
+ for scanner.Scan() {
+ logger.Print(scanner.Text())
+ }
+ if err := scanner.Err(); err != nil {
+ logger.Errorf("Error while reading from Writer: %s", err)
+ }
+ reader.Close()
+}
+
+func writerFinalizer(writer *io.PipeWriter) {
+ writer.Close()
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/inconshreveable/mousetrap/LICENSE
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/inconshreveable/mousetrap/LICENSE b/newt/vendor/github.com/inconshreveable/mousetrap/LICENSE
new file mode 100644
index 0000000..5f0d1fb
--- /dev/null
+++ b/newt/vendor/github.com/inconshreveable/mousetrap/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2014 Alan Shreve
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/inconshreveable/mousetrap/README.md
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/inconshreveable/mousetrap/README.md b/newt/vendor/github.com/inconshreveable/mousetrap/README.md
new file mode 100644
index 0000000..7a950d1
--- /dev/null
+++ b/newt/vendor/github.com/inconshreveable/mousetrap/README.md
@@ -0,0 +1,23 @@
+# mousetrap
+
+mousetrap is a tiny library that answers a single question.
+
+On a Windows machine, was the process invoked by someone double clicking on
+the executable file while browsing in explorer?
+
+### Motivation
+
+Windows developers unfamiliar with command line tools will often "double-click"
+the executable for a tool. Because most CLI tools print the help and then exit
+when invoked without arguments, this is often very frustrating for those users.
+
+mousetrap provides a way to detect these invocations so that you can provide
+more helpful behavior and instructions on how to run the CLI tool. To see what
+this looks like, both from an organizational and a technical perspective, see
+https://inconshreveable.com/09-09-2014/sweat-the-small-stuff/
+
+### The interface
+
+The library exposes a single interface:
+
+ func StartedByExplorer() (bool)
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/inconshreveable/mousetrap/trap_others.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/inconshreveable/mousetrap/trap_others.go b/newt/vendor/github.com/inconshreveable/mousetrap/trap_others.go
new file mode 100644
index 0000000..9d2d8a4
--- /dev/null
+++ b/newt/vendor/github.com/inconshreveable/mousetrap/trap_others.go
@@ -0,0 +1,15 @@
+// +build !windows
+
+package mousetrap
+
+// StartedByExplorer returns true if the program was invoked by the user
+// double-clicking on the executable from explorer.exe
+//
+// It is conservative and returns false if any of the internal calls fail.
+// It does not guarantee that the program was run from a terminal. It only can tell you
+// whether it was launched from explorer.exe
+//
+// On non-Windows platforms, it always returns false.
+func StartedByExplorer() bool {
+ return false
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/inconshreveable/mousetrap/trap_windows.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/inconshreveable/mousetrap/trap_windows.go b/newt/vendor/github.com/inconshreveable/mousetrap/trap_windows.go
new file mode 100644
index 0000000..336142a
--- /dev/null
+++ b/newt/vendor/github.com/inconshreveable/mousetrap/trap_windows.go
@@ -0,0 +1,98 @@
+// +build windows
+// +build !go1.4
+
+package mousetrap
+
+import (
+ "fmt"
+ "os"
+ "syscall"
+ "unsafe"
+)
+
+const (
+ // defined by the Win32 API
+ th32cs_snapprocess uintptr = 0x2
+)
+
+var (
+ kernel = syscall.MustLoadDLL("kernel32.dll")
+ CreateToolhelp32Snapshot = kernel.MustFindProc("CreateToolhelp32Snapshot")
+ Process32First = kernel.MustFindProc("Process32FirstW")
+ Process32Next = kernel.MustFindProc("Process32NextW")
+)
+
+// ProcessEntry32 structure defined by the Win32 API
+type processEntry32 struct {
+ dwSize uint32
+ cntUsage uint32
+ th32ProcessID uint32
+ th32DefaultHeapID int
+ th32ModuleID uint32
+ cntThreads uint32
+ th32ParentProcessID uint32
+ pcPriClassBase int32
+ dwFlags uint32
+ szExeFile [syscall.MAX_PATH]uint16
+}
+
+func getProcessEntry(pid int) (pe *processEntry32, err error) {
+ snapshot, _, e1 := CreateToolhelp32Snapshot.Call(th32cs_snapprocess, uintptr(0))
+ if snapshot == uintptr(syscall.InvalidHandle) {
+ err = fmt.Errorf("CreateToolhelp32Snapshot: %v", e1)
+ return
+ }
+ defer syscall.CloseHandle(syscall.Handle(snapshot))
+
+ var processEntry processEntry32
+ processEntry.dwSize = uint32(unsafe.Sizeof(processEntry))
+ ok, _, e1 := Process32First.Call(snapshot, uintptr(unsafe.Pointer(&processEntry)))
+ if ok == 0 {
+ err = fmt.Errorf("Process32First: %v", e1)
+ return
+ }
+
+ for {
+ if processEntry.th32ProcessID == uint32(pid) {
+ pe = &processEntry
+ return
+ }
+
+ ok, _, e1 = Process32Next.Call(snapshot, uintptr(unsafe.Pointer(&processEntry)))
+ if ok == 0 {
+ err = fmt.Errorf("Process32Next: %v", e1)
+ return
+ }
+ }
+}
+
+func getppid() (pid int, err error) {
+ pe, err := getProcessEntry(os.Getpid())
+ if err != nil {
+ return
+ }
+
+ pid = int(pe.th32ParentProcessID)
+ return
+}
+
+// StartedByExplorer returns true if the program was invoked by the user double-clicking
+// on the executable from explorer.exe
+//
+// It is conservative and returns false if any of the internal calls fail.
+// It does not guarantee that the program was run from a terminal. It only can tell you
+// whether it was launched from explorer.exe
+func StartedByExplorer() bool {
+ ppid, err := getppid()
+ if err != nil {
+ return false
+ }
+
+ pe, err := getProcessEntry(ppid)
+ if err != nil {
+ return false
+ }
+
+ name := syscall.UTF16ToString(pe.szExeFile[:])
+ return name == "explorer.exe"
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go b/newt/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go
new file mode 100644
index 0000000..9a28e57
--- /dev/null
+++ b/newt/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go
@@ -0,0 +1,46 @@
+// +build windows
+// +build go1.4
+
+package mousetrap
+
+import (
+ "os"
+ "syscall"
+ "unsafe"
+)
+
+func getProcessEntry(pid int) (*syscall.ProcessEntry32, error) {
+ snapshot, err := syscall.CreateToolhelp32Snapshot(syscall.TH32CS_SNAPPROCESS, 0)
+ if err != nil {
+ return nil, err
+ }
+ defer syscall.CloseHandle(snapshot)
+ var procEntry syscall.ProcessEntry32
+ procEntry.Size = uint32(unsafe.Sizeof(procEntry))
+ if err = syscall.Process32First(snapshot, &procEntry); err != nil {
+ return nil, err
+ }
+ for {
+ if procEntry.ProcessID == uint32(pid) {
+ return &procEntry, nil
+ }
+ err = syscall.Process32Next(snapshot, &procEntry)
+ if err != nil {
+ return nil, err
+ }
+ }
+}
+
+// StartedByExplorer returns true if the program was invoked by the user double-clicking
+// on the executable from explorer.exe
+//
+// It is conservative and returns false if any of the internal calls fail.
+// It does not guarantee that the program was run from a terminal. It only can tell you
+// whether it was launched from explorer.exe
+func StartedByExplorer() bool {
+ pe, err := getProcessEntry(os.Getppid())
+ if err != nil {
+ return false
+ }
+ return "explorer.exe" == syscall.UTF16ToString(pe.ExeFile[:])
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/f6ae9636/newt/vendor/github.com/kr/pretty/.gitignore
----------------------------------------------------------------------
diff --git a/newt/vendor/github.com/kr/pretty/.gitignore b/newt/vendor/github.com/kr/pretty/.gitignore
new file mode 100644
index 0000000..1f0a99f
--- /dev/null
+++ b/newt/vendor/github.com/kr/pretty/.gitignore
@@ -0,0 +1,4 @@
+[568].out
+_go*
+_test*
+_obj