Initial commit to go mod

revel/build.go

@@ -13,7 +13,6 @@ import (
 	"github.com/revel/cmd/harness"
 	"github.com/revel/cmd/model"
 	"github.com/revel/cmd/utils"
-	"go/build"
 )
 
 var cmdBuild = &Command{
@@ -153,10 +152,10 @@ func buildCopyModules(c *model.CommandConfig, revel_paths *model.RevelContainer,
 	destPath := filepath.Join(c.Build.TargetPath, "src")
 	// Find all the modules used and copy them over.
 	config := revel_paths.Config.Raw()
-	modulePaths := make(map[string]string) // import path => filesystem path
 
 	// We should only copy over the section of options what the build is targeted for
 	// We will default to prod
+	moduleImportList := []string{}
 	for _, section := range config.Sections() {
 		// If the runmode is defined we will only import modules defined for that run mode
 		if c.Build.Mode != "" && c.Build.Mode != section {
@@ -171,14 +170,15 @@ func buildCopyModules(c *model.CommandConfig, revel_paths *model.RevelContainer,
 			if moduleImportPath == "" {
 				continue
 			}
+			moduleImportList =append(moduleImportList,moduleImportPath)
 
-			modPkg, err := build.Import(moduleImportPath, revel_paths.RevelPath, build.FindOnly)
-			if err != nil {
-				utils.Logger.Fatalf("Failed to load module %s (%s): %s", key[len("module."):], c.ImportPath, err)
-			}
-			modulePaths[moduleImportPath] = modPkg.Dir
 		}
 	}
+	modulePaths, err := utils.FindSrcPaths(c.AppPath, moduleImportList, c.PackageResolver)
+
+	if err != nil {
+		utils.Logger.Fatalf("Failed to load modules ", "error", err)
+	}
 
 	// Copy the the paths for each of the modules
 	for importPath, fsPath := range modulePaths {

revel/new.go

@@ -76,56 +76,15 @@ func newApp(c *model.CommandConfig) (err error) {
 		return utils.NewBuildError("Abort: Unable to create app path.", "path", c.AppPath)
 	}
 
-	if c.New.Vendored {
-		utils.Logger.Info("Creating a new vendor app")
-
-		vendorPath := filepath.Join(c.AppPath, "vendor")
-		if !utils.DirExists(vendorPath) {
-
-			if err := os.MkdirAll(vendorPath, os.ModePerm); err != nil {
-				return utils.NewBuildError("Failed to create "+vendorPath, "error", err)
-			}
-		}
-
-		// In order for dep to run there needs to be a source file in the folder
-		tempPath := filepath.Join(c.AppPath, "tmp")
-		utils.Logger.Info("Checking for temp folder for source code", "path", tempPath)
-		if !utils.DirExists(tempPath) {
-			if err := os.MkdirAll(tempPath, os.ModePerm); err != nil {
-				return utils.NewBuildIfError(err, "Failed to create "+vendorPath)
-			}
-
-			if err = utils.GenerateTemplate(filepath.Join(tempPath, "main.go"), NEW_MAIN_FILE, nil); err != nil {
-				return utils.NewBuildIfError(err, "Failed to create main file "+vendorPath)
-			}
-		}
-
-		// Create a package template file if it does not exist
-		packageFile := filepath.Join(c.AppPath, "Gopkg.toml")
-		utils.Logger.Info("Checking for Gopkg.toml", "path", packageFile)
-		if !utils.Exists(packageFile) {
-			utils.Logger.Info("Generating Gopkg.toml", "path", packageFile)
-			if err := utils.GenerateTemplate(packageFile, VENDOR_GOPKG, nil); err != nil {
-				return utils.NewBuildIfError(err, "Failed to generate template")
-			}
-		} else {
-			utils.Logger.Info("Package file exists in skeleto, skipping adding")
-		}
-
-		getCmd := exec.Command("dep", "ensure", "-v")
-		utils.CmdInit(getCmd, c.AppPath)
-
-		utils.Logger.Info("Exec:", "args", getCmd.Args, "env", getCmd.Env, "workingdir",getCmd.Dir)
-		getOutput, err := getCmd.CombinedOutput()
-		if err != nil {
-			return utils.NewBuildIfError(err, string(getOutput))
-		}
+	if len(c.New.Package)>0 {
+		c.New.Vendored = true
 	}
 
 	// checking and setting application
 	if err = setApplicationPath(c); err != nil {
 		return err
 	}
+
 	// At this point the versions can be set
 	c.SetVersions()
 
@@ -136,12 +95,8 @@ func newApp(c *model.CommandConfig) (err error) {
 
 	// Rerun the dep tool if vendored
 	if c.New.Vendored {
-		getCmd := exec.Command("dep", "ensure", "-v")
-		utils.CmdInit(getCmd, c.AppPath)
-		utils.Logger.Info("Exec:", "args", getCmd.Args)
-		getOutput, err := getCmd.CombinedOutput()
-		if err != nil {
-			utils.Logger.Fatal(string(getOutput))
+		if err=createModVendor(c); err!=nil {
+			return
 		}
 	}
 
@@ -156,6 +111,70 @@ func newApp(c *model.CommandConfig) (err error) {
 	return
 }
 
+func createModVendor(c *model.CommandConfig) (err error) {
+
+	utils.Logger.Info("Creating a new mod app")
+	goModCmd := exec.Command("go", "mod", "init", filepath.Join(c.New.Package,c.AppName))
+
+
+	utils.CmdInit(goModCmd, c.AppPath)
+
+	utils.Logger.Info("Exec:", "args", goModCmd.Args, "env", goModCmd.Env, "workingdir",goModCmd.Dir)
+	getOutput, err := goModCmd.CombinedOutput()
+	if err != nil {
+		return utils.NewBuildIfError(err, string(getOutput))
+	}
+	return
+}
+
+func createDepVendor(c *model.CommandConfig) (err error) {
+
+	utils.Logger.Info("Creating a new vendor app")
+
+	vendorPath := filepath.Join(c.AppPath, "vendor")
+	if !utils.DirExists(vendorPath) {
+
+		if err := os.MkdirAll(vendorPath, os.ModePerm); err != nil {
+			return utils.NewBuildError("Failed to create "+vendorPath, "error", err)
+		}
+	}
+
+	// In order for dep to run there needs to be a source file in the folder
+	tempPath := filepath.Join(c.AppPath, "tmp")
+	utils.Logger.Info("Checking for temp folder for source code", "path", tempPath)
+	if !utils.DirExists(tempPath) {
+		if err := os.MkdirAll(tempPath, os.ModePerm); err != nil {
+			return utils.NewBuildIfError(err, "Failed to create "+vendorPath)
+		}
+
+		if err = utils.GenerateTemplate(filepath.Join(tempPath, "main.go"), NEW_MAIN_FILE, nil); err != nil {
+			return utils.NewBuildIfError(err, "Failed to create main file "+vendorPath)
+		}
+	}
+
+	// Create a package template file if it does not exist
+	packageFile := filepath.Join(c.AppPath, "Gopkg.toml")
+	utils.Logger.Info("Checking for Gopkg.toml", "path", packageFile)
+	if !utils.Exists(packageFile) {
+		utils.Logger.Info("Generating Gopkg.toml", "path", packageFile)
+		if err := utils.GenerateTemplate(packageFile, VENDOR_GOPKG, nil); err != nil {
+			return utils.NewBuildIfError(err, "Failed to generate template")
+		}
+	} else {
+		utils.Logger.Info("Package file exists in skeleto, skipping adding")
+	}
+
+	getCmd := exec.Command("dep", "ensure", "-v")
+	utils.CmdInit(getCmd, c.AppPath)
+
+	utils.Logger.Info("Exec:", "args", getCmd.Args, "env", getCmd.Env, "workingdir",getCmd.Dir)
+	getOutput, err := getCmd.CombinedOutput()
+	if err != nil {
+		return utils.NewBuildIfError(err, string(getOutput))
+	}
+	return
+}
+
 // Used to generate a new secret key
 const alphaNumeric = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
 

revel/new_test.go

@@ -55,12 +55,12 @@ func TestNewVendor(t *testing.T) {
 	a := assert.New(t)
 	gopath := setup("revel-test-new-vendor",  a)
 	precall := func(c *model.CommandConfig) {
-		c.New.Vendored = true
+		c.New.DepVendored = true
 	}
 	t.Run("New", func(t *testing.T) {
 		a := assert.New(t)
 		c := newApp("onlyone/v/a", model.NEW, precall, a)
-		c.New.Vendored = true
+		c.New.DepVendored = true
 		a.Nil(main.Commands[model.NEW].RunWith(c), "New failed")
 	})
 	t.Run("Test", func(t *testing.T) {

revel/revel.go

@@ -101,7 +101,7 @@ func main() {
 	println("Revel executing:", command.Short)
 
 	// Setting go paths
-	c.InitGoPaths()
+	// c.InitGoPaths()
 
 	// Setup package resolver
 	c.InitPackageResolver()

revel/run.go

@@ -126,7 +126,7 @@ func runApp(c *model.CommandConfig) (err error) {
 		c.Run.Mode = "dev"
 	}
 
-	revel_path, err := model.NewRevelPaths(c.Run.Mode, c.ImportPath, "", model.NewWrappedRevelCallback(nil, c.PackageResolver))
+	revel_path, err := model.NewRevelPaths(c.Run.Mode, c.ImportPath, c.AppPath, model.NewWrappedRevelCallback(nil, c.PackageResolver))
 	if err != nil {
 		return utils.NewBuildIfError(err, "Revel paths")
 	}

revel/test.go

@@ -258,7 +258,7 @@ func getTestsList(baseURL string) (*[]tests.TestSuiteDesc, error) {
 func runTestSuites(paths *model.RevelContainer, baseURL, resultPath string, testSuites *[]tests.TestSuiteDesc) (*[]tests.TestSuiteResult, bool) {
 
 	// We can determine the testsuite location by finding the test module and extracting the data from it
-	resultFilePath := filepath.Join(paths.ModulePathMap["testrunner"], "app", "views", "TestRunner/SuiteResult.html")
+	resultFilePath := filepath.Join(paths.ModulePathMap["testrunner"].Path, "app", "views", "TestRunner/SuiteResult.html")
 
 	var (
 		overallSuccess = true

revel/version.go

@@ -77,7 +77,7 @@ func (v *VersionCommand) RunWith(c *model.CommandConfig) (err error) {
 		versionInfo, needsUpdates = v.doRepoCheck(x==0)
 	}
 
-	fmt.Println(versionInfo)
+	fmt.Printf("%s\n\nGo Location:%s\n\n",versionInfo,c.GoCmd)
 	cmd := exec.Command(c.GoCmd, "version")
 	cmd.Stdout = os.Stdout
 	if e := cmd.Start(); e != nil {
@@ -234,28 +234,20 @@ func (v *VersionCommand) updateLocalVersions()  {
 	v.cmdVersion.BuildDate = cmd.BuildDate
 	v.cmdVersion.MinGoVersion = cmd.MinimumGoVersion
 
-	var modulePath, revelPath string
-	_, revelPath, err := utils.FindSrcPaths(v.Command.ImportPath, model.RevelImportPath, v.Command.PackageResolver)
+	pathMap, err := utils.FindSrcPaths(v.Command.AppPath,[]string{model.RevelImportPath,model.RevelModulesImportPath}, v.Command.PackageResolver)
 	if err != nil {
-		utils.Logger.Warn("Unable to extract version information from Revel library", "error,err")
+		utils.Logger.Warn("Unable to extract version information from Revel library", "path",pathMap[model.RevelImportPath], "error",err)
 		return
 	}
-	revelPath = revelPath + model.RevelImportPath
-	utils.Logger.Info("Fullpath to revel", "dir", revelPath)
-	v.revelVersion, err = v.versionFromFilepath(revelPath)
+	utils.Logger.Info("Fullpath to revel", "dir", pathMap[model.RevelModulesImportPath])
+	v.revelVersion, err = v.versionFromFilepath(pathMap[model.RevelModulesImportPath])
 	if err != nil {
 		utils.Logger.Warn("Unable to extract version information from Revel", "error,err")
 	}
 
-	_, modulePath, err = utils.FindSrcPaths(v.Command.ImportPath, model.RevelModulesImportPath, v.Command.PackageResolver)
+	v.modulesVersion, err = v.versionFromFilepath(pathMap[model.RevelModulesImportPath])
 	if err != nil {
-		utils.Logger.Warn("Unable to extract version information from Revel library", "error,err")
-		return
-	}
-	modulePath = modulePath + model.RevelModulesImportPath
-	v.modulesVersion, err = v.versionFromFilepath(modulePath)
-	if err != nil {
-		utils.Logger.Warn("Unable to extract version information from Revel Modules", "error", err)
+		utils.Logger.Warn("Unable to extract version information from Revel Modules", "path", pathMap[model.RevelModulesImportPath], "error", err)
 	}
 
 	return