Exemplo n.º 1
0
// buildAllPackages builds each package without vendor packages.
func buildAllPackages(buildPath string, args []string, packages []string) error {

	// Clean buildPath if exists before build
	if err := utils.CleanDirectory(buildPath); err != nil {
		return err
	}

	// Save root and change to build directory
	root, _ := os.Getwd()
	os.Chdir(buildPath)

	// Wait group
	var wg sync.WaitGroup
	wg.Add(len(packages))

	// Error channel
	chErr := make(chan error)

	// Build the packages
	for _, pkg := range packages {

		// Routine for package build
		go func(pkg string, args []string, chErr chan error) {

			defer wg.Done()

			// Add package to arguments
			args = append(args, pkg)

			// Shell command go build [flags] [binary] [package]
			cmdName := "go"
			cmdArgs := []string{"build"}

			// Add arguments
			cmdArgs = append(cmdArgs, args...)

			// Run go build with arguments command, send error to channel
			chErr <- utils.CmdRun(cmdName, cmdArgs...)

		}(pkg, args, chErr)
	}

	// Wait for channel errors
	for i := 0; i < len(packages); i++ {
		err := <-chErr
		if err != nil {
			return err
		}
	}

	// Wait for routines
	wg.Wait()

	// Change back to root
	os.Chdir(root)

	return nil
}
Exemplo n.º 2
0
// createFilesFromTemplates generate files from templates
func createFilesFromTemplates(settings *Settings) error {

	// For templates
	var lxbPath string

	// Loop through GOPATHs and find the LxbPackageName directory.
	for _, v := range settings.GoPaths {

		// Checking for LxbPackage in this directory
		checkPath := filepath.Join(v, "src", lxb.LxbPackageName)

		if _, err := os.Stat(checkPath); os.IsNotExist(err) {
			continue
		} else {
			lxbPath = checkPath
			break
		}
	}

	// Check whether LxbPackage was found
	if len(lxbPath) == 0 {
		return fmt.Errorf("Package path %s not found in gopaths.", lxb.LxbPackageName)
	}

	// Set binary name
	binaryName := settings.ProjectName

	if runtime.GOOS == "windows" {
		binaryName += ".exe"
	}

	// Project package name, if name with package-name than replace with package_name
	projectPackageName := strings.Replace(settings.ProjectName, "-", "_", -1)

	// Template vars
	tplVars := map[string]string{"ProjectName": settings.ProjectName, "ProjectPackageName": projectPackageName,
		"PackagePath": settings.PackagePath, "LxbPackageName": lxb.LxbPackageName, "BinaryName": binaryName}

	ftpls := map[string]FileTemplates{
		"changelog": FileTemplates{
			"changelog.tpl",
			"CHANGELOG.md",
			settings.Root,
			tplVars,
		},
		"cmd_doc": FileTemplates{
			"cmd_doc.tpl",
			"doc.go",
			filepath.Join(settings.Root, "cmd", settings.ProjectName),
			tplVars,
		},
		"cmd_main": FileTemplates{
			"cmd_main.tpl",
			"main.go",
			filepath.Join(settings.Root, "cmd", settings.ProjectName),
			tplVars,
		},
		"cmd_main_test": FileTemplates{
			"cmd_main_test.tpl",
			"main_test.go",
			filepath.Join(settings.Root, "cmd", settings.ProjectName),
			tplVars,
		},
		"editorconfig": FileTemplates{
			"editorconfig.tpl",
			".editorconfig",
			settings.Root,
			nil,
		},
		"gitignore": FileTemplates{
			"gitignore.tpl",
			".gitignore",
			settings.Root,
			nil,
		},
		"project_package": FileTemplates{
			"project_package.tpl",
			settings.ProjectName + ".go",
			settings.Root,
			tplVars,
		},
		"project_package_test": FileTemplates{
			"project_package_test.tpl",
			settings.ProjectName + "_test.go",
			settings.Root,
			tplVars,
		},
		"readme": FileTemplates{
			"readme.tpl",
			"README.md",
			settings.Root,
			tplVars,
		},
		"task-runner_build": FileTemplates{
			"task-runner_build.tpl",
			"build.go",
			filepath.Join(settings.Root, "_task-runner"),
			tplVars,
		},
		"task-runner_coverage": FileTemplates{
			"task-runner_coverage.tpl",
			"coverage.go",
			filepath.Join(settings.Root, "_task-runner"),
			tplVars,
		},
		"task-runner_get": FileTemplates{
			"task-runner_get.tpl",
			"get.go",
			filepath.Join(settings.Root, "_task-runner"),
			tplVars,
		},
		"task-runner_main": FileTemplates{
			"task-runner_main.tpl",
			"main.go",
			filepath.Join(settings.Root, "_task-runner"),
			tplVars,
		},
		"task-runner_run": FileTemplates{
			"task-runner_run.tpl",
			"run.go",
			filepath.Join(settings.Root, "_task-runner"),
			tplVars,
		},
		"task-runner_test": FileTemplates{
			"task-runner_test.tpl",
			"test.go",
			filepath.Join(settings.Root, "_task-runner"),
			tplVars,
		},
	}

	// Delete vendor if exists and create new
	if err := utils.CleanDirectory(filepath.Join(settings.Root, "vendor")); err != nil {
		return err
	}

	// Path to templates
	tplPath := filepath.Join(lxbPath, "_templates")

	// Read all templates
	tpl := template.Must(template.New("name").ParseGlob(filepath.Join(tplPath, "*.tpl")))

	// done channel with error
	done := make(chan error, len(ftpls))

	// start the template worker as go routines
	for _, ftpl := range ftpls {
		go templateWorker(tpl, ftpl, done)
	}

	// wait of end all channels
	for i := 0; i < len(ftpls); i++ {
		<-done
	}

	return nil
}
Exemplo n.º 3
0
// Coverage packages and create report
// // Example for coverage all packages with html report
// $lxb coverage -html
func coverageTask(c *taskRunner.Context) {

	report := ""
	reportPath := filepath.Join("_build", "reports")
	packages := []string{}

	// Clean reports
	if err := utils.CleanDirectory(reportPath); err != nil {
		log.Fatal(err)
	}

	// Check arguments for package or report options
	if len(c.Args) > 0 {

		// If the first argument a package name?
		// Check this by loading with getPackage.
		pkgName, err := utils.GetPackage(c.Args[0])
		if err != nil {
			log.Fatal(err)
		}

		// Check loaded package name
		if pkgName != "" {

			// First argument is valid package name.
			// Check report argument
			if len(c.Args) > 1 {

				// Overwrite with html report settings
				if c.Args[1] == "-html" || c.Args[1] == "-xml" {
					report = c.Args[1][1:]
				}
			}

			// Add the package name to packages for coverage.
			packages = append(packages, pkgName)

		} else {

			// First argument is not valid package name
			// Check if first argument a report setting
			if c.Args[0] == "-html" || c.Args[0] == "-xml" {

				// Set report
				report = c.Args[0][1:]

				// First argument is not valid package name but
				// a valid report setting. Set all packages for coverage
				packages, err = utils.GetAllPackages("/vendor/")
				if err != nil {
					log.Fatal(err)
				}

			} else {

				// First argument is not valid package name and
				// not a valid report setting. Exit with error.
				log.Fatalf("package %s not found", c.Args[0])
			}
		}
	} else {

		// Pass no arguments, use all packages
		var err error
		packages, err = utils.GetAllPackages("/vendor/")
		if err != nil {
			log.Fatal(err)
		}
	}

	// Start coverage and create report
	if err := lxCoverage.GocovCoverage(report, packages, reportPath, OpenHtmlReport); err != nil {
		log.Fatal(err)
	}
}