示例#1
0
func remove(c *cli.Context) {
	if len(c.Args()) != 1 {
		cli.ShowCommandHelp(c, "remove")
		fatalErrorf("Expected exactly 1 argument instead of %d", len(c.Args()))
	}

	project, err := godm.NewLocalProject(path.Dir(os.Args[0]), "")
	if err != nil {
		fatalErrorf("Error building the current project : %s", err.Error())
	}
	Log.Debug("Project's Type : %T", project, project.GetBaseDir())
	Log.Debug("Project's Base Dir : %s", project.GetBaseDir())

	importPath := c.Args().First()

	err = project.RemoveVendor(importPath)

	if err == godm.ErrUnknownVendor {
		Log.Warning("Import path %q cannot be removed from vendors because it is not vendored in current project", importPath)
		return
	} else if err != nil {
		fatalErrorf("Error removing import path %q from vendors : %s", importPath, err.Error())
	}
	Log.Notice("%q removed from vendors", importPath)
}
示例#2
0
func clean(c *cli.Context) {
	if len(c.Args()) > 0 {
		cli.ShowCommandHelp(c, "clean")
		fatalErrorf("Too much arguments")
	}

	project, err := godm.NewLocalProject(path.Dir(os.Args[0]), "")
	if err != nil {
		fatalErrorf("Error building the current project : %s", err.Error())
	}
	Log.Debug("Project's Type : %T", project, project.GetBaseDir())
	Log.Debug("Project's Base Dir : %s", project.GetBaseDir())

	imports, err := project.GetImports()
	if err != nil {
		fatalErrorf("Error listing import paths : %s", err.Error())
	}
	Log.Info("Found %d imports", len(imports))
	if len(imports) == 0 {
		// No imports, nothing to do
		return
	}

	vendors, err := project.GetVendors()
	if err != nil {
		fatalErrorf("Error listing vendors : %s", err.Error())
	}
	Log.Info("Found %d vendors", len(vendors))
	Log.Debug("Vendors list : %# v", vendors)

	errorCount := 0

vendorsLoop:
	for vendorImportPath := range vendors {
		if !imports.Has(vendorImportPath) {
			for importPath := range imports {
				if strings.HasPrefix(importPath, vendorImportPath) {
					// We are importing a sub-package of this vendor
					continue vendorsLoop
				}
			}
			err = project.RemoveVendor(vendorImportPath)
			if err != nil {
				errorCount++
				Log.Error("Error removing vendor %q : %s", vendorImportPath, err.Error())
			} else {
				fmt.Println(vendorImportPath)
			}
		}
	}

	if errorCount > 0 {
		os.Exit(errorCount)
	}
}
示例#3
0
文件: main.go 项目: hectorj/godm
func main() {
	checkGo15VendorActivated()

	cli.VersionFlag.Name = "version" // We use "v" for verbose
	app := cli.NewApp()
	app.Name = "godm"
	app.Usage = "Package Manager for Go 1.5+"
	app.Authors = []cli.Author{
		{
			Name:  "HectorJ",
			Email: "*****@*****.**",
		},
	}
	app.Flags = []cli.Flag{
		cli.BoolFlag{
			Name:  "verbose",
			Usage: "Verbose output",
		},
	}
	app.EnableBashCompletion = true
	app.Before = func(c *cli.Context) error {
		logging.SetFormatter(logFormatter)
		backend := logging.AddModuleLevel(logging.NewLogBackend(os.Stderr, "", 0))
		if c.GlobalBool("verbose") {
			backend.SetLevel(logging.DEBUG, "")
		} else {
			backend.SetLevel(logging.WARNING, "")
		}

		Log.SetBackend(backend)
		return nil
	}
	app.Commands = []cli.Command{
		{
			Name:   "clean",
			Usage:  "Removes vendors that are not imported in the current project. Outputs the import paths of vendors successfully removed.",
			Action: clean,
		},
		{
			Name:  "vendor",
			Usage: "Vendors imports that are not vendored yet in the current project. Outputs the import paths of vendors successfully added.",
			Flags: []cli.Flag{
			// Removed for now. Here is the current behavior :
			// - For Git projects : we start from the root dir and do scan recursively all sub-packages (except vendors)
			// - For "no-vcl" projects : we only scan the current dir we're in
			//				cli.BoolFlag{
			//					Name:  "r,recursive",
			//					Usage: "Scan dirs recursively for sub-packages",
			//				},

			// Removed for now. Here is the current behavior :
			// We exclude "vendor" directories
			//				cli.StringSliceFlag{
			//					Name:  "e,exclude",
			//					Usage: "Files/Directories names to exclude from scanning, as regexp.",
			//				},
			},
			Action: vendor,
		},
		{
			Name:    "remove",
			Aliases: []string{"rm"},
			Usage:   "Unvendors an import path. Takes a single import path as argument.",
			Flags:   []cli.Flag{
			// Removed for now, as there is no confirmation asked anywhere
			//				cli.BoolFlag{
			//					Name:  "y,yes",
			//					Usage: "Remove the submodule without asking any confirmation",
			//				},
			},
			Action: remove,
			BashComplete: func(c *cli.Context) {
				if len(c.Args()) > 0 {
					return
				}
				project, err := godm.NewLocalProject(path.Dir(os.Args[0]), "")
				if err != nil {
					return
				}

				vendors, err := project.GetVendors()

				if err != nil {
					return
				}

				for importPath := range vendors {
					fmt.Println(importPath)
				}
			},
		},
	}
	app.RunAndExitOnError()
}
示例#4
0
func vendor(c *cli.Context) {
	if len(c.Args()) > 0 {
		cli.ShowCommandHelp(c, "vendor")
		fatalErrorf("Too much arguments")
	}

	project, err := godm.NewLocalProject(path.Dir(os.Args[0]), "")
	if err != nil {
		fatalErrorf("Error building the current project : %s", err.Error())
	}
	Log.Debug("Project's Type : %T", project, project.GetBaseDir())
	Log.Debug("Project's Base Dir : %s", project.GetBaseDir())

	imports, err := project.GetImports()
	if err != nil {
		fatalErrorf("Error listing import paths : %s", err.Error())
	}
	Log.Info("Found %d imports", len(imports))
	if len(imports) == 0 {
		// No imports, nothing to do
		return
	}

	vendors, err := project.GetVendors()
	if err != nil {
		fatalErrorf("Error listing vendors : %s", err.Error())
	}
	Log.Info("Found %d vendors", len(vendors))
	Log.Debug("Vendors list : %# v", vendors)

importsLoop:
	for importPath := range imports {
		if _, exists := vendors[importPath]; !exists {
			vendorProject, canonicalImportPath, err := godm.NewProjectFromImportPath(importPath)
			if _, exists := vendors[canonicalImportPath]; exists {
				Log.Info("%q is a sub-package of %q which is already vendored", importPath, canonicalImportPath)
				continue importsLoop
			}

			if localVendorProject, ok := vendorProject.(godm.LocalProject); ok {
				if strings.HasPrefix(localVendorProject.GetBaseDir(), project.GetBaseDir()) {
					Log.Debug("%q ignored because it is a sub-package of current project", canonicalImportPath)
					continue importsLoop
				}
			}
			if err != nil {
				if err == godm.ErrStandardLibrary {
					Log.Debug("%q ignored because part of the standard library", canonicalImportPath)
					err = nil
				} else {
					fatalErrorf("Error with import path %q : %s", canonicalImportPath, err.Error())
				}
			} else {
				_, err = project.AddVendor(canonicalImportPath, vendorProject)
				if err != nil {
					fatalErrorf("Error vendoring import path %q : %s", canonicalImportPath, err.Error())
				} else {
					Log.Notice("%q vendored", canonicalImportPath)
					fmt.Println(canonicalImportPath)
				}
			}

		} else {
			Log.Info("%q is already vendored", importPath)
		}
	}
}