model

type COMMAND int

type 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
	FrameworkVersion *Version // The framework version
	CommandVersion   *Version // The command version
	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 (relative to a GOPATH)
	GoPath           string   // The GoPath
	GoCmd            string   // The full path to the go executable
	// SrcRoot           string                                                                                                                      // The source root
	AppPath           string                     // The application path (absolute)
	AppName           string                     // The application name
	HistoricBuildMode bool                       `long:"historic-build-mode" description:"If set the code is scanned using the original parsers, not the go.1.11+"` // True if debug is active
	Vendored          bool                       // True if the application is vendored
	PackageResolver   func(pkgName string) error //  a package resolver for the config
	BuildFlags        []string                   `` /* 186-byte string literal not displayed */
	GoModFlags        []string                   `` /* 126-byte string literal not displayed */
	New               command.New                `command:"new"`
	Build             command.Build              `command:"build"`
	Run               command.Run                `command:"run"`
	Package           command.Package            `command:"package"`
	Clean             command.Clean              `command:"clean"`
	Test              command.Test               `command:"test"`
	Version           command.Version            `command:"version"`
}

type EmbeddedTypeName struct {
	ImportPath, StructName string
}

type Error string

type Event int

type EventHandler func(typeOf Event, value interface{}) (responseOf EventResponse)

type EventResponse int

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.
}

type MethodCall struct {
	Path  string // e.g. "myapp/app/controllers.(*Application).Action"
	Line  int
	Names []string
}

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.
}

type ModuleInfo struct {
	ImportPath string
	Path       string
}

type RevelCallback interface {
	FireEvent(key Event, value interface{}) (response EventResponse)
	PackageResolver(pkgName string) error
}

type RevelContainer struct {
	BuildPaths struct {
		Revel string
	}
	Paths struct {
		Import   string
		Source   string
		Base     string
		App      string
		Views    string
		Code     []string
		Template []string
		Config   []string
	}
	PackageInfo struct {
		Config   config.Context
		Packaged bool
		DevMode  bool
		Vendor   bool
	}
	Application struct {
		Name string
		Root string
	}

	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]*ModuleInfo // The module path map
}

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

	// packageMap a map of import to system directory (if available)
	PackageMap map[string]string
	// contains filtered or unexported fields
}

type TypeExpr struct {
	Expr    string // The unqualified type expression, e.g. "[]*MyType"
	PkgName string // The default package idenifier

	Valid bool
	// contains filtered or unexported fields
}

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.
}

type Version struct {
	Prefix       string
	Major        int
	Minor        int
	Maintenance  int
	Suffix       string
	BuildDate    string
	MinGoVersion string
}

type WrappedRevelCallback struct {
	FireEventFunction func(key Event, value interface{}) (response EventResponse)
	ImportFunction    func(pkgName string) error
}