// Self upgrades this version of depman to the latest on the master branch
func Self() {
deps := dep.New()
d := new(dep.Dependency)
d.Repo = "github.com/vube/depman"
d.Version = "master"
d.Type = "git"
d.SetupVCS("depman")
deps.Map["depman"] = d
install.Recurse = false
install.Install(deps)
install.Recurse = true
util.RunCommand("go install github.com/vube/depman")
}
// Add interactively prompts the user for details of a dependency, adds it to deps.json, and writes out the file
func Add(deps dep.DependencyMap, name string) {
var cont = true
_, exists := deps.Map[name]
if exists {
util.Fatal(colors.Red("Dependency '" + name + "'' is already defined, pick another name."))
}
util.Print(colors.Blue("Adding: ") + name)
for cont {
d := new(dep.Dependency)
d.Type = promptType("Type", "git, git-clone, hg, bzr")
if d.Type == dep.TypeGitClone {
d.Repo = promptString("Repo", "git url")
} else {
d.Repo = promptString("Repo", "go import")
}
d.Version = promptString("Version", "hash, branch, or tag")
if d.Type == dep.TypeGitClone {
d.Alias = promptString("Alias", "where to install the repo")
}
deps.Map[name] = d
cont = promptBool("Add another", "y/N")
}
for name, d := range deps.Map {
err := d.SetupVCS(name)
if err != nil {
delete(deps.Map, name)
}
}
err := deps.Write()
if err != nil {
util.Fatal(colors.Red("Error Writing " + deps.Path + ": " + err.Error()))
}
install.Install(deps)
return
}
// Update rewrites Dependency name in deps.json to use the last commit in branch as version
func Update(deps dep.DependencyMap, name string, branch string) {
util.Print(colors.Blue("Updating:"))
d, ok := deps.Map[name]
if !ok {
util.Fatal(colors.Red("Dependency Name '" + name + "' not found in deps.json"))
}
// record the old version
oldVersion := d.Version
// temporarily use the branch
d.Version = branch
pwd := util.Pwd()
util.Cd(d.Path())
d.VCS.Checkout(d)
d.VCS.Update(d)
// get the last commit on the newly checked out branch
v, err := d.VCS.LastCommit(d, branch)
if err != nil {
util.Fatal(err)
}
// set the version to be the last commit
d.Version = v
util.PrintIndent(colors.Blue(name) + " (" + oldVersion + " --> " + d.Version + ")")
util.Cd(pwd)
deps.Map[name] = d
deps.Write()
install.Install(deps)
}
func main() {
var help bool
var path string
var command string
var arguments []string
var deps dep.DependencyMap
var err error
log.SetFlags(0)
flag.BoolVar(&help, "help", false, "Display help")
flag.StringVar(&path, "path", ".", "Directory or full path to deps.json")
util.Parse()
util.Version(VERSION)
fmt.Println(colors.Red("Depman was deprecated on 25 February 2015"))
fmt.Println(colors.Red("We recommend using 'godep' instead: https://github.com/tools/godep"))
util.GoPathIsSet()
if timelock.Clear() {
return
}
timelock.Read()
// check for a new version of depman
go upgrade.Check(VERSION)
runtime.Gosched()
defer upgrade.Print()
path = dep.GetPath(path)
if flag.NArg() > 0 {
command = strings.ToLower(flag.Arg(0))
}
if flag.NArg() > 1 {
arguments = flag.Args()[1:]
}
if help {
command = "help"
}
// switch to check for deps.json
switch command {
case "add", "", "install", "update", "show-frozen":
// check for deps.json
util.CheckPath(path)
deps, err = dep.Read(path)
if err != nil {
util.Fatal(colors.Red("Error Reading deps.json: " + err.Error()))
}
}
// switch to exec the sub command
switch command {
case "init", "create":
create.Create(path)
case "add":
if len(arguments) < 1 {
util.Print(colors.Red("Add command requires 1 argument: Add [nickname]"))
Help()
} else {
add.Add(deps, arguments[0])
}
case "update":
if len(arguments) < 2 {
util.Print(colors.Red("Update command requires 2 arguments: Update [nickname] [branch]"))
Help()
} else {
update.Update(deps, arguments[0], arguments[1])
}
case "install", "":
install.Install(deps)
case "self-upgrade":
upgrade.Self(VERSION)
case "show-frozen":
var recursive bool
flagset := flag.NewFlagSet("show-frozen", flag.ExitOnError)
flagset.BoolVar(&recursive, "recursive", false, "descend recursively (depth-first) into dependencies")
flagset.Parse(flag.Args()[1:])
if recursive {
fmt.Println(showfrozen.ReadRecursively(deps, nil))
} else {
fmt.Print(showfrozen.Read(deps))
}
default:
result.RegisterError()
log.Println(colors.Red("Unknown Command: " + command))
fallthrough
case "help":
Help()
}
timelock.Write()
if result.ShouldExitWithError() {
os.Exit(1)
} else {
util.Print("Success")
}
}