Fixes wildcards in router files in app from affecting modules or visa verisy

notzippy · notzippy · commit 150849cd0388 · 2017-06-17T09:12:44.000-07:00
diff --git a/controller.go b/controller.go
@@ -7,6 +7,7 @@ package revel
 import (
 	"errors"
 	"fmt"
+	"go/build"
 	"io"
 	"net/http"
 	"os"
@@ -131,7 +132,7 @@ func (c *Controller) RenderTemplate(templatePath string) Result {
 	}
 
 	return &RenderTemplateResult{
-		Template:   template,
+		Template: template,
 		ViewArgs: c.ViewArgs,
 	}
 }
@@ -364,6 +365,7 @@ func findControllers(appControllerType reflect.Type) (indexes [][]int) {
 // Controller registry and types.
 
 type ControllerType struct {
+	ModuleSource      *Module // The module for the controller
 	Type              reflect.Type
 	Methods           []*MethodType
 	ControllerIndexes [][]int // FieldByIndex to all embedded *Controllers
@@ -398,8 +400,7 @@ var controllers = make(map[string]*ControllerType)
 func RegisterController(c interface{}, methods []*MethodType) {
 	// De-star the controller type
 	// (e.g. given TypeOf((*Application)(nil)), want TypeOf(Application))
-	t := reflect.TypeOf(c)
-	elem := t.Elem()
+	elem := reflect.TypeOf(c).Elem()
 
 	// De-star all of the method arg types too.
 	for _, m := range methods {
@@ -408,8 +409,27 @@ func RegisterController(c interface{}, methods []*MethodType) {
 			arg.Type = arg.Type.Elem()
 		}
 	}
+	path := elem.PkgPath()
+	gopathList := filepath.SplitList(build.Default.GOPATH)
+	var controllerModule *Module
+
+	// See if the path exists in the module based
+	for i := range Modules {
+		found := false
+		for _, gopath := range gopathList {
+			if strings.HasPrefix(gopath+"/src/"+path, Modules[i].Path) {
+				controllerModule = Modules[i]
+				found = true
+				break
+			}
+		}
+		if found {
+			break
+		}
+	}
 
 	controllers[strings.ToLower(elem.Name())] = &ControllerType{
+		ModuleSource:      controllerModule,
 		Type:              elem,
 		Methods:           methods,
 		ControllerIndexes: findControllers(elem),
diff --git a/revel.go b/revel.go
@@ -70,7 +70,7 @@ var (
 	// 3. user supplied configs (...) - User configs can override/add any from above
 	ConfPaths []string
 
-	Modules []Module
+	Modules []*Module
 
 	// Server config.
 	//
@@ -399,7 +399,7 @@ func ResolveImportPath(importPath string) (string, error) {
 }
 
 func addModule(name, importPath, modulePath string) {
-	Modules = append(Modules, Module{Name: name, ImportPath: importPath, Path: modulePath})
+	Modules = append(Modules, &Module{Name: name, ImportPath: importPath, Path: modulePath})
 	if codePath := filepath.Join(modulePath, "app"); DirExists(codePath) {
 		CodePaths = append(CodePaths, codePath)
 		if viewsPath := filepath.Join(modulePath, "app", "views"); DirExists(viewsPath) {
@@ -422,13 +422,13 @@ func addModule(name, importPath, modulePath string) {
 }
 
 // ModuleByName returns the module of the given name, if loaded.
-func ModuleByName(name string) (m Module, found bool) {
+func ModuleByName(name string) (m *Module, found bool) {
 	for _, module := range Modules {
 		if module.Name == name {
 			return module, true
 		}
 	}
-	return Module{}, false
+	return nil, false
 }
 
 // CheckInit method checks `revel.Initialized` if not initialized it panics
diff --git a/router.go b/router.go
@@ -15,14 +15,15 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/robfig/pathtree"
+	"github.com/revel/pathtree"
 )
 
 const (
 	httpStatusCode = "404"
 )
 
 type Route struct {
+	ModuleSource   *Module  // Module name of route
 	Method         string   // e.g. GET
 	Path           string   // e.g. /app/:id
 	Action         string   // e.g. "Application.ShowApp", "404"
@@ -89,12 +90,13 @@ func treePath(method, path string) string {
 type Router struct {
 	Routes []*Route
 	Tree   *pathtree.Node
+	Module string // The module the route is associated with
 	path   string // path to the routes file
 }
 
 var notFound = &RouteMatch{Action: "404"}
 
-func (router *Router) Route(req *http.Request) *RouteMatch {
+func (router *Router) Route(req *http.Request) (routeMatch *RouteMatch) {
 	// Override method if set in header
 	if method := req.Header.Get("X-HTTP-Method-Override"); method != "" && req.Method == "POST" {
 		req.Method = method
@@ -104,7 +106,8 @@ func (router *Router) Route(req *http.Request) *RouteMatch {
 	if leaf == nil {
 		return nil
 	}
-	route := leaf.Value.(*Route)
+	routeList := leaf.Value.([]*Route)
+	INFO.Printf("Found route %s %#v",req.URL.Path,routeList)
 
 	// Create a map of the route parameters.
 	var params url.Values
@@ -114,27 +117,51 @@ func (router *Router) Route(req *http.Request) *RouteMatch {
 			params[leaf.Wildcards[i]] = []string{v}
 		}
 	}
+	var route *Route
+	var controllerName string
+	for index := range routeList {
+		route = routeList[index]
+		// Special handling for explicit 404's.
+		if route.Action == httpStatusCode {
+			route = nil
+			break
+		}
 
-	// Special handling for explicit 404's.
-	if route.Action == httpStatusCode {
-		return notFound
-	}
+		// If the action is variablized, replace into it with the captured args.
+		controllerName = route.ControllerName
+		if controllerName[0] == ':' {
+			controllerName = params[controllerName[1:]][0]
 
-	// If the action is variablized, replace into it with the captured args.
-	controllerName, methodName := route.ControllerName, route.MethodName
-	if controllerName[0] == ':' {
-		controllerName = params[controllerName[1:]][0]
-	}
-	if methodName[0] == ':' {
-		methodName = params[methodName[1:]][0]
+			// Check that the controller comes from a matching route
+			if controller, found := controllers[strings.ToLower(controllerName)]; found {
+
+				if route.ModuleSource == controller.ModuleSource {
+					break
+				}
+			}
+		} else {
+			break
+		}
+		route = nil
 	}
 
-	return &RouteMatch{
-		ControllerName: controllerName,
-		MethodName:     methodName,
-		Params:         params,
-		FixedParams:    route.FixedParams,
+	if route ==nil {
+		routeMatch = notFound
+	} else {
+		methodName := route.MethodName
+		if methodName[0] == ':' {
+			methodName = params[methodName[1:]][0]
+		}
+
+		routeMatch = &RouteMatch{
+			ControllerName: controllerName,
+			MethodName:     methodName,
+			Params:         params,
+			FixedParams:    route.FixedParams,
+		}
 	}
+
+	return
 }
 
 // Refresh re-reads the routes file and re-calculates the routing table.
@@ -150,17 +177,32 @@ func (router *Router) Refresh() (err *Error) {
 
 func (router *Router) updateTree() *Error {
 	router.Tree = pathtree.New()
+	pathMap := map[string][]*Route{}
+
+	allPathsOrdered := []string{}
+	// It is possible for some route paths to overlap
+	// based on wildcard matches,
+	// TODO when pathtree is fixed (made to be smart enough to not require a predefined intake order) keeping the routes in order is not necessary
 	for _, route := range router.Routes {
-		err := router.Tree.Add(route.TreePath, route)
+		if _,found := pathMap[route.TreePath];!found {
+			pathMap[route.TreePath] = append(pathMap[route.TreePath], route)
+			allPathsOrdered = append(allPathsOrdered, route.TreePath)
+		} else {
+			pathMap[route.TreePath] = append(pathMap[route.TreePath], route)
+		}
+	}
+	for _,path := range allPathsOrdered {
+		routeList := pathMap[path]
+		err := router.Tree.Add(path, routeList)
 
 		// Allow GETs to respond to HEAD requests.
-		if err == nil && route.Method == "GET" {
-			err = router.Tree.Add(treePath("HEAD", route.Path), route)
+		if err == nil && routeList[0].Method == "GET" {
+			err = router.Tree.Add(treePath("HEAD", routeList[0].Path), routeList)
 		}
 
 		// Error adding a route to the pathtree.
 		if err != nil {
-			return routeError(err, route.routesPath, "", route.line)
+			return routeError(err, path, fmt.Sprintf("%#v",routeList), routeList[0].line)
 		}
 	}
 	return nil
@@ -291,15 +333,22 @@ func routeError(err error, routesPath, content string, n int) *Error {
 
 // getModuleRoutes loads the routes file for the given module and returns the
 // list of routes.
-func getModuleRoutes(moduleName, joinedPath string, validate bool) ([]*Route, *Error) {
+func getModuleRoutes(moduleName, joinedPath string, validate bool) (routes []*Route, err *Error) {
 	// Look up the module.  It may be not found due to the common case of e.g. the
 	// testrunner module being active only in dev mode.
 	module, found := ModuleByName(moduleName)
 	if !found {
 		INFO.Println("Skipping routes for inactive module", moduleName)
 		return nil, nil
 	}
-	return parseRoutesFile(filepath.Join(module.Path, "conf", "routes"), joinedPath, validate)
+	routes, err = parseRoutesFile(filepath.Join(module.Path, "conf", "routes"), joinedPath, validate)
+	if err == nil {
+		for _, route := range routes {
+			route.ModuleSource = module
+		}
+	}
+
+	return routes,err
 }
 
 // Groups:
@@ -368,6 +417,20 @@ func (router *Router) Reverse(action string, argValues map[string]string) *Actio
 			argValues[route.MethodName[1:]] = methodName
 		}
 
+		// Constraint match - wildcard matches can only be made by the same module that created them
+		if controllerWildcard || methodWildcard {
+			if controller, found := controllers[strings.ToLower(controllerName)]; found {
+				// Wildcard match boundary
+				if controller.ModuleSource != route.ModuleSource {
+					continue
+				}
+				// See if the path exists in the module based
+			} else {
+				ERROR.Printf("Controller %s not found in reverse lookup", controllerName)
+				continue
+			}
+		}
+
 		// Build up the URL.
 		var (
 			queryValues  = make(url.Values)
diff --git a/router_test.go b/router_test.go
@@ -256,8 +256,8 @@ var routeMatchTestCases = map[*http.Request]*RouteMatch{
 		Params:         map[string][]string{"id": {"123"}},
 	},
 }
-
 func TestRouteMatches(t *testing.T) {
+	initControllers()
 	BasePath = "/BasePath"
 	router := NewRouter("")
 	router.Routes, _ = parseRoutes("", "", TestRoutes, false)
@@ -342,7 +342,16 @@ var reverseRoutingTestCases = map[*ReverseRouteArgs]*ActionDefinition{
 	},
 }
 
+type testController struct {
+	*Controller
+}
+func initControllers() {
+	controllers["implicit"] = &ControllerType{}
+	controllers["static"] = &ControllerType{}
+	controllers["application"] = &ControllerType{}
+}
 func TestReverseRouting(t *testing.T) {
+	initControllers()
 	router := NewRouter("")
 	router.Routes, _ = parseRoutes("", "", TestRoutes, false)
 	for routeArgs, expected := range reverseRoutingTestCases {
diff --git a/templates/errors/404-dev.html b/templates/errors/404-dev.html
@@ -57,7 +57,7 @@ <h1>
 	<h2>These routes have been tried, in this order :</h2>
 	<ol>
 		{{range .Router.Routes}}
-			<li>{{pad .Method 10}}{{pad .Path 50}}{{.Action}}</li>
+			<li>{{pad .Method 10}}{{pad .Path 50}}{{.Action}} {{with .ModuleSource}}(Module:{{.Name}}){{end}}</li>
 		{{end}}
 	</ol>
 </div>

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ var (`
`70`	`70`	`// 3. user supplied configs (...) - User configs can override/add any from above`
`71`	`71`	`ConfPaths []string`
`72`	`72`
`73`		`- Modules []Module`
	`73`	`+ Modules []*Module`
`74`	`74`
`75`	`75`	`// Server config.`
`76`	`76`	`//`
`@@ -399,7 +399,7 @@ func ResolveImportPath(importPath string) (string, error) {`
`399`	`399`	`}`
`400`	`400`
`401`	`401`	`func addModule(name, importPath, modulePath string) {`
`402`		`- Modules = append(Modules, Module{Name: name, ImportPath: importPath, Path: modulePath})`
	`402`	`+ Modules = append(Modules, &Module{Name: name, ImportPath: importPath, Path: modulePath})`
`403`	`403`	`if codePath := filepath.Join(modulePath, "app"); DirExists(codePath) {`
`404`	`404`	`CodePaths = append(CodePaths, codePath)`
`405`	`405`	`if viewsPath := filepath.Join(modulePath, "app", "views"); DirExists(viewsPath) {`
`@@ -422,13 +422,13 @@ func addModule(name, importPath, modulePath string) {`
`422`	`422`	`}`
`423`	`423`
`424`	`424`	`// ModuleByName returns the module of the given name, if loaded.`
`425`		`-func ModuleByName(name string) (m Module, found bool) {`
	`425`	`+func ModuleByName(name string) (m *Module, found bool) {`
`426`	`426`	`for _, module := range Modules {`
`427`	`427`	`if module.Name == name {`
`428`	`428`	`return module, true`
`429`	`429`	`}`
`430`	`430`	`}`
`431`		`- return Module{}, false`
	`431`	`+ return nil, false`
`432`	`432`	`}`
`433`	`433`
`434`	`434`	// CheckInit method checks `revel.Initialized` if not initialized it panics