Initial rewrite of revel/cmd to provide vendor support and enhanced CLI options

2026-01-11 18:54:31 +00:00 · 2018-09-13 13:21:10 -07:00
parent d2ac018544
commit d0baaeb9e9
40 changed files with 4435 additions and 1125 deletions
--- a/model/command_config.go
+++ b/model/command_config.go
@@ -0,0 +1,61 @@
+package model
+
+type (
+	// The Revel command type
+	COMMAND int
+
+	// The Command config for the line input
+	CommandConfig struct {
+		Index        COMMAND  // The index
+		Verbose      bool     `short:"v" long:"debug" description:"If set the logger is set to verbose"` // True if debug is active
+		HistoricMode bool     `long:"historic-run-mode" description:"If set the runmode is passed a string not json"` // True if debug is active
+		ImportPath   string   // The import path (converted from various commands)
+		GoPath       string   // The GoPath
+		GoCmd        string   // The full path to the go executable
+		SrcRoot      string   // The source root
+		AppPath      string   // The application path
+		AppName      string   // The applicaiton name
+		BasePath     string   // The base path
+		SkeletonPath string   // The skeleton path
+		BuildFlags   []string `short:"X" long:"build-flags" description:"These flags will be used when building the application. May be specified multiple times, only applicable for Build, Run, Package, Test commands"`
+		// The new command
+		New struct {
+			ImportPath string `short:"a" long:"application-path" description:"Path to applicaiton folder" required:"true"`
+			Skeleton   string `short:"s" long:"skeleton" description:"Path to skeleton folder (Must exist on GO PATH)" required:"false"`
+			Vendored   bool   `short:"V" long:"vendor" description:"True if project should contain a vendor folder to be initialized. Creates the vendor folder and the 'Gopkg.toml' file in the root"`
+			Run        bool   `short:"r" long:"run" description:"True if you want to run the application right away"`
+		} `command:"new"`
+		// The build command
+		Build struct {
+			TargetPath string `short:"t" long:"target-path" description:"Path to target folder. Folder will be completely deleted if it exists" required:"true"`
+			ImportPath string `short:"a" long:"application-path" description:"Path to applicaiton folder" required:"true"`
+			Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
+		} `command:"build"`
+		// The run command
+		Run struct {
+			ImportPath string `short:"a" long:"application-path" description:"Path to applicaiton folder" required:"true"`
+			Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
+			Port       string `short:"p" long:"port" description:"The port to listen"`
+			NoProxy    bool   `short:"n" long:"no-proxy" description:"True if proxy server should not be started. This will only update the main and routes files on change"`
+		} `command:"run"`
+		// The package command
+		Package struct {
+			Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
+			ImportPath string `short:"a" long:"application-path" description:"Path to applicaiton folder" required:"true"`
+		} `command:"package"`
+		// The clean command
+		Clean struct {
+			ImportPath string `short:"a" long:"application-path" description:"Path to applicaiton folder" required:"true"`
+		} `command:"clean"`
+		// The test command
+		Test struct {
+			Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
+			ImportPath string `short:"a" long:"application-path" description:"Path to applicaiton folder" required:"true"`
+			Function   string `short:"f" long:"suite-function" description:"The suite.function"`
+		} `command:"test"`
+		// The version command
+		Version struct {
+			ImportPath string `short:"a" long:"application-path" description:"Path to applicaiton folder" required:"false"`
+		} `command:"version"`
+	}
+)
--- a/model/embedded_type_name.go
+++ b/model/embedded_type_name.go
@@ -0,0 +1,11 @@
+package model
+
+// The embedded type name takes the import path and structure name
+type EmbeddedTypeName struct {
+	ImportPath, StructName string
+}
+
+// Convert the type to a properly formatted import line
+func (s *EmbeddedTypeName) String() string {
+	return s.ImportPath + "." + s.StructName
+}
--- a/model/method.go
+++ b/model/method.go
@@ -0,0 +1,25 @@
+package model
+
+
+// methodCall describes a call to c.Render(..)
+// It documents the argument names used, in order to propagate them to RenderArgs.
+type MethodCall struct {
+	Path  string // e.g. "myapp/app/controllers.(*Application).Action"
+	Line  int
+	Names []string
+}
+
+// MethodSpec holds the information of one Method
+type MethodSpec struct {
+	Name        string        // Name of the method, e.g. "Index"
+	Args        []*MethodArg  // Argument descriptors
+	RenderCalls []*MethodCall // Descriptions of Render() invocations from this Method.
+}
+
+// MethodArg holds the information of one argument
+type MethodArg struct {
+	Name       string   // Name of the argument.
+	TypeExpr   TypeExpr // The name of the type, e.g. "int", "*pkg.UserType"
+	ImportPath string   // If the arg is of an imported type, this is the import path.
+}
+
--- a/model/revel_container.go
+++ b/model/revel_container.go
@@ -0,0 +1,294 @@
+// This package will be shared between Revel and Revel CLI eventually
+package model
+
+import (
+	"github.com/revel/cmd/utils"
+	"github.com/revel/config"
+	"go/build"
+
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+const (
+	// Event type when templates are going to be refreshed (receivers are registered template engines added to the template.engine conf option)
+	TEMPLATE_REFRESH_REQUESTED = iota
+	// Event type when templates are refreshed (receivers are registered template engines added to the template.engine conf option)
+	TEMPLATE_REFRESH_COMPLETED
+	// Event type before all module loads, events thrown to handlers added to AddInitEventHandler
+
+	// Event type before all module loads, events thrown to handlers added to AddInitEventHandler
+	REVEL_BEFORE_MODULES_LOADED
+	// Event type called when a new module is found
+	REVEL_BEFORE_MODULE_LOADED
+	// Event type called when after a new module is found
+	REVEL_AFTER_MODULE_LOADED
+	// Event type after all module loads, events thrown to handlers added to AddInitEventHandler
+	REVEL_AFTER_MODULES_LOADED
+
+	// Event type before server engine is initialized, receivers are active server engine and handlers added to AddInitEventHandler
+	ENGINE_BEFORE_INITIALIZED
+	// Event type before server engine is started, receivers are active server engine and handlers added to AddInitEventHandler
+	ENGINE_STARTED
+	// Event type after server engine is stopped, receivers are active server engine and handlers added to AddInitEventHandler
+	ENGINE_SHUTDOWN
+
+	// Called before routes are refreshed
+	ROUTE_REFRESH_REQUESTED
+	// Called after routes have been refreshed
+	ROUTE_REFRESH_COMPLETED
+)
+type (
+	// The container object for describing all Revels variables
+	RevelContainer struct {
+		ImportPath    string // The import path
+		SourcePath    string // The full source path
+		RunMode       string // The current run mode
+		RevelPath     string // The path to the Revel source code
+		BasePath      string // The base path to the application
+		AppPath       string // The application path (BasePath + "/app"
+		ViewsPath     string // The application views path
+		CodePaths     []string // All the code paths
+		TemplatePaths []string // All the template paths
+		ConfPaths     []string // All the configuration paths
+		Config        *config.Context // The global config object
+		Packaged      bool // True if packaged
+		DevMode       bool // True if running in dev mode
+		HTTPPort      int // The http port
+		HTTPAddr      string // The http address
+		HTTPSsl       bool // True if running https
+		HTTPSslCert   string // The SSL certificate
+		HTTPSslKey    string // The SSL key
+		AppName       string // The application name
+		AppRoot       string // The application root from the config `app.root`
+		CookiePrefix  string // The cookie prefix
+		CookieDomain  string // The cookie domain
+		CookieSecure  bool // True if cookie is secure
+		SecretStr     string // The secret string
+		MimeConfig    *config.Context // The mime configuration
+		ModulePathMap map[string]string // The module path map
+	}
+
+	RevelCallback interface {
+		FireEvent(key int, value interface{}) (response int)
+	}
+	doNothingRevelCallback struct {
+
+	}
+
+)
+
+// Simple callback to pass to the RevelCallback that does nothing
+var DoNothingRevelCallback = RevelCallback(&doNothingRevelCallback{})
+
+func (_ *doNothingRevelCallback) FireEvent(key int, value interface{}) (response int) {
+	return
+}
+
+// RevelImportPath Revel framework import path
+var RevelImportPath = "github.com/revel/revel"
+
+// This function returns a container object describing the revel application
+// eventually this type of function will replace the global variables.
+func NewRevelPaths(mode, importPath, srcPath string, callback RevelCallback) (rp *RevelContainer) {
+	rp = &RevelContainer{ModulePathMap: map[string]string{}}
+	// Ignore trailing slashes.
+	rp.ImportPath = strings.TrimRight(importPath, "/")
+	rp.SourcePath = srcPath
+	rp.RunMode = mode
+
+	// If the SourcePath is not specified, find it using build.Import.
+	var revelSourcePath string // may be different from the app source path
+	if rp.SourcePath == "" {
+		revelSourcePath, rp.SourcePath = findSrcPaths(importPath)
+	} else {
+		// If the SourcePath was specified, assume both Revel and the app are within it.
+		rp.SourcePath = filepath.Clean(rp.SourcePath)
+		revelSourcePath = rp.SourcePath
+
+	}
+
+	// Setup paths for application
+	rp.RevelPath = filepath.Join(revelSourcePath, filepath.FromSlash(RevelImportPath))
+	rp.BasePath = filepath.Join(rp.SourcePath, filepath.FromSlash(importPath))
+	rp.AppPath = filepath.Join(rp.BasePath, "app")
+	rp.ViewsPath = filepath.Join(rp.AppPath, "views")
+
+	rp.CodePaths = []string{rp.AppPath}
+	rp.TemplatePaths = []string{}
+
+	if rp.ConfPaths == nil {
+		rp.ConfPaths = []string{}
+	}
+
+	// Config load order
+	// 1. framework (revel/conf/*)
+	// 2. application (conf/*)
+	// 3. user supplied configs (...) - User configs can override/add any from above
+	rp.ConfPaths = append(
+		[]string{
+			filepath.Join(rp.RevelPath, "conf"),
+			filepath.Join(rp.BasePath, "conf"),
+		},
+		rp.ConfPaths...)
+
+	var err error
+	rp.Config, err = config.LoadContext("app.conf", rp.ConfPaths)
+	if err != nil {
+		utils.Logger.Fatal("Unable to load configuartion file ","error", err)
+		os.Exit(1)
+	}
+
+	// Ensure that the selected runmode appears in app.conf.
+	// If empty string is passed as the mode, treat it as "DEFAULT"
+	if mode == "" {
+		mode = config.DefaultSection
+	}
+	if !rp.Config.HasSection(mode) {
+		utils.Logger.Fatal("app.conf: No mode found:", mode)
+	}
+	rp.Config.SetSection(mode)
+
+	// Configure properties from app.conf
+	rp.DevMode = rp.Config.BoolDefault("mode.dev", false)
+	rp.HTTPPort = rp.Config.IntDefault("http.port", 9000)
+	rp.HTTPAddr = rp.Config.StringDefault("http.addr", "")
+	rp.HTTPSsl = rp.Config.BoolDefault("http.ssl", false)
+	rp.HTTPSslCert = rp.Config.StringDefault("http.sslcert", "")
+	rp.HTTPSslKey = rp.Config.StringDefault("http.sslkey", "")
+	if rp.HTTPSsl {
+		if rp.HTTPSslCert == "" {
+			utils.Logger.Fatal("No http.sslcert provided.")
+		}
+		if rp.HTTPSslKey == "" {
+			utils.Logger.Fatal("No http.sslkey provided.")
+		}
+	}
+	//
+	rp.AppName = rp.Config.StringDefault("app.name", "(not set)")
+	rp.AppRoot = rp.Config.StringDefault("app.root", "")
+	rp.CookiePrefix = rp.Config.StringDefault("cookie.prefix", "REVEL")
+	rp.CookieDomain = rp.Config.StringDefault("cookie.domain", "")
+	rp.CookieSecure = rp.Config.BoolDefault("cookie.secure", rp.HTTPSsl)
+	rp.SecretStr = rp.Config.StringDefault("app.secret", "")
+
+
+	callback.FireEvent(REVEL_BEFORE_MODULES_LOADED, nil)
+	rp.loadModules(callback)
+	callback.FireEvent(REVEL_AFTER_MODULES_LOADED, nil)
+
+	return
+}
+
+// LoadMimeConfig load mime-types.conf on init.
+func (rp *RevelContainer) LoadMimeConfig() {
+	var err error
+	rp.MimeConfig, err = config.LoadContext("mime-types.conf", rp.ConfPaths)
+	if err != nil {
+		utils.Logger.Fatal("Failed to load mime type config:", "error", err)
+	}
+}
+
+// Loads modules based on the configuration setup.
+// This will fire the REVEL_BEFORE_MODULE_LOADED, REVEL_AFTER_MODULE_LOADED
+// for each module loaded. The callback will receive the RevelContainer, name, moduleImportPath and modulePath
+// It will automatically add in the code paths for the module to the
+// container object
+func (rp *RevelContainer) loadModules(callback RevelCallback) {
+	keys := []string{}
+	for _, key := range rp.Config.Options("module.") {
+		keys = append(keys, key)
+	}
+
+	// Reorder module order by key name, a poor mans sort but at least it is consistent
+	sort.Strings(keys)
+	for _, key := range keys {
+		moduleImportPath := rp.Config.StringDefault(key, "")
+		if moduleImportPath == "" {
+			continue
+		}
+
+		modulePath, err := rp.ResolveImportPath(moduleImportPath)
+		if err != nil {
+			utils.Logger.Error("Failed to load module.  Import of path failed", "modulePath", moduleImportPath, "error", err)
+		}
+		// Drop anything between module.???.<name of module>
+		name := key[len("module."):]
+		if index := strings.Index(name, "."); index > -1 {
+			name = name[index+1:]
+		}
+		callback.FireEvent(REVEL_BEFORE_MODULE_LOADED, []interface{}{rp, name, moduleImportPath, modulePath})
+		rp.addModulePaths(name, moduleImportPath, modulePath)
+		callback.FireEvent(REVEL_AFTER_MODULE_LOADED, []interface{}{rp, name, moduleImportPath, modulePath})
+	}
+}
+
+// Adds a module paths to the container object
+func (rp *RevelContainer) addModulePaths(name, importPath, modulePath string) {
+	if codePath := filepath.Join(modulePath, "app"); utils.DirExists(codePath) {
+		rp.CodePaths = append(rp.CodePaths, codePath)
+		rp.ModulePathMap[name] = modulePath
+		if viewsPath := filepath.Join(modulePath, "app", "views"); utils.DirExists(viewsPath) {
+			rp.TemplatePaths = append(rp.TemplatePaths, viewsPath)
+		}
+	}
+
+	// Hack: There is presently no way for the testrunner module to add the
+	// "test" subdirectory to the CodePaths.  So this does it instead.
+	if importPath == rp.Config.StringDefault("module.testrunner", "github.com/revel/modules/testrunner") {
+		joinedPath := filepath.Join(rp.BasePath, "tests")
+		rp.CodePaths = append(rp.CodePaths, joinedPath)
+	}
+	if testsPath := filepath.Join(modulePath, "tests"); utils.DirExists(testsPath) {
+		rp.CodePaths = append(rp.CodePaths, testsPath)
+	}
+}
+
+// ResolveImportPath returns the filesystem path for the given import path.
+// Returns an error if the import path could not be found.
+func (rp *RevelContainer) ResolveImportPath(importPath string) (string, error) {
+	if rp.Packaged {
+		return filepath.Join(rp.SourcePath, importPath), nil
+	}
+
+	modPkg, err := build.Import(importPath, rp.RevelPath, build.FindOnly)
+	if err != nil {
+		return "", err
+	}
+	return modPkg.Dir, nil
+}
+
+// Find the full source dir for the import path, uses the build.Default.GOPATH to search for the directory
+func findSrcPaths(importPath string) (revelSourcePath, appSourcePath string) {
+	var (
+		gopaths = filepath.SplitList(build.Default.GOPATH)
+		goroot  = build.Default.GOROOT
+	)
+
+	if len(gopaths) == 0 {
+		utils.Logger.Fatalf("GOPATH environment variable is not set. " +
+			"Please refer to http://golang.org/doc/code.html to configure your Go environment.")
+	}
+
+	if utils.ContainsString(gopaths, goroot) {
+		utils.Logger.Fatalf("GOPATH (%s) must not include your GOROOT (%s). "+
+			"Please refer to http://golang.org/doc/code.html to configure your Go environment.",
+			gopaths, goroot)
+
+	}
+
+	appPkg, err := build.Import(importPath, "", build.FindOnly)
+	if err != nil {
+		utils.Logger.Fatal("Failed to import "+importPath+" with error:", "error", err)
+	}
+
+	revelPkg, err := build.Import(RevelImportPath, appPkg.Dir, build.FindOnly)
+	if err != nil {
+		utils.Logger.Fatal("Failed to find Revel with error:", "error", err)
+	}
+
+	revelSourcePath, appSourcePath = revelPkg.Dir[:len(revelPkg.Dir)-len(RevelImportPath)], appPkg.SrcRoot
+	return
+}
+
--- a/model/source_info.go
+++ b/model/source_info.go
@@ -0,0 +1,121 @@
+package model
+
+// SourceInfo is the top-level struct containing all extracted information
+// about the app source code, used to generate main.go.
+import (
+	"github.com/revel/cmd/utils"
+	"path/filepath"
+	"unicode"
+	"strings"
+)
+
+type SourceInfo struct {
+	// StructSpecs lists type info for all structs found under the code paths.
+	// They may be queried to determine which ones (transitively) embed certain types.
+	StructSpecs []*TypeInfo
+	// ValidationKeys provides a two-level lookup.  The keys are:
+	// 1. The fully-qualified function name,
+	//    e.g. "github.com/revel/examples/chat/app/controllers.(*Application).Action"
+	// 2. Within that func's file, the line number of the (overall) expression statement.
+	//    e.g. the line returned from runtime.Caller()
+	// The result of the lookup the name of variable being validated.
+	ValidationKeys map[string]map[int]string
+	// A list of import paths.
+	// Revel notices files with an init() function and imports that package.
+	InitImportPaths []string
+
+	// controllerSpecs lists type info for all structs found under
+	// app/controllers/... that embed (directly or indirectly) revel.Controller
+	controllerSpecs []*TypeInfo
+	// testSuites list the types that constitute the set of application tests.
+	testSuites []*TypeInfo
+}
+
+// TypesThatEmbed returns all types that (directly or indirectly) embed the
+// target type, which must be a fully qualified type name,
+// e.g. "github.com/revel/revel.Controller"
+func (s *SourceInfo) TypesThatEmbed(targetType, packageFilter string) (filtered []*TypeInfo) {
+	// Do a search in the "embedded type graph", starting with the target type.
+	var (
+		nodeQueue = []string{targetType}
+		processed []string
+	)
+	for len(nodeQueue) > 0 {
+		controllerSimpleName := nodeQueue[0]
+		nodeQueue = nodeQueue[1:]
+		processed = append(processed, controllerSimpleName)
+
+		// Look through all known structs.
+		for _, spec := range s.StructSpecs {
+			// If this one has been processed or is already in nodeQueue, then skip it.
+			if utils.ContainsString(processed, spec.String()) ||
+				utils.ContainsString(nodeQueue, spec.String()) {
+				continue
+			}
+
+			// Look through the embedded types to see if the current type is among them.
+			for _, embeddedType := range spec.EmbeddedTypes {
+
+				// If so, add this type's simple name to the nodeQueue, and its spec to
+				// the filtered list.
+				if controllerSimpleName == embeddedType.String() {
+					nodeQueue = append(nodeQueue, spec.String())
+					filtered = append(filtered, spec)
+					break
+				}
+			}
+		}
+	}
+	// Strip out any specifications that contain a lower case
+	for exit := false; !exit; exit = true {
+		for i, filteredItem := range filtered {
+			if unicode.IsLower([]rune(filteredItem.StructName)[0]) {
+				utils.Logger.Info("Debug: Skipping adding spec for unexported type",
+					"type", filteredItem.StructName,
+					"package", filteredItem.ImportPath)
+				filtered = append(filtered[:i], filtered[i+1:]...)
+				exit = false
+				break
+			}
+		}
+	}
+
+	// Check for any missed types that where from expected packages
+	for _, spec := range s.StructSpecs {
+		if spec.PackageName == packageFilter {
+			found := false
+			for _, filteredItem := range filtered {
+				if filteredItem.StructName == spec.StructName {
+					found = true
+					break
+				}
+			}
+
+			// Report non controller structures in controller folder.
+			if !found && !strings.HasPrefix(spec.StructName, "Test") {
+				utils.Logger.Warn("Type found in package: " + packageFilter +
+					", but did not embed from: " + filepath.Base(targetType),
+					"name", spec.StructName, "path", spec.ImportPath)
+			}
+		}
+	}
+	return
+}
+
+// ControllerSpecs returns the all the contollers that embeds
+// `revel.Controller`
+func (s *SourceInfo) ControllerSpecs() []*TypeInfo {
+	if s.controllerSpecs == nil {
+		s.controllerSpecs = s.TypesThatEmbed(RevelImportPath+".Controller", "controllers")
+	}
+	return s.controllerSpecs
+}
+
+// TestSuites returns the all the Application tests that embeds
+// `testing.TestSuite`
+func (s *SourceInfo) TestSuites() []*TypeInfo {
+	if s.testSuites == nil {
+		s.testSuites = s.TypesThatEmbed(RevelImportPath+"/testing.TestSuite", "testsuite")
+	}
+	return s.testSuites
+}
--- a/model/type_expr.go
+++ b/model/type_expr.go
@@ -0,0 +1,100 @@
+package model
+
+
+
+// TypeExpr provides a type name that may be rewritten to use a package name.
+import (
+	"go/ast"
+	"fmt"
+)
+
+type TypeExpr struct {
+	Expr     string // The unqualified type expression, e.g. "[]*MyType"
+	PkgName  string // The default package idenifier
+	pkgIndex int    // The index where the package identifier should be inserted.
+	Valid    bool
+}
+
+// TypeName returns the fully-qualified type name for this expression.
+// The caller may optionally specify a package name to override the default.
+func (e TypeExpr) TypeName(pkgOverride string) string {
+	pkgName := FirstNonEmpty(pkgOverride, e.PkgName)
+	if pkgName == "" {
+		return e.Expr
+	}
+	return e.Expr[:e.pkgIndex] + pkgName + "." + e.Expr[e.pkgIndex:]
+}
+
+// NewTypeExpr returns the syntactic expression for referencing this type in Go.
+func NewTypeExpr(pkgName string, expr ast.Expr) TypeExpr {
+	error := ""
+	switch t := expr.(type) {
+	case *ast.Ident:
+		if IsBuiltinType(t.Name) {
+			pkgName = ""
+		}
+		return TypeExpr{t.Name, pkgName, 0, true}
+	case *ast.SelectorExpr:
+		e := NewTypeExpr(pkgName, t.X)
+		return TypeExpr{t.Sel.Name, e.Expr, 0, e.Valid}
+	case *ast.StarExpr:
+		e := NewTypeExpr(pkgName, t.X)
+		return TypeExpr{"*" + e.Expr, e.PkgName, e.pkgIndex + 1, e.Valid}
+	case *ast.ArrayType:
+		e := NewTypeExpr(pkgName, t.Elt)
+		return TypeExpr{"[]" + e.Expr, e.PkgName, e.pkgIndex + 2, e.Valid}
+	case *ast.MapType:
+		if identKey, ok := t.Key.(*ast.Ident); ok && IsBuiltinType(identKey.Name) {
+			e := NewTypeExpr(pkgName, t.Value)
+			return TypeExpr{"map[" + identKey.Name + "]" + e.Expr, e.PkgName, e.pkgIndex + len("map["+identKey.Name+"]"), e.Valid}
+		}
+		error = fmt.Sprintf("Failed to generate name for Map field :%v. Make sure the field name is valid.", t.Key)
+	case *ast.Ellipsis:
+		e := NewTypeExpr(pkgName, t.Elt)
+		return TypeExpr{"[]" + e.Expr, e.PkgName, e.pkgIndex + 2, e.Valid}
+	default:
+		error = fmt.Sprintf("Failed to generate name for field: %v Package: %v. Make sure the field name is valid.", expr, pkgName)
+
+	}
+	return TypeExpr{Valid: false, Expr:error}
+}
+
+var builtInTypes = map[string]struct{}{
+	"bool":       {},
+	"byte":       {},
+	"complex128": {},
+	"complex64":  {},
+	"error":      {},
+	"float32":    {},
+	"float64":    {},
+	"int":        {},
+	"int16":      {},
+	"int32":      {},
+	"int64":      {},
+	"int8":       {},
+	"rune":       {},
+	"string":     {},
+	"uint":       {},
+	"uint16":     {},
+	"uint32":     {},
+	"uint64":     {},
+	"uint8":      {},
+	"uintptr":    {},
+}
+
+// IsBuiltinType checks the given type is built-in types of Go
+func IsBuiltinType(name string) bool {
+	_, ok := builtInTypes[name]
+	return ok
+}
+
+// Returns the first non empty string from a list of arguements
+func FirstNonEmpty(strs ...string) string {
+	for _, str := range strs {
+		if len(str) > 0 {
+			return str
+		}
+	}
+	return ""
+}
+
--- a/model/type_info.go
+++ b/model/type_info.go
@@ -0,0 +1,16 @@
+package model
+
+// TypeInfo summarizes information about a struct type in the app source code.
+type TypeInfo struct {
+	StructName  string // e.g. "Application"
+	ImportPath  string // e.g. "github.com/revel/examples/chat/app/controllers"
+	PackageName string // e.g. "controllers"
+	MethodSpecs []*MethodSpec // Method specifications, the action functions
+	EmbeddedTypes []*EmbeddedTypeName // Used internally to identify controllers that indirectly embed *revel.Controller.
+}
+
+// Return the type information as a properly formatted import string
+func (s *TypeInfo) String() string {
+	return s.ImportPath + "." + s.StructName
+}
+