func loadApp(args []string, mode string) {
// Find and parse app.conf
revel.Init(mode, args[0], "")
revel.LoadMimeConfig()
revmgo.AppInit()
}
func BenchmarkProcessBookingSource(b *testing.B) {
revel.Init("", "github.com/robfig/revel/samples/booking", "")
revel.TRACE = log.New(ioutil.Discard, "", 0)
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, err := ProcessSource(revel.CodePaths)
if err != nil {
b.Error("Unexpected error:", err)
}
}
}
func buildApp(args []string) {
if len(args) != 2 {
fmt.Fprintf(os.Stderr, "%s\n%s", cmdBuild.UsageLine, cmdBuild.Long)
return
}
appImportPath, destPath := args[0], args[1]
if !revel.Initialized {
revel.Init("", appImportPath, "")
}
os.RemoveAll(destPath)
os.MkdirAll(destPath, 0777)
app, reverr := harness.Build()
panicOnError(reverr, "Failed to build")
// Included are:
// - run scripts
// - binary
// - revel
// - app
// Revel and the app are in a directory structure mirroring import path
srcPath := path.Join(destPath, "src")
tmpRevelPath := path.Join(srcPath, filepath.FromSlash(revel.REVEL_IMPORT_PATH))
mustCopyFile(path.Join(destPath, filepath.Base(app.BinaryPath)), app.BinaryPath)
mustCopyDir(path.Join(tmpRevelPath, "conf"), path.Join(revel.RevelPath, "conf"), nil)
mustCopyDir(path.Join(tmpRevelPath, "templates"), path.Join(revel.RevelPath, "templates"), nil)
mustCopyDir(path.Join(srcPath, filepath.FromSlash(appImportPath)), revel.BasePath, nil)
tmplData := map[string]interface{}{
"BinName": filepath.Base(app.BinaryPath),
"ImportPath": appImportPath,
}
mustRenderTemplate(
path.Join(destPath, "run.sh"),
path.Join(revel.RevelPath, "revel", "package_run.sh.template"),
tmplData)
mustRenderTemplate(
path.Join(destPath, "run.bat"),
path.Join(revel.RevelPath, "revel", "package_run.bat.template"),
tmplData)
}
func runApp(args []string) {
if len(args) == 0 {
errorf("No import path given.\nRun 'revel help run' for usage.\n")
}
// Determine the run mode.
mode := "dev"
if len(args) >= 2 {
mode = args[1]
}
// Find and parse app.conf
revel.Init(mode, args[0], "")
revel.LoadMimeConfig()
// Determine the override port, if any.
port := revel.HttpPort
if len(args) == 3 {
var err error
if port, err = strconv.Atoi(args[2]); err != nil {
errorf("Failed to parse port as integer: %s", args[2])
}
}
revel.INFO.Printf("Running %s (%s) in %s mode\n", revel.AppName, revel.ImportPath, mode)
revel.TRACE.Println("Base path:", revel.BasePath)
// If the app is run in "watched" mode, use the harness to run it.
if revel.Config.BoolDefault("watch", true) && revel.Config.BoolDefault("watch.code", true) {
revel.HttpPort = port
harness.NewHarness().Run() // Never returns.
}
// Else, just build and run the app.
app, err := harness.Build()
if err != nil {
errorf("Failed to build app: %s", err)
}
app.Port = port
app.Cmd().Run()
}
func TestProcessBookingSource(t *testing.T) {
revel.Init("", "github.com/robfig/revel/samples/booking", "")
sourceInfo, err := ProcessSource([]string{revel.AppPath})
if err != nil {
t.Fatal("Failed to process booking source with error:", err)
}
CONTROLLER_PKG := "github.com/robfig/revel/samples/booking/app/controllers"
expectedControllerSpecs := []*TypeInfo{
{"GorpController", CONTROLLER_PKG, "controllers", nil, nil},
{"Application", CONTROLLER_PKG, "controllers", nil, nil},
{"Hotels", CONTROLLER_PKG, "controllers", nil, nil},
}
if len(sourceInfo.ControllerSpecs()) != len(expectedControllerSpecs) {
t.Errorf("Unexpected number of controllers found. Expected %d, Found %d",
len(expectedControllerSpecs), len(sourceInfo.ControllerSpecs()))
}
NEXT_TEST:
for _, expected := range expectedControllerSpecs {
for _, actual := range sourceInfo.ControllerSpecs() {
if actual.StructName == expected.StructName {
if actual.ImportPath != expected.ImportPath {
t.Errorf("%s expected to have import path %s, actual %s",
actual.StructName, expected.ImportPath, actual.ImportPath)
}
if actual.PackageName != expected.PackageName {
t.Errorf("%s expected to have package name %s, actual %s",
actual.StructName, expected.PackageName, actual.PackageName)
}
continue NEXT_TEST
}
}
t.Errorf("Expected to find controller %s, but did not. Actuals: %s",
expected.StructName, sourceInfo.ControllerSpecs())
}
}
func packageApp(args []string) {
if len(args) == 0 {
fmt.Fprint(os.Stderr, cmdPackage.Long)
return
}
appImportPath := args[0]
revel.Init("", appImportPath, "")
// Remove the archive if it already exists.
destFile := path.Base(revel.BasePath) + ".tar.gz"
os.Remove(destFile)
// Collect stuff in a temp directory.
tmpDir, err := ioutil.TempDir("", path.Base(revel.BasePath))
panicOnError(err, "Failed to get temp dir")
buildApp([]string{args[0], tmpDir})
// Create the zip file.
archiveName := mustTarGzDir(destFile, tmpDir)
fmt.Println("Your archive is ready:", archiveName)
}
func buildApp(args []string) {
if len(args) != 2 {
fmt.Fprintf(os.Stderr, "%s\n%s", cmdBuild.UsageLine, cmdBuild.Long)
return
}
appImportPath, destPath := args[0], args[1]
if !revel.Initialized {
revel.Init("", appImportPath, "")
}
// First, verify that it is either already empty or looks like a previous
// build (to avoid clobbering anything)
if exists(destPath) && !empty(destPath) && !exists(path.Join(destPath, "run.sh")) {
errorf("Abort: %s exists and does not look like a build directory.", destPath)
}
os.RemoveAll(destPath)
os.MkdirAll(destPath, 0777)
app, reverr := harness.Build()
panicOnError(reverr, "Failed to build")
// Included are:
// - run scripts
// - binary
// - revel
// - app
// Revel and the app are in a directory structure mirroring import path
srcPath := path.Join(destPath, "src")
tmpRevelPath := path.Join(srcPath, filepath.FromSlash(revel.REVEL_IMPORT_PATH))
mustCopyFile(path.Join(destPath, filepath.Base(app.BinaryPath)), app.BinaryPath)
mustCopyDir(path.Join(tmpRevelPath, "conf"), path.Join(revel.RevelPath, "conf"), nil)
mustCopyDir(path.Join(tmpRevelPath, "templates"), path.Join(revel.RevelPath, "templates"), nil)
mustCopyDir(path.Join(srcPath, filepath.FromSlash(appImportPath)), revel.BasePath, nil)
// Find all the modules used and copy them over.
config := revel.Config.Raw()
modulePaths := make(map[string]string) // import path => filesystem path
for _, section := range config.Sections() {
options, _ := config.SectionOptions(section)
for _, key := range options {
if !strings.HasPrefix(key, "module.") {
continue
}
moduleImportPath, _ := config.String(section, key)
if moduleImportPath == "" {
continue
}
modulePath, err := revel.ResolveImportPath(moduleImportPath)
if err != nil {
revel.ERROR.Fatalln("Failed to load module %s: %s", key[len("module."):], err)
}
modulePaths[moduleImportPath] = modulePath
}
}
for importPath, fsPath := range modulePaths {
mustCopyDir(path.Join(srcPath, importPath), fsPath, nil)
}
tmplData := map[string]interface{}{
"BinName": filepath.Base(app.BinaryPath),
"ImportPath": appImportPath,
}
mustRenderTemplate(
path.Join(destPath, "run.sh"),
path.Join(revel.RevelPath, "revel", "package_run.sh.template"),
tmplData)
mustRenderTemplate(
path.Join(destPath, "run.bat"),
path.Join(revel.RevelPath, "revel", "package_run.bat.template"),
tmplData)
}
func testApp(args []string) {
var err error
if len(args) == 0 {
errorf("No import path given.\nRun 'revel help test' for usage.\n")
}
mode := "dev"
if len(args) >= 2 {
mode = args[1]
}
// Find and parse app.conf
revel.Init(mode, args[0], "")
// Ensure that the testrunner is loaded in this mode.
testRunnerFound := false
for _, module := range revel.Modules {
if module.ImportPath == "github.com/robfig/revel/modules/testrunner" {
testRunnerFound = true
break
}
}
if !testRunnerFound {
errorf(`Error: The testrunner module is not running.
You can add it to a run mode configuration with the following line:
module.testrunner = github.com/robfig/revel/modules/testrunner
`)
}
// Create a directory to hold the test result files.
resultPath := path.Join(revel.BasePath, "test-results")
if err = os.RemoveAll(resultPath); err != nil {
errorf("Failed to remove test result directory %s: %s", resultPath, err)
}
if err = os.Mkdir(resultPath, 0777); err != nil {
errorf("Failed to create test result directory %s: %s", resultPath, err)
}
// Direct all the output into a file in the test-results directory.
file, err := os.OpenFile(path.Join(resultPath, "app.log"), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err != nil {
errorf("Failed to create log file: %s", err)
}
app, reverr := harness.Build()
if reverr != nil {
errorf("Error building: %s", reverr)
}
cmd := app.Cmd()
cmd.Stderr = io.MultiWriter(cmd.Stderr, file)
cmd.Stdout = io.MultiWriter(cmd.Stderr, file)
// Start the app...
if err := cmd.Start(); err != nil {
errorf("%s", err)
}
defer cmd.Kill()
revel.INFO.Printf("Testing %s (%s) in %s mode\n", revel.AppName, revel.ImportPath, mode)
// Get a list of tests.
// Since this is the first request to the server, retry/sleep a couple times
// in case it hasn't finished starting up yet.
var (
testSuites []controllers.TestSuiteDesc
resp *http.Response
baseUrl = fmt.Sprintf("http://127.0.0.1:%d", revel.HttpPort)
)
for i := 0; ; i++ {
if resp, err = http.Get(baseUrl + "/@tests.list"); err == nil {
break
}
if i < 3 {
time.Sleep(3 * time.Second)
continue
}
errorf("Failed to request test list: %s", err)
}
defer resp.Body.Close()
json.NewDecoder(resp.Body).Decode(&testSuites)
// If a specific TestSuite[.Method] is specified, only run that suite/test
if len(args) == 3 {
testSuites = filterTestSuites(testSuites, args[2])
}
fmt.Printf("\n%d test suite%s to run.\n", len(testSuites), pluralize(len(testSuites), "", "s"))
fmt.Println()
// Load the result template, which we execute for each suite.
module, _ := revel.ModuleByName("testrunner")
TemplateLoader := revel.NewGoTemplateLoader([]string{path.Join(module.Path, "app", "views")})
if err := TemplateLoader.Refresh(); err != nil {
errorf("Failed to compile templates: %s", err)
}
resultTemplate, err := TemplateLoader.Template("TestRunner/SuiteResult.html")
if err != nil {
errorf("Failed to load suite result template: %s", err)
}
// Run each suite.
var (
overallSuccess = true
failedResults []controllers.TestSuiteResult
)
for _, suite := range testSuites {
// Print the name of the suite we're running.
name := suite.Name
if len(name) > 22 {
name = name[:19] + "..."
}
fmt.Printf("%-22s", name)
// Run every test.
startTime := time.Now()
suiteResult := controllers.TestSuiteResult{Name: suite.Name, Passed: true}
for _, test := range suite.Tests {
testUrl := baseUrl + "/@tests/" + suite.Name + "/" + test.Name
resp, err := http.Get(testUrl)
if err != nil {
errorf("Failed to fetch test result at url %s: %s", testUrl, err)
}
defer resp.Body.Close()
var testResult controllers.TestResult
json.NewDecoder(resp.Body).Decode(&testResult)
if !testResult.Passed {
suiteResult.Passed = false
}
suiteResult.Results = append(suiteResult.Results, testResult)
}
overallSuccess = overallSuccess && suiteResult.Passed
// Print result. (Just PASSED or FAILED, and the time taken)
suiteResultStr, suiteAlert := "PASSED", ""
if !suiteResult.Passed {
suiteResultStr, suiteAlert = "FAILED", "!"
failedResults = append(failedResults, suiteResult)
}
fmt.Printf("%8s%3s%6ds\n", suiteResultStr, suiteAlert, int(time.Since(startTime).Seconds()))
// Create the result HTML file.
suiteResultFilename := path.Join(resultPath,
fmt.Sprintf("%s.%s.html", suite.Name, strings.ToLower(suiteResultStr)))
suiteResultFile, err := os.Create(suiteResultFilename)
if err != nil {
errorf("Failed to create result file %s: %s", suiteResultFilename, err)
}
if err = resultTemplate.Render(suiteResultFile, suiteResult); err != nil {
errorf("Failed to render result template: %s", err)
}
}
fmt.Println()
if overallSuccess {
writeResultFile(resultPath, "result.passed", "passed")
fmt.Println("All Tests Passed.")
} else {
for _, failedResult := range failedResults {
fmt.Printf("Failures:\n")
for _, result := range failedResult.Results {
if !result.Passed {
fmt.Printf("%s.%s\n", failedResult.Name, result.Name)
fmt.Printf("%s\n\n", result.ErrorSummary)
}
}
}
writeResultFile(resultPath, "result.failed", "failed")
errorf("Some tests failed. See file://%s for results.", resultPath)
}
}
func main() {
flag.Parse()
revel.Init(*runMode, *importPath, *srcPath)
revel.INFO.Println("Running revel server")
revel.RegisterController((*controllers.App)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
118: []string{
"fnames",
},
},
},
&revel.MethodType{
Name: "Search",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "func_name", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "search_type", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "call_depth", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "direction", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "data_source", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "CreateImage",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "func_name", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "search_type", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "call_depth", Type: reflect.TypeOf((*uint)(nil))},
&revel.MethodArg{Name: "direction", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "data_source", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers0.Static)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Serve",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "ServeModule",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "moduleName", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers1.TestRunner)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
46: []string{
"testSuites",
},
},
},
&revel.MethodType{
Name: "Run",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "test", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{
69: []string{
"error",
},
},
},
&revel.MethodType{
Name: "List",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
})
revel.DefaultValidationKeys = map[string]map[int]string{
"github.com/jinlf/callgraph/app/controllers.App.Search": {
122: "func_name",
125: "search_type",
128: "call_depth",
135: "data_source",
},
}
revel.TestSuites = []interface{}{
(*tests.AppTest)(nil),
}
revel.Run(*port)
}
func main() {
flag.Parse()
revel.Init(*runMode, *importPath, *srcPath)
revel.INFO.Println("Running revel server")
revel.RegisterController((*controllers.App)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
10: []string{},
},
},
})
revel.RegisterController((*controllers0.Static)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Serve",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "ServeModule",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "moduleName", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers1.TestRunner)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
46: []string{
"testSuites",
},
},
},
&revel.MethodType{
Name: "Run",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "test", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{
69: []string{
"error",
},
},
},
&revel.MethodType{
Name: "List",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
})
revel.DefaultValidationKeys = map[string]map[int]string{}
revel.TestSuites = []interface{}{
(*tests.AppTest)(nil),
}
revel.Run(*port)
}
func main() {
flag.Parse()
revel.Init(*runMode, *importPath, *srcPath)
revel.INFO.Println("Running revel server")
revel.RegisterController((*controllers.Blog)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Permalink",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "id", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{
69: []string{
"title",
"content",
"menu",
"url",
"id",
},
},
},
&revel.MethodType{
Name: "NoJsRedirect",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "id", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "Ajax",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "id", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "About",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
94: []string{
"menu",
"title",
},
},
},
&revel.MethodType{
Name: "Thanks",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
101: []string{
"menu",
"title",
},
},
},
})
revel.RegisterController((*controllers0.Static)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Serve",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "ServeModule",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "moduleName", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers1.TestRunner)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
46: []string{
"testSuites",
},
},
},
&revel.MethodType{
Name: "Run",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "test", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{
69: []string{
"error",
},
},
},
&revel.MethodType{
Name: "List",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
})
revel.DefaultValidationKeys = map[string]map[int]string{}
revel.TestSuites = []interface{}{}
revel.Run(*port)
}
func main() {
flag.Parse()
revel.Init(*runMode, *importPath, *srcPath)
revel.INFO.Println("Running revel server")
revel.RegisterController((*controllers.App)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{
53: []string{
"title",
"sys_info",
},
},
},
})
revel.RegisterController((*controllers.Init)(nil),
[]*revel.MethodType{})
revel.RegisterController((*controllers0.Content)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
17: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers1.Extend)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
17: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers2.Logs)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
12: []string{},
},
},
})
revel.RegisterController((*controllers3.Module)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
17: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers4.Panel)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
17: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers5.Plugin)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
17: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers6.Captcha)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers7.Setting)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
17: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers8.Style)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
17: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers9.User)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
16: []string{},
},
},
&revel.MethodType{
Name: "Login",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
21: []string{},
},
},
&revel.MethodType{
Name: "LoginPost",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "Logout",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers10.TestRunner)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
46: []string{
"testSuites",
},
},
},
&revel.MethodType{
Name: "Run",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "test", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{
69: []string{
"error",
},
},
},
&revel.MethodType{
Name: "List",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers11.Static)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Serve",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "ServeModule",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "moduleName", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.DefaultValidationKeys = map[string]map[int]string{
"admin/app/models.(*Admin).Validate": {
31: "a.Username",
32: "a.Username",
46: "a.Email",
47: "a.Email",
61: "a.Password",
62: "a.Password",
},
"admin/app/models.(*Menu).Validate": {
20: "m.Name",
21: "m.Pid",
22: "m.Controller",
},
"admin/app/models.(*Password).ValidatePassword": {
67: "P.Password",
68: "P.PasswordConfirm",
70: "P.Password",
71: "P.Password",
},
}
revel.TestSuites = []interface{}{
(*tests.AppTest)(nil),
}
revel.Run(*port)
}
func main() {
flag.Parse()
revel.Init(*runMode, *importPath, *srcPath)
revel.INFO.Println("Running revel server")
revel.RegisterController((*controllers.App)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
113: []string{
"repos",
},
},
},
&revel.MethodType{
Name: "FindReport",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "repository", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "ReportCard",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "user", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "repo", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{
208: []string{
"user",
"repo",
"title",
"partial",
"review",
"missing",
},
},
},
})
revel.RegisterController((*controllers0.Static)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Serve",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "ServeModule",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "moduleName", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers1.TestRunner)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
46: []string{
"testSuites",
},
},
},
&revel.MethodType{
Name: "Run",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "test", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{
69: []string{
"error",
},
},
},
&revel.MethodType{
Name: "List",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
})
revel.DefaultValidationKeys = map[string]map[int]string{
"github.com/stackmachine/rottenrepos/app/controllers.App.FindReport": {
117: "repository",
118: "repository",
},
}
revel.TestSuites = []interface{}{
(*tests.AppTest)(nil),
}
revel.Run(*port)
}
func main() {
flag.Parse()
revel.Init(*runMode, *importPath, *srcPath)
revel.INFO.Println("Running revel server")
revel.RegisterController((*controllers.App)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{
52: []string{
"title",
},
},
},
&revel.MethodType{
Name: "Main",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{
60: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers.Init)(nil),
[]*revel.MethodType{})
revel.RegisterController((*controllers0.Content)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
13: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers1.Extend)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
13: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers2.Module)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
13: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers3.Panel)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
13: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers4.Plugin)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
13: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers5.Ajax)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Login",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
15: []string{},
},
},
&revel.MethodType{
Name: "Pos",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "menu", Type: reflect.TypeOf((**models.Menu)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "GetMessage",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "ScreenLock",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "ScreenUnlock",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers5.Captcha)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "GetCaptchaId",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers5.Public)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Map",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "menu", Type: reflect.TypeOf((**models.Menu)(nil))},
},
RenderArgNames: map[int][]string{
17: []string{
"map_html",
},
},
},
&revel.MethodType{
Name: "CreateHtml",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
23: []string{},
},
},
&revel.MethodType{
Name: "Search",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
29: []string{},
},
},
&revel.MethodType{
Name: "Message",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
35: []string{},
},
},
})
revel.RegisterController((*controllers6.Admin)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{
28: []string{
"title",
"admin_list",
"pages",
},
32: []string{
"title",
"admin_list",
"pages",
},
},
},
&revel.MethodType{
Name: "Add",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{
47: []string{
"title",
"role_list",
},
},
},
&revel.MethodType{
Name: "Edit",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{
179: []string{
"title",
"admin_info",
"role_list",
},
181: []string{
"title",
"role_list",
},
},
},
&revel.MethodType{
Name: "Delete",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers6.Logs)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "logs", Type: reflect.TypeOf((**models.Logs)(nil))},
},
RenderArgNames: map[int][]string{
47: []string{
"title",
"logs_list",
"pages",
},
53: []string{
"title",
"logs_list",
"pages",
},
},
},
})
revel.RegisterController((*controllers6.Menu)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "menu", Type: reflect.TypeOf((**models.Menu)(nil))},
},
RenderArgNames: map[int][]string{
18: []string{
"title",
"menus",
},
},
},
&revel.MethodType{
Name: "Add",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "menu", Type: reflect.TypeOf((**models.Menu)(nil))},
},
RenderArgNames: map[int][]string{
38: []string{
"title",
"menus",
"Id",
},
42: []string{
"title",
"menus",
},
},
},
&revel.MethodType{
Name: "Edit",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "menu", Type: reflect.TypeOf((**models.Menu)(nil))},
},
RenderArgNames: map[int][]string{
138: []string{
"title",
"menus",
"menu_info",
},
144: []string{
"title",
"menus",
},
},
},
&revel.MethodType{
Name: "Delete",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "menu", Type: reflect.TypeOf((**models.Menu)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers6.Role)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "role", Type: reflect.TypeOf((**models.Role)(nil))},
},
RenderArgNames: map[int][]string{
26: []string{
"title",
"role_list",
"pages",
},
30: []string{
"title",
"role_list",
"pages",
},
},
},
&revel.MethodType{
Name: "Member",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "role", Type: reflect.TypeOf((**models.Role)(nil))},
},
RenderArgNames: map[int][]string{
61: []string{
"title",
"admin_list",
"pages",
},
65: []string{
"title",
"admin_list",
"pages",
},
69: []string{
"title",
},
},
},
&revel.MethodType{
Name: "Add",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "role", Type: reflect.TypeOf((**models.Role)(nil))},
},
RenderArgNames: map[int][]string{
84: []string{
"title",
"tree",
},
},
},
&revel.MethodType{
Name: "Edit",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "role", Type: reflect.TypeOf((**models.Role)(nil))},
},
RenderArgNames: map[int][]string{
158: []string{
"title",
"role_info",
"tree",
"Id",
},
164: []string{
"title",
"tree",
},
},
},
&revel.MethodType{
Name: "SetStatus",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "role", Type: reflect.TypeOf((**models.Role)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "Delete",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "role", Type: reflect.TypeOf((**models.Role)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers6.Setting)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
14: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers7.Style)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
13: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers8.User)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
18: []string{
"title",
},
},
},
&revel.MethodType{
Name: "Login",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{
29: []string{
"title",
"CaptchaId",
},
},
},
&revel.MethodType{
Name: "Logout",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "EditInfo",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{
151: []string{
"title",
"admin_info",
},
153: []string{
"title",
},
},
},
&revel.MethodType{
Name: "EditPwd",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "admin", Type: reflect.TypeOf((**models.Admin)(nil))},
},
RenderArgNames: map[int][]string{
214: []string{
"title",
},
},
},
&revel.MethodType{
Name: "Left",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "menu", Type: reflect.TypeOf((**models.Menu)(nil))},
},
RenderArgNames: map[int][]string{
306: []string{
"title",
"left_menu",
},
308: []string{
"title",
},
326: []string{
"title",
"left_menu",
},
328: []string{
"title",
},
},
},
})
revel.RegisterController((*controllers9.Static)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Serve",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
&revel.MethodType{
Name: "ServeModule",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "moduleName", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{},
},
})
revel.RegisterController((*controllers10.TestRunner)(nil),
[]*revel.MethodType{
&revel.MethodType{
Name: "Index",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{
46: []string{
"testSuites",
},
},
},
&revel.MethodType{
Name: "Run",
Args: []*revel.MethodArg{
&revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil))},
&revel.MethodArg{Name: "test", Type: reflect.TypeOf((*string)(nil))},
},
RenderArgNames: map[int][]string{
69: []string{
"error",
},
},
},
&revel.MethodType{
Name: "List",
Args: []*revel.MethodArg{},
RenderArgNames: map[int][]string{},
},
})
revel.DefaultValidationKeys = map[string]map[int]string{
"admin/app/models.(*Admin).Validate": {
31: "a.Username",
32: "a.Username",
46: "a.Email",
47: "a.Email",
61: "a.Password",
62: "a.Password",
},
"admin/app/models.(*Menu).Validate": {
21: "menu.Name",
22: "menu.Name",
23: "menu.Pid",
24: "menu.Url",
25: "menu.Order",
},
"admin/app/models.(*Password).ValidatePassword": {
67: "P.Password",
68: "P.PasswordConfirm",
70: "P.Password",
71: "P.Password",
},
}
revel.TestSuites = []interface{}{
(*tests.AppTest)(nil),
}
revel.Run(*port)
}