Merge pull request #444 from Masterminds/feat/reworked-init
Rework create/init
diff --git a/action/config_wizard.go b/action/config_wizard.go
new file mode 100644
index 0000000..c00c3d7
--- /dev/null
+++ b/action/config_wizard.go
@@ -0,0 +1,362 @@
+package action
+
+import (
+ "os"
+ "os/exec"
+ "path/filepath"
+ "regexp"
+ "strings"
+
+ "github.com/Masterminds/glide/cache"
+ "github.com/Masterminds/glide/cfg"
+ "github.com/Masterminds/glide/msg"
+ gpath "github.com/Masterminds/glide/path"
+ "github.com/Masterminds/semver"
+ "github.com/Masterminds/vcs"
+)
+
+// ConfigWizard reads configuration from a glide.yaml file and attempts to suggest
+// improvements. The wizard is interactive.
+func ConfigWizard(base string) {
+ _, err := gpath.Glide()
+ glidefile := gpath.GlideFile
+ if err != nil {
+ msg.Info("Unable to find a glide.yaml file. Would you like to create one now? Yes (Y) or No (N)")
+ bres := msg.PromptUntilYorN()
+ if bres {
+ // Guess deps
+ conf := guessDeps(base, false)
+ // Write YAML
+ if err := conf.WriteFile(glidefile); err != nil {
+ msg.Die("Could not save %s: %s", glidefile, err)
+ }
+ } else {
+ msg.Err("Unable to find configuration file. Please create configuration information to continue.")
+ }
+ }
+
+ conf := EnsureConfig()
+
+ err = cache.Setup()
+ if err != nil {
+ msg.Die("Problem setting up cache: %s", err)
+ }
+
+ msg.Info("Looking for dependencies to make suggestions on")
+ msg.Info("--> Scanning for dependencies not using verion ranges")
+ msg.Info("--> Scanning for dependencies using commit ids")
+ var deps []*cfg.Dependency
+ for _, dep := range conf.Imports {
+ if wizardLookInto(dep) {
+ deps = append(deps, dep)
+ }
+ }
+
+ msg.Info("Gathering information on each dependency")
+ msg.Info("--> This may take a moment. Especially on a codebase with many dependencies")
+ msg.Info("--> Gathering release information for dependencies")
+ msg.Info("--> Looking for dependency imports where versions are commit ids")
+ for _, dep := range deps {
+ wizardFindVersions(dep)
+ }
+
+ var changes int
+ for _, dep := range deps {
+ var remote string
+ if dep.Repository != "" {
+ remote = dep.Repository
+ } else {
+ remote = "https://" + dep.Name
+ }
+
+ // First check, ask if the tag should be used instead of the commit id for it.
+ cur := cache.MemCurrent(remote)
+ if cur != "" && cur != dep.Reference {
+ wizardSugOnce()
+ var dres bool
+ asked, use, val := wizardOnce("current")
+ if !use {
+ dres = wizardAskCurrent(cur, dep)
+ }
+ if !asked {
+ as := wizardRemember()
+ wizardSetOnce("current", as, dres)
+ }
+
+ if asked && use {
+ dres = val.(bool)
+ }
+
+ if dres {
+ msg.Info("Updating %s to use the tag %s instead of commit id %s", dep.Name, cur, dep.Reference)
+ dep.Reference = cur
+ changes++
+ }
+ }
+
+ // Second check, if no version is being used and there's a semver release ask about latest.
+ memlatest := cache.MemLatest(remote)
+ if dep.Reference == "" && memlatest != "" {
+ wizardSugOnce()
+ var dres bool
+ asked, use, val := wizardOnce("latest")
+ if !use {
+ dres = wizardAskLatest(memlatest, dep)
+ }
+ if !asked {
+ as := wizardRemember()
+ wizardSetOnce("latest", as, dres)
+ }
+
+ if asked && use {
+ dres = val.(bool)
+ }
+
+ if dres {
+ msg.Info("Updating %s to use the release %s instead of no release", dep.Name, memlatest)
+ dep.Reference = memlatest
+ changes++
+ }
+ }
+
+ // Third check, if the version is semver offer to use a range instead.
+ sv, err := semver.NewVersion(dep.Reference)
+ if err == nil {
+ wizardSugOnce()
+ var res string
+ asked, use, val := wizardOnce("range")
+ if !use {
+ res = wizardAskRange(sv, dep)
+ }
+ if !asked {
+ as := wizardRemember()
+ wizardSetOnce("range", as, res)
+ }
+
+ if asked && use {
+ res = val.(string)
+ }
+
+ if res == "m" {
+ r := "^" + sv.String()
+ msg.Info("Updating %s to use the range %s instead of commit id %s", dep.Name, r, dep.Reference)
+ dep.Reference = r
+ changes++
+ } else if res == "p" {
+ r := "~" + sv.String()
+ msg.Info("Updating %s to use the range %s instead of commit id %s", dep.Name, r, dep.Reference)
+ dep.Reference = r
+ changes++
+ }
+ }
+ }
+
+ if changes > 0 {
+ msg.Info("Configuration changes have been made. Would you like to write these")
+ msg.Info("changes to your configuration file? Yes (Y) or No (N)")
+ dres := msg.PromptUntilYorN()
+ if dres {
+ msg.Info("Writing updates to configuration file (%s)", glidefile)
+ if err := conf.WriteFile(glidefile); err != nil {
+ msg.Die("Could not save %s: %s", glidefile, err)
+ }
+ msg.Info("You can now edit the glide.yaml file.:")
+ msg.Info("--> For more information on versions and ranges see https://glide.sh/docs/versions/")
+ msg.Info("--> For details on additional metadata see https://glide.sh/docs/glide.yaml/")
+ } else {
+ msg.Warn("Change not written to configuration file")
+ }
+ } else {
+ msg.Info("No proposed changes found. Have a nice day.")
+ }
+}
+
+var wizardOnceVal = make(map[string]interface{})
+var wizardOnceDo = make(map[string]bool)
+var wizardOnceAsked = make(map[string]bool)
+
+var wizardSuggeseOnce bool
+
+func wizardSugOnce() {
+ if !wizardSuggeseOnce {
+ msg.Info("Here are some suggestions...")
+ }
+ wizardSuggeseOnce = true
+}
+
+// Returns if it's you should prompt, if not prompt if you should use stored value,
+// and stored value if it has one.
+func wizardOnce(name string) (bool, bool, interface{}) {
+ return wizardOnceAsked[name], wizardOnceDo[name], wizardOnceVal[name]
+}
+
+func wizardSetOnce(name string, prompt bool, val interface{}) {
+ wizardOnceAsked[name] = true
+ wizardOnceDo[name] = prompt
+ wizardOnceVal[name] = val
+}
+
+func wizardRemember() bool {
+ msg.Info("Would you like to remember the previous decision and apply it to future")
+ msg.Info("dependencies? Yes (Y) or No (N)")
+ return msg.PromptUntilYorN()
+}
+
+func wizardAskRange(ver *semver.Version, d *cfg.Dependency) string {
+ vstr := ver.String()
+ msg.Info("The package %s appears to use semantic versions (http://semver.org).", d.Name)
+ msg.Info("Would you like to track the latest minor or patch releases (major.minor.path)?")
+ msg.Info("Tracking minor version releases would use '>= %s, < %d.0.0' ('^%s'). Tracking patch version", vstr, ver.Major()+1, vstr)
+ msg.Info("releases would use '>= %s, < %d.%d.0' ('~%s'). For more information on Glide versions", vstr, ver.Major(), ver.Minor()+1, vstr)
+ msg.Info("and ranges see https://glide.sh/docs/versions")
+ msg.Info("Minor (M), Patch (P), or Skip Ranges (S)?")
+ res, err := msg.PromptUntil([]string{"minor", "m", "patch", "p", "skip ranges", "s"})
+ if err != nil {
+ msg.Die("Error processing response: %s", err)
+ }
+ if res == "m" || res == "minor" {
+ return "m"
+ } else if res == "p" || res == "patch" {
+ return "p"
+ }
+
+ return "s"
+}
+
+func wizardAskCurrent(cur string, d *cfg.Dependency) bool {
+ msg.Info("The package %s is currently set to use the version %s.", d.Name, d.Reference)
+ msg.Info("There is an equivalent semantic version (http://semver.org) release of %s. Would", cur)
+ msg.Info("you like to use that instead? Yes (Y) or No (N)")
+ return msg.PromptUntilYorN()
+}
+
+func wizardAskLatest(latest string, d *cfg.Dependency) bool {
+ msg.Info("The package %s appears to have Semantic Version releases (http://semver.org). ", d.Name)
+ msg.Info("The latestrelease is %s. You are currently not using a release. Would you like", latest)
+ msg.Info("to use this release? Yes (Y) or No (N)")
+ return msg.PromptUntilYorN()
+}
+
+func wizardLookInto(d *cfg.Dependency) bool {
+ _, err := semver.NewConstraint(d.Reference)
+
+ // The existing version is already a valid semver constraint so we skip suggestions.
+ if err == nil {
+ return false
+ }
+
+ return true
+}
+
+// Note, this really needs a simpler name.
+var createGitParseVersion = regexp.MustCompile(`(?m-s)(?:tags)/(\S+)$`)
+
+func wizardFindVersions(d *cfg.Dependency) {
+ l, err := cache.Location()
+ if err != nil {
+ msg.Debug("Problem detecting cache location: %s", err)
+ }
+ var remote string
+ if d.Repository != "" {
+ remote = d.Repository
+ } else {
+ remote = "https://" + d.Name
+ }
+
+ key, err := cache.Key(remote)
+ if err != nil {
+ msg.Debug("Problem generating cache key for %s: %s", remote, err)
+ }
+
+ local := filepath.Join(l, "src", key)
+ repo, err := vcs.NewRepo(remote, local)
+ if err != nil {
+ msg.Debug("Problem getting repo instance: %s", err)
+ }
+
+ var useLocal bool
+ if _, err = os.Stat(local); err == nil {
+ useLocal = true
+ }
+
+ // Git endpoints allow for querying without fetching the codebase locally.
+ // We try that first to avoid fetching right away. Is this premature
+ // optimization?
+ cc := true
+ if !useLocal && repo.Vcs() == vcs.Git {
+ out, err2 := exec.Command("git", "ls-remote", remote).CombinedOutput()
+ if err2 == nil {
+ cache.MemTouch(remote)
+ cc = false
+ lines := strings.Split(string(out), "\n")
+ for _, i := range lines {
+ ti := strings.TrimSpace(i)
+ if found := createGitParseVersion.FindString(ti); found != "" {
+ tg := strings.TrimPrefix(strings.TrimSuffix(found, "^{}"), "tags/")
+ cache.MemPut(remote, tg)
+ if d.Reference != "" && strings.HasPrefix(ti, d.Reference) {
+ cache.MemSetCurrent(remote, tg)
+ }
+ }
+ }
+ }
+ }
+
+ if cc {
+ cache.Lock(key)
+ cache.MemTouch(remote)
+ if _, err = os.Stat(local); os.IsNotExist(err) {
+ repo.Get()
+ branch := findCurrentBranch(repo)
+ c := cache.RepoInfo{DefaultBranch: branch}
+ err = cache.SaveRepoData(key, c)
+ if err != nil {
+ msg.Debug("Error saving cache repo details: %s", err)
+ }
+ } else {
+ repo.Update()
+ }
+ tgs, err := repo.Tags()
+ if err != nil {
+ msg.Debug("Problem getting tags: %s", err)
+ } else {
+ for _, v := range tgs {
+ cache.MemPut(remote, v)
+ }
+ }
+ if d.Reference != "" && repo.IsReference(d.Reference) {
+ tgs, err = repo.TagsFromCommit(d.Reference)
+ if err != nil {
+ msg.Debug("Problem getting tags for commit: %s", err)
+ } else {
+ if len(tgs) > 0 {
+ for _, v := range tgs {
+ if !(repo.Vcs() == vcs.Hg && v == "tip") {
+ cache.MemSetCurrent(remote, v)
+ }
+ }
+ }
+ }
+ }
+ cache.Unlock(key)
+ }
+}
+
+func findCurrentBranch(repo vcs.Repo) string {
+ msg.Debug("Attempting to find current branch for %s", repo.Remote())
+ // Svn and Bzr don't have default branches.
+ if repo.Vcs() == vcs.Svn || repo.Vcs() == vcs.Bzr {
+ return ""
+ }
+
+ if repo.Vcs() == vcs.Git || repo.Vcs() == vcs.Hg {
+ ver, err := repo.Current()
+ if err != nil {
+ msg.Debug("Unable to find current branch for %s, error: %s", repo.Remote(), err)
+ return ""
+ }
+ return ver
+ }
+
+ return ""
+}
diff --git a/action/create.go b/action/create.go
index b66257c..4d1c0bb 100644
--- a/action/create.go
+++ b/action/create.go
@@ -25,7 +25,7 @@
// If skipImport is set to true, this will not attempt to import from an existing
// GPM, Godep, or GB project if one should exist. However, it will still attempt
// to read the local source to determine required packages.
-func Create(base string, skipImport bool) {
+func Create(base string, skipImport, nonInteractive bool) {
glidefile := gpath.GlideFile
// Guard against overwrites.
guardYAML(glidefile)
@@ -33,9 +33,28 @@
// Guess deps
conf := guessDeps(base, skipImport)
// Write YAML
+ msg.Info("Writing configuration file (%s)", glidefile)
if err := conf.WriteFile(glidefile); err != nil {
msg.Die("Could not save %s: %s", glidefile, err)
}
+
+ var res bool
+ if !nonInteractive {
+ msg.Info("Would you like Glide to help you find ways to improve your glide.yaml configuration?")
+ msg.Info("If you want to revisit this step you can use the config-wizard command at any time.")
+ msg.Info("Yes (Y) or No (N)?")
+ res = msg.PromptUntilYorN()
+ if res {
+ ConfigWizard(base)
+ }
+ }
+
+ if !res {
+ msg.Info("You can now edit the glide.yaml file. Consider:")
+ msg.Info("--> Using versions and ranges. See https://glide.sh/docs/versions/")
+ msg.Info("--> Adding additional metadata. See https://glide.sh/docs/glide.yaml/")
+ msg.Info("--> Running the config-wizard command to improve the versions in your configuration")
+ }
}
// guardYAML fails if the given file already exists.
@@ -76,6 +95,13 @@
guessImportDeps(base, config)
}
+ importLen := len(config.Imports)
+ if importLen == 0 {
+ msg.Info("Scanning code to look for dependencies")
+ } else {
+ msg.Info("Scanning code to look for dependencies not found in import")
+ }
+
// Resolve dependencies by looking at the tree.
r, err := dependency.NewResolver(base)
if err != nil {
@@ -102,7 +128,7 @@
root, subpkg := util.NormalizeName(n)
if !config.HasDependency(root) && root != config.Name {
- msg.Info("Found reference to %s\n", n)
+ msg.Info("--> Found reference to %s\n", n)
d := &cfg.Dependency{
Name: root,
}
@@ -115,13 +141,17 @@
subpkg = strings.TrimPrefix(subpkg, "/")
d := config.Imports.Get(root)
if !d.HasSubpackage(subpkg) {
- msg.Info("Adding sub-package %s to %s\n", subpkg, root)
+ msg.Info("--> Adding sub-package %s to %s\n", subpkg, root)
d.Subpackages = append(d.Subpackages, subpkg)
}
}
}
}
+ if len(config.Imports) == importLen && importLen != 0 {
+ msg.Info("--> Code scanning found no additional imports")
+ }
+
return config
}
@@ -146,7 +176,12 @@
}
for _, i := range deps {
- msg.Info("Found imported reference to %s\n", i.Name)
+ if i.Reference == "" {
+ msg.Info("--> Found imported reference to %s", i.Name)
+ } else {
+ msg.Info("--> Found imported reference to %s at revision %s", i.Name, i.Reference)
+ }
+
config.Imports = append(config.Imports, i)
}
}
diff --git a/action/debug.go b/action/debug.go
index 7b8eea6..6af9d26 100644
--- a/action/debug.go
+++ b/action/debug.go
@@ -7,6 +7,15 @@
// Debug sets the debugging flags across components.
func Debug(on bool) {
msg.Default.IsDebugging = on
+
+ if on == true {
+ msg.Default.IsVerbose = on
+ }
+}
+
+// Verbose sets the verbose flags across components.
+func Verbose(on bool) {
+ msg.Default.IsVerbose = on
}
// Quiet sets the quiet flags across components.
diff --git a/cache/memory.go b/cache/memory.go
new file mode 100644
index 0000000..3809331
--- /dev/null
+++ b/cache/memory.go
@@ -0,0 +1,139 @@
+package cache
+
+import (
+ "sync"
+
+ "github.com/Masterminds/glide/msg"
+ "github.com/Masterminds/semver"
+)
+
+// Provide an in memory cache of imported project information.
+
+var defaultMemCache = newMemCache()
+
+// MemPut put a version into the in memory cache for a name.
+// This will silently ignore non-semver and make sure the latest
+// is stored.
+func MemPut(name, version string) {
+ defaultMemCache.put(name, version)
+}
+
+// MemTouched returns true if the cache was touched for a name.
+func MemTouched(name string) bool {
+ return defaultMemCache.touched(name)
+}
+
+// MemTouch notes if a name has been looked at.
+func MemTouch(name string) {
+ defaultMemCache.touch(name)
+}
+
+// MemLatest returns the latest, that is most recent, semver release. This
+// may be a blank string if no put value
+func MemLatest(name string) string {
+ return defaultMemCache.getLatest(name)
+}
+
+// MemSetCurrent is used to set the current version in use.
+func MemSetCurrent(name, version string) {
+ defaultMemCache.setCurrent(name, version)
+}
+
+// MemCurrent is used to get the current version in use.
+func MemCurrent(name string) string {
+ return defaultMemCache.current(name)
+}
+
+// An in memory cache.
+type memCache struct {
+ sync.RWMutex
+ latest map[string]string
+ t map[string]bool
+ versions map[string][]string
+ c map[string]string
+}
+
+func newMemCache() *memCache {
+ return &memCache{
+ latest: make(map[string]string),
+ t: make(map[string]bool),
+ versions: make(map[string][]string),
+ c: make(map[string]string),
+ }
+}
+
+func (m *memCache) setCurrent(name, version string) {
+ m.Lock()
+ defer m.Unlock()
+
+ if m.c[name] == "" {
+ m.c[name] = version
+ } else {
+ // If we already have a version try to see if the new or old one is
+ // semver and use that one.
+ _, err := semver.NewVersion(m.c[name])
+ if err != nil {
+ _, err2 := semver.NewVersion(version)
+ if err2 == nil {
+ m.c[name] = version
+ }
+ }
+ }
+}
+
+func (m *memCache) current(name string) string {
+ m.RLock()
+ defer m.RUnlock()
+ return m.c[name]
+}
+
+func (m *memCache) put(name, version string) {
+ m.Lock()
+ defer m.Unlock()
+ m.t[name] = true
+ sv, err := semver.NewVersion(version)
+ if err != nil {
+ msg.Debug("Ignoring %s version %s: %s", name, version, err)
+ return
+ }
+
+ latest, found := m.latest[name]
+ if found {
+ lv, err := semver.NewVersion(latest)
+ if err != nil {
+ if sv.GreaterThan(lv) {
+ m.latest[name] = version
+ }
+ }
+ } else {
+ m.latest[name] = version
+ }
+
+ found = false
+ for _, v := range m.versions[name] {
+ if v == version {
+ found = true
+ }
+ }
+ if !found {
+ m.versions[name] = append(m.versions[name], version)
+ }
+}
+
+func (m *memCache) touch(name string) {
+ m.Lock()
+ defer m.Unlock()
+ m.t[name] = true
+}
+
+func (m *memCache) touched(name string) bool {
+ m.RLock()
+ defer m.RUnlock()
+ return m.t[name]
+}
+
+func (m *memCache) getLatest(name string) string {
+ m.RLock()
+ defer m.RUnlock()
+ return m.latest[name]
+}
diff --git a/gb/gb.go b/gb/gb.go
index 1f3b208..7837a42 100644
--- a/gb/gb.go
+++ b/gb/gb.go
@@ -26,6 +26,7 @@
}
msg.Info("Found GB manifest file in %s", gpath.StripBasepath(dir))
+ msg.Info("--> Parsing GB metadata...")
buf := []*cfg.Dependency{}
file, err := os.Open(path)
if err != nil {
diff --git a/glide.go b/glide.go
index 0e1e355..5bd2894 100644
--- a/glide.go
+++ b/glide.go
@@ -92,8 +92,12 @@
Usage: "Quiet (no info or debug messages)",
},
cli.BoolFlag{
+ Name: "verbose",
+ Usage: "Print detailed informational messages",
+ },
+ cli.BoolFlag{
Name: "debug",
- Usage: "Print Debug messages (verbose)",
+ Usage: "Print debug verbose informational messages",
},
cli.StringFlag{
Name: "home",
@@ -146,9 +150,24 @@
Name: "skip-import",
Usage: "When initializing skip importing from other package managers.",
},
+ cli.BoolFlag{
+ Name: "non-interactive",
+ Usage: "Disable interactive prompts.",
+ },
},
Action: func(c *cli.Context) {
- action.Create(".", c.Bool("skip-import"))
+ action.Create(".", c.Bool("skip-import"), c.Bool("non-interactive"))
+ },
+ },
+ {
+ Name: "config-wizard",
+ ShortName: "cw",
+ Usage: "Wizard that makes optional suggestions to improve config in a glide.yaml file.",
+ Description: `Glide will analyze a projects glide.yaml file and the imported
+ projects to find ways the glide.yaml file can potentially be improved. It
+ will then interactively make suggestions that you can skip or accept.`,
+ Action: func(c *cli.Context) {
+ action.ConfigWizard(".")
},
},
{
@@ -664,6 +683,7 @@
// so it can be used by any Glide command.
func startup(c *cli.Context) error {
action.Debug(c.Bool("debug"))
+ action.Verbose(c.Bool("verbose"))
action.NoColor(c.Bool("no-color"))
action.Quiet(c.Bool("quiet"))
action.Init(c.String("yaml"), c.String("home"))
diff --git a/godep/godep.go b/godep/godep.go
index a7d0525..71291b3 100644
--- a/godep/godep.go
+++ b/godep/godep.go
@@ -55,6 +55,7 @@
return []*cfg.Dependency{}, nil
}
msg.Info("Found Godeps.json file in %s", gpath.StripBasepath(dir))
+ msg.Info("--> Parsing Godeps metadata...")
buf := []*cfg.Dependency{}
diff --git a/gom/gom.go b/gom/gom.go
index 76305e4..51910b0 100644
--- a/gom/gom.go
+++ b/gom/gom.go
@@ -26,6 +26,7 @@
}
msg.Info("Found Gomfile in %s", gpath.StripBasepath(dir))
+ msg.Info("--> Parsing Gomfile metadata...")
buf := []*cfg.Dependency{}
goms, err := parseGomfile(path)
diff --git a/gpm/gpm.go b/gpm/gpm.go
index 45e316f..e58a81d 100644
--- a/gpm/gpm.go
+++ b/gpm/gpm.go
@@ -31,6 +31,7 @@
return []*cfg.Dependency{}, nil
}
msg.Info("Found Godeps file in %s", gpath.StripBasepath(dir))
+ msg.Info("--> Parsing GPM metadata...")
buf := []*cfg.Dependency{}
diff --git a/msg/msg.go b/msg/msg.go
index af49ecf..34213fd 100644
--- a/msg/msg.go
+++ b/msg/msg.go
@@ -1,6 +1,7 @@
package msg
import (
+ "bufio"
"fmt"
"io"
"os"
@@ -16,9 +17,12 @@
// Quiet, if true, suppresses chatty levels, like Info.
Quiet bool
- // IsDebugging, if true, shows verbose levels, like Debug.
+ // IsDebugging, if true, shows Debug.
IsDebugging bool
+ // IsVerbose, if true, shows detailed informational messages.
+ IsVerbose bool
+
// NoColor, if true, will not use color in the output.
NoColor bool
@@ -28,6 +32,9 @@
// Stderr is the location where this prints logs.
Stderr io.Writer
+ // Stdin is the location where input is read.
+ Stdin io.Reader
+
// PanicOnDie if true Die() will panic instead of exiting.
PanicOnDie bool
@@ -43,9 +50,11 @@
m := &Messenger{
Quiet: false,
IsDebugging: false,
+ IsVerbose: false,
NoColor: false,
Stdout: os.Stdout,
Stderr: os.Stderr,
+ Stdin: os.Stdin,
PanicOnDie: false,
ecode: 1,
}
@@ -76,7 +85,7 @@
return
}
prefix := "[DEBUG]\t"
- Msg(prefix+msg, args...)
+ m.Msg(prefix+msg, args...)
}
// Debug logs debug information using the Default Messenger
@@ -84,6 +93,19 @@
Default.Debug(msg, args...)
}
+// Verbose logs detailed information
+func (m *Messenger) Verbose(msg string, args ...interface{}) {
+ if m.Quiet || !m.IsVerbose {
+ return
+ }
+ m.Info(msg, args...)
+}
+
+// Verbose detailed information using the Default Messenger
+func Verbose(msg string, args ...interface{}) {
+ Default.Verbose(msg, args...)
+}
+
// Warn logs a warning
func (m *Messenger) Warn(msg string, args ...interface{}) {
prefix := m.Color(Yellow, "[WARN]\t")
@@ -238,3 +260,54 @@
func Color(code, msg string) string {
return Default.Color(code, msg)
}
+
+// PromptUntil provides a prompt until one of the passed in strings has been
+// entered and return is hit. Note, the comparisons are case insensitive meaning
+// Y == y. The returned value is the one from the passed in options (same case).
+func (m *Messenger) PromptUntil(opts []string) (string, error) {
+ reader := bufio.NewReader(os.Stdin)
+ for {
+ text, err := reader.ReadString('\n')
+ if err != nil {
+ return "", err
+ }
+
+ for _, c := range opts {
+ if strings.EqualFold(c, strings.TrimSpace(text)) {
+ return c, nil
+ }
+ }
+ }
+}
+
+// PromptUntil provides a prompt until one of the passed in strings has been
+// entered and return is hit. Note, the comparisons are case insensitive meaning
+// Y == y. The returned value is the one from the passed in options (same case).
+// Uses the default setup.
+func PromptUntil(opts []string) (string, error) {
+ return Default.PromptUntil(opts)
+}
+
+// PromptUntilYorN provides a prompt until the user chooses yes or no. This is
+// not case sensitive and they can input other options such as Y or N.
+// In the response Yes is bool true and No is bool false.
+func (m *Messenger) PromptUntilYorN() bool {
+ res, err := m.PromptUntil([]string{"y", "yes", "n", "no"})
+ if err != nil {
+ m.Die("Error processing response: %s", err)
+ }
+
+ if res == "y" || res == "yes" {
+ return true
+ }
+
+ return false
+}
+
+// PromptUntilYorN provides a prompt until the user chooses yes or no. This is
+// not case sensitive and they can input other options such as Y or N.
+// In the response Yes is bool true and No is bool false.
+// Uses the default setup.
+func PromptUntilYorN() bool {
+ return Default.PromptUntilYorN()
+}
