Merge pull request #187 from Laur1nMartins/master

Fixed parsing of user defined linker flags

.codebeatsettings

@@ -1,11 +1,13 @@
 {
   "GOLANG": {
-  "ABC":[25, 35, 50, 70],
-  "BLOCK_NESTING":[5, 6, 7, 8],
-  "CYCLO":[20, 30, 45, 60],
-    "TOO_MANY_IVARS": [15, 18, 20, 25],
+    "ABC":[33, 38, 50, 70],
+    "ARITY":[5,6,7,8],
+    "BLOCK_NESTING":[9, 10, 12, 13],
+    "CYCLO":[30, 35, 45, 60],
+    "TOO_MANY_IVARS": [28, 30, 40, 45],
     "TOO_MANY_FUNCTIONS": [20, 30, 40, 50],
     "TOTAL_COMPLEXITY": [150, 250, 400, 500],
-    "LOC": [50, 75, 90, 120]
+    "LOC": [100, 175, 250, 320],
+    "TOTAL_LOC": [300, 400, 500, 600]
   }
-}
+}

.travis.yml

@@ -1,10 +1,8 @@
 language: go
 
 go:
-  - "1.8.7"
-  - "1.9"
-  - "1.10"
-  - "1.11"
+  - "1.13.x"
+  - "1.14.x"
   - "tip"
 
 os:
@@ -19,48 +17,56 @@ branches:
     - master
     - develop
 
+env:
+  # Setting environments variables
+  - GO111MODULE=on
 
 install:
-  # Setting environments variables
   - export PATH=$PATH:$HOME/gopath/bin
   - export REVEL_BRANCH="develop"
   - 'if [[ "$TRAVIS_BRANCH" == "master" ]]; then export REVEL_BRANCH="master"; fi'
   - 'echo "Travis branch: $TRAVIS_BRANCH, Revel dependency branch: $REVEL_BRANCH"'
-  - go get -t -v github.com/revel/cmd/revel
-  - go get -u github.com/golang/dep/cmd/dep
-  - echo $GOPATH
-  - echo $PATH
+  # Since travis already checks out go build the commandline tool (revel)
+  - mkdir $HOME/GOPATH_PROTECTED
+  - export GOPATH=$HOME/GOPATH_PROTECTED
+  - go build -o $HOME/gopath/bin/revel github.com/revel/cmd/revel
   - pwd
+  - env
 script:
   - go test -v github.com/revel/cmd/revel/...
 
   # Ensure the new-app flow works (plus the other commands).
-  - revel version
-  - revel new     my/testapp
-  - revel test    my/testapp
-  - revel clean   my/testapp
-  - revel build   my/testapp build/testapp
-  - revel build   my/testapp build/testapp prod
-  - revel package my/testapp
-  - revel package my/testapp prod
+  #- revel version
+  #- revel new     my/testapp
+  #- revel test    my/testapp
+  #- revel clean   my/testapp
+  #- revel build   my/testapp build/testapp
+  #- revel build   my/testapp build/testapp prod
+  #- revel package my/testapp
+  #- revel package my/testapp prod
 
   # Ensure the new-app flow works (plus the other commands).
-  - revel new     -a my/testapp2
-  - revel test    -a my/testapp2
-  - revel clean   -a my/testapp2
-  - revel build   -a my/testapp2 -t build/testapp2
-  - revel build   -a my/testapp2 -t build/testapp2 -m prod
-  - revel package -a my/testapp2
-  - revel package -a my/testapp2 -m prod
+  - revel new     --gomod-flags "edit -replace=github.com/revel/revel=github.com/revel/revel@$REVEL_BRANCH" -a my/testapp2 --package revelframework.com -v
+  - revel test    --gomod-flags "edit -replace=github.com/revel/revel=github.com/revel/revel@$REVEL_BRANCH" -a my/testapp2 -v
+  - revel clean   --gomod-flags "edit -replace=github.com/revel/revel=github.com/revel/revel@$REVEL_BRANCH" -a my/testapp2 -v
+  - revel build   --gomod-flags "edit -replace=github.com/revel/revel=github.com/revel/revel@$REVEL_BRANCH" -a my/testapp2 -v -t build/testapp2
+  - revel build   --gomod-flags "edit -replace=github.com/revel/revel=github.com/revel/revel@$REVEL_BRANCH" -a my/testapp2 -v -t build/testapp2 -m prod
+  - revel package --gomod-flags "edit -replace=github.com/revel/revel=github.com/revel/revel@$REVEL_BRANCH" -a my/testapp2 -v
+  - revel package --gomod-flags "edit -replace=github.com/revel/revel=github.com/revel/revel@$REVEL_BRANCH" -a my/testapp2 -v -m prod
 
-  - revel new     -v -a my/testapp3 -V
-  - revel test    -v -a my/testapp3
-  - revel clean   -v -a my/testapp3
-  - revel build   -a my/testapp3 -t build/testapp3
-  - revel build   -a my/testapp3 -t build/testapp3 -m prod
-  - revel package -a my/testapp3
-  - revel package -a my/testapp3 -m prod
+  - export INITIALWD=$PWD
+  # Check build works with no-vendor flag
+  - cd $GOPATH
+  - export GO111MODULE=auto
+  - revel new  -a my/testapp2 --no-vendor -v
+  - revel test -a my/testapp2 -v
+
+  # Check non verbose build, outside of GO path
+  - cd $INITIALWD
+  - revel new     --gomod-flags "edit -replace=github.com/revel/revel=github.com/revel/revel@$REVEL_BRANCH" -a my/testapp3 --package revelframework.com
+  - revel test    --gomod-flags "edit -replace=github.com/revel/revel=github.com/revel/revel@$REVEL_BRANCH" -a my/testapp3
 
 matrix:
   allow_failures:
     - go: tip
+    - os: windows

README.md

@@ -21,3 +21,31 @@ Create a new application
 ```commandline
 revel new my/app
 ```
+
+## Community
+
+* [Gitter](https://gitter.im/revel/community)
+* [StackOverflow](http://stackoverflow.com/questions/tagged/revel)
+
+
+## Learn More
+
+* [Manual, Samples, Godocs, etc](http://revel.github.io)
+* [Apps using Revel](https://github.com/revel/revel/wiki/Apps-in-the-Wild)
+* [Articles Featuring Revel](https://github.com/revel/revel/wiki/Articles)
+
+## Contributing
+
+* [Contributing Code Guidelines](https://github.com/revel/revel/blob/master/CONTRIBUTING.md)
+* [Revel Contributors](https://github.com/revel/revel/graphs/contributors)
+
+## Contributors
+
+[![](https://sourcerer.io/fame/notzippy/revel/cmd/images/0)](https://sourcerer.io/fame/notzippy/revel/cmd/links/0)
+[![](https://sourcerer.io/fame/notzippy/revel/cmd/images/1)](https://sourcerer.io/fame/notzippy/revel/cmd/links/1)
+[![](https://sourcerer.io/fame/notzippy/revel/cmd/images/2)](https://sourcerer.io/fame/notzippy/revel/cmd/links/2)
+[![](https://sourcerer.io/fame/notzippy/revel/cmd/images/3)](https://sourcerer.io/fame/notzippy/revel/cmd/links/3)
+[![](https://sourcerer.io/fame/notzippy/revel/cmd/images/4)](https://sourcerer.io/fame/notzippy/revel/cmd/links/4)
+[![](https://sourcerer.io/fame/notzippy/revel/cmd/images/5)](https://sourcerer.io/fame/notzippy/revel/cmd/links/5)
+[![](https://sourcerer.io/fame/notzippy/revel/cmd/images/6)](https://sourcerer.io/fame/notzippy/revel/cmd/links/6)
+[![](https://sourcerer.io/fame/notzippy/revel/cmd/images/7)](https://sourcerer.io/fame/notzippy/revel/cmd/links/7)

go.mod

@@ -0,0 +1,30 @@
+module github.com/revel/cmd
+
+go 1.12
+
+require (
+	github.com/BurntSushi/toml v0.3.1 // indirect
+	github.com/agtorre/gocolorize v1.0.0
+	github.com/fsnotify/fsnotify v1.4.7
+	github.com/inconshreveable/log15 v0.0.0-20200109203555-b30bc20e4fd1 // indirect
+	github.com/jessevdk/go-flags v1.4.0
+	github.com/mattn/go-colorable v0.1.6
+	github.com/myesui/uuid v1.0.0 // indirect
+	github.com/pkg/errors v0.9.1
+	github.com/revel/config v0.21.0
+	github.com/revel/log15 v2.11.20+incompatible
+	github.com/revel/modules v0.21.0 // indirect
+	github.com/revel/pathtree v0.0.0-20140121041023-41257a1839e9 // indirect
+	github.com/revel/revel v0.21.0
+	github.com/stretchr/testify v1.4.0
+	github.com/twinj/uuid v1.0.0 // indirect
+	github.com/xeonx/timeago v1.0.0-rc4 // indirect
+	golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5 // indirect
+	golang.org/x/sys v0.0.0-20200501145240-bc7a7d42d5c3 // indirect
+	golang.org/x/tools v0.0.0-20200219054238-753a1d49df85
+	gopkg.in/fsnotify/fsnotify.v1 v1.4.7
+	gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22
+	gopkg.in/natefinch/lumberjack.v2 v2.0.0
+	gopkg.in/stack.v0 v0.0.0-20141108040640-9b43fcefddd0
+	gopkg.in/stretchr/testify.v1 v1.2.2 // indirect
+)

go.sum

@@ -0,0 +1,60 @@
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/agtorre/gocolorize v1.0.0 h1:TvGQd+fAqWQlDjQxSKe//Y6RaxK+RHpEU9X/zPmHW50=
+github.com/agtorre/gocolorize v1.0.0/go.mod h1:cH6imfTkHVBRJhSOeSeEZhB4zqEYSq0sXuIyehgZMIY=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/inconshreveable/log15 v0.0.0-20200109203555-b30bc20e4fd1 h1:KUDFlmBg2buRWNzIcwLlKvfcnujcHQRQ1As1LoaCLAM=
+github.com/inconshreveable/log15 v0.0.0-20200109203555-b30bc20e4fd1/go.mod h1:cOaXtrgN4ScfRrD9Bre7U1thNq5RtJ8ZoP4iXVGRj6o=
+github.com/jessevdk/go-flags v1.4.0 h1:4IU2WS7AumrZ/40jfhf4QVDMsQwqA7VEHozFRrGARJA=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/mattn/go-colorable v0.1.6 h1:6Su7aK7lXmJ/U79bYtBjLNaha4Fs1Rg9plHpcH+vvnE=
+github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/myesui/uuid v1.0.0/go.mod h1:2CDfNgU0LR8mIdO8vdWd8i9gWWxLlcoIGGpSNgafq84=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/revel/config v0.21.0 h1:Bw4iXLGAuD/Di2HEhPSOyDywrTlFIXUMbds91lXTtTU=
+github.com/revel/config v0.21.0/go.mod h1:GT4a9px5kDGRqLizcw/md0QFErrhen76toz4qS3oIoI=
+github.com/revel/log15 v2.11.20+incompatible h1:JkA4tbwIo/UGEMumY50zndKq816RQW3LQ0wIpRc+32U=
+github.com/revel/log15 v2.11.20+incompatible/go.mod h1:l0WmLRs+IM1hBl4noJiBc2tZQiOgZyXzS1mdmFt+5Gc=
+github.com/revel/modules v0.21.0/go.mod h1:UBlNmO9VGZo4j6Ptn2uC/26Iclefuic+V40jYRPBxQE=
+github.com/revel/pathtree v0.0.0-20140121041023-41257a1839e9/go.mod h1:TmlwoRLDvgRjoTe6rbsxIaka/CulzYrgfef7iNJcEWY=
+github.com/revel/revel v0.21.0/go.mod h1:VZWJnHjpDEtuGUuZJ2NO42XryitrtwsdVaJxfDeo5yc=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/twinj/uuid v1.0.0/go.mod h1:mMgcE1RHFUFqe5AfiwlINXisXfDGro23fWdPUfOMjRY=
+github.com/xeonx/timeago v1.0.0-rc4/go.mod h1:qDLrYEFynLO7y5Ho7w3GwgtYgpy5UfhcXIIQvMKVDkA=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501145240-bc7a7d42d5c3 h1:5B6i6EAiSYyejWfvc5Rc9BbI3rzIsrrXfAQBWnYfn+w=
+golang.org/x/sys v0.0.0-20200501145240-bc7a7d42d5c3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20200219054238-753a1d49df85 h1:XNHaQ2CZDl/SjEZlUXGh7+OQvfLuFgmk3oNWkCFfERE=
+golang.org/x/tools v0.0.0-20200219054238-753a1d49df85/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify/fsnotify.v1 v1.4.7/go.mod h1:Fyux9zXlo4rWoMSIzpn9fDAYjalPqJ/K1qJ27s+7ltE=
+gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
+gopkg.in/stack.v0 v0.0.0-20141108040640-9b43fcefddd0 h1:lMH45EKqD8Nf6LwoF+43YOKjOAEEHQRVgDyG8RCV4MU=
+gopkg.in/stack.v0 v0.0.0-20141108040640-9b43fcefddd0/go.mod h1:kl/bNzW/jgTgUOCGDj3XPn9/Hbfhw6pjfBRUnaTioFQ=
+gopkg.in/stretchr/testify.v1 v1.2.2/go.mod h1:QI5V/q6UbPmuhtm10CaFZxED9NreB8PnFYN9JcR6TxU=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

harness/app.go

@@ -12,24 +12,26 @@ import (
 	"os"
 	"os/exec"
 	"time"
+	"sync"
 
 	"github.com/revel/cmd/model"
 	"github.com/revel/cmd/utils"
-	"log"
+	"runtime"
 )
 
 // App contains the configuration for running a Revel app.  (Not for the app itself)
 // Its only purpose is constructing the command to execute.
 type App struct {
-	BinaryPath string // Path to the app executable
-	Port       int    // Port to pass as a command line argument.
-	cmd        AppCmd // The last cmd returned.
-	Paths      *model.RevelContainer
+	BinaryPath     string            // Path to the app executable
+	Port           int               // Port to pass as a command line argument.
+	cmd            AppCmd            // The last cmd returned.
+	PackagePathMap map[string]string // Package to directory path map
+	Paths          *model.RevelContainer
 }
 
 // NewApp returns app instance with binary path in it
-func NewApp(binPath string, paths *model.RevelContainer) *App {
-	return &App{BinaryPath: binPath, Paths: paths, Port: paths.HTTPPort}
+func NewApp(binPath string, paths *model.RevelContainer, packagePathMap map[string]string) *App {
+	return &App{BinaryPath: binPath, Paths: paths, Port: paths.HTTPPort, PackagePathMap:packagePathMap}
 }
 
 // Cmd returns a command to run the app server using the current configuration.
@@ -61,18 +63,21 @@ func NewAppCmd(binPath string, port int, runMode string, paths *model.RevelConta
 
 // Start the app server, and wait until it is ready to serve requests.
 func (cmd AppCmd) Start(c *model.CommandConfig) error {
-	listeningWriter := &startupListeningWriter{os.Stdout, make(chan bool), c}
+	listeningWriter := &startupListeningWriter{os.Stdout, make(chan bool), c, &bytes.Buffer{}}
 	cmd.Stdout = listeningWriter
+	utils.CmdInit(cmd.Cmd, !c.Vendored, c.AppPath)
 	utils.Logger.Info("Exec app:", "path", cmd.Path, "args", cmd.Args, "dir", cmd.Dir, "env", cmd.Env)
-	utils.CmdInit(cmd.Cmd, c.AppPath)
 	if err := cmd.Cmd.Start(); err != nil {
 		utils.Logger.Fatal("Error running:", "error", err)
 	}
 
 	select {
 	case exitState := <-cmd.waitChan():
-		println("Revel proxy is listening, point your browser to :", c.Run.Port)
-		return errors.New("revel/harness: app died reason: " + exitState)
+		fmt.Println("Startup failure view previous messages, \n Proxy is listening :", c.Run.Port)
+		err := utils.NewError("", "Revel Run Error", "starting your application there was an exception. See terminal output, " + exitState, "")
+	// TODO pretiffy command line output
+	// err.MetaError = listeningWriter.getLastOutput()
+		return err
 
 	case <-time.After(60 * time.Second):
 		println("Revel proxy is listening, point your browser to :", c.Run.Port)
@@ -88,8 +93,9 @@ func (cmd AppCmd) Start(c *model.CommandConfig) error {
 }
 
 // Run the app server inline.  Never returns.
-func (cmd AppCmd) Run() {
-	log.Println("Exec app:", "path", cmd.Path, "args", cmd.Args)
+func (cmd AppCmd) Run(c *model.CommandConfig) {
+	utils.CmdInit(cmd.Cmd, !c.Vendored, c.AppPath)
+	utils.Logger.Info("Exec app:", "path", cmd.Path, "args", cmd.Args)
 	if err := cmd.Cmd.Run(); err != nil {
 		utils.Logger.Fatal("Error running:", "error", err)
 	}
@@ -97,12 +103,67 @@ func (cmd AppCmd) Run() {
 
 // Kill terminates the app server if it's running.
 func (cmd AppCmd) Kill() {
+
 	if cmd.Cmd != nil && (cmd.ProcessState == nil || !cmd.ProcessState.Exited()) {
-		utils.Logger.Info("Killing revel server pid", "pid", cmd.Process.Pid)
-		err := cmd.Process.Kill()
-		if err != nil {
-			utils.Logger.Fatal("Failed to kill revel server:", "error", err)
+		// Windows appears to send the kill to all threads, shutting down the
+		// server before this can, this check will ensure the process is still running
+		if _, err := os.FindProcess(int(cmd.Process.Pid)); err != nil {
+			// Server has already exited
+			utils.Logger.Info("Server not running revel server pid", "pid", cmd.Process.Pid)
+			return
 		}
+
+		// Wait for the shutdown channel
+		waitMutex := &sync.WaitGroup{}
+		waitMutex.Add(1)
+		ch := make(chan bool, 1)
+		go func() {
+			waitMutex.Done()
+			s, err := cmd.Process.Wait()
+			defer func() {
+				ch <- true
+			}()
+			if err != nil {
+				utils.Logger.Info("Wait failed for process ", "error", err)
+			}
+			if s != nil {
+				utils.Logger.Info("Revel App exited", "state", s.String())
+			}
+		}()
+		// Wait for the channel to begin waiting
+		waitMutex.Wait()
+
+		// Send an interrupt signal to allow for a graceful shutdown
+		utils.Logger.Info("Killing revel server pid", "pid", cmd.Process.Pid)
+		var err error
+		if runtime.GOOS != "windows" {
+			// os.Interrupt is not available on windows
+			err = cmd.Process.Signal(os.Interrupt)
+		}
+
+		if err != nil {
+			utils.Logger.Info(
+				"Revel app already exited.",
+				"processid", cmd.Process.Pid, "error", err,
+				"killerror", cmd.Process.Kill())
+			return
+		}
+
+
+		// Use a timer to ensure that the process exits
+		utils.Logger.Info("Waiting to exit")
+		select {
+		case <-ch:
+			return
+		case <-time.After(60 * time.Second):
+		// Kill the process
+			utils.Logger.Error(
+				"Revel app failed to exit in 60 seconds - killing.",
+				"processid", cmd.Process.Pid,
+				"killerror", cmd.Process.Kill())
+		}
+
+		utils.Logger.Info("Done Waiting to exit")
 	}
 }
 
@@ -129,8 +190,10 @@ type startupListeningWriter struct {
 	dest        io.Writer
 	notifyReady chan bool
 	c           *model.CommandConfig
+	buffer      *bytes.Buffer
 }
 
+// Writes to this output stream
 func (w *startupListeningWriter) Write(p []byte) (int, error) {
 	if w.notifyReady != nil && bytes.Contains(p, []byte("Revel engine is listening on")) {
 		w.notifyReady <- true
@@ -142,5 +205,15 @@ func (w *startupListeningWriter) Write(p []byte) (int, error) {
 			w.notifyReady = nil
 		}
 	}
+	if w.notifyReady != nil {
+		w.buffer.Write(p)
+	}
 	return w.dest.Write(p)
 }
+
+// Returns the cleaned output from the response
+// TODO clean the response more
+func (w *startupListeningWriter) getLastOutput() string {
+	return w.buffer.String()
+}
+

harness/build.go

@@ -19,17 +19,25 @@ import (
 	"time"
 
 	"github.com/revel/cmd/model"
-	"github.com/revel/cmd/parser"
+	_ "github.com/revel/cmd/parser"
 	"github.com/revel/cmd/utils"
+	"github.com/revel/cmd/parser2"
+	"github.com/revel/cmd/parser"
 )
 
 var importErrorPattern = regexp.MustCompile("cannot find package \"([^\"]+)\"")
 
 type ByString []*model.TypeInfo
 
-func (c ByString) Len() int           { return len(c) }
-func (c ByString) Swap(i, j int)      { c[i], c[j] = c[j], c[i] }
-func (c ByString) Less(i, j int) bool { return c[i].String() < c[j].String() }
+func (c ByString) Len() int {
+	return len(c)
+}
+func (c ByString) Swap(i, j int) {
+	c[i], c[j] = c[j], c[i]
+}
+func (c ByString) Less(i, j int) bool {
+	return c[i].String() < c[j].String()
+}
 
 // Build the app:
 // 1. Generate the the main.go file.
@@ -40,7 +48,13 @@ func Build(c *model.CommandConfig, paths *model.RevelContainer) (_ *App, err err
 	// First, clear the generated files (to avoid them messing with ProcessSource).
 	cleanSource(paths, "tmp", "routes")
 
-	sourceInfo, err := parser.ProcessSource(paths)
+	var sourceInfo *model.SourceInfo
+
+	if c.HistoricBuildMode {
+		sourceInfo, err = parser.ProcessSource(paths)
+	} else {
+		sourceInfo, err = parser2.ProcessSource(paths)
+	}
 	if err != nil {
 		return
 	}
@@ -88,33 +102,8 @@ func Build(c *model.CommandConfig, paths *model.RevelContainer) (_ *App, err err
 		utils.Logger.Fatal("Go executable not found in PATH.")
 	}
 
-	// Detect if deps tool should be used (is there a vendor folder ?)
-	useVendor := utils.DirExists(filepath.Join(paths.BasePath, "vendor"))
-	basePath := paths.BasePath
-	for !useVendor {
-		basePath = filepath.Dir(basePath)
-		found := false
-		// Check to see if we are still in the GOPATH
-		for _, gopath := range filepath.SplitList(build.Default.GOPATH) {
-			if strings.HasPrefix(basePath, gopath) {
-				found = true
-				break
-			}
-		}
-		if !found {
-			break
-		} else {
-			useVendor = utils.DirExists(filepath.Join(basePath, "vendor"))
-		}
-	}
-
-	pkg, err := build.Default.Import(paths.ImportPath, "", build.FindOnly)
-	if err != nil {
-		return
-	}
-
-	// Binary path is a combination of $GOBIN/revel.d directory, app's import path and its name.
-	binName := filepath.Join(pkg.BinDir, "revel.d", paths.ImportPath, filepath.Base(paths.BasePath))
+	// Binary path is a combination of target/app directory, app's import path and its name.
+	binName := filepath.Join("target", "app", paths.ImportPath, filepath.Base(paths.BasePath))
 
 	// Change binary path for Windows build
 	goos := runtime.GOOS
@@ -135,11 +124,28 @@ func Build(c *model.CommandConfig, paths *model.RevelContainer) (_ *App, err err
 		return false
 	}
 
+	if len(c.GoModFlags) > 0 {
+		for _, gomod := range c.GoModFlags {
+			goModCmd := exec.Command(goPath, append([]string{"mod"}, strings.Split(gomod, " ")...)...)
+			utils.CmdInit(goModCmd, !c.Vendored, c.AppPath)
+			output, err := goModCmd.CombinedOutput()
+			utils.Logger.Info("Gomod applied ", "output", string(output))
+
+			// If the build succeeded, we're done.
+			if err != nil {
+				utils.Logger.Error("Gomod Failed continuing ", "error", err, "output", string(output))
+			}
+		}
+	}
+
 	for {
 		appVersion := getAppVersion(paths)
+		if appVersion == "" {
+			appVersion = "noVersionProvided"
+		}
 
 		buildTime := time.Now().UTC().Format(time.RFC3339)
-		versionLinkerFlags := fmt.Sprintf("-X %s/app.AppVersion=%s -X %s/app.BuildTime=%s",
+		versionLinkerFlags := fmt.Sprintf("-X '%s/app.AppVersion=%s' -X '%s/app.BuildTime=%s'",
 			paths.ImportPath, appVersion, paths.ImportPath, buildTime)
 
 		// Append any build flags specified, they will override existing flags
@@ -147,7 +153,6 @@ func Build(c *model.CommandConfig, paths *model.RevelContainer) (_ *App, err err
 		if len(c.BuildFlags) == 0 {
 			flags = []string{
 				"build",
-				"-i",
 				"-ldflags", versionLinkerFlags,
 				"-tags", buildTags,
 				"-o", binName}
@@ -155,11 +160,15 @@ func Build(c *model.CommandConfig, paths *model.RevelContainer) (_ *App, err err
 			if !contains(c.BuildFlags, "build") {
 				flags = []string{"build"}
 			}
-			flags = append(flags, c.BuildFlags...)
 			if !contains(flags, "-ldflags") {
-				flags = append(flags, "-ldflags", versionLinkerFlags)
+				ldflags := "-ldflags= " + versionLinkerFlags
+				// Add user defined build flags
+				for i := range c.BuildFlags {
+					ldflags += " -X '" + c.BuildFlags[i] + "'"
+				}
+				flags = append(flags, ldflags)
 			}
-			if !contains(flags, "-tags") {
+			if !contains(flags, "-tags") && buildTags != "" {
 				flags = append(flags, "-tags", buildTags)
 			}
 			if !contains(flags, "-o") {
@@ -167,34 +176,35 @@ func Build(c *model.CommandConfig, paths *model.RevelContainer) (_ *App, err err
 			}
 		}
 
-		// Add in build flags
-		flags = append(flags, c.BuildFlags...)
-
-		// This is Go main path
-		gopath := c.GoPath
-		for _, o := range paths.ModulePathMap {
-			gopath += string(filepath.ListSeparator) + o
-		}
-
 		// Note: It's not applicable for filepath.* usage
 		flags = append(flags, path.Join(paths.ImportPath, "app", "tmp"))
 
 		buildCmd := exec.Command(goPath, flags...)
-		buildCmd.Env = append(os.Environ(),
-			"GOPATH="+gopath,
-		)
-		utils.CmdInit(buildCmd, c.AppPath)
-		utils.Logger.Info("Exec:", "args", buildCmd.Args)
+		if !c.Vendored {
+			// This is Go main path
+			gopath := c.GoPath
+			for _, o := range paths.ModulePathMap {
+				gopath += string(filepath.ListSeparator) + o.Path
+			}
+
+			buildCmd.Env = append(os.Environ(),
+				"GOPATH=" + gopath,
+			)
+		}
+		utils.CmdInit(buildCmd, !c.Vendored, c.AppPath)
+
+		utils.Logger.Info("Exec:", "args", buildCmd.Args, "working dir", buildCmd.Dir)
 		output, err := buildCmd.CombinedOutput()
 
 		// If the build succeeded, we're done.
 		if err == nil {
 			utils.Logger.Info("Build successful continuing")
-			return NewApp(binName, paths), nil
+			return NewApp(binName, paths, sourceInfo.PackageMap), nil
 		}
 
 		// Since there was an error, capture the output in case we need to report it
 		stOutput := string(output)
+		utils.Logger.Infof("Got error on build of app %s", stOutput)
 
 		// See if it was an import error that we can go get.
 		matches := importErrorPattern.FindAllStringSubmatch(stOutput, -1)
@@ -246,7 +256,7 @@ func getAppVersion(paths *model.RevelContainer) string {
 		if (err != nil && os.IsNotExist(err)) || !info.IsDir() {
 			return ""
 		}
-		gitCmd := exec.Command(gitPath, "--git-dir="+gitDir, "--work-tree="+paths.BasePath, "describe", "--always", "--dirty")
+		gitCmd := exec.Command(gitPath, "--git-dir=" + gitDir, "--work-tree=" + paths.BasePath, "describe", "--always", "--dirty")
 		utils.Logger.Info("Exec:", "args", gitCmd.Args)
 		output, err := gitCmd.Output()
 
@@ -376,7 +386,7 @@ func containsValue(m map[string]string, val string) bool {
 
 // Parse the output of the "go build" command.
 // Return a detailed Error.
-func newCompileError(paths *model.RevelContainer, output []byte) *utils.Error {
+func newCompileError(paths *model.RevelContainer, output []byte) *utils.SourceError {
 	errorMatch := regexp.MustCompile(`(?m)^([^:#]+):(\d+):(\d+:)? (.*)$`).
 		FindSubmatch(output)
 	if errorMatch == nil {
@@ -384,7 +394,7 @@ func newCompileError(paths *model.RevelContainer, output []byte) *utils.Error {
 
 		if errorMatch == nil {
 			utils.Logger.Error("Failed to parse build errors", "error", string(output))
-			return &utils.Error{
+			return &utils.SourceError{
 				SourceType:  "Go code",
 				Title:       "Go Compilation Error",
 				Description: "See console for build error.",
@@ -400,7 +410,7 @@ func newCompileError(paths *model.RevelContainer, output []byte) *utils.Error {
 		// Extract the paths from the gopaths, and search for file there first
 		gopaths := filepath.SplitList(build.Default.GOPATH)
 		for _, gp := range gopaths {
-			newPath := filepath.Join(gp,"src", paths.ImportPath, relFilename)
+			newPath := filepath.Join(gp, "src", paths.ImportPath, relFilename)
 			println(newPath)
 			if utils.Exists(newPath) {
 				return newPath
@@ -414,11 +424,11 @@ func newCompileError(paths *model.RevelContainer, output []byte) *utils.Error {
 
 	// Read the source for the offending file.
 	var (
-		relFilename  = string(errorMatch[1]) // e.g. "src/revel/sample/app/controllers/app.go"
-		absFilename  = findInPaths(relFilename)
-		line, _      = strconv.Atoi(string(errorMatch[2]))
-		description  = string(errorMatch[4])
-		compileError = &utils.Error{
+		relFilename = string(errorMatch[1]) // e.g. "src/revel/sample/app/controllers/app.go"
+		absFilename = findInPaths(relFilename)
+		line, _ = strconv.Atoi(string(errorMatch[2]))
+		description = string(errorMatch[4])
+		compileError = &utils.SourceError{
 			SourceType:  "Go code",
 			Title:       "Go Compilation Error",
 			Path:        relFilename,
@@ -436,7 +446,7 @@ func newCompileError(paths *model.RevelContainer, output []byte) *utils.Error {
 	fileStr, err := utils.ReadLines(absFilename)
 	if err != nil {
 		compileError.MetaError = absFilename + ": " + err.Error()
-		utils.Logger.Info("Unable to readlines "+compileError.MetaError, "error", err)
+		utils.Logger.Info("Unable to readlines " + compileError.MetaError, "error", err)
 		return compileError
 	}
 
@@ -444,7 +454,7 @@ func newCompileError(paths *model.RevelContainer, output []byte) *utils.Error {
 	return compileError
 }
 
-// RevelMainTemplate template for app/tmp/main.go
+// RevelMainTemplate template for app/tmp/run/run.go
 const RevelRunTemplate = `// GENERATED CODE - DO NOT EDIT
 // This file is the run file for Revel.
 // It registers all the controllers and provides details for the Revel server engine to

harness/harness.go

@@ -16,6 +16,7 @@ package harness
 import (
 	"crypto/tls"
 	"fmt"
+	"time"
 	"go/build"
 	"io"
 	"net"
@@ -34,6 +35,7 @@ import (
 	"html/template"
 	"io/ioutil"
 	"sync"
+	"encoding/json"
 )
 
 var (
@@ -55,6 +57,8 @@ type Harness struct {
 	paths      *model.RevelContainer  // The Revel container
 	config     *model.CommandConfig   // The configuration
 	runMode    string                 // The runmode the harness is running in
+	isError    bool                   // True if harness is in error state
+	ranOnce    bool                   // True app compiled once
 }
 
 func (h *Harness) renderError(iw http.ResponseWriter, ir *http.Request, err error) {
@@ -89,12 +93,12 @@ func (h *Harness) renderError(iw http.ResponseWriter, ir *http.Request, err erro
 		fmt.Fprintf(iw, "An error ocurred %s", err.Error())
 		return
 	}
-	var revelError *utils.Error
+	var revelError *utils.SourceError
 	switch e := err.(type) {
-	case *utils.Error:
+	case *utils.SourceError:
 		revelError = e
 	case error:
-		revelError = &utils.Error{
+		revelError = &utils.SourceError{
 			Title:       "Server Error",
 			Description: e.Error(),
 		}
@@ -161,6 +165,7 @@ func NewHarness(c *model.CommandConfig, paths *model.RevelContainer, runMode str
 	addr := paths.HTTPAddr
 	port := paths.Config.IntDefault("harness.port", 0)
 	scheme := "http"
+
 	if paths.HTTPSsl {
 		scheme = "https"
 	}
@@ -199,7 +204,22 @@ func NewHarness(c *model.CommandConfig, paths *model.RevelContainer, runMode str
 
 // Refresh method rebuilds the Revel application and run it on the given port.
 // called by the watcher
-func (h *Harness) Refresh() (err *utils.Error) {
+func (h *Harness) Refresh() (err *utils.SourceError) {
+	t  := time.Now();
+	fmt.Println("Changed detected, recompiling")
+	err = h.refresh()
+	if err!=nil && !h.ranOnce && h.useProxy {
+		addr := fmt.Sprintf("%s:%d", h.paths.HTTPAddr, h.paths.HTTPPort)
+
+		fmt.Printf("\nError compiling code, to view error details see proxy running on http://%s\n\n",addr)
+	}
+
+	h.ranOnce = true
+	fmt.Printf("\nTime to recompile %s\n",time.Now().Sub(t).String())
+	return
+}
+
+func (h *Harness) refresh() (err *utils.SourceError) {
 	// Allow only one thread to rebuild the process
 	// If multiple requests to rebuild are queued only the last one is executed on
 	// So before a build is started we wait for a second to determine if
@@ -217,10 +237,10 @@ func (h *Harness) Refresh() (err *utils.Error) {
 	h.app, newErr = Build(h.config, h.paths)
 	if newErr != nil {
 		utils.Logger.Error("Build detected an error", "error", newErr)
-		if castErr, ok := newErr.(*utils.Error); ok {
+		if castErr, ok := newErr.(*utils.SourceError); ok {
 			return castErr
 		}
-		err = &utils.Error{
+		err = &utils.SourceError{
 			Title:       "App failed to start up",
 			Description: err.Error(),
 		}
@@ -229,9 +249,22 @@ func (h *Harness) Refresh() (err *utils.Error) {
 
 	if h.useProxy {
 		h.app.Port = h.port
-		if err2 := h.app.Cmd(h.runMode).Start(h.config); err2 != nil {
+		runMode := h.runMode
+		if !h.config.HistoricMode {
+			// Recalulate run mode based on the config
+			var paths []byte
+			if len(h.app.PackagePathMap)>0 {
+				paths, _ = json.Marshal(h.app.PackagePathMap)
+			}
+			runMode = fmt.Sprintf(`{"mode":"%s", "specialUseFlag":%v,"packagePathMap":%s}`, h.app.Paths.RunMode, h.config.Verbose, string(paths))
+
+		}
+		if err2 := h.app.Cmd(runMode).Start(h.config); err2 != nil {
 			utils.Logger.Error("Could not start application", "error", err2)
-			return &utils.Error{
+			if err,k :=err2.(*utils.SourceError);k {
+				return err
+			}
+			return &utils.SourceError{
 				Title:       "App failed to start up",
 				Description: err2.Error(),
 			}
@@ -266,7 +299,8 @@ func (h *Harness) Run() {
 	paths = append(paths, h.paths.CodePaths...)
 	h.watcher = watcher.NewWatcher(h.paths, false)
 	h.watcher.Listen(h, paths...)
-	h.watcher.Notify()
+	go h.Refresh()
+	// h.watcher.Notify()
 
 	if h.useProxy {
 		go func() {
@@ -277,6 +311,7 @@ func (h *Harness) Run() {
 			addr := fmt.Sprintf("%s:%d", h.paths.HTTPAddr, h.paths.HTTPPort)
 			utils.Logger.Infof("Proxy server is listening on %s", addr)
 
+
 			var err error
 			if h.paths.HTTPSsl {
 				err = http.ListenAndServeTLS(
@@ -293,10 +328,12 @@ func (h *Harness) Run() {
 		}()
 
 	}
-	// Kill the app on signal.
+
+	// Make a new channel to listen for the interrupt event
 	ch := make(chan os.Signal)
 	signal.Notify(ch, os.Interrupt, os.Kill)
 	<-ch
+	// Kill the app and exit
 	if h.app != nil {
 		h.app.Kill()
 	}

logger/composite_multihandler.go

@@ -0,0 +1,174 @@
+package logger
+
+import (
+	"github.com/mattn/go-colorable"
+	"gopkg.in/natefinch/lumberjack.v2"
+	"io"
+	"os"
+)
+
+type CompositeMultiHandler struct {
+	DebugHandler    LogHandler
+	InfoHandler     LogHandler
+	WarnHandler     LogHandler
+	ErrorHandler    LogHandler
+	CriticalHandler LogHandler
+}
+
+func NewCompositeMultiHandler() (*CompositeMultiHandler, LogHandler) {
+	cw := &CompositeMultiHandler{}
+	return cw, cw
+}
+func (h *CompositeMultiHandler) Log(r *Record) (err error) {
+
+	var handler LogHandler
+
+	switch r.Level {
+	case LvlInfo:
+		handler = h.InfoHandler
+	case LvlDebug:
+		handler = h.DebugHandler
+	case LvlWarn:
+		handler = h.WarnHandler
+	case LvlError:
+		handler = h.ErrorHandler
+	case LvlCrit:
+		handler = h.CriticalHandler
+	}
+
+	// Embed the caller function in the context
+	if handler != nil {
+		handler.Log(r)
+	}
+	return
+}
+
+func (h *CompositeMultiHandler) SetHandler(handler LogHandler, replace bool, level LogLevel) {
+	if handler == nil {
+		// Ignore empty handler
+		return
+	}
+	source := &h.DebugHandler
+	switch level {
+	case LvlDebug:
+		source = &h.DebugHandler
+	case LvlInfo:
+		source = &h.InfoHandler
+	case LvlWarn:
+		source = &h.WarnHandler
+	case LvlError:
+		source = &h.ErrorHandler
+	case LvlCrit:
+		source = &h.CriticalHandler
+	}
+
+	if !replace && *source != nil {
+		// If we are not replacing the source make sure that the level handler is applied first
+		if _, isLevel := (*source).(*LevelFilterHandler); !isLevel {
+			*source = LevelHandler(level, *source)
+		}
+		// If this already was a list add a new logger to it
+		if ll, found := (*source).(*ListLogHandler); found {
+			ll.Add(handler)
+		} else {
+			*source = NewListLogHandler(*source, handler)
+		}
+	} else {
+		*source = handler
+	}
+}
+
+// For the multi handler set the handler, using the LogOptions defined
+func (h *CompositeMultiHandler) SetHandlers(handler LogHandler, options *LogOptions) {
+	if len(options.Levels) == 0 {
+		options.Levels = LvlAllList
+	}
+
+	// Set all levels
+	for _, lvl := range options.Levels {
+		h.SetHandler(handler, options.ReplaceExistingHandler, lvl)
+	}
+
+}
+func (h *CompositeMultiHandler) SetJson(writer io.Writer, options *LogOptions) {
+	handler := CallerFileHandler(StreamHandler(writer, JsonFormatEx(
+		options.GetBoolDefault("pretty", false),
+		options.GetBoolDefault("lineSeparated", true),
+	)))
+	if options.HandlerWrap != nil {
+		handler = options.HandlerWrap.SetChild(handler)
+	}
+	h.SetHandlers(handler, options)
+}
+
+// Use built in rolling function
+func (h *CompositeMultiHandler) SetJsonFile(filePath string, options *LogOptions) {
+	writer := &lumberjack.Logger{
+		Filename:   filePath,
+		MaxSize:    options.GetIntDefault("maxSizeMB", 1024), // megabytes
+		MaxAge:     options.GetIntDefault("maxAgeDays", 7),   //days
+		MaxBackups: options.GetIntDefault("maxBackups", 7),
+		Compress:   options.GetBoolDefault("compress", true),
+	}
+	h.SetJson(writer, options)
+}
+
+func (h *CompositeMultiHandler) SetTerminal(writer io.Writer, options *LogOptions) {
+	streamHandler := StreamHandler(
+		writer,
+		TerminalFormatHandler(
+			options.GetBoolDefault("noColor", false),
+			options.GetBoolDefault("smallDate", true)))
+
+	if os.Stdout == writer {
+		streamHandler = StreamHandler(
+			colorable.NewColorableStdout(),
+			TerminalFormatHandler(
+				options.GetBoolDefault("noColor", false),
+				options.GetBoolDefault("smallDate", true)))
+	} else if os.Stderr == writer {
+		streamHandler = StreamHandler(
+			colorable.NewColorableStderr(),
+			TerminalFormatHandler(
+				options.GetBoolDefault("noColor", false),
+				options.GetBoolDefault("smallDate", true)))
+	}
+	handler := CallerFileHandler(streamHandler)
+
+	if options.HandlerWrap != nil {
+		handler = options.HandlerWrap.SetChild(handler)
+	}
+	h.SetHandlers(handler, options)
+}
+
+// Use built in rolling function
+func (h *CompositeMultiHandler) SetTerminalFile(filePath string, options *LogOptions) {
+	writer := &lumberjack.Logger{
+		Filename:   filePath,
+		MaxSize:    options.GetIntDefault("maxSizeMB", 1024), // megabytes
+		MaxAge:     options.GetIntDefault("maxAgeDays", 7),   //days
+		MaxBackups: options.GetIntDefault("maxBackups", 7),
+		Compress:   options.GetBoolDefault("compress", true),
+	}
+	h.SetTerminal(writer, options)
+}
+
+func (h *CompositeMultiHandler) Disable(levels ...LogLevel) {
+	if len(levels) == 0 {
+		levels = LvlAllList
+	}
+	for _, level := range levels {
+		switch level {
+		case LvlDebug:
+			h.DebugHandler = nil
+		case LvlInfo:
+			h.InfoHandler = nil
+		case LvlWarn:
+			h.WarnHandler = nil
+		case LvlError:
+			h.ErrorHandler = nil
+		case LvlCrit:
+			h.CriticalHandler = nil
+		}
+	}
+}

logger/doc.go

@@ -3,8 +3,13 @@
   These facilities all currently use the logging library called log15 at
   https://github.com/inconshreveable/log15
 
-  Wrappers for the handlers are written here to provide a kind of isolation layer for Revel
-  in case sometime in the future we would like to switch to another source to implement logging
+	Defining handlers happens as follows
+	1) ALL handlers (log.all.output) replace any existing handlers
+	2) Output handlers (log.error.output) replace any existing handlers
+	3) Filter handlers (log.xxx.filter, log.xxx.nfilter) append to existing handlers,
+	   note log.all.filter is treated as a filter handler, so it will NOT replace existing ones
+
+
 
 */
 package logger

logger/handlers.go

@@ -1,82 +1,93 @@
 package logger
 
 import (
+	"fmt"
 	"io"
-	"os"
-
-	colorable "github.com/mattn/go-colorable"
-	"github.com/revel/log15"
-	"gopkg.in/natefinch/lumberjack.v2"
 )
 
+type LevelFilterHandler struct {
+	Level LogLevel
+	h     LogHandler
+}
+
 // Filters out records which do not match the level
 // Uses the `log15.FilterHandler` to perform this task
 func LevelHandler(lvl LogLevel, h LogHandler) LogHandler {
-	l15Lvl := log15.Lvl(lvl)
-	return log15.FilterHandler(func(r *log15.Record) (pass bool) {
-		return r.Lvl == l15Lvl
-	}, h)
+	return &LevelFilterHandler{lvl, h}
+}
+
+// The implementation of the Log
+func (h LevelFilterHandler) Log(r *Record) error {
+	if r.Level == h.Level {
+		return h.h.Log(r)
+	}
+	return nil
 }
 
 // Filters out records which do not match the level
 // Uses the `log15.FilterHandler` to perform this task
 func MinLevelHandler(lvl LogLevel, h LogHandler) LogHandler {
-	l15Lvl := log15.Lvl(lvl)
-	return log15.FilterHandler(func(r *log15.Record) (pass bool) {
-		return r.Lvl <= l15Lvl
+	return FilterHandler(func(r *Record) (pass bool) {
+		return r.Level <= lvl
 	}, h)
 }
 
 // Filters out records which match the level
 // Uses the `log15.FilterHandler` to perform this task
 func NotLevelHandler(lvl LogLevel, h LogHandler) LogHandler {
-	l15Lvl := log15.Lvl(lvl)
-	return log15.FilterHandler(func(r *log15.Record) (pass bool) {
-		return r.Lvl != l15Lvl
+	return FilterHandler(func(r *Record) (pass bool) {
+		return r.Level != lvl
 	}, h)
 }
 
-// Adds in a context called `caller` to the record (contains file name and line number like `foo.go:12`)
-// Uses the `log15.CallerFileHandler` to perform this task
 func CallerFileHandler(h LogHandler) LogHandler {
-	return log15.CallerFileHandler(h)
+	return FuncHandler(func(r *Record) error {
+		r.Context.Add("caller", fmt.Sprint(r.Call))
+		return h.Log(r)
+	})
 }
 
 // Adds in a context called `caller` to the record (contains file name and line number like `foo.go:12`)
 // Uses the `log15.CallerFuncHandler` to perform this task
 func CallerFuncHandler(h LogHandler) LogHandler {
-	return log15.CallerFuncHandler(h)
+	return CallerFuncHandler(h)
 }
 
 // Filters out records which match the key value pair
 // Uses the `log15.MatchFilterHandler` to perform this task
 func MatchHandler(key string, value interface{}, h LogHandler) LogHandler {
-	return log15.MatchFilterHandler(key, value, h)
+	return MatchFilterHandler(key, value, h)
+}
+
+// MatchFilterHandler returns a Handler that only writes records
+// to the wrapped Handler if the given key in the logged
+// context matches the value. For example, to only log records
+// from your ui package:
+//
+//    log.MatchFilterHandler("pkg", "app/ui", log.StdoutHandler)
+//
+func MatchFilterHandler(key string, value interface{}, h LogHandler) LogHandler {
+	return FilterHandler(func(r *Record) (pass bool) {
+		return r.Context[key] == value
+	}, h)
 }
 
 // If match then A handler is called otherwise B handler is called
 func MatchAbHandler(key string, value interface{}, a, b LogHandler) LogHandler {
-	return log15.FuncHandler(func(r *log15.Record) error {
-		for i := 0; i < len(r.Ctx); i += 2 {
-			if r.Ctx[i] == key {
-				if r.Ctx[i+1] == value {
-					if a != nil {
-						return a.Log(r)
-					}
-					return nil
-				}
-			}
-		}
-		if b != nil {
+	return FuncHandler(func(r *Record) error {
+		if r.Context[key] == value {
+			return a.Log(r)
+		} else if b != nil {
 			return b.Log(r)
 		}
+
 		return nil
 	})
 }
 
 // The nil handler is used if logging for a specific request needs to be turned off
 func NilHandler() LogHandler {
-	return log15.FuncHandler(func(r *log15.Record) error {
+	return FuncHandler(func(r *Record) error {
 		return nil
 	})
 }
@@ -93,80 +104,83 @@ func NotMatchMapHandler(matchMap map[string]interface{}, a LogHandler) LogHandle
 
 // Rather then chaining multiple filter handlers, process all here
 func matchMapHandler(matchMap map[string]interface{}, inverse bool, a LogHandler) LogHandler {
-	return log15.FuncHandler(func(r *log15.Record) error {
-		checkMap := map[string]bool{}
-		// Copy the map to a bool
-		for i := 0; i < len(r.Ctx); i += 2 {
-			if value, found := matchMap[r.Ctx[i].(string)]; found && value == r.Ctx[i+1] {
-				checkMap[r.Ctx[i].(string)] = true
+	return FuncHandler(func(r *Record) error {
+		matchCount := 0
+		for k, v := range matchMap {
+			value, found := r.Context[k]
+			if !found {
+				return nil
+			}
+			// Test for two failure cases
+			if value == v && inverse || value != v && !inverse {
+				return nil
+			} else {
+				matchCount++
 			}
 		}
-		if len(checkMap) == len(matchMap) {
-			if !inverse {
-				return a.Log(r)
-			}
-		} else if inverse {
-			return a.Log(r)
+		if matchCount != len(matchMap) {
+			return nil
 		}
-		return nil
+		return a.Log(r)
 	})
 }
 
 // Filters out records which do not match the key value pair
 // Uses the `log15.FilterHandler` to perform this task
 func NotMatchHandler(key string, value interface{}, h LogHandler) LogHandler {
-	return log15.FilterHandler(func(r *log15.Record) (pass bool) {
-		switch key {
-		case r.KeyNames.Lvl:
-			return r.Lvl != value
-		case r.KeyNames.Time:
-			return r.Time != value
-		case r.KeyNames.Msg:
-			return r.Msg != value
-		}
-
-		for i := 0; i < len(r.Ctx); i += 2 {
-			if r.Ctx[i] == key {
-				return r.Ctx[i+1] == value
-			}
-		}
-		return true
+	return FilterHandler(func(r *Record) (pass bool) {
+		return r.Context[key] != value
 	}, h)
 }
 
 func MultiHandler(hs ...LogHandler) LogHandler {
-	// Convert the log handlers to log15.Handlers
-	handlers := []log15.Handler{}
-	for _, h := range hs {
-		if h != nil {
-			handlers = append(handlers, h)
+	return FuncHandler(func(r *Record) error {
+		for _, h := range hs {
+			// what to do about failures?
+			h.Log(r)
 		}
-	}
-
-	return log15.MultiHandler(handlers...)
+		return nil
+	})
 }
 
-// Outputs the records to the passed in stream
-// Uses the `log15.StreamHandler` to perform this task
+// StreamHandler writes log records to an io.Writer
+// with the given format. StreamHandler can be used
+// to easily begin writing log records to other
+// outputs.
+//
+// StreamHandler wraps itself with LazyHandler and SyncHandler
+// to evaluate Lazy objects and perform safe concurrent writes.
 func StreamHandler(wr io.Writer, fmtr LogFormat) LogHandler {
-	return log15.StreamHandler(wr, fmtr)
+	h := FuncHandler(func(r *Record) error {
+		_, err := wr.Write(fmtr.Format(r))
+		return err
+	})
+	return LazyHandler(SyncHandler(h))
 }
 
-// Filter handler, this is the only
-// Uses the `log15.FilterHandler` to perform this task
-func FilterHandler(fn func(r *log15.Record) bool, h LogHandler) LogHandler {
-	return log15.FilterHandler(fn, h)
+// Filter handler
+func FilterHandler(fn func(r *Record) bool, h LogHandler) LogHandler {
+	return FuncHandler(func(r *Record) error {
+		if fn(r) {
+			return h.Log(r)
+		}
+		return nil
+	})
 }
 
+// List log handler handles a list of LogHandlers
 type ListLogHandler struct {
 	handlers []LogHandler
 }
 
+// Create a new list of log handlers
 func NewListLogHandler(h1, h2 LogHandler) *ListLogHandler {
 	ll := &ListLogHandler{handlers: []LogHandler{h1, h2}}
 	return ll
 }
-func (ll *ListLogHandler) Log(r *log15.Record) (err error) {
+
+// Log the record
+func (ll *ListLogHandler) Log(r *Record) (err error) {
 	for _, handler := range ll.handlers {
 		if err == nil {
 			err = handler.Log(r)
@@ -176,11 +190,15 @@ func (ll *ListLogHandler) Log(r *log15.Record) (err error) {
 	}
 	return
 }
+
+// Add another log handler
 func (ll *ListLogHandler) Add(h LogHandler) {
 	if h != nil {
 		ll.handlers = append(ll.handlers, h)
 	}
 }
+
+// Remove a log handler
 func (ll *ListLogHandler) Del(h LogHandler) {
 	if h != nil {
 		for i, handler := range ll.handlers {
@@ -190,161 +208,3 @@ func (ll *ListLogHandler) Del(h LogHandler) {
 		}
 	}
 }
-
-type CompositeMultiHandler struct {
-	DebugHandler    LogHandler
-	InfoHandler     LogHandler
-	WarnHandler     LogHandler
-	ErrorHandler    LogHandler
-	CriticalHandler LogHandler
-}
-
-func NewCompositeMultiHandler() (*CompositeMultiHandler, LogHandler) {
-	cw := &CompositeMultiHandler{}
-	return cw, cw
-}
-func (h *CompositeMultiHandler) Log(r *log15.Record) (err error) {
-
-	var handler LogHandler
-	switch r.Lvl {
-	case log15.LvlInfo:
-		handler = h.InfoHandler
-	case log15.LvlDebug:
-		handler = h.DebugHandler
-	case log15.LvlWarn:
-		handler = h.WarnHandler
-	case log15.LvlError:
-		handler = h.ErrorHandler
-	case log15.LvlCrit:
-		handler = h.CriticalHandler
-	}
-
-	// Embed the caller function in the context
-	if handler != nil {
-		handler.Log(r)
-	}
-	return
-}
-func (h *CompositeMultiHandler) SetHandler(handler LogHandler, replace bool, level LogLevel) {
-	if handler == nil {
-		// Ignore empty handler
-		return
-	}
-	source := &h.DebugHandler
-	switch level {
-	case LvlDebug:
-		source = &h.DebugHandler
-	case LvlInfo:
-		source = &h.InfoHandler
-	case LvlWarn:
-		source = &h.WarnHandler
-	case LvlError:
-		source = &h.ErrorHandler
-	case LvlCrit:
-		source = &h.CriticalHandler
-	}
-
-	if !replace && *source != nil {
-		// If this already was a list add a new logger to it
-		if ll, found := (*source).(*ListLogHandler); found {
-			ll.Add(handler)
-		} else {
-			*source = NewListLogHandler(*source, handler)
-		}
-	} else {
-		*source = handler
-	}
-}
-
-func (h *CompositeMultiHandler) SetHandlers(handler LogHandler, options *LogOptions) {
-	if len(options.Levels) == 0 {
-		options.Levels = LvlAllList
-	}
-	// Set all levels
-	for _, lvl := range options.Levels {
-		h.SetHandler(handler, options.ReplaceExistingHandler, lvl)
-	}
-
-}
-func (h *CompositeMultiHandler) SetJson(writer io.Writer, options *LogOptions) {
-	handler := CallerFileHandler(StreamHandler(writer, log15.JsonFormatEx(
-		options.GetBoolDefault("pretty", false),
-		options.GetBoolDefault("lineSeparated", true),
-	)))
-	if options.HandlerWrap != nil {
-		handler = options.HandlerWrap.SetChild(handler)
-	}
-	h.SetHandlers(handler, options)
-}
-
-// Use built in rolling function
-func (h *CompositeMultiHandler) SetJsonFile(filePath string, options *LogOptions) {
-	writer := &lumberjack.Logger{
-		Filename:   filePath,
-		MaxSize:    options.GetIntDefault("maxSizeMB", 1024), // megabytes
-		MaxAge:     options.GetIntDefault("maxAgeDays", 7),   //days
-		MaxBackups: options.GetIntDefault("maxBackups", 7),
-		Compress:   options.GetBoolDefault("compress", true),
-	}
-	h.SetJson(writer, options)
-}
-
-func (h *CompositeMultiHandler) SetTerminal(writer io.Writer, options *LogOptions) {
-	streamHandler := StreamHandler(
-		writer,
-		TerminalFormatHandler(
-			options.GetBoolDefault("noColor", false),
-			options.GetBoolDefault("smallDate", true)))
-
-	if os.Stdout == writer {
-		streamHandler = StreamHandler(
-			colorable.NewColorableStdout(),
-			TerminalFormatHandler(
-				options.GetBoolDefault("noColor", false),
-				options.GetBoolDefault("smallDate", true)))
-	} else if os.Stderr == writer {
-		streamHandler = StreamHandler(
-			colorable.NewColorableStderr(),
-			TerminalFormatHandler(
-				options.GetBoolDefault("noColor", false),
-				options.GetBoolDefault("smallDate", true)))
-	}
-
-	handler := CallerFileHandler(streamHandler)
-	if options.HandlerWrap != nil {
-		handler = options.HandlerWrap.SetChild(handler)
-	}
-	h.SetHandlers(handler, options)
-}
-
-// Use built in rolling function
-func (h *CompositeMultiHandler) SetTerminalFile(filePath string, options *LogOptions) {
-	writer := &lumberjack.Logger{
-		Filename:   filePath,
-		MaxSize:    options.GetIntDefault("maxSizeMB", 1024), // megabytes
-		MaxAge:     options.GetIntDefault("maxAgeDays", 7),   //days
-		MaxBackups: options.GetIntDefault("maxBackups", 7),
-		Compress:   options.GetBoolDefault("compress", true),
-	}
-	h.SetTerminal(writer, options)
-}
-
-func (h *CompositeMultiHandler) Disable(levels ...LogLevel) {
-	if len(levels) == 0 {
-		levels = LvlAllList
-	}
-	for _, level := range levels {
-		switch level {
-		case LvlDebug:
-			h.DebugHandler = nil
-		case LvlInfo:
-			h.InfoHandler = nil
-		case LvlWarn:
-			h.WarnHandler = nil
-		case LvlError:
-			h.ErrorHandler = nil
-		case LvlCrit:
-			h.CriticalHandler = nil
-		}
-	}
-}

logger/init.go

@@ -0,0 +1,189 @@
+package logger
+
+// Get all handlers based on the Config (if available)
+import (
+	"fmt"
+	"github.com/revel/config"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func InitializeFromConfig(basePath string, config *config.Context) (c *CompositeMultiHandler) {
+	// If running in test mode suppress anything that is not an error
+	if config != nil && config.BoolDefault(TEST_MODE_FLAG, false) {
+		// Preconfigure all the options
+		config.SetOption("log.info.output", "none")
+		config.SetOption("log.debug.output", "none")
+		config.SetOption("log.warn.output", "none")
+		config.SetOption("log.error.output", "stderr")
+		config.SetOption("log.crit.output", "stderr")
+	}
+
+	// If the configuration has an all option we can skip some
+	c, _ = NewCompositeMultiHandler()
+
+	// Filters are assigned first, non filtered items override filters
+	if config != nil && !config.BoolDefault(TEST_MODE_FLAG, false) {
+		initAllLog(c, basePath, config)
+	}
+	initLogLevels(c, basePath, config)
+	if c.CriticalHandler == nil && c.ErrorHandler != nil {
+		c.CriticalHandler = c.ErrorHandler
+	}
+	if config != nil && !config.BoolDefault(TEST_MODE_FLAG, false) {
+		initFilterLog(c, basePath, config)
+		if c.CriticalHandler == nil && c.ErrorHandler != nil {
+			c.CriticalHandler = c.ErrorHandler
+		}
+		initRequestLog(c, basePath, config)
+	}
+
+	return c
+}
+
+// Init the log.all configuration options
+func initAllLog(c *CompositeMultiHandler, basePath string, config *config.Context) {
+	if config != nil {
+		extraLogFlag := config.BoolDefault(SPECIAL_USE_FLAG, false)
+		if output, found := config.String("log.all.output"); found {
+			// Set all output for the specified handler
+			if extraLogFlag {
+				log.Printf("Adding standard handler for levels to >%s< ", output)
+			}
+			initHandlerFor(c, output, basePath, NewLogOptions(config, true, nil, LvlAllList...))
+		}
+	}
+}
+
+// Init the filter options
+// log.all.filter ....
+// log.error.filter ....
+func initFilterLog(c *CompositeMultiHandler, basePath string, config *config.Context) {
+
+	if config != nil {
+		extraLogFlag := config.BoolDefault(SPECIAL_USE_FLAG, false)
+
+		for _, logFilter := range logFilterList {
+			// Init for all filters
+			for _, name := range []string{"all", "debug", "info", "warn", "error", "crit",
+				"trace", // TODO trace is deprecated
+			} {
+				optionList := config.Options(logFilter.LogPrefix + name + logFilter.LogSuffix)
+				for _, option := range optionList {
+					splitOptions := strings.Split(option, ".")
+					keyMap := map[string]interface{}{}
+					for x := 3; x < len(splitOptions); x += 2 {
+						keyMap[splitOptions[x]] = splitOptions[x+1]
+					}
+					phandler := logFilter.parentHandler(keyMap)
+					if extraLogFlag {
+						log.Printf("Adding key map handler %s %s output %s", option, name, config.StringDefault(option, ""))
+						fmt.Printf("Adding key map handler %s %s output %s matching %#v\n", option, name, config.StringDefault(option, ""), keyMap)
+					}
+
+					if name == "all" {
+						initHandlerFor(c, config.StringDefault(option, ""), basePath, NewLogOptions(config, false, phandler))
+					} else {
+						initHandlerFor(c, config.StringDefault(option, ""), basePath, NewLogOptions(config, false, phandler, toLevel[name]))
+					}
+				}
+			}
+		}
+	}
+}
+
+// Init the log.error, log.warn etc configuration options
+func initLogLevels(c *CompositeMultiHandler, basePath string, config *config.Context) {
+	for _, name := range []string{"debug", "info", "warn", "error", "crit",
+		"trace", // TODO trace is deprecated
+	} {
+		if config != nil {
+			extraLogFlag := config.BoolDefault(SPECIAL_USE_FLAG, false)
+			output, found := config.String("log." + name + ".output")
+			if found {
+				if extraLogFlag {
+					log.Printf("Adding standard handler %s output %s", name, output)
+				}
+				initHandlerFor(c, output, basePath, NewLogOptions(config, true, nil, toLevel[name]))
+			}
+			// Gets the list of options with said prefix
+		} else {
+			initHandlerFor(c, "stderr", basePath, NewLogOptions(config, true, nil, toLevel[name]))
+		}
+	}
+}
+
+// Init the request log options
+func initRequestLog(c *CompositeMultiHandler, basePath string, config *config.Context) {
+	// Request logging to a separate output handler
+	// This takes the InfoHandlers and adds a MatchAbHandler handler to it to direct
+	// context with the word "section=requestlog" to that handler.
+	// Note if request logging is not enabled the MatchAbHandler will not be added and the
+	// request log messages will be sent out the INFO handler
+	outputRequest := "stdout"
+	if config != nil {
+		outputRequest = config.StringDefault("log.request.output", "")
+	}
+	oldInfo := c.InfoHandler
+	c.InfoHandler = nil
+	if outputRequest != "" {
+		initHandlerFor(c, outputRequest, basePath, NewLogOptions(config, false, nil, LvlInfo))
+	}
+	if c.InfoHandler != nil || oldInfo != nil {
+		if c.InfoHandler == nil {
+			c.InfoHandler = oldInfo
+		} else {
+			c.InfoHandler = MatchAbHandler("section", "requestlog", c.InfoHandler, oldInfo)
+		}
+	}
+}
+
+// Returns a handler for the level using the output string
+// Accept formats for output string are
+// LogFunctionMap[value] callback function
+// `stdout` `stderr` `full/file/path/to/location/app.log` `full/file/path/to/location/app.json`
+func initHandlerFor(c *CompositeMultiHandler, output, basePath string, options *LogOptions) {
+	if options.Ctx != nil {
+		options.SetExtendedOptions(
+			"noColor", !options.Ctx.BoolDefault("log.colorize", true),
+			"smallDate", options.Ctx.BoolDefault("log.smallDate", true),
+			"maxSize", options.Ctx.IntDefault("log.maxsize", 1024*10),
+			"maxAge", options.Ctx.IntDefault("log.maxage", 14),
+			"maxBackups", options.Ctx.IntDefault("log.maxbackups", 14),
+			"compressBackups", !options.Ctx.BoolDefault("log.compressBackups", true),
+		)
+	}
+
+	output = strings.TrimSpace(output)
+	if funcHandler, found := LogFunctionMap[output]; found {
+		funcHandler(c, options)
+	} else {
+		switch output {
+		case "":
+			fallthrough
+		case "off":
+		// No handler, discard data
+		default:
+			// Write to file specified
+			if !filepath.IsAbs(output) {
+				output = filepath.Join(basePath, output)
+			}
+
+			if err := os.MkdirAll(filepath.Dir(output), 0755); err != nil {
+				log.Panic(err)
+			}
+
+			if strings.HasSuffix(output, "json") {
+				c.SetJsonFile(output, options)
+			} else {
+				// Override defaults for a terminal file
+				options.SetExtendedOptions("noColor", true)
+				options.SetExtendedOptions("smallDate", false)
+				c.SetTerminalFile(output, options)
+			}
+		}
+	}
+	return
+}

logger/init_test.go

@@ -0,0 +1,273 @@
+// Copyright (c) 2012-2018 The Revel Framework Authors, All rights reserved.
+// Revel Framework source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package logger_test
+
+import (
+	"github.com/revel/config"
+	"github.com/revel/revel/logger"
+	"github.com/stretchr/testify/assert"
+	"os"
+	"strings"
+	"testing"
+)
+
+type (
+	// A counter for the tester
+	testCounter struct {
+		debug, info, warn, error, critical int
+	}
+	// The data to tes
+	testData struct {
+		config []string
+		result testResult
+		tc     *testCounter
+	}
+	// The test result
+	testResult struct {
+		debug, info, warn, error, critical int
+	}
+)
+
+// Single test cases
+var singleCases = []testData{
+	{config: []string{"log.crit.output"},
+		result: testResult{0, 0, 0, 0, 1}},
+	{config: []string{"log.error.output"},
+		result: testResult{0, 0, 0, 1, 1}},
+	{config: []string{"log.warn.output"},
+		result: testResult{0, 0, 1, 0, 0}},
+	{config: []string{"log.info.output"},
+		result: testResult{0, 1, 0, 0, 0}},
+	{config: []string{"log.debug.output"},
+		result: testResult{1, 0, 0, 0, 0}},
+}
+
+// Test singles
+func TestSingleCases(t *testing.T) {
+	rootLog := logger.New()
+	for _, testCase := range singleCases {
+		testCase.logTest(rootLog, t)
+		testCase.validate(t)
+	}
+}
+
+// Filter test cases
+var filterCases = []testData{
+	{config: []string{"log.crit.filter.module.app"},
+		result: testResult{0, 0, 0, 0, 1}},
+	{config: []string{"log.crit.filter.module.appa"},
+		result: testResult{0, 0, 0, 0, 0}},
+	{config: []string{"log.error.filter.module.app"},
+		result: testResult{0, 0, 0, 1, 1}},
+	{config: []string{"log.error.filter.module.appa"},
+		result: testResult{0, 0, 0, 0, 0}},
+	{config: []string{"log.warn.filter.module.app"},
+		result: testResult{0, 0, 1, 0, 0}},
+	{config: []string{"log.warn.filter.module.appa"},
+		result: testResult{0, 0, 0, 0, 0}},
+	{config: []string{"log.info.filter.module.app"},
+		result: testResult{0, 1, 0, 0, 0}},
+	{config: []string{"log.info.filter.module.appa"},
+		result: testResult{0, 0, 0, 0, 0}},
+	{config: []string{"log.debug.filter.module.app"},
+		result: testResult{1, 0, 0, 0, 0}},
+	{config: []string{"log.debug.filter.module.appa"},
+		result: testResult{0, 0, 0, 0, 0}},
+}
+
+// Filter test
+func TestFilterCases(t *testing.T) {
+	rootLog := logger.New("module", "app")
+	for _, testCase := range filterCases {
+		testCase.logTest(rootLog, t)
+		testCase.validate(t)
+	}
+}
+
+// Inverse test cases
+var nfilterCases = []testData{
+	{config: []string{"log.crit.nfilter.module.appa"},
+		result: testResult{0, 0, 0, 0, 1}},
+	{config: []string{"log.crit.nfilter.modules.appa"},
+		result: testResult{0, 0, 0, 0, 0}},
+	{config: []string{"log.crit.nfilter.module.app"},
+		result: testResult{0, 0, 0, 0, 0}},
+	{config: []string{"log.error.nfilter.module.appa"}, // Special case, when error is not nill critical inherits from error
+		result: testResult{0, 0, 0, 1, 1}},
+	{config: []string{"log.error.nfilter.module.app"},
+		result: testResult{0, 0, 0, 0, 0}},
+	{config: []string{"log.warn.nfilter.module.appa"},
+		result: testResult{0, 0, 1, 0, 0}},
+	{config: []string{"log.warn.nfilter.module.app"},
+		result: testResult{0, 0, 0, 0, 0}},
+	{config: []string{"log.info.nfilter.module.appa"},
+		result: testResult{0, 1, 0, 0, 0}},
+	{config: []string{"log.info.nfilter.module.app"},
+		result: testResult{0, 0, 0, 0, 0}},
+	{config: []string{"log.debug.nfilter.module.appa"},
+		result: testResult{1, 0, 0, 0, 0}},
+	{config: []string{"log.debug.nfilter.module.app"},
+		result: testResult{0, 0, 0, 0, 0}},
+}
+
+// Inverse test
+func TestNotFilterCases(t *testing.T) {
+	rootLog := logger.New("module", "app")
+	for _, testCase := range nfilterCases {
+		testCase.logTest(rootLog, t)
+		testCase.validate(t)
+	}
+}
+
+// off test cases
+var offCases = []testData{
+	{config: []string{"log.all.output", "log.error.output=off"},
+		result: testResult{1, 1, 1, 0, 1}},
+}
+
+// Off test
+func TestOffCases(t *testing.T) {
+	rootLog := logger.New("module", "app")
+	for _, testCase := range offCases {
+		testCase.logTest(rootLog, t)
+		testCase.validate(t)
+	}
+}
+
+// Duplicate test cases
+var duplicateCases = []testData{
+	{config: []string{"log.all.output", "log.error.output", "log.error.filter.module.app"},
+		result: testResult{1, 1, 1, 2, 1}},
+}
+
+// test duplicate cases
+func TestDuplicateCases(t *testing.T) {
+	rootLog := logger.New("module", "app")
+	for _, testCase := range duplicateCases {
+		testCase.logTest(rootLog, t)
+		testCase.validate(t)
+	}
+}
+
+// Contradicting cases
+var contradictCases = []testData{
+	{config: []string{"log.all.output", "log.error.output=off", "log.all.output"},
+		result: testResult{1, 1, 1, 0, 1}},
+	{config: []string{"log.all.output", "log.error.output=off", "log.debug.filter.module.app"},
+		result: testResult{2, 1, 1, 0, 1}},
+	{config: []string{"log.all.filter.module.app", "log.info.output=off", "log.info.filter.module.app"},
+		result: testResult{1, 2, 1, 1, 1}},
+	{config: []string{"log.all.output", "log.info.output=off", "log.info.filter.module.app"},
+		result: testResult{1, 1, 1, 1, 1}},
+}
+
+// Contradiction test
+func TestContradictCases(t *testing.T) {
+	rootLog := logger.New("module", "app")
+	for _, testCase := range contradictCases {
+		testCase.logTest(rootLog, t)
+		testCase.validate(t)
+	}
+}
+
+// All test cases
+var allCases = []testData{
+	{config: []string{"log.all.filter.module.app"},
+		result: testResult{1, 1, 1, 1, 1}},
+	{config: []string{"log.all.output"},
+		result: testResult{2, 2, 2, 2, 2}},
+}
+
+// All tests
+func TestAllCases(t *testing.T) {
+	rootLog := logger.New("module", "app")
+	for i, testCase := range allCases {
+		testCase.logTest(rootLog, t)
+		allCases[i] = testCase
+	}
+	rootLog = logger.New()
+	for i, testCase := range allCases {
+		testCase.logTest(rootLog, t)
+		allCases[i] = testCase
+	}
+	for _, testCase := range allCases {
+		testCase.validate(t)
+	}
+
+}
+
+func (c *testCounter) Log(r *logger.Record) error {
+	switch r.Level {
+	case logger.LvlDebug:
+		c.debug++
+	case logger.LvlInfo:
+		c.info++
+	case logger.LvlWarn:
+		c.warn++
+	case logger.LvlError:
+		c.error++
+	case logger.LvlCrit:
+		c.critical++
+	default:
+		panic("Unknown log level")
+	}
+	return nil
+}
+func (td *testData) logTest(rootLog logger.MultiLogger, t *testing.T) {
+	if td.tc == nil {
+		td.tc = &testCounter{}
+		counterInit(td.tc)
+	}
+	newContext := config.NewContext()
+	for _, i := range td.config {
+		iout := strings.Split(i, "=")
+		if len(iout) > 1 {
+			newContext.SetOption(iout[0], iout[1])
+		} else {
+			newContext.SetOption(i, "test")
+		}
+	}
+
+	newContext.SetOption("specialUseFlag", "true")
+
+	handler := logger.InitializeFromConfig("test", newContext)
+
+	rootLog.SetHandler(handler)
+
+	td.runLogTest(rootLog)
+}
+
+func (td *testData) runLogTest(log logger.MultiLogger) {
+	log.Debug("test")
+	log.Info("test")
+	log.Warn("test")
+	log.Error("test")
+	log.Crit("test")
+}
+
+func (td *testData) validate(t *testing.T) {
+	t.Logf("Test %#v expected %#v", td.tc, td.result)
+	assert.Equal(t, td.result.debug, td.tc.debug, "Debug failed "+strings.Join(td.config, " "))
+	assert.Equal(t, td.result.info, td.tc.info, "Info failed "+strings.Join(td.config, " "))
+	assert.Equal(t, td.result.warn, td.tc.warn, "Warn failed "+strings.Join(td.config, " "))
+	assert.Equal(t, td.result.error, td.tc.error, "Error failed "+strings.Join(td.config, " "))
+	assert.Equal(t, td.result.critical, td.tc.critical, "Critical failed "+strings.Join(td.config, " "))
+}
+
+// Add test to the function map
+func counterInit(tc *testCounter) {
+	logger.LogFunctionMap["test"] = func(c *logger.CompositeMultiHandler, logOptions *logger.LogOptions) {
+		// Output to the test log and the stdout
+		outHandler := logger.LogHandler(
+			logger.NewListLogHandler(tc,
+				logger.StreamHandler(os.Stdout, logger.TerminalFormatHandler(false, true))),
+		)
+		if logOptions.HandlerWrap != nil {
+			outHandler = logOptions.HandlerWrap.SetChild(outHandler)
+		}
+
+		c.SetHandlers(outHandler, logOptions)
+	}
+}

logger/log.go.old

@@ -1,656 +0,0 @@
-package logger
-
-
-// LoggedError is wrapper to differentiate logged panics from unexpected ones.
-import (
-	"os"
-	"fmt"
-	"strings"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-	"sync"
-	"go.uber.org/zap/buffer"
-	"time"
-	"encoding/base64"
-	"unicode/utf8"
-	"encoding/json"
-	"math"
-
-	"io"
-)
-
-type (
-	MultiLogger interface {
-		//log15.Logger
-		//// New returns a new Logger that has this logger's context plus the given context
-		New(ctx ...interface{}) MultiLogger
-		//
-		// The encoders job is to encode the
-		SetHandler(h LogHandler)
-		SetStackDepth(int) MultiLogger
-		//
-		//// Log a message at the given level with context key/value pairs
-		Debug(msg string, ctx ...interface{})
-		Debugf(msg string, params ...interface{})
-		Info(msg string, ctx ...interface{})
-		Infof(msg string, params ...interface{})
-		Warn(msg string, ctx ...interface{})
-		Warnf(msg string, params ...interface{})
-		Error(msg string, ctx ...interface{})
-		Errorf(msg string, params ...interface{})
-		Crit(msg string, ctx ...interface{})
-		Critf(msg string, params ...interface{})
-
-		//// Logs a message as an Crit and exits
-		Fatal(msg string, ctx ...interface{})
-		Fatalf(msg string, params ...interface{})
-		//// Logs a message as an Crit and panics
-		Panic(msg string, ctx ...interface{})
-		Panicf(msg string, params ...interface{})
-	}
-
-	// The log han
-	LogHandler interface {
-		Encode(Record) ([]byte, error)
-		GetLevel() Level
-		GetWriter() io.Writer
-	}
-
-	// The Record
-	Record struct {
-		Level      Level
-		Time       time.Time
-		LoggerName string
-		Message    string
-		Caller     EntryCaller
-		Stack      string
-    Context    []Field
-}
-
-	// The fields passed in
-	Field interface {
-		GetKey() string
-		GetValueAsString() string
-		GetValue() interface{}
-	}
-
-	EntryCaller interface {
-		IsDefined() bool
-		GetPC() uintptr
-		GetFile() string
-		GetLine() int
-	}
-
-	// Called only if the logger needs
-	ResolveLaterLogger func() interface{}
-
-	FieldType int
-	Level int
-)
-
-type (
-	zapLogger struct {
-		logger *zap.SugaredLogger
-		coreList []*zapcore.Core
-	}
-	zapField struct {
-		Key       string
-		Type      FieldType
-		Integer   int64
-		String    string
-		Interface interface{}
-	}
-	zapEntryCaller struct {
-		Defined bool
-		PC      uintptr
-		File    string
-		Line    int
-	}
-	zapEncoder struct {
-		lh LogHandler
-	}
-)
-
-func newLogger(addCaller bool) MultiLogger {
-	logger := zap.New(nil).WithOptions(zap.AddCaller())
-	l := &zapLogger{logger:logger.Sugar()}
-
-	return l
-}
-
-// It is up to the handler to determine the synchronization to the output
-// streams
-func (z *zapLogger) SetHandler(lh LogHandler) {
-	// Swap out the logger when a new handler is attached
-	encoder := &zapEncoder{lh}
-	levelHandler := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
-		return  lvl >= zapcore.Level(lh.GetLevel())
-	})
-	logger := zap.New(zapcore.NewCore(encoder, nil, levelHandler)).WithOptions(zap.AddCaller())
-	Logger.With("foo","bar").Desugar().Core()
-}
-
-var Logger *zap.SugaredLogger
-
-func InitLogger(logLevel zapcore.Level) {
-	config :=zap.NewDevelopmentEncoderConfig()
-	config.EncodeLevel = zapcore.CapitalColorLevelEncoder
-
-	consoleEncoder := NewConsoleEncoder(config)
-	lowPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
-		return  lvl >= logLevel
-	})
-
-	consoleDebugging := zapcore.Lock(os.Stdout)
-	core := zapcore.NewTee(
-		zapcore.NewCore(consoleEncoder, consoleDebugging, lowPriority),
-	)
-	logger := zap.New(core).WithOptions(zap.AddCaller())
-	Logger = logger.Sugar()
-}
-type LoggedError struct{ error }
-
-func NewLoggedError(err error) *LoggedError {
-	return &LoggedError{err}
-}
-
-func Errorf(format string, args ...interface{}) {
-	// Ensure the user's command prompt starts on the next line.
-	if !strings.HasSuffix(format, "\n") {
-		format += "\n"
-	}
-	fmt.Fprintf(os.Stderr, format, args...)
-	panic(format) // Panic instead of os.Exit so that deferred will run.
-}
-
-
-
-// This is all for the Console logger - a little wordy but it works
-
-var _sliceEncoderPool = sync.Pool{
-	New: func() interface{} {
-		return &sliceArrayEncoder{elems: make([]interface{}, 0, 2)}
-	},
-}
-
-func getSliceEncoder() *sliceArrayEncoder {
-	return _sliceEncoderPool.Get().(*sliceArrayEncoder)
-}
-
-func putSliceEncoder(e *sliceArrayEncoder) {
-	e.elems = e.elems[:0]
-	_sliceEncoderPool.Put(e)
-}
-
-type consoleEncoder struct {
-	*zapcore.EncoderConfig
-	openNamespaces int
-	buf            *buffer.Buffer
-	reflectBuf *buffer.Buffer
-	reflectEnc *json.Encoder
-}
-
-var (
-	_pool = buffer.NewPool()
-	// Get retrieves a buffer from the pool, creating one if necessary.
-	Get = _pool.Get
-)
-
-
-// NewConsoleEncoder creates an encoder whose output is designed for human -
-// rather than machine - consumption. It serializes the core log entry data
-// (message, level, timestamp, etc.) in a plain-text format and leaves the
-// structured context as JSON.
-//
-// Note that although the console encoder doesn't use the keys specified in the
-// encoder configuration, it will omit any element whose key is set to the empty
-// string.
-func NewConsoleEncoder(cfg zapcore.EncoderConfig) zapcore.Encoder {
-	ec := &consoleEncoder{buf : Get(), reflectBuf: Get()}
-	ec.EncoderConfig = &cfg
-	return ec
-}
-
-func (c consoleEncoder) Clone() zapcore.Encoder {
-	return &consoleEncoder{buf : Get(), reflectBuf: Get()}
-}
-
-func (c consoleEncoder) EncodeEntry(ent zapcore.Entry, fields []zapcore.Field) (*buffer.Buffer, error) {
-	line := Get()
-
-	var color = 0
-	switch ent.Level {
-	case zap.PanicLevel:
-		// Magenta
-		color = 35
-	case zap.ErrorLevel:
-		// Red
-		color = 31
-	case zap.WarnLevel:
-		// Yellow
-		color = 33
-	case zap.InfoLevel:
-		// Green
-		color = 32
-	case zap.DebugLevel:
-		// Cyan
-		color = 36
-	}
-
-	// We don't want the entry's metadata to be quoted and escaped (if it's
-	// encoded as strings), which means that we can't use the JSON encoder. The
-	// simplest option is to use the memory encoder and fmt.Fprint.
-	//
-	// If this ever becomes a performance bottleneck, we can implement
-	// ArrayEncoder for our plain-text format.
-	arr := getSliceEncoder()
-	if c.LevelKey != "" && c.EncodeLevel != nil {
-		arr.AppendString(fmt.Sprintf("\x1b[%dm%-5s\x1b[0m",color,ent.Level.CapitalString()))
-	}
-	if ent.LoggerName != "" && c.NameKey != "" {
-		nameEncoder := c.EncodeName
-
-		if nameEncoder == nil {
-			// Fall back to FullNameEncoder for backward compatibility.
-			nameEncoder = zapcore.FullNameEncoder
-		}
-
-		nameEncoder(ent.LoggerName, arr)
-	}
-	if c.TimeKey != "" && c.EncodeTime != nil {
-		arr.AppendString(ent.Time.Format("15:04:05"))
-	}
-
-	if ent.Caller.Defined && c.CallerKey != "" && c.EncodeCaller != nil {
-		c.EncodeCaller(ent.Caller, arr)
-	}
-	for i := range arr.elems {
-		if i > 0 {
-			line.AppendByte(' ')
-		}
-		fmt.Fprint(line, arr.elems[i])
-	}
-	putSliceEncoder(arr)
-
-	// Add the message itself.
-	if c.MessageKey != "" {
-		c.addTabIfNecessary(line)
-		line.AppendString(ent.Message)
-	}
-
-	// Add any structured context.
-	 c.writeContext(line, fields)
-
-	// If there's no stacktrace key, honor that; this allows users to force
-	// single-line output.
-	if ent.Stack != "" && c.StacktraceKey != "" {
-		line.AppendByte('\n')
-		line.AppendString(ent.Stack)
-	}
-
-	if c.LineEnding != "" {
-		line.AppendString(c.LineEnding)
-	} else {
-		line.AppendString(zapcore.DefaultLineEnding)
-	}
-	return line, nil
-}
-
-func (c consoleEncoder) writeContext(line *buffer.Buffer, extra []zapcore.Field) {
-	context := c.Clone().(*consoleEncoder)
-	defer context.buf.Free()
-	//
-	addFields(context, extra)
-	context.closeOpenNamespaces()
-	if context.buf.Len() == 0 {
-		return
-	}
-	//
-	line.Write(context.buf.Bytes())
-}
-func addFields(enc zapcore.ObjectEncoder, fields []zapcore.Field) {
-	for i := range fields {
-		fields[i].AddTo(enc)
-	}
-}
-
-
-func (c consoleEncoder) addTabIfNecessary(line *buffer.Buffer) {
-	if line.Len() > 0 {
-		line.AppendByte('\t')
-	}
-}
-
-
-func (enc *consoleEncoder) AddArray(key string, arr zapcore.ArrayMarshaler) error {
-	enc.addKey(key)
-	return enc.AppendArray(arr)
-}
-
-func (enc *consoleEncoder) AddObject(key string, obj zapcore.ObjectMarshaler) error {
-	enc.addKey(key)
-	return enc.AppendObject(obj)
-}
-
-func (enc *consoleEncoder) AddBinary(key string, val []byte) {
-	enc.AddString(key, base64.StdEncoding.EncodeToString(val))
-}
-
-func (enc *consoleEncoder) AddByteString(key string, val []byte) {
-	enc.addKey(key)
-	enc.AppendByteString(val)
-}
-
-func (enc *consoleEncoder) AddBool(key string, val bool) {
-	enc.addKey(key)
-	enc.AppendBool(val)
-}
-
-func (enc *consoleEncoder) AddComplex128(key string, val complex128) {
-	enc.addKey(key)
-	enc.AppendComplex128(val)
-}
-
-func (enc *consoleEncoder) AddDuration(key string, val time.Duration) {
-	enc.addKey(key)
-	enc.AppendDuration(val)
-}
-
-func (enc *consoleEncoder) AddFloat64(key string, val float64) {
-	enc.addKey(key)
-	enc.AppendFloat64(val)
-}
-
-func (enc *consoleEncoder) AddInt64(key string, val int64) {
-	enc.addKey(key)
-	enc.AppendInt64(val)
-}
-
-func (enc *consoleEncoder) AddReflected(key string, obj interface{}) error {
-	enc.resetReflectBuf()
-	err := enc.reflectEnc.Encode(obj)
-	if err != nil {
-		return err
-	}
-	enc.reflectBuf.TrimNewline()
-	enc.addKey(key)
-	_, err = enc.buf.Write(enc.reflectBuf.Bytes())
-	return err
-}
-
-func (enc *consoleEncoder) OpenNamespace(key string) {
-	enc.addKey(key)
-	enc.buf.AppendByte('{')
-	enc.openNamespaces++
-}
-
-func (enc *consoleEncoder) AddString(key, val string) {
-	enc.addKey(key)
-	enc.AppendString(val)
-}
-
-func (enc *consoleEncoder) AddTime(key string, val time.Time) {
-	enc.addKey(key)
-	enc.AppendTime(val)
-}
-
-func (enc *consoleEncoder) AddUint64(key string, val uint64) {
-	enc.addKey(key)
-	enc.AppendUint64(val)
-}
-
-func (enc *consoleEncoder) addKey(key string) {
-	// Print key in different color
-	enc.buf.AppendString(fmt.Sprintf(" \x1b[%dm%s\x1b[0m",36,key))
-
-	enc.buf.AppendByte('=')
-}
-
-func (enc *consoleEncoder) AppendArray(arr zapcore.ArrayMarshaler) error {
-	enc.buf.AppendByte('[')
-	err := arr.MarshalLogArray(enc)
-	enc.buf.AppendByte(']')
-	return err
-}
-
-func (enc *consoleEncoder) AppendObject(obj zapcore.ObjectMarshaler) error {
-	enc.buf.AppendByte('{')
-	err := obj.MarshalLogObject(enc)
-	enc.buf.AppendByte('}')
-	return err
-}
-
-func (enc *consoleEncoder) AppendBool(val bool) {
-	enc.buf.AppendBool(val)
-}
-
-func (enc *consoleEncoder) AppendByteString(val []byte) {
-	enc.buf.AppendByte('"')
-	enc.safeAddByteString(val)
-	enc.buf.AppendByte('"')
-}
-
-func (enc *consoleEncoder) AppendComplex128(val complex128) {
-	// Cast to a platform-independent, fixed-size type.
-	r, i := float64(real(val)), float64(imag(val))
-	enc.buf.AppendByte('"')
-	// Because we're always in a quoted string, we can use strconv without
-	// special-casing NaN and +/-Inf.
-	enc.buf.AppendFloat(r, 64)
-	enc.buf.AppendByte('+')
-	enc.buf.AppendFloat(i, 64)
-	enc.buf.AppendByte('i')
-	enc.buf.AppendByte('"')
-}
-
-func (enc *consoleEncoder) AppendDuration(val time.Duration) {
-	cur := enc.buf.Len()
-	enc.EncodeDuration(val, enc)
-	if cur == enc.buf.Len() {
-		// User-supplied EncodeDuration is a no-op. Fall back to nanoseconds to keep
-		// JSON valid.
-		enc.AppendInt64(int64(val))
-	}
-}
-
-func (enc *consoleEncoder) AppendInt64(val int64) {
-	enc.buf.AppendInt(val)
-}
-func (enc *consoleEncoder) resetReflectBuf() {
-	if enc.reflectBuf == nil {
-		enc.reflectBuf = Get()
-		enc.reflectEnc = json.NewEncoder(enc.reflectBuf)
-	} else {
-		enc.reflectBuf.Reset()
-	}
-}
-func (enc *consoleEncoder) AppendReflected(val interface{}) error {
-	enc.resetReflectBuf()
-	err := enc.reflectEnc.Encode(val)
-	if err != nil {
-		return err
-	}
-	enc.reflectBuf.TrimNewline()
-	_, err = enc.buf.Write(enc.reflectBuf.Bytes())
-	return err
-}
-
-func (enc *consoleEncoder) AppendString(val string) {
-	enc.safeAddString(val)
-}
-
-func (enc *consoleEncoder) AppendTime(val time.Time) {
-	cur := enc.buf.Len()
-	enc.EncodeTime(val, enc)
-	if cur == enc.buf.Len() {
-		// User-supplied EncodeTime is a no-op. Fall back to nanos since epoch to keep
-		// output JSON valid.
-		enc.AppendInt64(val.UnixNano())
-	}
-}
-
-func (enc *consoleEncoder) AppendUint64(val uint64) {
-	enc.buf.AppendUint(val)
-}
-func (enc *consoleEncoder) appendFloat(val float64, bitSize int) {
-	switch {
-	case math.IsNaN(val):
-		enc.buf.AppendString(`"NaN"`)
-	case math.IsInf(val, 1):
-		enc.buf.AppendString(`"+Inf"`)
-	case math.IsInf(val, -1):
-		enc.buf.AppendString(`"-Inf"`)
-	default:
-		enc.buf.AppendFloat(val, bitSize)
-	}
-}
-
-// safeAddString JSON-escapes a string and appends it to the internal buffer.
-// Unlike the standard library's encoder, it doesn't attempt to protect the
-// user from browser vulnerabilities or JSONP-related problems.
-func (enc *consoleEncoder) safeAddString(s string) {
-	for i := 0; i < len(s); {
-		if enc.tryAddRuneSelf(s[i]) {
-			i++
-			continue
-		}
-		r, size := utf8.DecodeRuneInString(s[i:])
-		if enc.tryAddRuneError(r, size) {
-			i++
-			continue
-		}
-		enc.buf.AppendString(s[i : i+size])
-		i += size
-	}
-}
-
-// safeAddByteString is no-alloc equivalent of safeAddString(string(s)) for s []byte.
-func (enc *consoleEncoder) safeAddByteString(s []byte) {
-	for i := 0; i < len(s); {
-		if enc.tryAddRuneSelf(s[i]) {
-			i++
-			continue
-		}
-		r, size := utf8.DecodeRune(s[i:])
-		if enc.tryAddRuneError(r, size) {
-			i++
-			continue
-		}
-		enc.buf.Write(s[i : i+size])
-		i += size
-	}
-}
-
-// tryAddRuneSelf appends b if it is valid UTF-8 character represented in a single byte.
-func (enc *consoleEncoder) tryAddRuneSelf(b byte) bool {
-	if b >= utf8.RuneSelf {
-		return false
-	}
-	if 0x20 <= b && b != '\\' && b != '"' {
-		enc.buf.AppendByte(b)
-		return true
-	}
-	switch b {
-	case '\\', '"':
-		enc.buf.AppendByte('\\')
-		enc.buf.AppendByte(b)
-	case '\n':
-		enc.buf.AppendByte('\\')
-		enc.buf.AppendByte('n')
-	case '\r':
-		enc.buf.AppendByte('\\')
-		enc.buf.AppendByte('r')
-	case '\t':
-		enc.buf.AppendByte('\\')
-		enc.buf.AppendByte('t')
-	default:
-		// Encode bytes < 0x20, except for the escape sequences above.
-		enc.buf.AppendString(`\u00`)
-		enc.buf.AppendByte(_hex[b>>4])
-		enc.buf.AppendByte(_hex[b&0xF])
-	}
-	return true
-}
-func (enc *consoleEncoder) closeOpenNamespaces() {
-	for i := 0; i < enc.openNamespaces; i++ {
-		enc.buf.AppendByte('}')
-	}
-}
-
-
-func (enc *consoleEncoder) tryAddRuneError(r rune, size int) bool {
-	if r == utf8.RuneError && size == 1 {
-		enc.buf.AppendString(`\ufffd`)
-		return true
-	}
-	return false
-}
-func (enc *consoleEncoder) AddComplex64(k string, v complex64) { enc.AddComplex128(k, complex128(v)) }
-func (enc *consoleEncoder) AddFloat32(k string, v float32)     { enc.AddFloat64(k, float64(v)) }
-func (enc *consoleEncoder) AddInt(k string, v int)             { enc.AddInt64(k, int64(v)) }
-func (enc *consoleEncoder) AddInt32(k string, v int32)         { enc.AddInt64(k, int64(v)) }
-func (enc *consoleEncoder) AddInt16(k string, v int16)         { enc.AddInt64(k, int64(v)) }
-func (enc *consoleEncoder) AddInt8(k string, v int8)           { enc.AddInt64(k, int64(v)) }
-func (enc *consoleEncoder) AddUint(k string, v uint)           { enc.AddUint64(k, uint64(v)) }
-func (enc *consoleEncoder) AddUint32(k string, v uint32)       { enc.AddUint64(k, uint64(v)) }
-func (enc *consoleEncoder) AddUint16(k string, v uint16)       { enc.AddUint64(k, uint64(v)) }
-func (enc *consoleEncoder) AddUint8(k string, v uint8)         { enc.AddUint64(k, uint64(v)) }
-func (enc *consoleEncoder) AddUintptr(k string, v uintptr)     { enc.AddUint64(k, uint64(v)) }
-func (enc *consoleEncoder) AppendComplex64(v complex64)        { enc.AppendComplex128(complex128(v)) }
-func (enc *consoleEncoder) AppendFloat64(v float64)            { enc.appendFloat(v, 64) }
-func (enc *consoleEncoder) AppendFloat32(v float32)            { enc.appendFloat(float64(v), 32) }
-func (enc *consoleEncoder) AppendInt(v int)                    { enc.AppendInt64(int64(v)) }
-func (enc *consoleEncoder) AppendInt32(v int32)                { enc.AppendInt64(int64(v)) }
-func (enc *consoleEncoder) AppendInt16(v int16)                { enc.AppendInt64(int64(v)) }
-func (enc *consoleEncoder) AppendInt8(v int8)                  { enc.AppendInt64(int64(v)) }
-func (enc *consoleEncoder) AppendUint(v uint)                  { enc.AppendUint64(uint64(v)) }
-func (enc *consoleEncoder) AppendUint32(v uint32)              { enc.AppendUint64(uint64(v)) }
-func (enc *consoleEncoder) AppendUint16(v uint16)              { enc.AppendUint64(uint64(v)) }
-func (enc *consoleEncoder) AppendUint8(v uint8)                { enc.AppendUint64(uint64(v)) }
-func (enc *consoleEncoder) AppendUintptr(v uintptr)            { enc.AppendUint64(uint64(v)) }
-
-const _hex = "0123456789abcdef"
-
-type sliceArrayEncoder struct {
-	elems []interface{}
-}
-
-func (s *sliceArrayEncoder) AppendArray(v zapcore.ArrayMarshaler) error {
-	enc := &sliceArrayEncoder{}
-	err := v.MarshalLogArray(enc)
-	s.elems = append(s.elems, enc.elems)
-	return err
-}
-
-func (s *sliceArrayEncoder) AppendObject(v zapcore.ObjectMarshaler) error {
-	m := zapcore.NewMapObjectEncoder()
-	err := v.MarshalLogObject(m)
-	s.elems = append(s.elems, m.Fields)
-	return err
-}
-
-func (s *sliceArrayEncoder) AppendReflected(v interface{}) error {
-	s.elems = append(s.elems, v)
-	return nil
-}
-
-func (s *sliceArrayEncoder) AppendBool(v bool)              { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendByteString(v []byte)      { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendComplex128(v complex128)  { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendComplex64(v complex64)    { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendDuration(v time.Duration) { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendFloat64(v float64)        { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendFloat32(v float32)        { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendInt(v int)                { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendInt64(v int64)            { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendInt32(v int32)            { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendInt16(v int16)            { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendInt8(v int8)              { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendString(v string)          { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendTime(v time.Time)         { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendUint(v uint)              { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendUint64(v uint64)          { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendUint32(v uint32)          { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendUint16(v uint16)          { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendUint8(v uint8)            { s.elems = append(s.elems, v) }
-func (s *sliceArrayEncoder) AppendUintptr(v uintptr)        { s.elems = append(s.elems, v) }

logger/log_function_map.go

@@ -0,0 +1,37 @@
+package logger
+
+import (
+	"os"
+)
+
+// The log function map can be added to, so that you can specify your own logging mechanism
+// it has defaults for off, stdout, stderr
+var LogFunctionMap = map[string]func(*CompositeMultiHandler, *LogOptions){
+	// Do nothing - set the logger off
+	"off": func(c *CompositeMultiHandler, logOptions *LogOptions) {
+		// Only drop the results if there is a parent handler defined
+		if logOptions.HandlerWrap != nil {
+			for _, l := range logOptions.Levels {
+				c.SetHandler(logOptions.HandlerWrap.SetChild(NilHandler()), logOptions.ReplaceExistingHandler, l)
+			}
+		} else {
+			// Clear existing handler
+			c.SetHandlers(NilHandler(), logOptions)
+		}
+	},
+	// Do nothing - set the logger off
+	"": func(*CompositeMultiHandler, *LogOptions) {},
+	// Set the levels to stdout, replace existing
+	"stdout": func(c *CompositeMultiHandler, logOptions *LogOptions) {
+		if logOptions.Ctx != nil {
+			logOptions.SetExtendedOptions(
+				"noColor", !logOptions.Ctx.BoolDefault("log.colorize", true),
+				"smallDate", logOptions.Ctx.BoolDefault("log.smallDate", true))
+		}
+		c.SetTerminal(os.Stdout, logOptions)
+	},
+	// Set the levels to stderr output to terminal
+	"stderr": func(c *CompositeMultiHandler, logOptions *LogOptions) {
+		c.SetTerminal(os.Stderr, logOptions)
+	},
+}

logger/logger.go

@@ -3,9 +3,7 @@ package logger
 import (
 	"fmt"
 	"github.com/revel/config"
-	"github.com/revel/log15"
-	"log"
-	"os"
+	"time"
 )
 
 // The LogHandler defines the interface to handle the log records
@@ -13,51 +11,82 @@ type (
 	// The Multilogger reduces the number of exposed defined logging variables,
 	// and allows the output to be easily refined
 	MultiLogger interface {
-		//log15.Logger
-		//// New returns a new Logger that has this logger's context plus the given context
+		// New returns a new Logger that has this logger's context plus the given context
 		New(ctx ...interface{}) MultiLogger
-		//
-		//// SetHandler updates the logger to write records to the specified handler.
+
+		// SetHandler updates the logger to write records to the specified handler.
 		SetHandler(h LogHandler)
+
+		// Set the stack depth for the logger
 		SetStackDepth(int) MultiLogger
-		//
-		//// Log a message at the given level with context key/value pairs
+
+		// Log a message at the given level with context key/value pairs
 		Debug(msg string, ctx ...interface{})
+
+		// Log a message at the given level formatting message with the parameters
 		Debugf(msg string, params ...interface{})
+
+		// Log a message at the given level with context key/value pairs
 		Info(msg string, ctx ...interface{})
+
+		// Log a message at the given level formatting message with the parameters
 		Infof(msg string, params ...interface{})
+
+		// Log a message at the given level with context key/value pairs
 		Warn(msg string, ctx ...interface{})
+
+		// Log a message at the given level formatting message with the parameters
 		Warnf(msg string, params ...interface{})
+
+		// Log a message at the given level with context key/value pairs
 		Error(msg string, ctx ...interface{})
+
+		// Log a message at the given level formatting message with the parameters
 		Errorf(msg string, params ...interface{})
+
+		// Log a message at the given level with context key/value pairs
 		Crit(msg string, ctx ...interface{})
+
+		// Log a message at the given level formatting message with the parameters
 		Critf(msg string, params ...interface{})
 
-		//// Logs a message as an Crit and exits
+		// Log a message at the given level with context key/value pairs and exits
 		Fatal(msg string, ctx ...interface{})
+
+		// Log a message at the given level formatting message with the parameters and exits
 		Fatalf(msg string, params ...interface{})
-		//// Logs a message as an Crit and panics
+
+		// Log a message at the given level with context key/value pairs and panics
 		Panic(msg string, ctx ...interface{})
+
+		// Log a message at the given level formatting message with the parameters and panics
 		Panicf(msg string, params ...interface{})
 	}
+
+	// The log handler interface
 	LogHandler interface {
-		log15.Handler
+		Log(*Record) error
+		//log15.Handler
 	}
+
+	// The log stack handler interface
 	LogStackHandler interface {
 		LogHandler
 		GetStack() int
 	}
+
+	// The log handler interface which has child logs
 	ParentLogHandler interface {
 		SetChild(handler LogHandler) LogHandler
 	}
+
+	// The log format interface
 	LogFormat interface {
-		log15.Format
+		Format(r *Record) []byte
 	}
 
-	LogLevel    log15.Lvl
-	RevelLogger struct {
-		log15.Logger
-	}
+	// The log level type
+	LogLevel int
 
 	// Used for the callback to LogFunctionMap
 	LogOptions struct {
@@ -67,125 +96,65 @@ type (
 		Levels                 []LogLevel
 		ExtendedOptions        map[string]interface{}
 	}
+
+	// The log record
+	Record struct {
+		Message string     // The message
+		Time    time.Time  // The time
+		Level   LogLevel   //The level
+		Call    CallStack  // The call stack if built
+		Context ContextMap // The context
+	}
+
+	// The lazy structure to implement a function to be invoked only if needed
+	Lazy struct {
+		Fn interface{} // the function
+	}
+
+	// Currently the only requirement for the callstack is to support the Formatter method
+	// which stack.Call does so we use that
+	CallStack interface {
+		fmt.Formatter // Requirement
+	}
 )
 
+// FormatFunc returns a new Format object which uses
+// the given function to perform record formatting.
+func FormatFunc(f func(*Record) []byte) LogFormat {
+	return formatFunc(f)
+}
+
+type formatFunc func(*Record) []byte
+
+func (f formatFunc) Format(r *Record) []byte {
+	return f(r)
+}
+func NewRecord(message string, level LogLevel) *Record {
+	return &Record{Message: message, Context: ContextMap{}, Level: level}
+}
+
 const (
-	LvlDebug = LogLevel(log15.LvlDebug)
-	LvlInfo  = LogLevel(log15.LvlInfo)
-	LvlWarn  = LogLevel(log15.LvlWarn)
-	LvlError = LogLevel(log15.LvlError)
-	LvlCrit  = LogLevel(log15.LvlCrit)
+	LvlCrit  LogLevel = iota // Critical
+	LvlError                 // Error
+	LvlWarn                  // Warning
+	LvlInfo                  // Information
+	LvlDebug                 // Debug
 )
 
 // A list of all the log levels
 var LvlAllList = []LogLevel{LvlDebug, LvlInfo, LvlWarn, LvlError, LvlCrit}
 
-// The log function map can be added to, so that you can specify your own logging mechanism
-var LogFunctionMap = map[string]func(*CompositeMultiHandler, *LogOptions){
-	// Do nothing - set the logger off
-	"off": func(c *CompositeMultiHandler, logOptions *LogOptions) {
-		// Only drop the results if there is a parent handler defined
-		if logOptions.HandlerWrap != nil {
-			for _, l := range logOptions.Levels {
-				c.SetHandler(logOptions.HandlerWrap.SetChild(NilHandler()), logOptions.ReplaceExistingHandler, l)
-			}
-		}
-	},
-	// Do nothing - set the logger off
-	"": func(*CompositeMultiHandler, *LogOptions) {},
-	// Set the levels to stdout, replace existing
-	"stdout": func(c *CompositeMultiHandler, logOptions *LogOptions) {
-		if logOptions.Ctx != nil {
-			logOptions.SetExtendedOptions(
-				"noColor", !logOptions.Ctx.BoolDefault("log.colorize", true),
-				"smallDate", logOptions.Ctx.BoolDefault("log.smallDate", true))
-		}
-
-		c.SetTerminal(os.Stdout, logOptions)
-	},
-	// Set the levels to stderr output to terminal
-	"stderr": func(c *CompositeMultiHandler, logOptions *LogOptions) {
-		c.SetTerminal(os.Stderr, logOptions)
-	},
-}
-
-// Set the systems default logger
-// Default logs will be captured and handled by revel at level info
-func SetDefaultLog(fromLog MultiLogger) {
-	log.SetOutput(loggerRewrite{Logger: fromLog, Level: log15.LvlInfo, hideDeprecated: true})
-	// No need to show date and time, that will be logged with revel
-	log.SetFlags(0)
-}
-
-// Formatted debug call
-func (rl *RevelLogger) Debugf(msg string, param ...interface{}) {
-	rl.Debug(fmt.Sprintf(msg, param...))
-}
-
-// Formatted info call
-func (rl *RevelLogger) Infof(msg string, param ...interface{}) {
-	rl.Info(fmt.Sprintf(msg, param...))
-}
-func (rl *RevelLogger) Warnf(msg string, param ...interface{}) {
-	rl.Warn(fmt.Sprintf(msg, param...))
-}
-func (rl *RevelLogger) Errorf(msg string, param ...interface{}) {
-	rl.Error(fmt.Sprintf(msg, param...))
-}
-func (rl *RevelLogger) Critf(msg string, param ...interface{}) {
-	rl.Crit(fmt.Sprintf(msg, param...))
-}
-func (rl *RevelLogger) Fatalf(msg string, param ...interface{}) {
-	rl.Crit(fmt.Sprintf(msg, param...))
-	os.Exit(1)
-}
-func (rl *RevelLogger) Panicf(msg string, param ...interface{}) {
-	rl.Crit(fmt.Sprintf(msg, param...))
-	panic(msg)
-}
-
-func (rl *RevelLogger) Fatal(msg string, ctx ...interface{}) {
-	rl.Crit(msg, ctx...)
-	os.Exit(1)
-}
-
-func (rl *RevelLogger) Panic(msg string, ctx ...interface{}) {
-	rl.Crit(msg, ctx...)
-	panic(msg)
-}
-
-// Override log15 method
-func (rl *RevelLogger) New(ctx ...interface{}) MultiLogger {
-	old := &RevelLogger{Logger: rl.Logger.New(ctx...)}
-	return old
-}
-
-// Set the stack level to check for the caller
-func (rl *RevelLogger) SetStackDepth(amount int) MultiLogger {
-	rl.Logger.SetStackDepth(amount) // Ignore the logger returned
-	return rl
-}
-
-// Create a new logger
-func New(ctx ...interface{}) MultiLogger {
-	r := &RevelLogger{Logger: log15.New(ctx...)}
-	r.SetStackDepth(1)
-	return r
-}
-
-// Set the handler in the Logger
-func (rl *RevelLogger) SetHandler(h LogHandler) {
-	rl.Logger.SetHandler(h)
-}
-
+// Implements the ParentLogHandler
 type parentLogHandler struct {
 	setChild func(handler LogHandler) LogHandler
 }
 
+// Create a new parent log handler
 func NewParentLogHandler(callBack func(child LogHandler) LogHandler) ParentLogHandler {
 	return &parentLogHandler{callBack}
 }
 
+// Sets the child of the log handler
 func (p *parentLogHandler) SetChild(child LogHandler) LogHandler {
 	return p.setChild(child)
 }
@@ -208,18 +177,24 @@ func (l *LogOptions) SetExtendedOptions(options ...interface{}) {
 		l.ExtendedOptions[options[x].(string)] = options[x+1]
 	}
 }
+
+// Gets a string option with default
 func (l *LogOptions) GetStringDefault(option, value string) string {
 	if v, found := l.ExtendedOptions[option]; found {
 		return v.(string)
 	}
 	return value
 }
+
+// Gets an int option with default
 func (l *LogOptions) GetIntDefault(option string, value int) int {
 	if v, found := l.ExtendedOptions[option]; found {
 		return v.(int)
 	}
 	return value
 }
+
+// Gets a boolean option with default
 func (l *LogOptions) GetBoolDefault(option string, value bool) bool {
 	if v, found := l.ExtendedOptions[option]; found {
 		return v.(bool)

logger/revel_logger.go

@@ -0,0 +1,142 @@
+package logger
+
+import (
+	"fmt"
+	"github.com/revel/log15"
+	"log"
+	"os"
+)
+
+// This type implements the MultiLogger
+type RevelLogger struct {
+	log15.Logger
+}
+
+// Set the systems default logger
+// Default logs will be captured and handled by revel at level info
+func SetDefaultLog(fromLog MultiLogger) {
+	log.SetOutput(loggerRewrite{Logger: fromLog, Level: log15.LvlInfo, hideDeprecated: true})
+	// No need to show date and time, that will be logged with revel
+	log.SetFlags(0)
+}
+
+func (rl *RevelLogger) Debugf(msg string, param ...interface{}) {
+	rl.Debug(fmt.Sprintf(msg, param...))
+}
+
+// Print a formatted info message
+func (rl *RevelLogger) Infof(msg string, param ...interface{}) {
+	rl.Info(fmt.Sprintf(msg, param...))
+}
+
+// Print a formatted warn message
+func (rl *RevelLogger) Warnf(msg string, param ...interface{}) {
+	rl.Warn(fmt.Sprintf(msg, param...))
+}
+
+// Print a formatted error message
+func (rl *RevelLogger) Errorf(msg string, param ...interface{}) {
+	rl.Error(fmt.Sprintf(msg, param...))
+}
+
+// Print a formatted critical message
+func (rl *RevelLogger) Critf(msg string, param ...interface{}) {
+	rl.Crit(fmt.Sprintf(msg, param...))
+}
+
+// Print a formatted fatal message
+func (rl *RevelLogger) Fatalf(msg string, param ...interface{}) {
+	rl.Fatal(fmt.Sprintf(msg, param...))
+}
+
+// Print a formatted panic message
+func (rl *RevelLogger) Panicf(msg string, param ...interface{}) {
+	rl.Panic(fmt.Sprintf(msg, param...))
+}
+
+// Print a critical message and call os.Exit(1)
+func (rl *RevelLogger) Fatal(msg string, ctx ...interface{}) {
+	rl.Crit(msg, ctx...)
+	os.Exit(1)
+}
+
+// Print a critical message and panic
+func (rl *RevelLogger) Panic(msg string, ctx ...interface{}) {
+	rl.Crit(msg, ctx...)
+	panic(msg)
+}
+
+// Override log15 method
+func (rl *RevelLogger) New(ctx ...interface{}) MultiLogger {
+	old := &RevelLogger{Logger: rl.Logger.New(ctx...)}
+	return old
+}
+
+// Set the stack level to check for the caller
+func (rl *RevelLogger) SetStackDepth(amount int) MultiLogger {
+	rl.Logger.SetStackDepth(amount) // Ignore the logger returned
+	return rl
+}
+
+// Create a new logger
+func New(ctx ...interface{}) MultiLogger {
+	r := &RevelLogger{Logger: log15.New(ctx...)}
+	r.SetStackDepth(0)
+	return r
+}
+
+// Set the handler in the Logger
+func (rl *RevelLogger) SetHandler(h LogHandler) {
+	rl.Logger.SetHandler(callHandler(h.Log))
+}
+
+// The function wrapper to implement the callback
+type callHandler func(r *Record) error
+
+// Log implementation, reads the record and extracts the details from the log record
+// Hiding the implementation.
+func (c callHandler) Log(log *log15.Record) error {
+	ctx := log.Ctx
+	var ctxMap ContextMap
+	if len(ctx) > 0 {
+		ctxMap = make(ContextMap, len(ctx) / 2)
+
+		for i := 0; i < len(ctx); i += 2 {
+			v := ctx[i]
+			key, ok := v.(string)
+			if !ok {
+				key = fmt.Sprintf("LOGGER_INVALID_KEY %v", v)
+			}
+			var value interface{}
+			if len(ctx) > i + 1 {
+				value = ctx[i + 1]
+			} else {
+				value = "LOGGER_VALUE_MISSING"
+			}
+			ctxMap[key] = value
+		}
+	} else {
+		ctxMap = make(ContextMap, 0)
+	}
+	r := &Record{Message: log.Msg, Context: ctxMap, Time: log.Time, Level: LogLevel(log.Lvl), Call: CallStack(log.Call)}
+	return c(r)
+}
+
+// Internally used contextMap, allows conversion of map to map[string]string
+type ContextMap map[string]interface{}
+
+// Convert the context map to be string only values, any non string values are ignored
+func (m ContextMap) StringMap() (newMap map[string]string) {
+	if m != nil {
+		newMap = map[string]string{}
+		for key, value := range m {
+			if svalue, isstring := value.(string); isstring {
+				newMap[key] = svalue
+			}
+		}
+	}
+	return
+}
+func (m ContextMap) Add(key string, value interface{}) {
+	m[key] = value
+}

logger/terminal_format.go

@@ -2,8 +2,8 @@ package logger
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
-	"github.com/revel/log15"
 	"reflect"
 	"strconv"
 	"sync"
@@ -19,9 +19,8 @@ const (
 )
 
 var (
-	// Name the log level
-	toRevel = map[log15.Lvl]string{log15.LvlDebug: "DEBUG",
-		log15.LvlInfo: "INFO", log15.LvlWarn: "WARN", log15.LvlError: "ERROR", log15.LvlCrit: "CRIT"}
+	levelString = map[LogLevel]string{LvlDebug: "DEBUG",
+		LvlInfo: "INFO", LvlWarn: "WARN", LvlError: "ERROR", LvlCrit: "CRIT"}
 )
 
 // Outputs to the terminal in a format like below
@@ -31,53 +30,51 @@ func TerminalFormatHandler(noColor bool, smallDate bool) LogFormat {
 	if smallDate {
 		dateFormat = termSmallTimeFormat
 	}
-	return log15.FormatFunc(func(r *log15.Record) []byte {
+	return FormatFunc(func(r *Record) []byte {
 		// Bash coloring http://misc.flogisoft.com/bash/tip_colors_and_formatting
 		var color = 0
-		switch r.Lvl {
-		case log15.LvlCrit:
+		switch r.Level {
+		case LvlCrit:
 			// Magenta
 			color = 35
-		case log15.LvlError:
+		case LvlError:
 			// Red
 			color = 31
-		case log15.LvlWarn:
+		case LvlWarn:
 			// Yellow
 			color = 33
-		case log15.LvlInfo:
+		case LvlInfo:
 			// Green
 			color = 32
-		case log15.LvlDebug:
+		case LvlDebug:
 			// Cyan
 			color = 36
 		}
 
 		b := &bytes.Buffer{}
-		caller := findInContext("caller", r.Ctx)
-		module := findInContext("module", r.Ctx)
+		caller, _ := r.Context["caller"].(string)
+		module, _ := r.Context["module"].(string)
 		if noColor == false && color > 0 {
 			if len(module) > 0 {
-				fmt.Fprintf(b, "\x1b[%dm%-5s\x1b[0m %s %6s %13s: %-40s ", color, toRevel[r.Lvl], r.Time.Format(dateFormat), module, caller, r.Msg)
+				fmt.Fprintf(b, "\x1b[%dm%-5s\x1b[0m %s %6s %13s: %-40s ", color, levelString[r.Level], r.Time.Format(dateFormat), module, caller, r.Message)
 			} else {
-				fmt.Fprintf(b, "\x1b[%dm%-5s\x1b[0m %s %13s: %-40s ", color, toRevel[r.Lvl], r.Time.Format(dateFormat), caller, r.Msg)
+				fmt.Fprintf(b, "\x1b[%dm%-5s\x1b[0m %s %13s: %-40s ", color, levelString[r.Level], r.Time.Format(dateFormat), caller, r.Message)
 			}
 		} else {
-			fmt.Fprintf(b, "%-5s %s %6s %13s: %-40s", toRevel[r.Lvl], r.Time.Format(dateFormat), module, caller, r.Msg)
+			fmt.Fprintf(b, "%-5s %s %6s %13s: %-40s", levelString[r.Level], r.Time.Format(dateFormat), module, caller, r.Message)
 		}
 
-		for i := 0; i < len(r.Ctx); i += 2 {
+		i := 0
+		for k, v := range r.Context {
 			if i != 0 {
 				b.WriteByte(' ')
 			}
-
-			k, ok := r.Ctx[i].(string)
-			if k == "caller" || k == "fn" || k == "module" {
+			i++
+			if k == "module" || k == "caller" {
 				continue
 			}
-			v := formatLogfmtValue(r.Ctx[i+1])
-			if !ok {
-				k, v = errorKey, formatLogfmtValue(k)
-			}
+
+			v := formatLogfmtValue(v)
 
 			// TODO: we should probably check that all of your key bytes aren't invalid
 			if noColor == false && color > 0 {
@@ -94,15 +91,6 @@ func TerminalFormatHandler(noColor bool, smallDate bool) LogFormat {
 		return b.Bytes()
 	})
 }
-func findInContext(key string, ctx []interface{}) string {
-	for i := 0; i < len(ctx); i += 2 {
-		k := ctx[i].(string)
-		if key == k {
-			return formatLogfmtValue(ctx[i+1])
-		}
-	}
-	return ""
-}
 
 // formatValue formats a value for serialization
 func formatLogfmtValue(value interface{}) string {
@@ -132,6 +120,8 @@ func formatLogfmtValue(value interface{}) string {
 		return escapeString(fmt.Sprintf("%+v", value))
 	}
 }
+
+// Format the value in json format
 func formatShared(value interface{}) (result interface{}) {
 	defer func() {
 		if err := recover(); err != nil {
@@ -158,10 +148,12 @@ func formatShared(value interface{}) (result interface{}) {
 	}
 }
 
+// A reusuable buffer for outputting data
 var stringBufPool = sync.Pool{
 	New: func() interface{} { return new(bytes.Buffer) },
 }
 
+// Escape the string when needed
 func escapeString(s string) string {
 	needsQuotes := false
 	needsEscape := false
@@ -204,3 +196,50 @@ func escapeString(s string) string {
 	stringBufPool.Put(e)
 	return ret
 }
+
+// JsonFormatEx formats log records as JSON objects. If pretty is true,
+// records will be pretty-printed. If lineSeparated is true, records
+// will be logged with a new line between each record.
+func JsonFormatEx(pretty, lineSeparated bool) LogFormat {
+	jsonMarshal := json.Marshal
+	if pretty {
+		jsonMarshal = func(v interface{}) ([]byte, error) {
+			return json.MarshalIndent(v, "", "    ")
+		}
+	}
+
+	return FormatFunc(func(r *Record) []byte {
+		props := make(map[string]interface{})
+
+		props["t"] = r.Time
+		props["lvl"] = levelString[r.Level]
+		props["msg"] = r.Message
+		for k, v := range r.Context {
+			props[k] = formatJsonValue(v)
+		}
+
+		b, err := jsonMarshal(props)
+		if err != nil {
+			b, _ = jsonMarshal(map[string]string{
+				errorKey: err.Error(),
+			})
+			return b
+		}
+
+		if lineSeparated {
+			b = append(b, '\n')
+		}
+
+		return b
+	})
+}
+
+func formatJsonValue(value interface{}) interface{} {
+	value = formatShared(value)
+	switch value.(type) {
+	case int, int8, int16, int32, int64, float32, float64, uint, uint8, uint16, uint32, uint64, string:
+		return value
+	default:
+		return fmt.Sprintf("%+v", value)
+	}
+}

logger/utils.go

@@ -1,13 +1,9 @@
 package logger
 
 import (
-	"github.com/revel/config"
 	"github.com/revel/log15"
 	"gopkg.in/stack.v0"
 	"log"
-	"os"
-	"path/filepath"
-	"strings"
 )
 
 // Utility package to make existing logging backwards compatible
@@ -20,6 +16,14 @@ var (
 	}
 )
 
+const (
+	// The test mode flag overrides the default log level and shows only errors
+	TEST_MODE_FLAG = "testModeFlag"
+	// The special use flag enables showing messages when the logger is setup
+	SPECIAL_USE_FLAG = "specialUseFlag"
+)
+
+// Returns the logger for the name
 func GetLogger(name string, logger MultiLogger) (l *log.Logger) {
 	switch name {
 	case "trace": // TODO trace is deprecated, replaced by debug
@@ -40,198 +44,26 @@ func GetLogger(name string, logger MultiLogger) (l *log.Logger) {
 
 }
 
-// Get all handlers based on the Config (if available)
-func InitializeFromConfig(basePath string, config *config.Context) (c *CompositeMultiHandler) {
-	// If running in test mode suppress anything that is not an error
-	if config != nil && config.BoolDefault("testModeFlag", false) {
-		config.SetOption("log.info.output", "off")
-		config.SetOption("log.debug.output", "off")
-		config.SetOption("log.warn.output", "off")
-		config.SetOption("log.error.output", "stderr")
-		config.SetOption("log.crit.output", "stderr")
-	}
+// Used by the initFilterLog to handle the filters
+var logFilterList = []struct {
+	LogPrefix, LogSuffix string
+	parentHandler        func(map[string]interface{}) ParentLogHandler
+}{{
+	"log.", ".filter",
+	func(keyMap map[string]interface{}) ParentLogHandler {
+		return NewParentLogHandler(func(child LogHandler) LogHandler {
+			return MatchMapHandler(keyMap, child)
+		})
 
-	// If the configuration has an all option we can skip some
-	c, _ = NewCompositeMultiHandler()
-
-	// Filters are assigned first, non filtered items override filters
-	initAllLog(c, basePath, config)
-	initLogLevels(c, basePath, config)
-	if c.CriticalHandler == nil && c.ErrorHandler != nil {
-		c.CriticalHandler = c.ErrorHandler
-	}
-	initFilterLog(c, basePath, config)
-	if c.CriticalHandler == nil && c.ErrorHandler != nil {
-		c.CriticalHandler = c.ErrorHandler
-	}
-	initRequestLog(c, basePath, config)
-
-	return c
-}
-
-// Init the log.all configuration options
-func initAllLog(c *CompositeMultiHandler, basePath string, config *config.Context) {
-	if config != nil {
-		extraLogFlag := config.BoolDefault("specialUseFlag", false)
-		if output, found := config.String("log.all.output"); found {
-			// Set all output for the specified handler
-			if extraLogFlag {
-				log.Printf("Adding standard handler for levels to >%s< ", output)
-			}
-			initHandlerFor(c, output, basePath, NewLogOptions(config, true, nil, LvlAllList...))
-		}
-	}
-}
-
-// Init the filter options
-// log.all.filter ....
-// log.error.filter ....
-func initFilterLog(c *CompositeMultiHandler, basePath string, config *config.Context) {
-	if config != nil {
-		extraLogFlag := config.BoolDefault("specialUseFlag", false)
-
-		// The commands to use
-		logFilterList := []struct {
-			LogPrefix, LogSuffix string
-			parentHandler        func(map[string]interface{}) ParentLogHandler
-		}{{
-			"log.", ".filter",
-			func(keyMap map[string]interface{}) ParentLogHandler {
-				return NewParentLogHandler(func(child LogHandler) LogHandler {
-					return MatchMapHandler(keyMap, child)
-				})
-
-			},
-		}, {
-			"log.", ".nfilter",
-			func(keyMap map[string]interface{}) ParentLogHandler {
-				return NewParentLogHandler(func(child LogHandler) LogHandler {
-					return NotMatchMapHandler(keyMap, child)
-				})
-			},
-		}}
-
-		for _, logFilter := range logFilterList {
-			// Init for all filters
-			for _, name := range []string{"all", "debug", "info", "warn", "error", "crit",
-				"trace", // TODO trace is deprecated
-			} {
-				optionList := config.Options(logFilter.LogPrefix + name + logFilter.LogSuffix)
-				for _, option := range optionList {
-					splitOptions := strings.Split(option, ".")
-					keyMap := map[string]interface{}{}
-					for x := 3; x < len(splitOptions); x += 2 {
-						keyMap[splitOptions[x]] = splitOptions[x+1]
-					}
-					phandler := logFilter.parentHandler(keyMap)
-					if extraLogFlag {
-						log.Printf("Adding key map handler %s %s output %s", option, name, config.StringDefault(option, ""))
-					}
-
-					if name == "all" {
-						initHandlerFor(c, config.StringDefault(option, ""), basePath, NewLogOptions(config, false, phandler))
-					} else {
-						initHandlerFor(c, config.StringDefault(option, ""), basePath, NewLogOptions(config, false, phandler, toLevel[name]))
-					}
-				}
-			}
-		}
-	}
-}
-
-// Init the log.error, log.warn etc configuration options
-func initLogLevels(c *CompositeMultiHandler, basePath string, config *config.Context) {
-	for _, name := range []string{"debug", "info", "warn", "error", "crit",
-		"trace", // TODO trace is deprecated
-	} {
-		if config != nil {
-			extraLogFlag := config.BoolDefault("specialUseFlag", false)
-			output, found := config.String("log." + name + ".output")
-			if found {
-				if extraLogFlag {
-					log.Printf("Adding standard handler %s output %s", name, output)
-				}
-				initHandlerFor(c, output, basePath, NewLogOptions(config, true, nil, toLevel[name]))
-			}
-			// Gets the list of options with said prefix
-		} else {
-			initHandlerFor(c, "stderr", basePath, NewLogOptions(config, true, nil, toLevel[name]))
-		}
-	}
-}
-
-// Init the request log options
-func initRequestLog(c *CompositeMultiHandler, basePath string, config *config.Context) {
-	// Request logging to a separate output handler
-	// This takes the InfoHandlers and adds a MatchAbHandler handler to it to direct
-	// context with the word "section=requestlog" to that handler.
-	// Note if request logging is not enabled the MatchAbHandler will not be added and the
-	// request log messages will be sent out the INFO handler
-	outputRequest := "stdout"
-	if config != nil {
-		outputRequest = config.StringDefault("log.request.output", "")
-	}
-	oldInfo := c.InfoHandler
-	c.InfoHandler = nil
-	if outputRequest != "" {
-		initHandlerFor(c, outputRequest, basePath, NewLogOptions(config, false, nil, LvlInfo))
-	}
-	if c.InfoHandler != nil || oldInfo != nil {
-		if c.InfoHandler == nil {
-			c.InfoHandler = oldInfo
-		} else {
-			c.InfoHandler = MatchAbHandler("section", "requestlog", c.InfoHandler, oldInfo)
-		}
-	}
-}
-
-// Returns a handler for the level using the output string
-// Accept formats for output string are
-// LogFunctionMap[value] callback function
-// `stdout` `stderr` `full/file/path/to/location/app.log` `full/file/path/to/location/app.json`
-func initHandlerFor(c *CompositeMultiHandler, output, basePath string, options *LogOptions) {
-	if options.Ctx != nil {
-		options.SetExtendedOptions(
-			"noColor", !options.Ctx.BoolDefault("log.colorize", true),
-			"smallDate", options.Ctx.BoolDefault("log.smallDate", true),
-			"maxSize", options.Ctx.IntDefault("log.maxsize", 1024*10),
-			"maxAge", options.Ctx.IntDefault("log.maxage", 14),
-			"maxBackups", options.Ctx.IntDefault("log.maxbackups", 14),
-			"compressBackups", !options.Ctx.BoolDefault("log.compressBackups", true),
-		)
-	}
-
-	output = strings.TrimSpace(output)
-	if funcHandler, found := LogFunctionMap[output]; found {
-		funcHandler(c, options)
-	} else {
-		switch output {
-		case "":
-			fallthrough
-		case "off":
-		// No handler, discard data
-		default:
-			// Write to file specified
-			if !filepath.IsAbs(output) {
-				output = filepath.Join(basePath, output)
-			}
-
-			if err := os.MkdirAll(filepath.Dir(output), 0755); err != nil {
-				log.Panic(err)
-			}
-
-			if strings.HasSuffix(output, "json") {
-				c.SetJsonFile(output, options)
-			} else {
-				// Override defaults for a terminal file
-				options.SetExtendedOptions("noColor", true)
-				options.SetExtendedOptions("smallDate", false)
-				c.SetTerminalFile(output, options)
-			}
-		}
-	}
-	return
-}
+	},
+}, {
+	"log.", ".nfilter",
+	func(keyMap map[string]interface{}) ParentLogHandler {
+		return NewParentLogHandler(func(child LogHandler) LogHandler {
+			return NotMatchMapHandler(keyMap, child)
+		})
+	},
+}}
 
 // This structure and method will handle the old output format and log it to the new format
 type loggerRewrite struct {
@@ -240,8 +72,10 @@ type loggerRewrite struct {
 	hideDeprecated bool
 }
 
+// The message indicating that a logger is using a deprecated log mechanism
 var log_deprecated = []byte("* LOG DEPRECATED * ")
 
+// Implements the Write of the logger
 func (lr loggerRewrite) Write(p []byte) (n int, err error) {
 	if !lr.hideDeprecated {
 		p = append(log_deprecated, p...)
@@ -270,7 +104,7 @@ func (lr loggerRewrite) Write(p []byte) (n int, err error) {
 
 // For logging purposes the call stack can be used to record the stack trace of a bad error
 // simply pass it as a context field in your log statement like
-// `controller.Log.Critc("This should not occur","stack",revel.NewCallStack())`
+// `controller.Log.Crit("This should not occur","stack",revel.NewCallStack())`
 func NewCallStack() interface{} {
 	return stack.Trace()
 }

logger/wrap_handlers.go

@@ -0,0 +1,98 @@
+package logger
+
+// FuncHandler returns a Handler that logs records with the given
+// function.
+import (
+	"fmt"
+	"reflect"
+	"sync"
+	"time"
+)
+
+// Function handler wraps the declared function and returns the handler for it
+func FuncHandler(fn func(r *Record) error) LogHandler {
+	return funcHandler(fn)
+}
+
+// The type decleration for the function
+type funcHandler func(r *Record) error
+
+// The implementation of the Log
+func (h funcHandler) Log(r *Record) error {
+	return h(r)
+}
+
+// This function allows you to do a full declaration for the log,
+// it is recommended you use FuncHandler instead
+func HandlerFunc(log func(message string, time time.Time, level LogLevel, call CallStack, context ContextMap) error) LogHandler {
+	return remoteHandler(log)
+}
+
+// The type used for the HandlerFunc
+type remoteHandler func(message string, time time.Time, level LogLevel, call CallStack, context ContextMap) error
+
+// The Log implementation
+func (c remoteHandler) Log(record *Record) error {
+	return c(record.Message, record.Time, record.Level, record.Call, record.Context)
+}
+
+// SyncHandler can be wrapped around a handler to guarantee that
+// only a single Log operation can proceed at a time. It's necessary
+// for thread-safe concurrent writes.
+func SyncHandler(h LogHandler) LogHandler {
+	var mu sync.Mutex
+	return FuncHandler(func(r *Record) error {
+		defer mu.Unlock()
+		mu.Lock()
+		return h.Log(r)
+	})
+}
+
+// LazyHandler writes all values to the wrapped handler after evaluating
+// any lazy functions in the record's context. It is already wrapped
+// around StreamHandler and SyslogHandler in this library, you'll only need
+// it if you write your own Handler.
+func LazyHandler(h LogHandler) LogHandler {
+	return FuncHandler(func(r *Record) error {
+		for k, v := range r.Context {
+			if lz, ok := v.(Lazy); ok {
+				value, err := evaluateLazy(lz)
+				if err != nil {
+					r.Context[errorKey] = "bad lazy " + k
+				} else {
+					v = value
+				}
+			}
+		}
+
+		return h.Log(r)
+	})
+}
+
+func evaluateLazy(lz Lazy) (interface{}, error) {
+	t := reflect.TypeOf(lz.Fn)
+
+	if t.Kind() != reflect.Func {
+		return nil, fmt.Errorf("INVALID_LAZY, not func: %+v", lz.Fn)
+	}
+
+	if t.NumIn() > 0 {
+		return nil, fmt.Errorf("INVALID_LAZY, func takes args: %+v", lz.Fn)
+	}
+
+	if t.NumOut() == 0 {
+		return nil, fmt.Errorf("INVALID_LAZY, no func return val: %+v", lz.Fn)
+	}
+
+	value := reflect.ValueOf(lz.Fn)
+	results := value.Call([]reflect.Value{})
+	if len(results) == 1 {
+		return results[0].Interface(), nil
+	} else {
+		values := make([]interface{}, len(results))
+		for i, v := range results {
+			values[i] = v.Interface()
+		}
+		return values, nil
+	}
+}

model/command/build.go

@@ -0,0 +1,10 @@
+package command
+type (
+	Build struct {
+		ImportCommand
+		TargetPath string `short:"t" long:"target-path" description:"Path to target folder. Folder will be completely deleted if it exists" required:"false"`
+		Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
+		CopySource bool   `short:"s" long:"include-source" description:"Copy the source code as well"`
+	}
+
+)

model/command/clean.go

@@ -0,0 +1,6 @@
+package command
+type (
+	Clean struct {
+		ImportCommand
+	}
+)

model/command/import_command.go

@@ -0,0 +1,7 @@
+package command
+
+type (
+	ImportCommand struct {
+		ImportPath string `short:"a" long:"application-path" description:"Path to application folder"  required:"false"`
+	}
+)

model/command/new.go

@@ -0,0 +1,14 @@
+package command
+
+
+type (
+	New struct {
+		ImportCommand
+		SkeletonPath string `short:"s" long:"skeleton" description:"Path to skeleton folder (Must exist on GO PATH)" required:"false"`
+		Package      string `short:"p" long:"package" description:"The package name, this becomes the repfix to the app name, if defined vendored is set to true" required:"false"`
+		NotVendored  bool   `long:"no-vendor" description:"True if project should not be configured with a go.mod, this requires you to have the project on the GOPATH, this is only compatible with go versions v1.12 or older"`
+		Run          bool   `short:"r" long:"run" description:"True if you want to run the application right away"`
+		Callback func() error
+	}
+
+)

model/command/package.go

@@ -0,0 +1,9 @@
+package command
+type (
+	Package struct {
+		ImportCommand
+		TargetPath string `short:"t" long:"target-path" description:"Full path and filename of target package to deploy" required:"false"`
+		Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
+		CopySource bool   `short:"s" long:"include-source" description:"Copy the source code as well"`
+	}
+)

model/command/run.go

@@ -0,0 +1,9 @@
+package command
+type (
+	Run struct {
+		ImportCommand
+		Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
+		Port       int    `short:"p" long:"port" default:"-1" 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"`
+	}
+)

model/command/test_command.go

@@ -0,0 +1,9 @@
+package command
+
+type (
+	Test struct {
+		ImportCommand
+		Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
+		Function   string `short:"f" long:"suite-function" description:"The suite.function"`
+	}
+)

model/command/version.go

@@ -0,0 +1,6 @@
+package command
+type (
+	Version struct {
+		ImportCommand
+	}
+)

model/command_config.go

@@ -1,17 +1,22 @@
 package model
 
-// The constants
 import (
 	"fmt"
-	"github.com/revel/cmd/logger"
+	"github.com/revel/cmd"
 	"github.com/revel/cmd/utils"
+	"go/ast"
 	"go/build"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"github.com/revel/cmd/model/command"
 )
 
+// The constants
 const (
 	NEW COMMAND = iota + 1
 	RUN
@@ -28,64 +33,34 @@ type (
 
 	// 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 (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
-		PackageResolver func(pkgName string) error //  a packge resolver for the config
-		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 application folder" required:"false"`
-			SkeletonPath 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:"false"`
-			ImportPath string `short:"a" long:"application-path" description:"Path to application folder"  required:"false"`
-			Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
-			CopySource bool   `short:"s" long:"include-source" description:"Copy the source code as well"`
-		} `command:"build"`
-		// The run command
-		Run struct {
-			ImportPath string `short:"a" long:"application-path" description:"Path to application folder"  required:"false"`
-			Mode       string `short:"m" long:"run-mode" description:"The mode to run the application in"`
-			Port       int `short:"p" long:"port" default:"-1" 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 {
-			TargetPath string `short:"t" long:"target-path" description:"Full path and filename of target package to deploy" required:"false"`
-			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 application folder"  required:"false"`
-			CopySource bool   `short:"s" long:"include-source" description:"Copy the source code as well"`
-		} `command:"package"`
-		// The clean command
-		Clean struct {
-			ImportPath string `short:"a" long:"application-path" description:"Path to application folder"  required:"false"`
-		} `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 application folder" required:"false"`
-			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 application folder" required:"false"`
-		} `command:"version"`
+		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                   `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"`
+		GoModFlags        []string            `long:"gomod-flags" description:"These flags will execute go mod commands for each flag, this happens during the build process"`
+		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"`
 	}
 )
 
 // Updates the import path depending on the command
-func (c *CommandConfig) UpdateImportPath() bool {
+func (c *CommandConfig) UpdateImportPath() error {
 	var importPath string
 	required := true
 	switch c.Index {
@@ -93,20 +68,26 @@ func (c *CommandConfig) UpdateImportPath() bool {
 		importPath = c.New.ImportPath
 	case RUN:
 		importPath = c.Run.ImportPath
+		c.Vendored = utils.Exists(filepath.Join(importPath, "go.mod"))
 	case BUILD:
 		importPath = c.Build.ImportPath
+		c.Vendored = utils.Exists(filepath.Join(importPath, "go.mod"))
 	case PACKAGE:
 		importPath = c.Package.ImportPath
+		c.Vendored = utils.Exists(filepath.Join(importPath, "go.mod"))
 	case CLEAN:
 		importPath = c.Clean.ImportPath
+		c.Vendored = utils.Exists(filepath.Join(importPath, "go.mod"))
 	case TEST:
 		importPath = c.Test.ImportPath
+		c.Vendored = utils.Exists(filepath.Join(importPath, "go.mod"))
 	case VERSION:
 		importPath = c.Version.ImportPath
 		required = false
 	}
 
 	if len(importPath) == 0 || filepath.IsAbs(importPath) || importPath[0] == '.' {
+		utils.Logger.Info("Import path is absolute or not specified", "path", importPath)
 		// Try to determine the import path from the GO paths and the command line
 		currentPath, err := os.Getwd()
 		if len(importPath) > 0 {
@@ -116,18 +97,20 @@ func (c *CommandConfig) UpdateImportPath() bool {
 			}
 			// For an absolute path
 			currentPath, _ = filepath.Abs(importPath)
-
 		}
 
 		if err == nil {
 			for _, path := range strings.Split(build.Default.GOPATH, string(filepath.ListSeparator)) {
 				utils.Logger.Infof("Checking import path %s with %s", currentPath, path)
-				if strings.HasPrefix(currentPath, path) && len(currentPath) > len(path)+1 {
-					importPath = currentPath[len(path)+1:]
+				if strings.HasPrefix(currentPath, path) && len(currentPath) > len(path) + 1 {
+					importPath = currentPath[len(path) + 1:]
 					// Remove the source from the path if it is there
-					if len(importPath) > 4 && strings.ToLower(importPath[0:4]) == "src/" {
+					if len(importPath) > 4 && (strings.ToLower(importPath[0:4]) == "src/" || strings.ToLower(importPath[0:4]) == "src\\") {
 						importPath = importPath[4:]
 					} else if importPath == "src" {
+						if c.Index != VERSION {
+							return fmt.Errorf("Invlaid import path, working dir is in GOPATH root")
+						}
 						importPath = ""
 					}
 					utils.Logger.Info("Updated import path", "path", importPath)
@@ -137,77 +120,144 @@ func (c *CommandConfig) UpdateImportPath() bool {
 	}
 
 	c.ImportPath = importPath
-	utils.Logger.Info("Returned import path", "path", importPath, "buildpath", build.Default.GOPATH)
-	return (len(importPath) > 0 || !required)
+	// We need the source root determined at this point to check the setversions
+	c.initAppFolder()
+	utils.Logger.Info("Returned import path", "path", importPath)
+	if required && c.Index != NEW {
+		if err := c.SetVersions(); err != nil {
+			utils.Logger.Panic("Failed to fetch revel versions", "error", err)
+		}
+		if err := c.FrameworkVersion.CompatibleFramework(c); err != nil {
+			utils.Logger.Fatal("Compatibility Error", "message", err,
+				"Revel framework version", c.FrameworkVersion.String(), "Revel tool version", c.CommandVersion.String())
+		}
+		utils.Logger.Info("Revel versions", "revel-tool", c.CommandVersion.String(), "Revel Framework", c.FrameworkVersion.String())
+	}
+	if !required {
+		return nil
+	}
+	if len(importPath) == 0 {
+		return fmt.Errorf("Unable to determine import path from : %s", importPath)
+	}
+	return nil
+}
+
+func (c *CommandConfig) initAppFolder() (err error) {
+	utils.Logger.Info("initAppFolder", "vendored", c.Vendored, "build-gopath", build.Default.GOPATH, "gopath-env", os.Getenv("GOPATH"))
+
+	// check for go executable
+	c.GoCmd, err = exec.LookPath("go")
+	if err != nil {
+		utils.Logger.Fatal("Go executable not found in PATH.")
+	}
+
+	// First try to determine where the application is located - this should be the import value
+	appFolder := c.ImportPath
+	wd, err := os.Getwd()
+	if len(appFolder) == 0 {
+		// We will assume the working directory is the appFolder
+		appFolder = wd
+	} else if strings.LastIndex(wd, appFolder) == len(wd) - len(appFolder) {
+		// Check for existence of an /app folder
+		if utils.Exists(filepath.Join(wd, "app")) {
+			appFolder = wd
+		} else {
+			appFolder = filepath.Join(wd, appFolder)
+		}
+	} else if strings.Contains(appFolder, ".") {
+		appFolder = filepath.Join(wd, filepath.Base(c.ImportPath))
+	} else if !filepath.IsAbs(appFolder) {
+		appFolder = filepath.Join(wd, appFolder)
+	}
+
+	utils.Logger.Info("Determined app folder to be", "appfolder", appFolder, "working", wd, "importPath", c.ImportPath)
+
+	// Use app folder to read the go.mod if it exists and extract the package information
+	goModFile := filepath.Join(appFolder, "go.mod")
+	utils.Logger.Info("Checking gomod, extracting from file", "path", goModFile,"exists", utils.Exists(goModFile))
+	if utils.Exists(goModFile) {
+		c.Vendored = true
+		utils.Logger.Info("Found go mod, extracting from file", "path", goModFile)
+		file, err := ioutil.ReadFile(goModFile)
+		if err != nil {
+			return err
+		}
+		for _, line := range strings.Split(string(file), "\n") {
+			if strings.Index(line, "module ") == 0 {
+				c.ImportPath = strings.TrimSpace(strings.Split(line, "module")[1])
+				c.AppPath = appFolder
+				//c.SrcRoot = appFolder
+				utils.Logger.Info("Set application path and package based on go mod", "path", c.AppPath)
+				return nil
+			}
+		}
+		// c.SrcRoot = appFolder
+		c.AppPath = appFolder
+	} else if c.Index != NEW || (c.Index == NEW && c.New.NotVendored) {
+		workingDir, _ := os.Getwd()
+		goPathList := filepath.SplitList(c.GoPath)
+		bestpath := ""
+		for _, path := range goPathList {
+			if c.Index == NEW {
+				// If the GOPATH is part of the working dir this is the most likely target
+				if strings.HasPrefix(workingDir, path) {
+					bestpath = path
+				}
+			} else {
+				if utils.Exists(filepath.Join(path, "src", c.ImportPath)) {
+					bestpath = path
+					break
+				}
+			}
+		}
+
+		utils.Logger.Info("Source root", "cwd", workingDir, "gopath", c.GoPath, "c.ImportPath", c.ImportPath, "bestpath", bestpath)
+		if len(bestpath) > 0 {
+			c.AppPath = filepath.Join(bestpath, "src", c.ImportPath)
+		}
+		// Recalculate the appFolder because we are using a GOPATH
+
+	} else {
+		// This is new and not vendored, so the app path is the appFolder
+		c.AppPath = appFolder
+	}
+
+	utils.Logger.Info("Set application path", "path", c.AppPath, "vendored",c.Vendored, "importpath",c.ImportPath)
+	return nil
 }
 
 // Used to initialize the package resolver
 func (c *CommandConfig) InitPackageResolver() {
-	useVendor := utils.DirExists(filepath.Join(c.AppPath, "vendor"))
-	if c.Index == NEW && c.New.Vendored {
-		useVendor = true
-	}
-	utils.Logger.Info("InitPackageResolver", "useVendor", useVendor, "path", c.AppPath)
-
-	var (
-		depPath string
-		err     error
-	)
-
-	if useVendor {
-		utils.Logger.Info("Vendor folder detected, scanning for deps in path")
-		depPath, err = exec.LookPath("dep")
-		if err != nil {
-			// Do not halt build unless a new package needs to be imported
-			utils.Logger.Fatal("Build: `dep` executable not found in PATH, but vendor folder detected." +
-				"Packages can only be added automatically to the vendor folder using the `dep` tool. " +
-				"You can install the `dep` tool by doing a `go get -u github.com/golang/dep/cmd/dep`")
-		}
-	}
+	c.initGoPaths()
+	utils.Logger.Info("InitPackageResolver", "useVendor", c.Vendored, "path", c.AppPath)
 
 	// This should get called when needed
 	c.PackageResolver = func(pkgName string) error {
-		//useVendor := utils.DirExists(filepath.Join(c.AppPath, "vendor"))
-
+		utils.Logger.Info("Request for package ", "package", pkgName, "use vendor", c.Vendored)
 		var getCmd *exec.Cmd
-		utils.Logger.Info("Request for package ", "package", pkgName, "use vendor", useVendor)
-		if useVendor {
-			utils.Logger.Info("Using dependency manager to import package", "package", pkgName)
-
-			if depPath == "" {
-				utils.Logger.Error("Build: Vendor folder found, but the `dep` tool was not found, " +
-					"if you use a different vendoring (package management) tool please add the following packages by hand, " +
-					"or install the `dep` tool into your gopath by doing a `go get -u github.com/golang/dep/cmd/dep`. " +
-					"For more information and usage of the tool please see http://github.com/golang/dep")
-				utils.Logger.Error("Missing package", "package", pkgName)
-				return fmt.Errorf("Missing package %s", pkgName)
-			}
-			getCmd = exec.Command(depPath, "ensure", "-add", pkgName)
+		print("Downloading related packages ...")
+		if c.Vendored {
+			getCmd = exec.Command(c.GoCmd, "mod", "tidy")
 		} else {
 			utils.Logger.Info("No vendor folder detected, not using dependency manager to import package", "package", pkgName)
-			getCmd = exec.Command(c.GoCmd, "get", pkgName)
+			getCmd = exec.Command(c.GoCmd, "get", "-u", pkgName)
 		}
 
-		utils.CmdInit(getCmd, c.AppPath)
+		utils.CmdInit(getCmd, !c.Vendored, c.AppPath)
 		utils.Logger.Info("Go get command ", "exec", getCmd.Path, "dir", getCmd.Dir, "args", getCmd.Args, "env", getCmd.Env, "package", pkgName)
 		output, err := getCmd.CombinedOutput()
 		if err != nil {
-			fmt.Printf("Error stack %v\n", logger.NewCallStack())
 			utils.Logger.Error("Failed to import package", "error", err, "gopath", build.Default.GOPATH, "GO-ROOT", build.Default.GOROOT, "output", string(output))
 		}
-		return err
+		println(" completed.")
+
+		return nil
 	}
 }
 
 // lookup and set Go related variables
-func (c *CommandConfig) InitGoPaths() {
-	// lookup go path
-	c.GoPath = build.Default.GOPATH
-	if c.GoPath == "" {
-		utils.Logger.Fatal("Abort: GOPATH environment variable is not set. " +
-			"Please refer to http://golang.org/doc/code.html to configure your Go environment.")
-	}
-
+func (c *CommandConfig) initGoPaths() {
+	utils.Logger.Info("InitGoPaths", "vendored", c.Vendored)
 	// check for go executable
 	var err error
 	c.GoCmd, err = exec.LookPath("go")
@@ -215,44 +265,89 @@ func (c *CommandConfig) InitGoPaths() {
 		utils.Logger.Fatal("Go executable not found in PATH.")
 	}
 
+	if c.Vendored {
+		return
+	}
+
+	// lookup go path
+	c.GoPath = build.Default.GOPATH
+	if c.GoPath == "" {
+		utils.Logger.Fatal("Abort: GOPATH environment variable is not set. " +
+			"Please refer to http://golang.org/doc/code.html to configure your Go environment.")
+	}
+	return
+	//todo determine if the rest needs to happen
+
+
 	// revel/revel#1004 choose go path relative to current working directory
 
 	// What we want to do is to add the import to the end of the
 	// gopath, and discover which import exists - If none exist this is an error except in the case
 	// where we are dealing with new which is a special case where we will attempt to target the working directory first
-	workingDir, _ := os.Getwd()
-	goPathList := filepath.SplitList(c.GoPath)
-	bestpath := ""
-	for _, path := range goPathList {
-		if c.Index == NEW {
-			// If the GOPATH is part of the working dir this is the most likely target
-			if strings.HasPrefix(workingDir, path) {
-				bestpath = path
-			}
-		} else {
-			if utils.Exists(filepath.Join(path, "src", c.ImportPath)) {
-				c.SrcRoot = path
-				break
+	/*
+		// If source root is empty and this isn't a version then skip it
+		if len(c.SrcRoot) == 0 {
+			if c.Index == NEW {
+				c.SrcRoot = c.New.ImportPath
+			} else {
+				if c.Index != VERSION {
+					utils.Logger.Fatal("Abort: could not create a Revel application outside of GOPATH.")
+				}
+				return
 			}
 		}
-	}
 
-	if len(c.SrcRoot)==0 && len(bestpath) > 0 {
-		c.SrcRoot = bestpath
-	}
-	utils.Logger.Info("Source root", "path", c.SrcRoot, "cwd", workingDir, "gopath", c.GoPath)
+		// set go src path
+		c.SrcRoot = filepath.Join(c.SrcRoot, "src")
 
-	// If source root is empty and this isn't a version then skip it
-	if len(c.SrcRoot) == 0 {
-		if c.Index != VERSION {
-			utils.Logger.Fatal("Abort: could not create a Revel application outside of GOPATH.")
-		}
-		return
-	}
+		c.AppPath = filepath.Join(c.SrcRoot, filepath.FromSlash(c.ImportPath))
+		utils.Logger.Info("Set application path", "path", c.AppPath)
 
-	// set go src path
-	c.SrcRoot = filepath.Join(c.SrcRoot, "src")
+	 */
 
-	c.AppPath = filepath.Join(c.SrcRoot, filepath.FromSlash(c.ImportPath))
-	utils.Logger.Info("Set application path", "path", c.AppPath)
+}
+
+// Sets the versions on the command config
+func (c *CommandConfig) SetVersions() (err error) {
+	c.CommandVersion, _ = ParseVersion(cmd.Version)
+	pathMap, err := utils.FindSrcPaths(c.AppPath, []string{RevelImportPath}, c.PackageResolver)
+	if err == nil {
+		utils.Logger.Info("Fullpath to revel", "dir", pathMap[RevelImportPath])
+		fset := token.NewFileSet() // positions are relative to fset
+
+		versionData, err := ioutil.ReadFile(filepath.Join(pathMap[RevelImportPath], "version.go"))
+		if err != nil {
+			utils.Logger.Error("Failed to find Revel version:", "error", err, "path", pathMap[RevelImportPath])
+		}
+
+		// Parse src but stop after processing the imports.
+		f, err := parser.ParseFile(fset, "", versionData, parser.ParseComments)
+		if err != nil {
+			return utils.NewBuildError("Failed to parse Revel version error:", "error", err)
+		}
+
+		// Print the imports from the file's AST.
+		for _, s := range f.Decls {
+			genDecl, ok := s.(*ast.GenDecl)
+			if !ok {
+				continue
+			}
+			if genDecl.Tok != token.CONST {
+				continue
+			}
+			for _, a := range genDecl.Specs {
+				spec := a.(*ast.ValueSpec)
+				r := spec.Values[0].(*ast.BasicLit)
+				if spec.Names[0].Name == "Version" {
+					c.FrameworkVersion, err = ParseVersion(strings.Replace(r.Value, `"`, ``, -1))
+					if err != nil {
+						utils.Logger.Errorf("Failed to parse version")
+					} else {
+						utils.Logger.Info("Parsed revel version", "version", c.FrameworkVersion.String())
+					}
+				}
+			}
+		}
+	}
+	return
 }

model/event_test.go

@@ -10,15 +10,15 @@ import (
 func TestEventHandler(t *testing.T) {
 	counter := 0
 	newListener := func(typeOf revel.Event, value interface{}) (responseOf revel.EventResponse) {
-		if typeOf == revel.REVEL_FAILURE {
+		if typeOf == revel.ENGINE_SHUTDOWN_REQUEST {
 			counter++
 		}
 		return
 	}
-	// Attach the same handlder twice so we expect to see the response twice as well
+	// Attach the same handler twice so we expect to see the response twice as well
 	revel.AddInitEventHandler(newListener)
 	revel.AddInitEventHandler(newListener)
-	revel.RaiseEvent(revel.REVEL_AFTER_MODULES_LOADED, nil)
-	revel.RaiseEvent(revel.REVEL_FAILURE, nil)
+	revel.StopServer(1)
 	assert.Equal(t, counter, 2, "Expected event handler to have been called")
 }
+

model/revel_container.go

@@ -4,13 +4,12 @@ package model
 import (
 	"github.com/revel/cmd/utils"
 	"github.com/revel/config"
-	"go/build"
-
 	"errors"
 	"fmt"
 	"path/filepath"
 	"sort"
 	"strings"
+	"golang.org/x/tools/go/packages"
 )
 
 type (
@@ -65,7 +64,11 @@ type (
 		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
+		ModulePathMap map[string]*ModuleInfo // The module path map
+	}
+	ModuleInfo struct {
+		ImportPath string
+		Path string
 	}
 
 	WrappedRevelCallback struct {
@@ -92,36 +95,37 @@ func (w *WrappedRevelCallback) PackageResolver(pkgName string) error {
 
 // RevelImportPath Revel framework import path
 var RevelImportPath = "github.com/revel/revel"
+var RevelModulesImportPath = "github.com/revel/modules"
 
 // 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, err error) {
-	rp = &RevelContainer{ModulePathMap: map[string]string{}}
+func NewRevelPaths(mode, importPath, appSrcPath string, callback RevelCallback) (rp *RevelContainer, err error) {
+	rp = &RevelContainer{ModulePathMap: map[string]*ModuleInfo{}}
 	// Ignore trailing slashes.
 	rp.ImportPath = strings.TrimRight(importPath, "/")
-	rp.SourcePath = srcPath
+	rp.SourcePath = appSrcPath
 	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 == "" {
-		rp.SourcePath, revelSourcePath, err = utils.FindSrcPaths(importPath, RevelImportPath, callback.PackageResolver)
-		if err != nil {
-			return
-		}
-	} else {
-		// If the SourcePath was specified, assume both Revel and the app are within it.
-		rp.SourcePath = filepath.Clean(rp.SourcePath)
-		revelSourcePath = rp.SourcePath
+	// We always need to determine the paths for files
+	pathMap, err := utils.FindSrcPaths(appSrcPath, []string{importPath+"/app", RevelImportPath}, callback.PackageResolver)
+	if err != nil {
+		return
+	}
+	rp.AppPath, rp.RevelPath = pathMap[importPath], pathMap[RevelImportPath]
+	// Setup paths for application
+	rp.BasePath = rp.SourcePath
+	rp.PackageInfo.Vendor = utils.Exists(filepath.Join(rp.BasePath, "go.mod"))
+	rp.AppPath = filepath.Join(rp.BasePath, "app")
+
+	// Sanity check , ensure app and conf paths exist
+	if !utils.DirExists(rp.AppPath)  {
+		return rp, fmt.Errorf("No application found at path %s", rp.AppPath)
+	}
+	if !utils.DirExists(filepath.Join(rp.BasePath, "conf")) {
+		return rp, fmt.Errorf("No configuration found at path %s", filepath.Join(rp.BasePath, "conf"))
 	}
 
-	// Setup paths for application
-	rp.RevelPath = filepath.Join(revelSourcePath, filepath.FromSlash(RevelImportPath))
-	rp.BasePath = filepath.Join(rp.SourcePath, filepath.FromSlash(importPath))
-	rp.PackageInfo.Vendor = utils.Exists(filepath.Join(rp.BasePath, "vendor"))
-	rp.AppPath = filepath.Join(rp.BasePath, "app")
 	rp.ViewsPath = filepath.Join(rp.AppPath, "views")
-
 	rp.CodePaths = []string{rp.AppPath}
 	rp.TemplatePaths = []string{}
 
@@ -179,6 +183,7 @@ func NewRevelPaths(mode, importPath, srcPath string, callback RevelCallback) (rp
 	rp.SecretStr = rp.Config.StringDefault("app.secret", "")
 
 	callback.FireEvent(REVEL_BEFORE_MODULES_LOADED, nil)
+	utils.Logger.Info("Loading modules")
 	if err := rp.loadModules(callback); err != nil {
 		return rp, err
 	}
@@ -218,7 +223,7 @@ func (rp *RevelContainer) loadModules(callback RevelCallback) (err error) {
 
 		modulePath, err := rp.ResolveImportPath(moduleImportPath)
 		if err != nil {
-			utils.Logger.Info("Missing module ", "module", moduleImportPath, "error",err)
+			utils.Logger.Info("Missing module ", "module_import_path", moduleImportPath, "error",err)
 			callback.PackageResolver(moduleImportPath)
 			modulePath, err = rp.ResolveImportPath(moduleImportPath)
 			if err != nil {
@@ -239,9 +244,10 @@ func (rp *RevelContainer) loadModules(callback RevelCallback) (err error) {
 
 // Adds a module paths to the container object
 func (rp *RevelContainer) addModulePaths(name, importPath, modulePath string) {
+	utils.Logger.Info("Adding module path","name", name,"import path", importPath,"system path", modulePath)
 	if codePath := filepath.Join(modulePath, "app"); utils.DirExists(codePath) {
 		rp.CodePaths = append(rp.CodePaths, codePath)
-		rp.ModulePathMap[name] = modulePath
+		rp.ModulePathMap[name] = &ModuleInfo{importPath, modulePath}
 		if viewsPath := filepath.Join(modulePath, "app", "views"); utils.DirExists(viewsPath) {
 			rp.TemplatePaths = append(rp.TemplatePaths, viewsPath)
 		}
@@ -264,13 +270,21 @@ func (rp *RevelContainer) ResolveImportPath(importPath string) (string, error) {
 	if rp.Packaged {
 		return filepath.Join(rp.SourcePath, importPath), nil
 	}
+	config := &packages.Config{
+		Mode: packages.LoadSyntax,
+		Dir:rp.AppPath,
+	}
 
-	modPkg, err := build.Import(importPath, rp.AppPath, build.FindOnly)
+	pkgs, err := packages.Load(config,  importPath)
+	if len(pkgs)==0 {
+		return "", errors.New("No packages found for import " + importPath +" using app path "+ rp.AppPath)
+	}
+//	modPkg, err := build.Import(importPath, rp.AppPath, build.FindOnly)
 	if err != nil {
 		return "", err
 	}
-	if rp.PackageInfo.Vendor && !strings.HasPrefix(modPkg.Dir,rp.BasePath) {
-		return "", fmt.Errorf("Module %s was found outside of path %s.",importPath, modPkg.Dir)
+	if len(pkgs[0].GoFiles)>0 {
+		return filepath.Dir(pkgs[0].GoFiles[0]), nil
 	}
-	return modPkg.Dir, nil
+	return pkgs[0].PkgPath, errors.New("No files found in import path " + importPath)
 }

model/source_info.go

@@ -12,14 +12,14 @@ import (
 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
+	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
+	ValidationKeys  map[string]map[int]string
 	// A list of import paths.
 	// Revel notices files with an init() function and imports that package.
 	InitImportPaths []string
@@ -28,7 +28,9 @@ type SourceInfo struct {
 	// app/controllers/... that embed (directly or indirectly) revel.Controller
 	controllerSpecs []*TypeInfo
 	// testSuites list the types that constitute the set of application tests.
-	testSuites []*TypeInfo
+	testSuites      []*TypeInfo
+	// packageMap a map of import to system directory (if available)
+	PackageMap      map[string]string
 }
 
 // TypesThatEmbed returns all types that (directly or indirectly) embed the
@@ -55,7 +57,6 @@ func (s *SourceInfo) TypesThatEmbed(targetType, packageFilter string) (filtered
 
 			// 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 typeSimpleName == embeddedType.String() {
@@ -74,7 +75,7 @@ func (s *SourceInfo) TypesThatEmbed(targetType, packageFilter string) (filtered
 				utils.Logger.Info("Debug: Skipping adding spec for unexported type",
 					"type", filteredItem.StructName,
 					"package", filteredItem.ImportPath)
-				filtered = append(filtered[:i], filtered[i+1:]...)
+				filtered = append(filtered[:i], filtered[i + 1:]...)
 				exit = false
 				break
 			}
@@ -97,8 +98,8 @@ func (s *SourceInfo) TypesThatEmbed(targetType, packageFilter string) (filtered
 
 			// 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),
+				utils.Logger.Warn("Type found in package: " + packageFilter +
+					", but did not embed from: " + filepath.Base(targetType),
 					"name", spec.StructName, "importpath", spec.ImportPath, "foundstructures", unfoundNames)
 			}
 		}
@@ -109,8 +110,9 @@ func (s *SourceInfo) TypesThatEmbed(targetType, packageFilter string) (filtered
 // ControllerSpecs returns the all the controllers that embeds
 // `revel.Controller`
 func (s *SourceInfo) ControllerSpecs() []*TypeInfo {
+	utils.Logger.Info("Scanning controller specifications for types ","typePath",RevelImportPath + ".Controller", "speclen",len(s.controllerSpecs))
 	if s.controllerSpecs == nil {
-		s.controllerSpecs = s.TypesThatEmbed(RevelImportPath+".Controller", "controllers")
+		s.controllerSpecs = s.TypesThatEmbed(RevelImportPath + ".Controller", "controllers")
 	}
 	return s.controllerSpecs
 }
@@ -119,7 +121,19 @@ func (s *SourceInfo) ControllerSpecs() []*TypeInfo {
 // `testing.TestSuite`
 func (s *SourceInfo) TestSuites() []*TypeInfo {
 	if s.testSuites == nil {
-		s.testSuites = s.TypesThatEmbed(RevelImportPath+"/testing.TestSuite", "testsuite")
+		s.testSuites = s.TypesThatEmbed(RevelImportPath + "/testing.TestSuite", "testsuite")
 	}
 	return s.testSuites
 }
+
+func (s *SourceInfo) Merge(srcInfo2 *SourceInfo) {
+	s.StructSpecs = append(s.StructSpecs, srcInfo2.StructSpecs...)
+	s.InitImportPaths = append(s.InitImportPaths, srcInfo2.InitImportPaths...)
+	for k, v := range srcInfo2.ValidationKeys {
+		if _, ok := s.ValidationKeys[k]; ok {
+			utils.Logger.Warn("Warn: Key conflict when scanning validation calls:", "key", k)
+			continue
+		}
+		s.ValidationKeys[k] = v
+	}
+}

model/version.go

@@ -0,0 +1,126 @@
+package model
+
+import (
+	"fmt"
+	"github.com/pkg/errors"
+	"regexp"
+	"strconv"
+)
+
+type Version struct {
+	Prefix       string
+	Major        int
+	Minor        int
+	Maintenance  int
+	Suffix       string
+	BuildDate    string
+	MinGoVersion string
+}
+
+// The compatibility list
+var frameworkCompatibleRangeList = [][]string{
+	{"0.0.0", "0.20.0"}, // minimum Revel version to use with this version of the tool
+	{"0.19.99", "0.30.0"}, // Compatible with Framework V 0.19.99 - 0.30.0
+	{"1.0.0", "1.9.0"}, // Compatible with Framework V 1.0 - 1.9
+}
+
+// Parses a version like v1.2.3a or 1.2
+var versionRegExp = regexp.MustCompile(`([^\d]*)?([0-9]*)\.([0-9]*)(\.([0-9]*))?(.*)`)
+
+// Parse the version and return it as a Version object
+func ParseVersion(version string) (v *Version, err error) {
+
+	v = &Version{}
+	return v, v.ParseVersion(version)
+}
+
+// Parse the version and return it as a Version object
+func (v *Version)ParseVersion(version string) (err error) {
+
+	parsedResult := versionRegExp.FindAllStringSubmatch(version, -1)
+	if len(parsedResult) != 1 {
+		err = errors.Errorf("Invalid version %s", version)
+		return
+	}
+	if len(parsedResult[0]) != 7 {
+		err = errors.Errorf("Invalid version %s", version)
+		return
+	}
+
+	v.Prefix = parsedResult[0][1]
+	v.Major = v.intOrZero(parsedResult[0][2])
+	v.Minor = v.intOrZero(parsedResult[0][3])
+	v.Maintenance = v.intOrZero(parsedResult[0][5])
+	v.Suffix = parsedResult[0][6]
+
+	return
+}
+// Returns 0 or an int value for the string, errors are returned as 0
+func (v *Version) intOrZero(input string) (value int) {
+	if input != "" {
+		value, _ = strconv.Atoi(input)
+	}
+	return value
+}
+
+// Returns true if this major revision is compatible
+func (v *Version) CompatibleFramework(c *CommandConfig) error {
+	for i, rv := range frameworkCompatibleRangeList {
+		start, _ := ParseVersion(rv[0])
+		end, _ := ParseVersion(rv[1])
+		if !v.Newer(start) || v.Newer(end) {
+			continue
+		}
+
+		// Framework is older then 0.20, turn on historic mode
+		if i == 0 {
+			c.HistoricMode = true
+		}
+		return nil
+	}
+	return errors.New("Tool out of date - do a 'go get -u github.com/revel/cmd/revel'")
+}
+
+// Returns true if this major revision is newer then the passed in
+func (v *Version) MajorNewer(o *Version) bool {
+	if v.Major != o.Major {
+		return v.Major > o.Major
+	}
+	return false
+}
+
+// Returns true if this major or major and minor revision is newer then the value passed in
+func (v *Version) MinorNewer(o *Version) bool {
+	if v.Major != o.Major {
+		return v.Major > o.Major
+	}
+	if v.Minor != o.Minor {
+		return v.Minor > o.Minor
+	}
+	return false
+}
+
+// Returns true if the version is newer then the current on
+func (v *Version) Newer(o *Version) bool {
+	if v.Major != o.Major {
+		return v.Major > o.Major
+	}
+	if v.Minor != o.Minor {
+		return v.Minor > o.Minor
+	}
+	if v.Maintenance != o.Maintenance {
+		return v.Maintenance > o.Maintenance
+	}
+	return true
+}
+
+// Convert the version to a string
+func (v *Version) VersionString() string {
+	return fmt.Sprintf("%s%d.%d.%d%s", v.Prefix, v.Major, v.Minor, v.Maintenance, v.Suffix)
+}
+
+// Convert the version build date and go version to a string
+func (v *Version) String() string {
+	return fmt.Sprintf("Version: %s%d.%d.%d%s\nBuild Date: %s\n Minimium Go Version: %s",
+		v.Prefix, v.Major, v.Minor, v.Maintenance, v.Suffix, v.BuildDate, v.MinGoVersion)
+}

model/version_test.go

@@ -0,0 +1,33 @@
+package model_test
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"github.com/revel/cmd/model"
+)
+
+var versionTests = [][]string{
+	{"v0.20.0-dev", "v0.20.0-dev"},
+	{"v0.20-dev", "v0.20.0-dev"},
+	{"v0.20.", "v0.20.0"},
+	{"2.0", "2.0.0"},
+}
+// Test that the event handler can be attached and it dispatches the event received
+func TestVersion(t *testing.T) {
+	for _, v:= range versionTests {
+		p,e:=model.ParseVersion(v[0])
+		assert.Nil(t,e,"Should have parsed %s",v)
+		assert.Equal(t,p.String(),v[1], "Should be equal %s==%s",p.String(),v)
+	}
+}
+
+// test the ranges
+func TestVersionRange(t *testing.T) {
+	a,_ := model.ParseVersion("0.1.2")
+	b,_ := model.ParseVersion("0.2.1")
+	c,_ := model.ParseVersion("1.0.1")
+	assert.True(t, b.MinorNewer(a), "B is newer then A")
+	assert.False(t, b.MajorNewer(a), "B is not major newer then A")
+	assert.False(t, b.MajorNewer(c), "B is not major newer then A")
+	assert.True(t, c.MajorNewer(b), "C is major newer then b")
+}

parser/appends.go

@@ -134,7 +134,7 @@ func appendAction(fset *token.FileSet, mm methodMap, decl ast.Decl, pkgImportPat
 			var importPath string
 			typeExpr := model.NewTypeExprFromAst(pkgName, field.Type)
 			if !typeExpr.Valid {
-				utils.Logger.Warn("Warn: Didn't understand argument '%s' of action %s. Ignoring.", name, getFuncName(funcDecl))
+				utils.Logger.Warnf("Warn: Didn't understand argument '%s' of action %s. Ignoring.", name, getFuncName(funcDecl))
 				return // We didn't understand one of the args.  Ignore this action.
 			}
 			// Local object

parser/imports.go

@@ -29,7 +29,10 @@ func addImports(imports map[string]string, decl ast.Decl, srcDir string) {
 				continue
 			}
 		}
-		quotedPath := importSpec.Path.Value           // e.g. "\"sample/app/models\""
+		quotedPath := importSpec.Path.Value // e.g. "\"sample/app/models\""
+		if quotedPath == `"C"` {
+			continue
+		}
 		fullPath := quotedPath[1 : len(quotedPath)-1] // Remove the quotes
 
 		// If the package was not aliased (common case), we have to import it
@@ -39,13 +42,14 @@ func addImports(imports map[string]string, decl ast.Decl, srcDir string) {
 		// 2. Exempt the standard library; their directories always match the package name.
 		// 3. Can use build.FindOnly and then use parser.ParseDir with mode PackageClauseOnly
 		if pkgAlias == "" {
+
 			utils.Logger.Debug("Reading from build", "path", fullPath, "srcPath", srcDir, "gopath", build.Default.GOPATH)
 			pkg, err := build.Import(fullPath, srcDir, 0)
 			if err != nil {
 				// We expect this to happen for apps using reverse routing (since we
 				// have not yet generated the routes).  Don't log that.
 				if !strings.HasSuffix(fullPath, "/app/routes") {
-					utils.Logger.Error("Could not find import:", "path", fullPath, "srcPath", srcDir, "error", err)
+					utils.Logger.Warn("Could not find import:", "path", fullPath, "srcPath", srcDir, "error", err)
 				}
 				continue
 			} else {
@@ -60,9 +64,10 @@ func addImports(imports map[string]string, decl ast.Decl, srcDir string) {
 
 // Returns a valid import string from the path
 // using the build.Defaul.GOPATH to determine the root
-func importPathFromPath(root string) string {
-	if vendorIdx := strings.Index(root, "/vendor/"); vendorIdx != -1 {
-		return filepath.ToSlash(root[vendorIdx+8:])
+func importPathFromPath(root, basePath string) string {
+	vendorTest := filepath.Join(basePath, "vendor")
+	if len(root) > len(vendorTest) && root[:len(vendorTest)] == vendorTest {
+		return filepath.ToSlash(root[len(vendorTest)+1:])
 	}
 	for _, gopath := range filepath.SplitList(build.Default.GOPATH) {
 		srcPath := filepath.Join(gopath, "src")

parser/reflect.go

@@ -37,7 +37,7 @@ type methodMap map[string][]*model.MethodSpec
 func ProcessSource(paths *model.RevelContainer) (_ *model.SourceInfo, compileError error) {
 	pc := &processContainer{paths: paths}
 	for _, root := range paths.CodePaths {
-		rootImportPath := importPathFromPath(root)
+		rootImportPath := importPathFromPath(root, paths.BasePath)
 		if rootImportPath == "" {
 			utils.Logger.Info("Skipping empty code path", "path", root)
 			continue
@@ -46,6 +46,9 @@ func ProcessSource(paths *model.RevelContainer) (_ *model.SourceInfo, compileErr
 
 		// Start walking the directory tree.
 		compileError = utils.Walk(root, pc.processPath)
+		if compileError != nil {
+			return
+		}
 	}
 
 	return pc.srcInfo, compileError
@@ -82,7 +85,7 @@ func (pc *processContainer) processPath(path string, info os.FileInfo, err error
 	if err != nil {
 		if errList, ok := err.(scanner.ErrorList); ok {
 			var pos = errList[0].Pos
-			newError := &utils.Error{
+			newError := &utils.SourceError{
 				SourceType:  ".go source",
 				Title:       "Go Compilation Error",
 				Path:        pos.Filename,

parser2/source_info_processor.go

@@ -0,0 +1,427 @@
+package parser2
+
+import (
+	"github.com/revel/cmd/utils"
+	"golang.org/x/tools/go/packages"
+	"github.com/revel/cmd/model"
+	"go/ast"
+	"go/token"
+	"strings"
+	"path/filepath"
+	"github.com/revel/cmd/logger"
+)
+
+type (
+	SourceInfoProcessor struct {
+		sourceProcessor *SourceProcessor
+	}
+)
+
+func NewSourceInfoProcessor(sourceProcessor *SourceProcessor) *SourceInfoProcessor {
+	return &SourceInfoProcessor{sourceProcessor:sourceProcessor}
+}
+
+func (s *SourceInfoProcessor) processPackage(p *packages.Package) (sourceInfo *model.SourceInfo) {
+	sourceInfo = &model.SourceInfo{
+		ValidationKeys: map[string]map[int]string{},
+	}
+	var (
+		isController = strings.HasSuffix(p.PkgPath, "/controllers") ||
+			strings.Contains(p.PkgPath, "/controllers/")
+		isTest = strings.HasSuffix(p.PkgPath, "/tests") ||
+			strings.Contains(p.PkgPath, "/tests/")
+		methodMap = map[string][]*model.MethodSpec{}
+	)
+	localImportMap := map[string]string{}
+	log := s.sourceProcessor.log.New("package", p.PkgPath)
+	log.Info("Processing package")
+	for _, tree := range p.Syntax {
+		for _, decl := range tree.Decls {
+
+			s.sourceProcessor.packageMap[p.PkgPath] = filepath.Dir(p.Fset.Position(decl.Pos()).Filename)
+			if !s.addImport(decl, p, localImportMap, log) {
+				continue
+			}
+			spec, found := s.getStructTypeDecl(decl, p.Fset)
+			//log.Info("Checking file","filename", p.Fset.Position(decl.Pos()).Filename,"found",found)
+			if found {
+				if isController || isTest {
+					controllerSpec := s.getControllerSpec(spec, p, localImportMap)
+					sourceInfo.StructSpecs = append(sourceInfo.StructSpecs, controllerSpec)
+				}
+			} else {
+				// Not a type definition, this could be a method for a controller try to extract that
+				// Func declaration?
+				funcDecl, ok := decl.(*ast.FuncDecl)
+				if !ok {
+					continue
+				}
+				// This could be a controller action endpoint, check and add if needed
+				if isController &&
+					funcDecl.Recv != nil && // Must have a receiver
+					funcDecl.Name.IsExported() && // be public
+					funcDecl.Type.Results != nil && len(funcDecl.Type.Results.List) == 1 {
+					// return one result
+					if m, receiver := s.getControllerFunc(funcDecl, p, localImportMap); m != nil {
+						methodMap[receiver] = append(methodMap[receiver], m)
+						log.Info("Added method map to ", "receiver", receiver, "method", m.Name)
+					}
+				}
+				// Check for validation
+				if lineKeyMap := s.getValidation(funcDecl, p); len(lineKeyMap) > 1 {
+					sourceInfo.ValidationKeys[p.PkgPath + "." + s.getFuncName(funcDecl)] = lineKeyMap
+				}
+				if funcDecl.Name.Name == "init" {
+					sourceInfo.InitImportPaths = append(sourceInfo.InitImportPaths, p.PkgPath)
+				}
+			}
+		}
+	}
+
+	// Add the method specs to the struct specs.
+	for _, spec := range sourceInfo.StructSpecs {
+		spec.MethodSpecs = methodMap[spec.StructName]
+	}
+
+	return
+}
+// Scan app source code for calls to X.Y(), where X is of type *Validation.
+//
+// Recognize these scenarios:
+// - "Y" = "Validation" and is a member of the receiver.
+//   (The common case for inline validation)
+// - "X" is passed in to the func as a parameter.
+//   (For structs implementing Validated)
+//
+// The line number to which a validation call is attributed is that of the
+// surrounding ExprStmt.  This is so that it matches what runtime.Callers()
+// reports.
+//
+// The end result is that we can set the default validation key for each call to
+// be the same as the local variable.
+func (s *SourceInfoProcessor) getValidation(funcDecl *ast.FuncDecl, p *packages.Package) (map[int]string) {
+	var (
+		lineKeys = make(map[int]string)
+
+		// Check the func parameters and the receiver's members for the *revel.Validation type.
+		validationParam = s.getValidationParameter(funcDecl)
+	)
+
+	ast.Inspect(funcDecl.Body, func(node ast.Node) bool {
+		// e.g. c.Validation.Required(arg) or v.Required(arg)
+		callExpr, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+
+		// e.g. c.Validation.Required or v.Required
+		funcSelector, ok := callExpr.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+
+		switch x := funcSelector.X.(type) {
+		case *ast.SelectorExpr: // e.g. c.Validation
+			if x.Sel.Name != "Validation" {
+				return true
+			}
+
+		case *ast.Ident: // e.g. v
+			if validationParam == nil || x.Obj != validationParam {
+				return true
+			}
+
+		default:
+			return true
+		}
+
+		if len(callExpr.Args) == 0 {
+			return true
+		}
+
+		// Given the validation expression, extract the key.
+		key := callExpr.Args[0]
+		switch expr := key.(type) {
+		case *ast.BinaryExpr:
+			// If the argument is a binary expression, take the first expression.
+			// (e.g. c.Validation.Required(myName != ""))
+			key = expr.X
+		case *ast.UnaryExpr:
+			// If the argument is a unary expression, drill in.
+			// (e.g. c.Validation.Required(!myBool)
+			key = expr.X
+		case *ast.BasicLit:
+			// If it's a literal, skip it.
+			return true
+		}
+
+		if typeExpr := model.NewTypeExprFromAst("", key); typeExpr.Valid {
+			lineKeys[p.Fset.Position(callExpr.End()).Line] = typeExpr.TypeName("")
+		} else {
+			s.sourceProcessor.log.Error("Error: Failed to generate key for field validation. Make sure the field name is valid.", "file", p.PkgPath,
+				"line", p.Fset.Position(callExpr.End()).Line, "function", funcDecl.Name.String())
+		}
+		return true
+	})
+
+	return lineKeys
+
+}
+// Check to see if there is a *revel.Validation as an argument.
+func (s *SourceInfoProcessor)  getValidationParameter(funcDecl *ast.FuncDecl) *ast.Object {
+	for _, field := range funcDecl.Type.Params.List {
+		starExpr, ok := field.Type.(*ast.StarExpr) // e.g. *revel.Validation
+		if !ok {
+			continue
+		}
+
+		selExpr, ok := starExpr.X.(*ast.SelectorExpr) // e.g. revel.Validation
+		if !ok {
+			continue
+		}
+
+		xIdent, ok := selExpr.X.(*ast.Ident) // e.g. rev
+		if !ok {
+			continue
+		}
+
+		if selExpr.Sel.Name == "Validation" && s.sourceProcessor.importMap[xIdent.Name] == model.RevelImportPath {
+			return field.Names[0].Obj
+		}
+	}
+	return nil
+}
+func (s *SourceInfoProcessor) getControllerFunc(funcDecl *ast.FuncDecl, p *packages.Package, localImportMap map[string]string) (method *model.MethodSpec, recvTypeName string) {
+	selExpr, ok := funcDecl.Type.Results.List[0].Type.(*ast.SelectorExpr)
+	if !ok {
+		return
+	}
+	if selExpr.Sel.Name != "Result" {
+		return
+	}
+	if pkgIdent, ok := selExpr.X.(*ast.Ident); !ok || s.sourceProcessor.importMap[pkgIdent.Name] != model.RevelImportPath {
+		return
+	}
+	method = &model.MethodSpec{
+		Name: funcDecl.Name.Name,
+	}
+
+	// Add a description of the arguments to the method.
+	for _, field := range funcDecl.Type.Params.List {
+		for _, name := range field.Names {
+			var importPath string
+			typeExpr := model.NewTypeExprFromAst(p.Name, field.Type)
+			if !typeExpr.Valid {
+				utils.Logger.Warn("Warn: Didn't understand argument '%s' of action %s. Ignoring.", name, s.getFuncName(funcDecl))
+				return // We didn't understand one of the args.  Ignore this action.
+			}
+			// Local object
+			if typeExpr.PkgName == p.Name {
+				importPath = p.PkgPath
+			} else if typeExpr.PkgName != "" {
+				var ok bool
+				if importPath, ok = localImportMap[typeExpr.PkgName]; !ok {
+					if importPath, ok = s.sourceProcessor.importMap[typeExpr.PkgName]; !ok {
+						utils.Logger.Error("Unable to find import", "importMap", s.sourceProcessor.importMap, "localimport", localImportMap)
+						utils.Logger.Fatalf("Failed to find import for arg of type: %s , %s", typeExpr.PkgName, typeExpr.TypeName(""))
+					}
+				}
+			}
+			method.Args = append(method.Args, &model.MethodArg{
+				Name:       name.Name,
+				TypeExpr:   typeExpr,
+				ImportPath: importPath,
+			})
+		}
+	}
+
+	// Add a description of the calls to Render from the method.
+	// Inspect every node (e.g. always return true).
+	method.RenderCalls = []*model.MethodCall{}
+	ast.Inspect(funcDecl.Body, func(node ast.Node) bool {
+		// Is it a function call?
+		callExpr, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+
+		// Is it calling (*Controller).Render?
+		selExpr, ok := callExpr.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+
+		// The type of the receiver is not easily available, so just store every
+		// call to any method called Render.
+		if selExpr.Sel.Name != "Render" {
+			return true
+		}
+
+		// Add this call's args to the renderArgs.
+		pos := p.Fset.Position(callExpr.Lparen)
+		methodCall := &model.MethodCall{
+			Line:  pos.Line,
+			Names: []string{},
+		}
+		for _, arg := range callExpr.Args {
+			argIdent, ok := arg.(*ast.Ident)
+			if !ok {
+				continue
+			}
+			methodCall.Names = append(methodCall.Names, argIdent.Name)
+		}
+		method.RenderCalls = append(method.RenderCalls, methodCall)
+		return true
+	})
+
+	var recvType = funcDecl.Recv.List[0].Type
+	if recvStarType, ok := recvType.(*ast.StarExpr); ok {
+		recvTypeName = recvStarType.X.(*ast.Ident).Name
+	} else {
+		recvTypeName = recvType.(*ast.Ident).Name
+	}
+	return
+}
+func (s *SourceInfoProcessor) getControllerSpec(spec *ast.TypeSpec, p *packages.Package, localImportMap map[string]string) (controllerSpec *model.TypeInfo) {
+	structType := spec.Type.(*ast.StructType)
+
+	// At this point we know it's a type declaration for a struct.
+	// Fill in the rest of the info by diving into the fields.
+	// Add it provisionally to the Controller list -- it's later filtered using field info.
+	controllerSpec = &model.TypeInfo{
+		StructName:  spec.Name.Name,
+		ImportPath:  p.PkgPath,
+		PackageName: p.Name,
+	}
+	log := s.sourceProcessor.log.New("file", p.Fset.Position(spec.Pos()).Filename, "position", p.Fset.Position(spec.Pos()).Line)
+	for _, field := range structType.Fields.List {
+		// If field.Names is set, it's not an embedded type.
+		if field.Names != nil {
+			continue
+		}
+
+		// A direct "sub-type" has an ast.Field as either:
+		//   Ident { "AppController" }
+		//   SelectorExpr { "rev", "Controller" }
+		// Additionally, that can be wrapped by StarExprs.
+		fieldType := field.Type
+		pkgName, typeName := func() (string, string) {
+			// Drill through any StarExprs.
+			for {
+				if starExpr, ok := fieldType.(*ast.StarExpr); ok {
+					fieldType = starExpr.X
+					continue
+				}
+				break
+			}
+
+			// If the embedded type is in the same package, it's an Ident.
+			if ident, ok := fieldType.(*ast.Ident); ok {
+				return "", ident.Name
+			}
+
+			if selectorExpr, ok := fieldType.(*ast.SelectorExpr); ok {
+				if pkgIdent, ok := selectorExpr.X.(*ast.Ident); ok {
+					return pkgIdent.Name, selectorExpr.Sel.Name
+				}
+			}
+			return "", ""
+		}()
+
+		// If a typename wasn't found, skip it.
+		if typeName == "" {
+			continue
+		}
+
+		// Find the import path for this type.
+		// If it was referenced without a package name, use the current package import path.
+		// Else, look up the package's import path by name.
+		var importPath string
+		if pkgName == "" {
+			importPath = p.PkgPath
+		} else {
+			var ok bool
+			if importPath, ok = localImportMap[pkgName]; !ok {
+				log.Debug("Debug: Unusual, failed to find package locally ", "package", pkgName, "type", typeName, "map", s.sourceProcessor.importMap, "usedin", )
+				if importPath, ok = s.sourceProcessor.importMap[pkgName]; !ok {
+					log.Error("Error: Failed to find import path for ", "package", pkgName, "type", typeName, "map", s.sourceProcessor.importMap, "usedin", )
+					continue
+				}
+			}
+		}
+
+		controllerSpec.EmbeddedTypes = append(controllerSpec.EmbeddedTypes, &model.EmbeddedTypeName{
+			ImportPath: importPath,
+			StructName: typeName,
+		})
+	}
+	s.sourceProcessor.log.Info("Added controller spec", "name", controllerSpec.StructName, "package", controllerSpec.ImportPath)
+	return
+}
+func (s *SourceInfoProcessor) getStructTypeDecl(decl ast.Decl, fset *token.FileSet) (spec *ast.TypeSpec, found bool) {
+	genDecl, ok := decl.(*ast.GenDecl)
+	if !ok {
+		return
+	}
+
+	if genDecl.Tok != token.TYPE {
+		return
+	}
+
+	if len(genDecl.Specs) == 0 {
+		utils.Logger.Warn("Warn: Surprising: %s:%d Decl contains no specifications", fset.Position(decl.Pos()).Filename, fset.Position(decl.Pos()).Line)
+		return
+	}
+
+	spec = genDecl.Specs[0].(*ast.TypeSpec)
+	_, found = spec.Type.(*ast.StructType)
+
+	return
+
+}
+func (s *SourceInfoProcessor) getFuncName(funcDecl *ast.FuncDecl) string {
+	prefix := ""
+	if funcDecl.Recv != nil {
+		recvType := funcDecl.Recv.List[0].Type
+		if recvStarType, ok := recvType.(*ast.StarExpr); ok {
+			prefix = "(*" + recvStarType.X.(*ast.Ident).Name + ")"
+		} else {
+			prefix = recvType.(*ast.Ident).Name
+		}
+		prefix += "."
+	}
+	return prefix + funcDecl.Name.Name
+}
+func (s *SourceInfoProcessor) addImport(decl ast.Decl, p *packages.Package, localImportMap map[string]string, log logger.MultiLogger) (shouldContinue bool) {
+	shouldContinue = true
+	genDecl, ok := decl.(*ast.GenDecl)
+	if !ok {
+		return
+	}
+
+	if genDecl.Tok == token.IMPORT {
+		shouldContinue = false
+		for _, spec := range genDecl.Specs {
+			importSpec := spec.(*ast.ImportSpec)
+			//fmt.Printf("*** import specification %#v\n", importSpec)
+			var pkgAlias string
+			if importSpec.Name != nil {
+				pkgAlias = importSpec.Name.Name
+				if pkgAlias == "_" {
+					continue
+				}
+			}
+			quotedPath := importSpec.Path.Value           // e.g. "\"sample/app/models\""
+			fullPath := quotedPath[1 : len(quotedPath) - 1] // Remove the quotes
+			if pkgAlias == "" {
+				pkgAlias = fullPath
+				if index := strings.LastIndex(pkgAlias, "/"); index > 0 {
+					pkgAlias = pkgAlias[index + 1:]
+				}
+			}
+			localImportMap[pkgAlias] = fullPath
+		}
+
+	}
+	return
+}

parser2/source_processor.go

@@ -0,0 +1,251 @@
+package parser2
+
+import (
+	"github.com/revel/cmd/model"
+	"golang.org/x/tools/go/packages"
+	"github.com/revel/cmd/utils"
+	"go/parser"
+	"strings"
+	"github.com/revel/cmd/logger"
+	"os"
+	"path/filepath"
+	"go/ast"
+	"go/token"
+	"go/scanner"
+)
+
+type (
+	SourceProcessor struct {
+		revelContainer      *model.RevelContainer
+		log                 logger.MultiLogger
+		packageList         []*packages.Package
+		importMap           map[string]string
+		packageMap          map[string]string
+		sourceInfoProcessor *SourceInfoProcessor
+		sourceInfo          *model.SourceInfo
+	}
+)
+
+func ProcessSource(revelContainer *model.RevelContainer) (sourceInfo *model.SourceInfo, compileError error) {
+	utils.Logger.Info("ProcessSource")
+	processor := NewSourceProcessor(revelContainer)
+	compileError = processor.parse()
+	sourceInfo = processor.sourceInfo
+	if compileError == nil {
+		processor.log.Infof("From parsers : Structures:%d InitImports:%d ValidationKeys:%d %v", len(sourceInfo.StructSpecs), len(sourceInfo.InitImportPaths), len(sourceInfo.ValidationKeys), sourceInfo.PackageMap)
+	}
+
+	return
+}
+
+func NewSourceProcessor(revelContainer *model.RevelContainer) *SourceProcessor {
+	s := &SourceProcessor{revelContainer:revelContainer, log:utils.Logger.New("parser", "SourceProcessor")}
+	s.sourceInfoProcessor = NewSourceInfoProcessor(s)
+	return s
+}
+
+func (s *SourceProcessor) parse() (compileError error) {
+	print("Parsing packages, (may require download if not cached)...")
+	if compileError = s.addPackages(); compileError != nil {
+		return
+	}
+	println(" Completed")
+	if compileError = s.addImportMap(); compileError != nil {
+		return
+	}
+	if compileError = s.addSourceInfo(); compileError != nil {
+		return
+	}
+
+	s.sourceInfo.PackageMap = map[string]string{}
+	getImportFromMap := func(packagePath string) string {
+		for path := range s.packageMap {
+			if strings.Index(path, packagePath) == 0 {
+				fullPath := s.packageMap[path]
+				return fullPath[:(len(fullPath) - len(path) + len(packagePath))]
+			}
+		}
+		return ""
+	}
+	s.sourceInfo.PackageMap[model.RevelImportPath] = getImportFromMap(model.RevelImportPath)
+	s.sourceInfo.PackageMap[s.revelContainer.ImportPath] = getImportFromMap(s.revelContainer.ImportPath)
+	for _, module := range s.revelContainer.ModulePathMap {
+		s.sourceInfo.PackageMap[module.ImportPath] = getImportFromMap(module.ImportPath)
+	}
+
+	return
+}
+
+// Using the packages.Load function load all the packages and type specifications (forces compile).
+// this sets the SourceProcessor.packageList         []*packages.Package
+func (s *SourceProcessor) addPackages() (err error) {
+	allPackages := []string{model.RevelImportPath + "/..."}
+	for _, module := range s.revelContainer.ModulePathMap {
+		allPackages = append(allPackages, module.ImportPath + "/...") // +"/app/controllers/...")
+	}
+	s.log.Info("Reading packages", "packageList", allPackages)
+	//allPackages = []string{s.revelContainer.ImportPath + "/..."} //+"/app/controllers/..."}
+
+	config := &packages.Config{
+		// ode: packages.NeedSyntax | packages.NeedCompiledGoFiles,
+		Mode:
+		packages.NeedTypes | // For compile error
+			packages.NeedDeps | // To load dependent files
+			packages.NeedName | // Loads the full package name
+			packages.NeedSyntax, // To load ast tree (for end points)
+		//Mode:	packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+		//	packages.NeedImports | packages.NeedDeps | packages.NeedExportsFile |
+		//	packages.NeedTypes | packages.NeedSyntax | packages.NeedTypesInfo |
+		//	packages.NeedTypesSizes,
+
+		//Mode: packages.NeedName | packages.NeedImports | packages.NeedDeps | packages.NeedExportsFile | packages.NeedFiles |
+		//	packages.NeedCompiledGoFiles | packages.NeedTypesSizes |
+		//	packages.NeedSyntax | packages.NeedCompiledGoFiles ,
+		//Mode:  packages.NeedSyntax | packages.NeedCompiledGoFiles |  packages.NeedName | packages.NeedFiles |
+		//	packages.LoadTypes | packages.NeedTypes | packages.NeedDeps,  //, // |
+		// packages.NeedTypes, // packages.LoadTypes | packages.NeedSyntax | packages.NeedTypesInfo,
+		//packages.LoadSyntax | packages.NeedDeps,
+		Dir:s.revelContainer.AppPath,
+	}
+	s.packageList, err = packages.Load(config, allPackages...)
+	s.log.Info("Loaded modules ", "len results", len(s.packageList), "error", err)
+
+	// Now process the files in the aap source folder	s.revelContainer.ImportPath + "/...",
+	err = utils.Walk(s.revelContainer.BasePath, s.processPath)
+	s.log.Info("Loaded apps and modules ", "len results", len(s.packageList), "error", err)
+	return
+}
+
+// This callback is used to build the packages for the "app" package. This allows us to
+// parse the source files without doing a full compile on them
+// This callback only processes folders, so any files passed to this will return a nil
+func (s *SourceProcessor) processPath(path string, info os.FileInfo, err error) error {
+	if err != nil {
+		s.log.Error("Error scanning app source:", "error", err)
+		return nil
+	}
+
+	// Ignore files and folders not marked tmp (since those are generated)
+	if !info.IsDir() || info.Name() == "tmp" {
+		return nil
+	}
+
+	// Real work for processing the folder
+	pkgImportPath := s.revelContainer.ImportPath
+	appPath := s.revelContainer.BasePath
+	if appPath != path {
+		pkgImportPath = s.revelContainer.ImportPath + "/" + filepath.ToSlash(path[len(appPath) + 1:])
+	}
+	s.log.Info("Processing source package folder", "package", pkgImportPath, "path", path)
+
+	// Parse files within the path.
+	var pkgMap map[string]*ast.Package
+	fset := token.NewFileSet()
+	pkgMap, err = parser.ParseDir(
+		fset,
+		path,
+		func(f os.FileInfo) bool {
+			return !f.IsDir() && !strings.HasPrefix(f.Name(), ".") && strings.HasSuffix(f.Name(), ".go")
+		},
+		0)
+
+	if err != nil {
+		if errList, ok := err.(scanner.ErrorList); ok {
+			var pos = errList[0].Pos
+			newError := &utils.SourceError{
+				SourceType:  ".go source",
+				Title:       "Go Compilation Error",
+				Path:        pos.Filename,
+				Description: errList[0].Msg,
+				Line:        pos.Line,
+				Column:      pos.Column,
+				SourceLines: utils.MustReadLines(pos.Filename),
+			}
+
+			errorLink := s.revelContainer.Config.StringDefault("error.link", "")
+			if errorLink != "" {
+				newError.SetLink(errorLink)
+			}
+			return newError
+		}
+
+		// This is exception, err already checked above. Here just a print
+		ast.Print(nil, err)
+		s.log.Fatal("Failed to parse dir", "error", err)
+	}
+
+	// Skip "main" packages.
+	delete(pkgMap, "main")
+
+	// Ignore packages that end with _test
+	// These cannot be included in source code that is not generated specifically as a test
+	for i := range pkgMap {
+		if len(i) > 6 {
+			if string(i[len(i) - 5:]) == "_test" {
+				delete(pkgMap, i)
+			}
+		}
+	}
+
+	// If there is no code in this directory, skip it.
+	if len(pkgMap) == 0 {
+		return nil
+	}
+
+	// There should be only one package in this directory.
+	if len(pkgMap) > 1 {
+		for i := range pkgMap {
+			println("Found duplicate packages in single directory ", i)
+		}
+		utils.Logger.Fatal("Most unexpected! Multiple packages in a single directory:", "packages", pkgMap)
+	}
+
+	// At this point there is only one package in the pkgs map,
+	p := &packages.Package{}
+	p.PkgPath = pkgImportPath
+	p.Fset = fset
+	for _, pkg := range pkgMap {
+		p.Name = pkg.Name
+		s.log.Info("Found package", "pkg.Name", pkg.Name, "p.Name", p.PkgPath)
+		for filename, astFile := range pkg.Files {
+			p.Syntax = append(p.Syntax, astFile)
+			p.GoFiles = append(p.GoFiles, filename)
+		}
+	}
+	s.packageList = append(s.packageList, p)
+
+	return nil
+}
+
+// This function is used to populate a map so that we can lookup controller embedded types in order to determine
+// if a Struct inherits from from revel.Controller
+func (s *SourceProcessor) addImportMap() (err error) {
+	s.importMap = map[string]string{}
+	s.packageMap = map[string]string{}
+	for _, p := range s.packageList {
+
+		if len(p.Errors) > 0 {
+			// Generate a compile error
+			for _, e := range p.Errors {
+				s.log.Info("While reading packages encountered import error ignoring ", "PkgPath", p.PkgPath, "error", e)
+			}
+		}
+		for _, tree := range p.Syntax {
+			s.importMap[tree.Name.Name] = p.PkgPath
+		}
+	}
+	return
+}
+
+func (s *SourceProcessor) addSourceInfo() (err error) {
+	for _, p := range s.packageList {
+		if sourceInfo := s.sourceInfoProcessor.processPackage(p); sourceInfo != nil {
+			if s.sourceInfo != nil {
+				s.sourceInfo.Merge(sourceInfo)
+			} else {
+				s.sourceInfo = sourceInfo
+			}
+		}
+	}
+	return
+}

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{
@@ -38,6 +37,12 @@ func init() {
 // The update config updates the configuration command so that it can run
 func updateBuildConfig(c *model.CommandConfig, args []string) bool {
 	c.Index = model.BUILD
+	if c.Build.TargetPath == "" {
+		c.Build.TargetPath = "target"
+	}
+	if len(args) == 0 && c.Build.ImportPath != "" {
+		return true
+	}
 	// If arguments were passed in then there must be two
 	if len(args) < 2 {
 		fmt.Fprintf(os.Stderr, "%s\n%s", cmdBuild.UsageLine, cmdBuild.Long)
@@ -54,6 +59,7 @@ func updateBuildConfig(c *model.CommandConfig, args []string) bool {
 
 // The main entry point to build application from command line
 func buildApp(c *model.CommandConfig) (err error) {
+
 	appImportPath, destPath, mode := c.ImportPath, c.Build.TargetPath, DefaultRunMode
 	if len(c.Build.Mode) > 0 {
 		mode = c.Build.Mode
@@ -62,13 +68,16 @@ func buildApp(c *model.CommandConfig) (err error) {
 	// Convert target to absolute path
 	c.Build.TargetPath, _ = filepath.Abs(destPath)
 	c.Build.Mode = mode
+	c.Build.ImportPath = appImportPath
 
-	revel_paths, err := model.NewRevelPaths(mode, appImportPath, "", model.NewWrappedRevelCallback(nil, c.PackageResolver))
+	revel_paths, err := model.NewRevelPaths(mode, appImportPath, c.AppPath, model.NewWrappedRevelCallback(nil, c.PackageResolver))
 	if err != nil {
 		return
 	}
 
-	buildSafetyCheck(destPath)
+	if err = buildSafetyCheck(destPath); err != nil {
+		return
+	}
 
 	// Ensure the application can be built, this generates the main file
 	app, err := harness.Build(c, revel_paths)
@@ -86,7 +95,7 @@ func buildApp(c *model.CommandConfig) (err error) {
 	if err != nil {
 		return
 	}
-	err = buildCopyModules(c, revel_paths, packageFolders)
+	err = buildCopyModules(c, revel_paths, packageFolders, app)
 	if err != nil {
 		return
 	}
@@ -105,7 +114,7 @@ func buildCopyFiles(c *model.CommandConfig, app *harness.App, revel_paths *model
 	srcPath := filepath.Join(destPath, "src")
 	destBinaryPath := filepath.Join(destPath, filepath.Base(app.BinaryPath))
 	tmpRevelPath := filepath.Join(srcPath, filepath.FromSlash(model.RevelImportPath))
-	if err = utils.CopyFile(destBinaryPath, app.BinaryPath); err != nil {
+	if err = utils.CopyFile(destBinaryPath, filepath.Join(revel_paths.BasePath, app.BinaryPath)); err != nil {
 		return
 	}
 	utils.MustChmod(destBinaryPath, 0755)
@@ -146,14 +155,14 @@ func buildCopyFiles(c *model.CommandConfig, app *harness.App, revel_paths *model
 }
 
 // Based on the section copy over the build modules
-func buildCopyModules(c *model.CommandConfig, revel_paths *model.RevelContainer, packageFolders []string) (err error) {
+func buildCopyModules(c *model.CommandConfig, revel_paths *model.RevelContainer, packageFolders []string, app *harness.App) (err error) {
 	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 {
@@ -168,17 +177,14 @@ 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
 		}
 	}
 
 	// Copy the the paths for each of the modules
-	for importPath, fsPath := range modulePaths {
+	for _, importPath := range moduleImportList {
+		fsPath := app.PackagePathMap[importPath]
 		utils.Logger.Info("Copy files ", "to", filepath.Join(destPath, importPath), "from", fsPath)
 		if c.Build.CopySource {
 			err = utils.CopyDir(filepath.Join(destPath, importPath), fsPath, nil)

revel/build_test.go

@@ -1,19 +1,20 @@
 package main_test
 
 import (
-	"github.com/revel/cmd/model"
-	"github.com/revel/cmd/revel"
-	"github.com/revel/cmd/utils"
-	"github.com/stretchr/testify/assert"
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/revel/cmd/model"
+	main "github.com/revel/cmd/revel"
+	"github.com/revel/cmd/utils"
+	"github.com/stretchr/testify/assert"
 )
 
 // test the commands
 func TestBuild(t *testing.T) {
 	a := assert.New(t)
-	gopath := setup("revel-test-build",  a)
+	gopath := setup("revel-test-build", a)
 
 	t.Run("Build", func(t *testing.T) {
 		a := assert.New(t)
@@ -26,6 +27,21 @@ func TestBuild(t *testing.T) {
 		a.True(utils.Exists(filepath.Join(gopath, "build-test", "target")))
 	})
 
+	t.Run("Build-withFlags", func(t *testing.T) {
+		a := assert.New(t)
+		c := newApp("build-test-WithFlags", model.NEW, nil, a)
+		c.BuildFlags = []string{
+			"build-test-WithFlags/app.AppVersion=SomeValue",
+			"build-test-WithFlags/app.SomeOtherValue=SomeValue",
+		}
+		main.Commands[model.NEW].RunWith(c)
+		c.Index = model.BUILD
+		c.Build.TargetPath = filepath.Join(gopath, "build-test", "target")
+		c.Build.ImportPath = c.ImportPath
+		a.Nil(main.Commands[model.BUILD].RunWith(c), "Failed to run build-test-withFlags")
+		a.True(utils.Exists(filepath.Join(gopath, "build-test", "target")))
+	})
+
 	if !t.Failed() {
 		if err := os.RemoveAll(gopath); err != nil {
 			a.Fail("Failed to remove test path")

revel/clean.go

@@ -8,7 +8,7 @@ import (
 	"fmt"
 	"github.com/revel/cmd/model"
 	"github.com/revel/cmd/utils"
-	"go/build"
+
 	"os"
 	"path/filepath"
 )
@@ -37,6 +37,9 @@ func init() {
 // Update the clean command configuration, using old method
 func updateCleanConfig(c *model.CommandConfig, args []string) bool {
 	c.Index = model.CLEAN
+	if len(args) == 0 && c.Clean.ImportPath != "" {
+		return true
+	}
 	if len(args) == 0 {
 		fmt.Fprintf(os.Stderr, cmdClean.Long)
 		return false
@@ -47,14 +50,10 @@ func updateCleanConfig(c *model.CommandConfig, args []string) bool {
 
 // Clean the source directory of generated files
 func cleanApp(c *model.CommandConfig) (err error) {
-	appPkg, err := build.Import(c.ImportPath, "", build.FindOnly)
-	if err != nil {
-		utils.Logger.Fatal("Abort: Failed to find import path:", "error", err)
-	}
 
 	purgeDirs := []string{
-		filepath.Join(appPkg.Dir, "app", "tmp"),
-		filepath.Join(appPkg.Dir, "app", "routes"),
+		filepath.Join(c.AppPath, "app", "tmp"),
+		filepath.Join(c.AppPath, "app", "routes"),
 	}
 
 	for _, dir := range purgeDirs {

revel/clean_test.go

@@ -22,12 +22,12 @@ func TestClean(t *testing.T) {
 		main.Commands[model.NEW].RunWith(c)
 		c.Index = model.TEST
 		main.Commands[model.TEST].RunWith(c)
-		a.True(utils.Exists(filepath.Join(gopath, "src", "clean-test", "app", "tmp", "main.go")),
-			"Missing main from path "+filepath.Join(gopath, "src", "clean-test", "app", "tmp", "main.go"))
+		a.True(utils.Exists(filepath.Join(gopath, "clean-test", "app", "tmp", "main.go")),
+			"Missing main from path "+filepath.Join(gopath, "clean-test", "app", "tmp", "main.go"))
 		c.Clean.ImportPath = c.ImportPath
 		a.Nil(main.Commands[model.CLEAN].RunWith(c), "Failed to run clean-test")
-		a.False(utils.Exists(filepath.Join(gopath, "src", "clean-test", "app", "tmp", "main.go")),
-			"Did not remove main from path "+filepath.Join(gopath, "src", "clean-test", "app", "tmp", "main.go"))
+		a.False(utils.Exists(filepath.Join(gopath, "clean-test", "app", "tmp", "main.go")),
+			"Did not remove main from path "+filepath.Join(gopath, "clean-test", "app", "tmp", "main.go"))
 	})
 	if !t.Failed() {
 		if err := os.RemoveAll(gopath); err != nil {

revel/command_test.go

@@ -7,7 +7,9 @@ import (
 	"github.com/stretchr/testify/assert"
 	"go/build"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"fmt"
 )
 
 // Test that the event handler can be attached and it dispatches the event received
@@ -43,10 +45,26 @@ func setup(suffix string, a *assert.Assertions) (string) {
 
 // Create a new app for the name
 func newApp(name string, command model.COMMAND, precall func(c *model.CommandConfig), a *assert.Assertions) *model.CommandConfig {
-	c := &model.CommandConfig{}
+	c := &model.CommandConfig{Vendored:true}
 	switch command {
 	case model.NEW:
 		c.New.ImportPath = name
+		c.New.Callback=func() error {
+			// On callback we will invoke a specific branch of revel so that it works
+
+			goModCmd := exec.Command("go", "mod", "tidy")
+			utils.CmdInit(goModCmd, !c.Vendored, c.AppPath)
+			getOutput, _ := goModCmd.CombinedOutput()
+			fmt.Printf("Calling go mod tidy %s",string(getOutput))
+
+			goModCmd = exec.Command("go", "mod", "edit", "-replace=github.com/revel/revel=github.com/revel/revel@develop")
+			utils.CmdInit(goModCmd, !c.Vendored, c.AppPath)
+			getOutput, _ = goModCmd.CombinedOutput()
+			fmt.Printf("Calling go mod edit %v",string(getOutput))
+
+
+			return nil
+		}
 	case model.BUILD:
 		c.Build.ImportPath = name
 	case model.TEST:
@@ -65,10 +83,10 @@ func newApp(name string, command model.COMMAND, precall func(c *model.CommandCon
 	if precall != nil {
 		precall(c)
 	}
-	if !c.UpdateImportPath() {
+	if c.UpdateImportPath()!=nil {
 		a.Fail("Unable to update import path")
 	}
-	c.InitGoPaths()
+
 	c.InitPackageResolver()
 	return c
 }

revel/new.go

@@ -46,14 +46,23 @@ func init() {
 // Called when unable to parse the command line automatically and assumes an old launch
 func updateNewConfig(c *model.CommandConfig, args []string) bool {
 	c.Index = model.NEW
+	if len(c.New.Package) > 0 {
+		c.New.NotVendored = false
+	}
+	c.Vendored = !c.New.NotVendored
+
 	if len(args) == 0 {
-		fmt.Fprintf(os.Stderr, cmdNew.Long)
-		return false
+		if len(c.New.ImportPath) == 0 {
+			fmt.Fprintf(os.Stderr, cmdNew.Long)
+			return false
+		}
+		return true
 	}
 	c.New.ImportPath = args[0]
 	if len(args) > 1 {
 		c.New.SkeletonPath = args[1]
 	}
+
 	return true
 
 }
@@ -63,81 +72,39 @@ func newApp(c *model.CommandConfig) (err error) {
 	// Check for an existing folder so we don't clobber it
 	_, err = build.Import(c.ImportPath, "", build.FindOnly)
 	if err == nil || !utils.Empty(c.AppPath) {
-		return utils.NewBuildError("Abort: Import path already exists.", "path", c.ImportPath)
+		return utils.NewBuildError("Abort: Import path already exists.", "path", c.ImportPath, "apppath", c.AppPath)
 	}
+
+	// checking and setting skeleton
+	if err = setSkeletonPath(c); err != nil {
+		return
+	}
+
+	// Create application path
 	if err := os.MkdirAll(c.AppPath, os.ModePerm); err != nil {
 		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)
-		getOutput, err := getCmd.CombinedOutput()
-		if err != nil {
-			return utils.NewBuildIfError(err, string(getOutput))
-		}
-	}
-
 	// checking and setting application
-
 	if err = setApplicationPath(c); err != nil {
 		return err
 	}
 
-	// checking and setting skeleton
-	if err=setSkeletonPath(c);err!=nil {
-		return
+	// This kicked off the download of the revel app, not needed for vendor
+	if !c.Vendored {
+		// At this point the versions can be set
+		c.SetVersions()
 	}
 
 	// copy files to new app directory
-	if err = copyNewAppFiles(c);err != nil {
+	if err = copyNewAppFiles(c); err != nil {
 		return
 	}
 
-	// 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))
+	// Run the vendor tool if needed
+	if c.Vendored {
+		if err = createModVendor(c); err != nil {
+			return
 		}
 	}
 
@@ -145,6 +112,10 @@ func newApp(c *model.CommandConfig) (err error) {
 	fmt.Fprintln(os.Stdout, "Your application has been created in:\n  ", c.AppPath)
 	// Check to see if it should be run right off
 	if c.New.Run {
+		// Need to prep the run command
+		c.Run.ImportPath = c.ImportPath
+		updateRunConfig(c,nil)
+		c.UpdateImportPath()
 		runApp(c)
 	} else {
 		fmt.Fprintln(os.Stdout, "\nYou can run it with:\n   revel run -a ", c.ImportPath)
@@ -152,6 +123,72 @@ 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.Vendored, c.AppPath)
+
+	utils.Logger.Info("Exec:", "args", goModCmd.Args, "env", goModCmd.Env, "workingdir", goModCmd.Dir)
+	getOutput, err := goModCmd.CombinedOutput()
+	if c.New.Callback != nil {
+		err = c.New.Callback()
+	}
+	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.Vendored, 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"
 
@@ -170,59 +207,65 @@ func setApplicationPath(c *model.CommandConfig) (err error) {
 	// revel/revel#1014 validate relative path, we cannot use built-in functions
 	// since Go import path is valid relative path too.
 	// so check basic part of the path, which is "."
-	if filepath.IsAbs(c.ImportPath) || strings.HasPrefix(c.ImportPath, ".") {
-		utils.Logger.Fatalf("Abort: '%s' looks like a directory.  Please provide a Go import path instead.",
-			c.ImportPath)
-	}
 
 	// If we are running a vendored version of Revel we do not need to check for it.
-	if !c.New.Vendored {
+	if !c.Vendored {
+		if filepath.IsAbs(c.ImportPath) || strings.HasPrefix(c.ImportPath, ".") {
+			utils.Logger.Fatalf("Abort: '%s' looks like a directory.  Please provide a Go import path instead.",
+				c.ImportPath)
+		}
 		_, err = build.Import(model.RevelImportPath, "", build.FindOnly)
 		if err != nil {
 			//// Go get the revel project
 			err = c.PackageResolver(model.RevelImportPath)
 			if err != nil {
-				return utils.NewBuildIfError(err, "Failed to fetch revel "+model.RevelImportPath)
+				return utils.NewBuildIfError(err, "Failed to fetch revel " + model.RevelImportPath)
 			}
 		}
 	}
 
 	c.AppName = filepath.Base(c.AppPath)
 
-	//if c.BasePath == "." {
-	//	// we need to remove the a single '.' when
-	//	// the app is in the $GOROOT/src directory
-	//	c.BasePath = ""
-	//} else {
-	//	// we need to append a '/' when the app is
-	//	// is a subdirectory such as $GOROOT/src/path/to/revelapp
-	//	c.BasePath += "/"
-	//}
-
 	return nil
 }
 
 // Set the skeleton path
 func setSkeletonPath(c *model.CommandConfig) (err error) {
 	if len(c.New.SkeletonPath) == 0 {
-		c.New.SkeletonPath = "git://" + RevelSkeletonsImportPath + ":basic/bootstrap4"
+		c.New.SkeletonPath = "https://" + RevelSkeletonsImportPath + ":basic/bootstrap4"
 	}
 
 	// First check to see the protocol of the string
-	if sp, err := url.Parse(c.New.SkeletonPath); err == nil {
+	sp, err := url.Parse(c.New.SkeletonPath)
+	if err == nil {
 		utils.Logger.Info("Detected skeleton path", "path", sp)
 
 		switch strings.ToLower(sp.Scheme) {
-		// TODO Add support for https, http, ftp, file
+		// TODO Add support for ftp, sftp, scp ??
+		case "" :
+			sp.Scheme = "file"
+			fallthrough
+		case "file" :
+			fullpath := sp.String()[7:]
+			if !filepath.IsAbs(fullpath) {
+				fullpath, err = filepath.Abs(fullpath)
+				if err != nil {
+					return
+				}
+			}
+			c.New.SkeletonPath = fullpath
+			utils.Logger.Info("Set skeleton path to ", fullpath)
+			if !utils.DirExists(fullpath) {
+				return fmt.Errorf("Failed to find skeleton in filepath %s %s", fullpath, sp.String())
+			}
 		case "git":
+			fallthrough
+		case "http":
+			fallthrough
+		case "https":
 			if err := newLoadFromGit(c, sp); err != nil {
 				return err
 			}
-		//case "":
-
-			//if err := newLoadFromGo(c, sp); err != nil {
-			//	return err
-			//}
 		default:
 			utils.Logger.Fatal("Unsupported skeleton schema ", "path", c.New.SkeletonPath)
 
@@ -241,11 +284,11 @@ func newLoadFromGit(c *model.CommandConfig, sp *url.URL) (err error) {
 	targetPath := filepath.Join(os.TempDir(), "revel", "skeleton")
 	os.RemoveAll(targetPath)
 	pathpart := strings.Split(sp.Path, ":")
-	getCmd := exec.Command("git", "clone", sp.Scheme+"://"+sp.Host+pathpart[0], targetPath)
+	getCmd := exec.Command("git", "clone", sp.Scheme + "://" + sp.Host + pathpart[0], targetPath)
 	utils.Logger.Info("Exec:", "args", getCmd.Args)
 	getOutput, err := getCmd.CombinedOutput()
 	if err != nil {
-		utils.Logger.Fatalf("Abort: could not clone the  Skeleton  source code: \n%s\n%s\n", getOutput, c.New.SkeletonPath)
+		utils.Logger.Fatal("Abort: could not clone the  Skeleton  source code: ", "output", string(getOutput), "path", c.New.SkeletonPath)
 	}
 	outputPath := targetPath
 	if len(pathpart) > 1 {
@@ -307,20 +350,27 @@ const (
 # [[override]]
 #  name = "github.com/x/y"
 #  version = "2.4.0"
-required = ["github.com/revel/cmd/revel"]
+required = ["github.com/revel/revel", "github.com/revel/modules"]
+
+# Note to use a specific version changes this to
+#
+# [[override]]
+#   version = "0.20.1"
+#   name = "github.com/revel/modules"
 
 [[override]]
   branch = "master"
   name = "github.com/revel/modules"
 
+# Note to use a specific version changes this to
+#
+# [[override]]
+#   version = "0.20.0"
+#   name = "github.com/revel/revel"
 [[override]]
   branch = "master"
   name = "github.com/revel/revel"
 
-[[override]]
-  branch = "master"
-  name = "github.com/revel/cmd"
-
 [[override]]
   branch = "master"
   name = "github.com/revel/log15"

revel/new_test.go

@@ -3,95 +3,48 @@ package main_test
 import (
 	"github.com/revel/cmd/model"
 	"github.com/revel/cmd/revel"
-	"github.com/revel/cmd/utils"
 	"github.com/stretchr/testify/assert"
-	"io/ioutil"
 	"os"
-	"path/filepath"
 	"testing"
 )
 
 // test the commands
 func TestNew(t *testing.T) {
 	a := assert.New(t)
-	gopath := setup("revel-test-new",  a)
+	gopath := setup("revel-test-new", a)
 
-		t.Run("New", func(t *testing.T) {
-			a := assert.New(t)
-			c := newApp("new-test", model.NEW, nil, a)
-			a.Nil(main.Commands[model.NEW].RunWith(c), "New failed")
-		})
-		t.Run("Path", func(t *testing.T) {
-			a := assert.New(t)
-			c := newApp("new/test/a", model.NEW, nil, a)
-			a.Nil(main.Commands[model.NEW].RunWith(c), "New path failed")
-		})
-		t.Run("Path-Duplicate", func(t *testing.T) {
-			a := assert.New(t)
-			c := newApp("new/test/b", model.NEW, nil, a)
-			a.Nil(main.Commands[model.NEW].RunWith(c), "New path failed")
-			c = newApp("new/test/b", model.NEW, nil, a)
-			a.NotNil(main.Commands[model.NEW].RunWith(c), "Duplicate path Did Not failed")
-		})
-		t.Run("Skeleton-Git", func(t *testing.T) {
-			a := assert.New(t)
-			c := newApp("new/test/c/1", model.NEW, nil, a)
-			c.New.SkeletonPath = "git://github.com/revel/skeletons:basicnsadnsak"
-			a.NotNil(main.Commands[model.NEW].RunWith(c), "Expected Failed to run with new")
-			// We need to pick a different path
-			c = newApp("new/test/c/2", model.NEW, nil, a)
-			c.New.SkeletonPath = "git://github.com/revel/skeletons:basic/bootstrap4"
-			a.Nil(main.Commands[model.NEW].RunWith(c), "Failed to run with new skeleton git")
-		})
-	if !t.Failed() {
-		if err := os.RemoveAll(gopath); err != nil {
-			a.Fail("Failed to remove test path")
-		}
-	}
-}
-
-// test the commands
-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
-	}
 	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 := newApp("new-test", model.NEW, nil, a)
 		a.Nil(main.Commands[model.NEW].RunWith(c), "New failed")
 	})
-	t.Run("Test", func(t *testing.T) {
+	t.Run("New-NotVendoredmode", func(t *testing.T) {
 		a := assert.New(t)
-		c := newApp("onlyone/v/a", model.TEST, nil, a)
-		a.Nil(main.Commands[model.TEST].RunWith(c), "Test failed")
+		c := newApp("new-notvendored", model.NEW, nil, a)
+		c.New.NotVendored = true
+		a.Nil(main.Commands[model.NEW].RunWith(c), "New failed")
 	})
-	t.Run("Build", func(t *testing.T) {
+	t.Run("Path", func(t *testing.T) {
 		a := assert.New(t)
-		c := newApp("onlyone/v/a", model.BUILD, nil, a)
-		c.Index = model.BUILD
-		c.Build.TargetPath = filepath.Join(gopath, "src/onlyone/v/a", "target")
-		a.Nil(main.Commands[model.BUILD].RunWith(c), " Build failed")
-		a.True(utils.DirExists(c.Build.TargetPath), "Target folder not made", c.Build.TargetPath)
+		c := newApp("new/test/a", model.NEW, nil, a)
+		a.Nil(main.Commands[model.NEW].RunWith(c), "New path failed")
 	})
-	t.Run("Package", func(t *testing.T) {
+	t.Run("Path-Duplicate", func(t *testing.T) {
 		a := assert.New(t)
-		c := newApp("onlyone/v/a", model.PACKAGE, nil, a)
-		c.Package.TargetPath = filepath.Join(gopath, "src/onlyone/v/a", "target.tar.gz")
-		a.Nil(main.Commands[model.PACKAGE].RunWith(c), "Package Failed")
-		a.True(utils.Exists(c.Package.TargetPath), "Target package not made", c.Package.TargetPath)
+		c := newApp("new/test/b", model.NEW, nil, a)
+		a.Nil(main.Commands[model.NEW].RunWith(c), "New path failed")
+		c = newApp("new/test/b", model.NEW, nil, a)
+		a.NotNil(main.Commands[model.NEW].RunWith(c), "Duplicate path Did Not failed")
 	})
-	t.Run("TestVendorDir", func(t *testing.T) {
-		// Check to see that no additional packages were downloaded outside the vendor folder
-		files, err := ioutil.ReadDir(gopath)
-		a.Nil(err, "Failed to read gopath folder")
-		// bin/     onlyone/ pkg/     src/
-		a.Equal(3, len(files), "Expected single file in "+gopath)
-		files, err = ioutil.ReadDir(filepath.Join(gopath, "src"))
-		a.Nil(err, "Failed to read src folder")
-		a.Equal(1, len(files), "Expected single file in source folder", filepath.Join(gopath, "src"))
+	t.Run("Skeleton-Git", func(t *testing.T) {
+		a := assert.New(t)
+		c := newApp("new/test/c/1", model.NEW, nil, a)
+		c.New.SkeletonPath = "git://github.com/revel/skeletons:basicnsadnsak"
+		a.NotNil(main.Commands[model.NEW].RunWith(c), "Expected Failed to run with new")
+		// We need to pick a different path
+		c = newApp("new/test/c/2", model.NEW, nil, a)
+		c.New.SkeletonPath = "git://github.com/revel/skeletons:basic/bootstrap4"
+		a.Nil(main.Commands[model.NEW].RunWith(c), "Failed to run with new skeleton git")
 	})
 	if !t.Failed() {
 		if err := os.RemoveAll(gopath); err != nil {
@@ -99,3 +52,4 @@ func TestNewVendor(t *testing.T) {
 		}
 	}
 }
+

revel/package.go

@@ -40,6 +40,9 @@ func init() {
 // Called when unable to parse the command line automatically and assumes an old launch
 func updatePackageConfig(c *model.CommandConfig, args []string) bool {
 	c.Index = model.PACKAGE
+	if len(args)==0 && c.Package.ImportPath!="" {
+		return true
+	}
 	c.Package.ImportPath = args[0]
 	if len(args) > 1 {
 		c.Package.Mode = args[1]
@@ -58,7 +61,7 @@ func packageApp(c *model.CommandConfig) (err error) {
 	}
 
 	appImportPath := c.ImportPath
-	revel_paths, err := model.NewRevelPaths(mode, appImportPath, "", model.NewWrappedRevelCallback(nil, c.PackageResolver))
+	revel_paths, err := model.NewRevelPaths(mode, appImportPath, c.AppPath, model.NewWrappedRevelCallback(nil, c.PackageResolver))
 	if err != nil {
 		return
 	}
@@ -86,7 +89,9 @@ func packageApp(c *model.CommandConfig) (err error) {
 	}
 	c.Build.TargetPath = tmpDir
 	c.Build.CopySource = c.Package.CopySource
-	buildApp(c)
+	if err = buildApp(c); err != nil {
+		return
+	}
 
 	// Create the zip file.
 

revel/revel.go

@@ -20,6 +20,7 @@ import (
 	"github.com/revel/cmd/logger"
 	"github.com/revel/cmd/model"
 	"github.com/revel/cmd/utils"
+	"bytes"
 )
 
 const (
@@ -70,38 +71,40 @@ func main() {
 	wd, _ := os.Getwd()
 
 	utils.InitLogger(wd, logger.LvlError)
-
-	parser := flags.NewParser(c, flags.HelpFlag|flags.PassDoubleDash)
-	if err := ParseArgs(c, parser, os.Args[1:]); err != nil {
-		fmt.Fprint(os.Stderr, err.Error())
+	parser := flags.NewParser(c, flags.HelpFlag | flags.PassDoubleDash)
+	if len(os.Args) < 2 {
 		parser.WriteHelp(os.Stdout)
 		os.Exit(1)
 	}
 
+	if err := ParseArgs(c, parser, os.Args[1:]); err != nil {
+		fmt.Fprint(os.Stderr, err.Error() + "\n")
+		os.Exit(1)
+	}
+
 	// Switch based on the verbose flag
-	if len(c.Verbose)>1 {
+	if len(c.Verbose) > 1 {
 		utils.InitLogger(wd, logger.LvlDebug)
-	} else if len(c.Verbose)>0 {
+	} else if len(c.Verbose) > 0 {
 		utils.InitLogger(wd, logger.LvlInfo)
 	} else {
 		utils.InitLogger(wd, logger.LvlWarn)
 	}
 
-	if !c.UpdateImportPath() {
-		utils.Logger.Fatal("Unable to determine application path")
+	// Setup package resolver
+	c.InitPackageResolver()
+
+	if err := c.UpdateImportPath(); err != nil {
+		utils.Logger.Error(err.Error())
+		parser.WriteHelp(os.Stdout)
+		os.Exit(1)
 	}
 
 	command := Commands[c.Index]
 	println("Revel executing:", command.Short)
 
-	// Setting go paths
-	c.InitGoPaths()
-
-	// Setup package resolver
-	c.InitPackageResolver()
-
 	if err := command.RunWith(c); err != nil {
-		utils.Logger.Error("Unable to execute","error",err)
+		utils.Logger.Error("Unable to execute", "error", err)
 		os.Exit(1)
 	}
 }
@@ -136,13 +139,10 @@ func ParseArgs(c *model.CommandConfig, parser *flags.Parser, args []string) (err
 		}
 	}
 
-	if c.Index == 0 {
-		err = fmt.Errorf("Unknown command %v", extraArgs)
-	} else if len(extraArgs) > 0 {
-		utils.Logger.Info("Found additional arguements, setting them")
-		if !Commands[c.Index].UpdateConfig(c, extraArgs) {
-			err = fmt.Errorf("Invalid command line arguements %v", extraArgs)
-		}
+	if !Commands[c.Index].UpdateConfig(c, extraArgs) {
+		buffer := &bytes.Buffer{}
+		parser.WriteHelp(buffer)
+		err = fmt.Errorf("Invalid command line arguements %v\n%s", extraArgs, buffer.String())
 	}
 
 	return

revel/run.go

@@ -6,12 +6,12 @@ package main
 
 import (
 	"strconv"
-
+	"encoding/json"
 	"fmt"
 	"github.com/revel/cmd/harness"
 	"github.com/revel/cmd/model"
 	"github.com/revel/cmd/utils"
-	"go/build"
+	"os"
 )
 
 var cmdRun = &Command{
@@ -71,7 +71,7 @@ func updateRunConfig(c *model.CommandConfig, args []string) bool {
 		// 3. revel run [run-mode] [port]
 
 		// Check to see if the import path evaluates out to something that may be on a gopath
-		if _, err := build.Import(args[0], "", build.FindOnly); err == nil {
+		if runIsImportPath(args[0]) {
 			// 1st arg is the import path
 			c.Run.ImportPath = args[0]
 
@@ -92,12 +92,7 @@ func updateRunConfig(c *model.CommandConfig, args []string) bool {
 		// 1. revel run [import-path]
 		// 2. revel run [port]
 		// 3. revel run [run-mode]
-		_, err := build.Import(args[0], "", build.FindOnly)
-		if err != nil {
-			utils.Logger.Warn("Unable to run using an import path, assuming import path is working directory %s %s", "Argument", args[0], "error", err.Error())
-		}
-		utils.Logger.Info("Trying to build with", args[0], err)
-		if err == nil {
+		if runIsImportPath(args[0]) {
 			// 1st arg is the import path
 			c.Run.ImportPath = args[0]
 		} else if _, err := strconv.Atoi(args[0]); err == nil {
@@ -108,19 +103,27 @@ func updateRunConfig(c *model.CommandConfig, args []string) bool {
 			c.Run.Mode = args[0]
 		}
 	case 0:
-		return false
+		// Attempt to set the import path to the current working director.
+		if c.Run.ImportPath == "" {
+			c.Run.ImportPath, _ = os.Getwd()
+		}
 	}
 	c.Index = model.RUN
 	return true
 }
 
+// Returns true if this is an absolute path or a relative gopath
+func runIsImportPath(pathToCheck string) bool {
+	return utils.DirExists(pathToCheck)
+}
+
 // Called to run the app
 func runApp(c *model.CommandConfig) (err error) {
 	if c.Run.Mode == "" {
 		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")
 	}
@@ -151,10 +154,14 @@ func runApp(c *model.CommandConfig) (err error) {
 		utils.Logger.Errorf("Failed to build app: %s", err)
 	}
 	app.Port = revel_path.HTTPPort
-	runMode := fmt.Sprintf(`{"mode":"%s", "specialUseFlag":%v}`, app.Paths.RunMode, c.Verbose)
+	var paths []byte
+	if len(app.PackagePathMap) > 0 {
+		paths, _ = json.Marshal(app.PackagePathMap)
+	}
+	runMode := fmt.Sprintf(`{"mode":"%s", "specialUseFlag":%v,"packagePathMap":%s}`, app.Paths.RunMode, c.Verbose, string(paths))
 	if c.HistoricMode {
 		runMode = revel_path.RunMode
 	}
-	app.Cmd(runMode).Run()
+	app.Cmd(runMode).Run(c)
 	return
 }

revel/test.go

@@ -55,6 +55,10 @@ func init() {
 // Called to update the config command with from the older stype
 func updateTestConfig(c *model.CommandConfig, args []string) bool {
 	c.Index = model.TEST
+	if len(args) == 0 && c.Test.ImportPath != "" {
+		return true
+	}
+
 	// The full test runs
 	// revel test <import path> (run mode) (suite(.function))
 	if len(args) < 1 {
@@ -78,7 +82,7 @@ func testApp(c *model.CommandConfig) (err error) {
 	}
 
 	// Find and parse app.conf
-	revel_path, err := model.NewRevelPaths(mode, c.ImportPath, "", model.NewWrappedRevelCallback(nil, c.PackageResolver))
+	revel_path, err := model.NewRevelPaths(mode, c.ImportPath, c.AppPath, model.NewWrappedRevelCallback(nil, c.PackageResolver))
 	if err != nil {
 		return
 	}
@@ -95,7 +99,7 @@ func testApp(c *model.CommandConfig) (err error) {
 	}
 
 	// Direct all the output into a file in the test-results directory.
-	file, err := os.OpenFile(filepath.Join(resultPath, "app.log"), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	file, err := os.OpenFile(filepath.Join(resultPath, "app.log"), os.O_CREATE | os.O_WRONLY | os.O_APPEND, 0666)
 	if err != nil {
 		return utils.NewBuildError("Failed to create test result log file: ", "error", err)
 	}
@@ -104,11 +108,16 @@ func testApp(c *model.CommandConfig) (err error) {
 	if reverr != nil {
 		return utils.NewBuildIfError(reverr, "Error building: ")
 	}
-	runMode := fmt.Sprintf(`{"mode":"%s","testModeFlag":true, "specialUseFlag":%v}`, app.Paths.RunMode, c.Verbose)
+	var paths []byte
+	if len(app.PackagePathMap) > 0 {
+		paths, _ = json.Marshal(app.PackagePathMap)
+	}
+	runMode := fmt.Sprintf(`{"mode":"%s", "specialUseFlag":%v,"packagePathMap":%s}`, app.Paths.RunMode, c.Verbose, string(paths))
 	if c.HistoricMode {
 		runMode = app.Paths.RunMode
 	}
 	cmd := app.Cmd(runMode)
+	cmd.Dir = c.AppPath
 
 	cmd.Stderr = io.MultiWriter(cmd.Stderr, file)
 	cmd.Stdout = io.MultiWriter(cmd.Stderr, file)
@@ -225,7 +234,7 @@ func filterTestSuites(suites *[]tests.TestSuiteDesc, suiteArgument string) *[]te
 // in case it hasn't finished starting up yet.
 func getTestsList(baseURL string) (*[]tests.TestSuiteDesc, error) {
 	var (
-		err        error
+		err error
 		resp       *http.Response
 		testSuites []tests.TestSuiteDesc
 	)
@@ -258,7 +267,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

@@ -10,19 +10,30 @@ package main
 
 import (
 	"fmt"
-	"runtime"
 
 	"github.com/revel/cmd"
 	"github.com/revel/cmd/model"
 	"github.com/revel/cmd/utils"
 	"go/ast"
-	"go/build"
 	"go/parser"
 	"go/token"
 	"io/ioutil"
+	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
+	"bytes"
+)
+
+type (
+	// The version container
+	VersionCommand struct {
+		Command        *model.CommandConfig // The command
+		revelVersion   *model.Version       // The Revel framework version
+		modulesVersion *model.Version       // The Revel modules version
+		cmdVersion     *model.Version       // The tool version
+	}
 )
 
 var cmdVersion = &Command{
@@ -38,12 +49,13 @@ For example:
 }
 
 func init() {
-	cmdVersion.RunWith = versionApp
-	cmdVersion.UpdateConfig = updateVersionConfig
+	v := &VersionCommand{}
+	cmdVersion.UpdateConfig = v.UpdateConfig
+	cmdVersion.RunWith = v.RunWith
 }
 
 // Update the version
-func updateVersionConfig(c *model.CommandConfig, args []string) bool {
+func (v *VersionCommand) UpdateConfig(c *model.CommandConfig, args []string) bool {
 	if len(args) > 0 {
 		c.Version.ImportPath = args[0]
 	}
@@ -51,69 +63,185 @@ func updateVersionConfig(c *model.CommandConfig, args []string) bool {
 }
 
 // Displays the version of go and Revel
-func versionApp(c *model.CommandConfig) (err error) {
+func (v *VersionCommand) RunWith(c *model.CommandConfig) (err error) {
+	utils.Logger.Info("Requesting version information", "config", c)
+	v.Command = c
 
-	var revelPath, appPath string
+	// Update the versions with the local values
+	v.updateLocalVersions()
 
-
-	appPath, revelPath, err = utils.FindSrcPaths(c.ImportPath, model.RevelImportPath, c.PackageResolver)
-	if err != nil {
-		return utils.NewBuildError("Failed to import "+c.ImportPath+" with error:", "error", err)
+	needsUpdates := true
+	versionInfo := ""
+	for x := 0; x < 2 && needsUpdates; x++ {
+		needsUpdates = false
+		versionInfo, needsUpdates = v.doRepoCheck(x == 0)
 	}
-	revelPath = revelPath + model.RevelImportPath
 
-	fmt.Println("\nRevel Framework",revelPath, appPath )
-	if err != nil {
-		utils.Logger.Info("Failed to find Revel in GOPATH with error:", "error", err, "gopath", build.Default.GOPATH)
-		fmt.Println("Information not available (not on GOPATH)")
+	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 {
+		fmt.Println("Go command error ", e)
 	} else {
-		utils.Logger.Info("Fullpath to revel", "dir", revelPath)
-		fset := token.NewFileSet() // positions are relative to fset
-
-		version, err := ioutil.ReadFile(filepath.Join(revelPath, "version.go"))
-		if err != nil {
-			utils.Logger.Error("Failed to find Revel version:", "error", err, "path", revelPath)
-		}
-
-		// Parse src but stop after processing the imports.
-		f, err := parser.ParseFile(fset, "", version, parser.ParseComments)
-		if err != nil {
-			return utils.NewBuildError("Failed to parse Revel version error:", "error", err)
-		}
-
-		// Print the imports from the file's AST.
-		for _, s := range f.Decls {
-			genDecl, ok := s.(*ast.GenDecl)
-			if !ok {
-				continue
-			}
-			if genDecl.Tok != token.CONST {
-				continue
-			}
-			for _, a := range genDecl.Specs {
-				spec := a.(*ast.ValueSpec)
-				r := spec.Values[0].(*ast.BasicLit)
-				fmt.Printf("Revel %s = %s\n", spec.Names[0].Name, r.Value)
-			}
-		}
-	}
-	fmt.Println("\nRevel Command Utility Tool")
-	fmt.Println("Version", cmd.Version)
-	fmt.Println("Build Date", cmd.BuildDate)
-	fmt.Println("Minimum Go Version", cmd.MinimumGoVersion)
-
-	fmt.Printf("Compiled By   %s %s/%s\n\n", runtime.Version(), runtime.GOOS, runtime.GOARCH)
-	// Extract the goversion detected
-	if len(c.GoCmd) > 0 {
-		cmd := exec.Command(c.GoCmd, "version")
-		cmd.Stdout = os.Stdout
-		if e := cmd.Start(); e != nil {
-			fmt.Println("Go command error ", e)
-		} else {
-			cmd.Wait()
-		}
-	} else {
-		fmt.Println("Go command not found ")
+		cmd.Wait()
+	}
+
+	return
+}
+
+// Checks the Revel repos for the latest version
+func (v *VersionCommand) doRepoCheck(updateLibs bool) (versionInfo string, needsUpdate bool) {
+	var (
+		title string
+		localVersion *model.Version
+	)
+	for _, repo := range []string{"revel", "cmd", "modules"} {
+		versonFromRepo, err := v.versionFromRepo(repo, "", "version.go")
+		if err != nil {
+			utils.Logger.Info("Failed to get version from repo", "repo", repo, "error", err)
+		}
+		switch repo {
+		case "revel":
+			title, repo, localVersion = "Revel Framework", "github.com/revel/revel", v.revelVersion
+		case "cmd":
+			title, repo, localVersion = "Revel Cmd", "github.com/revel/cmd/revel", v.cmdVersion
+		case "modules":
+			title, repo, localVersion = "Revel Modules", "github.com/revel/modules", v.modulesVersion
+		}
+
+		// Only do an update on the first loop, and if specified to update
+		versionInfo = versionInfo + v.outputVersion(title, repo, localVersion, versonFromRepo)
+	}
+	return
+}
+
+// Checks for updates if needed
+func (v *VersionCommand) doUpdate(title, repo string, local, remote *model.Version) {
+	utils.Logger.Info("Updating package", "package", title, "repo", repo)
+	fmt.Println("Attempting to update package", title)
+	if err := v.Command.PackageResolver(repo); err != nil {
+		utils.Logger.Error("Unable to update repo", "repo", repo, "error", err)
+	} else if repo == "github.com/revel/cmd/revel" {
+		// One extra step required here to run the install for the command
+		utils.Logger.Fatal("Revel command tool was updated, you must manually run the following command before continuing\ngo install github.com/revel/cmd/revel")
+	}
+	return
+}
+
+// Prints out the local and remote versions, calls update if needed
+func (v *VersionCommand) outputVersion(title, repo string, local, remote *model.Version) (output string) {
+	buffer := &bytes.Buffer{}
+	remoteVersion := "Unknown"
+	if remote != nil {
+		remoteVersion = remote.VersionString()
+	}
+	localVersion := "Unknown"
+	if local != nil {
+		localVersion = local.VersionString()
+	}
+
+	fmt.Fprintf(buffer, "%s\t:\t%s\t(%s remote master branch)\n", title, localVersion, remoteVersion)
+	return buffer.String()
+}
+
+// Returns the version from the repository
+func (v *VersionCommand) versionFromRepo(repoName, branchName, fileName string) (version *model.Version, err error) {
+	if branchName == "" {
+		branchName = "master"
+	}
+	// Try to download the version of file from the repo, just use an http connection to retrieve the source
+	// Assuming that the repo is github
+	fullurl := "https://raw.githubusercontent.com/revel/" + repoName + "/" + branchName + "/" + fileName
+	resp, err := http.Get(fullurl)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	utils.Logger.Info("Got version file", "from", fullurl, "content", string(body))
+
+	return v.versionFromBytes(body)
+}
+
+// Returns version information from a file called version on the gopath
+func (v *VersionCommand) compareAndUpdateVersion(remoteVersion *model.Version, localVersion *model.Version) (err error) {
+	return
+}
+func (v *VersionCommand) versionFromFilepath(sourcePath string) (version *model.Version, err error) {
+	utils.Logger.Info("Fullpath to revel", "dir", sourcePath)
+
+	sourceStream, err := ioutil.ReadFile(filepath.Join(sourcePath, "version.go"))
+	if err != nil {
+		return
+	}
+	return v.versionFromBytes(sourceStream)
+}
+
+// Returns version information from a file called version on the gopath
+func (v *VersionCommand) versionFromBytes(sourceStream []byte) (version *model.Version, err error) {
+	fset := token.NewFileSet() // positions are relative to fset
+
+	// Parse src but stop after processing the imports.
+	f, err := parser.ParseFile(fset, "", sourceStream, parser.ParseComments)
+	if err != nil {
+		err = utils.NewBuildError("Failed to parse Revel version error:", "error", err)
+		return
+	}
+	version = &model.Version{}
+
+	// Print the imports from the file's AST.
+	for _, s := range f.Decls {
+		genDecl, ok := s.(*ast.GenDecl)
+		if !ok {
+			continue
+		}
+		if genDecl.Tok != token.CONST {
+			continue
+		}
+		for _, a := range genDecl.Specs {
+			spec := a.(*ast.ValueSpec)
+			r := spec.Values[0].(*ast.BasicLit)
+			switch spec.Names[0].Name {
+			case "Version":
+				version.ParseVersion(strings.Replace(r.Value, `"`, "", -1))
+			case "BuildDate":
+				version.BuildDate = r.Value
+			case "MinimumGoVersion":
+				version.MinGoVersion = r.Value
+			}
+		}
+	}
+	return
+}
+
+// Fetch the local version of revel from the file system
+func (v *VersionCommand) updateLocalVersions() {
+	v.cmdVersion = &model.Version{}
+	v.cmdVersion.ParseVersion(cmd.Version)
+	v.cmdVersion.BuildDate = cmd.BuildDate
+	v.cmdVersion.MinGoVersion = cmd.MinimumGoVersion
+
+	if v.Command.Version.ImportPath=="" {
+		return
+	}
+
+	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", "path", pathMap[model.RevelImportPath], "error", err)
+		return
+	}
+	utils.Logger.Info("Fullpath to revel modules", "dir", pathMap[model.RevelImportPath])
+	v.revelVersion, err = v.versionFromFilepath(pathMap[model.RevelImportPath])
+	if err != nil {
+		utils.Logger.Warn("Unable to extract version information from Revel", "error,err")
+	}
+
+	v.modulesVersion, err = v.versionFromFilepath(pathMap[model.RevelModulesImportPath])
+	if err != nil {
+		utils.Logger.Warn("Unable to extract version information from Revel Modules", "path", pathMap[model.RevelModulesImportPath], "error", err)
 	}
 
 	return

revel/version_test.go

@@ -34,8 +34,8 @@ func TestVersion(t *testing.T) {
 		a.Nil(main.Commands[model.VERSION].RunWith(c), "Failed to run version-test")
 	})
 	if !t.Failed() {
-		if err := os.RemoveAll(gopath); err != nil {
-			a.Fail("Failed to remove test path")
+		if err := os.RemoveAll(gopath); err != nil && err!=os.ErrNotExist {
+			a.Fail("Failed to remove test path",err.Error())
 		}
 	}
 }

tests/testrunner.go

@@ -107,7 +107,7 @@ func describeSuite(testSuite interface{}) TestSuiteDesc {
 }
 
 // errorSummary gets an error and returns its summary in human readable format.
-func errorSummary(err *utils.Error) (message string) {
+func errorSummary(err *utils.SourceError) (message string) {
 	expectedPrefix := "(expected)"
 	actualPrefix := "(actual)"
 	errDesc := err.Description

utils/build_error.go

@@ -3,6 +3,8 @@ package utils
 import (
 	"fmt"
 	"github.com/revel/cmd/logger"
+	"strconv"
+	"regexp"
 )
 
 type (
@@ -43,3 +45,60 @@ func NewBuildIfError(err error, message string, args ...interface{}) (b error) {
 func (b *BuildError) Error() string {
 	return fmt.Sprint(b.Message, b.Args)
 }
+
+// Parse the output of the "go build" command.
+// Return a detailed Error.
+func NewCompileError(importPath, errorLink string, error error) *SourceError {
+	// Get the stack from the error
+
+	errorMatch := regexp.MustCompile(`(?m)^([^:#]+):(\d+):(\d+:)? (.*)$`).
+		FindSubmatch([]byte(error.Error()))
+	if errorMatch == nil {
+		errorMatch = regexp.MustCompile(`(?m)^(.*?):(\d+):\s(.*?)$`).FindSubmatch([]byte(error.Error()))
+
+		if errorMatch == nil {
+			Logger.Error("Failed to parse build errors", "error", error)
+			return &SourceError{
+				SourceType:  "Go code",
+				Title:       "Go Compilation Error",
+				Description: "See console for build error.",
+			}
+		}
+
+		errorMatch = append(errorMatch, errorMatch[3])
+
+		Logger.Error("Build errors", "errors", error)
+	}
+
+
+	// Read the source for the offending file.
+	var (
+		relFilename = string(errorMatch[1]) // e.g. "src/revel/sample/app/controllers/app.go"
+		absFilename = relFilename
+		line, _ = strconv.Atoi(string(errorMatch[2]))
+		description = string(errorMatch[4])
+		compileError = &SourceError{
+			SourceType:  "Go code",
+			Title:       "Go Compilation Error",
+			Path:        relFilename,
+			Description: description,
+			Line:        line,
+		}
+	)
+
+	// errorLink := paths.Config.StringDefault("error.link", "")
+
+	if errorLink != "" {
+		compileError.SetLink(errorLink)
+	}
+
+	fileStr, err := ReadLines(absFilename)
+	if err != nil {
+		compileError.MetaError = absFilename + ": " + err.Error()
+		Logger.Info("Unable to readlines " + compileError.MetaError, "error", err)
+		return compileError
+	}
+
+	compileError.SourceLines = fileStr
+	return compileError
+}

utils/command.go

@@ -5,23 +5,32 @@ import (
 	"os"
 	"os/exec"
 	"strings"
+	"bytes"
+	"path/filepath"
 )
 
 // Initialize the command based on the GO environment
-func CmdInit(c *exec.Cmd, basePath string) {
+func CmdInit(c *exec.Cmd, addGoPath bool, basePath string) {
 	c.Dir = basePath
-	// Go 1.8 fails if we do not include the GOROOT
-	c.Env = []string{"GOPATH=" + build.Default.GOPATH, "PATH=" + GetEnv("PATH"), "GOROOT="+ GetEnv("GOROOT")}
-
-}
-
-// Returns an environment variable
-func GetEnv(name string) string {
-	for _, v := range os.Environ() {
-		split := strings.Split(v, "=")
-		if split[0] == name {
-			return strings.Join(split[1:], "")
+	// Dep does not like paths that are not real, convert all paths in go to real paths
+	realPath := &bytes.Buffer{}
+	if addGoPath {
+		for _, p := range filepath.SplitList(build.Default.GOPATH) {
+			rp, _ := filepath.EvalSymlinks(p)
+			if realPath.Len() > 0 {
+				realPath.WriteString(string(filepath.ListSeparator))
+			}
+			realPath.WriteString(rp)
 		}
+		// Go 1.8 fails if we do not include the GOROOT
+		c.Env = []string{"GOPATH=" + realPath.String(), "GOROOT=" + os.Getenv("GOROOT")}
 	}
-	return ""
-}
+	// Fetch the rest of the env variables
+	for _, e := range os.Environ() {
+		pair := strings.Split(e, "=")
+		if pair[0] == "GOPATH" || pair[0] == "GOROOT" {
+			continue
+		}
+		c.Env = append(c.Env, e)
+	}
+}

utils/error.go

@@ -8,7 +8,7 @@ import (
 
 // The error is a wrapper for the
 type (
-	Error struct {
+	SourceError struct {
 		SourceType               string   // The type of source that failed to build.
 		Title, Path, Description string   // Description of the error, as presented to the user.
 		Line, Column             int      // Where the error was encountered.
@@ -23,9 +23,18 @@ type (
 		IsError bool
 	}
 )
+// Return a new error object
+func NewError(source, title, path, description string) *SourceError {
+	return &SourceError{
+		SourceType:source,
+		Title:title,
+		Path:path,
+		Description:description,
+	}
+}
 
 // Creates a link based on the configuration setting "errors.link"
-func (e *Error) SetLink(errorLink string) {
+func (e *SourceError) SetLink(errorLink string) {
 	errorLink = strings.Replace(errorLink, "{{Path}}", e.Path, -1)
 	errorLink = strings.Replace(errorLink, "{{Line}}", strconv.Itoa(e.Line), -1)
 
@@ -35,7 +44,7 @@ func (e *Error) SetLink(errorLink string) {
 // Error method constructs a plaintext version of the error, taking
 // account that fields are optionally set. Returns e.g. Compilation Error
 // (in views/header.html:51): expected right delim in end; got "}"
-func (e *Error) Error() string {
+func (e *SourceError) Error() string {
 	if e == nil {
 		panic("opps")
 	}
@@ -60,7 +69,7 @@ func (e *Error) Error() string {
 
 // ContextSource method returns a snippet of the source around
 // where the error occurred.
-func (e *Error) ContextSource() []SourceLine {
+func (e *SourceError) ContextSource() []SourceLine {
 	if e.SourceLines == nil {
 		return nil
 	}
@@ -73,7 +82,7 @@ func (e *Error) ContextSource() []SourceLine {
 		end = len(e.SourceLines)
 	}
 
-	lines := make([]SourceLine, end-start)
+	lines := make([]SourceLine, end - start)
 	for i, src := range e.SourceLines[start:end] {
 		fileLine := start + i + 1
 		lines[i] = SourceLine{src, fileLine, fileLine == e.Line}

utils/file.go

@@ -4,15 +4,15 @@ import (
 	"archive/tar"
 	"bytes"
 	"compress/gzip"
-	"errors"
 	"fmt"
-	"go/build"
+	"errors"
 	"html/template"
 	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
+	"golang.org/x/tools/go/packages"
 )
 
 // DirExists returns true if the given path exists and is a directory.
@@ -109,7 +109,7 @@ func GenerateTemplate(filename, templateSource string, args map[string]interface
 func RenderTemplate(destPath, srcPath string, data interface{}) (err error) {
 	tmpl, err := template.ParseFiles(srcPath)
 	if err != nil {
-		return NewBuildIfError(err, "Failed to parse template "+srcPath)
+		return NewBuildIfError(err, "Failed to parse template " + srcPath)
 	}
 
 	f, err := os.Create(destPath)
@@ -119,12 +119,12 @@ func RenderTemplate(destPath, srcPath string, data interface{}) (err error) {
 
 	err = tmpl.Execute(f, data)
 	if err != nil {
-		return NewBuildIfError(err, "Failed to Render template "+srcPath)
+		return NewBuildIfError(err, "Failed to Render template " + srcPath)
 	}
 
 	err = f.Close()
 	if err != nil {
-		return NewBuildIfError(err, "Failed to close file stream "+destPath)
+		return NewBuildIfError(err, "Failed to close file stream " + destPath)
 	}
 	return
 }
@@ -133,12 +133,12 @@ func RenderTemplate(destPath, srcPath string, data interface{}) (err error) {
 func RenderTemplateToStream(output io.Writer, srcPath []string, data interface{}) (err error) {
 	tmpl, err := template.ParseFiles(srcPath...)
 	if err != nil {
-		return NewBuildIfError(err, "Failed to parse template "+srcPath[0])
+		return NewBuildIfError(err, "Failed to parse template " + srcPath[0])
 	}
 
 	err = tmpl.Execute(output, data)
 	if err != nil {
-		return NewBuildIfError(err, "Failed to render template "+srcPath[0])
+		return NewBuildIfError(err, "Failed to render template " + srcPath[0])
 	}
 	return
 }
@@ -150,8 +150,8 @@ func MustChmod(filename string, mode os.FileMode) {
 
 // Called if panic
 func PanicOnError(err error, msg string) {
-	if revErr, ok := err.(*Error); (ok && revErr != nil) || (!ok && err != nil) {
-		Logger.Panicf("Abort: %s: %s %s\n", msg, revErr, err)
+	if revErr, ok := err.(*SourceError); (ok && revErr != nil) || (!ok && err != nil) {
+		Logger.Panicf("Abort: %s: %s %s", msg, revErr, err)
 	}
 }
 
@@ -160,6 +160,9 @@ func PanicOnError(err error, msg string) {
 // Additionally, the trailing ".template" is stripped from the file name.
 // Also, dot files and dot directories are skipped.
 func CopyDir(destDir, srcDir string, data map[string]interface{}) error {
+	if !DirExists(srcDir) {
+		return nil
+	}
 	return fsWalk(srcDir, srcDir, func(srcPath string, info os.FileInfo, err error) error {
 		// Get the relative path from the source base, and the corresponding path in
 		// the dest directory.
@@ -178,7 +181,7 @@ func CopyDir(destDir, srcDir string, data map[string]interface{}) error {
 		if info.IsDir() {
 			err := os.MkdirAll(filepath.Join(destDir, relSrcPath), 0777)
 			if !os.IsExist(err) {
-				return NewBuildIfError(err, "Failed to create directory", "path", destDir+"/"+relSrcPath)
+				return NewBuildIfError(err, "Failed to create directory", "path", destDir + "/" + relSrcPath)
 			}
 			return nil
 		}
@@ -186,7 +189,7 @@ func CopyDir(destDir, srcDir string, data map[string]interface{}) error {
 		// If this file ends in ".template", render it as a template.
 		if strings.HasSuffix(relSrcPath, ".template") {
 
-			return RenderTemplate(destPath[:len(destPath)-len(".template")], srcPath, data)
+			return RenderTemplate(destPath[:len(destPath) - len(".template")], srcPath, data)
 		}
 
 		// Else, just copy it over.
@@ -200,7 +203,8 @@ func Walk(root string, walkFn filepath.WalkFunc) error {
 	return fsWalk(root, root, walkFn)
 }
 
-// Walk the tree using the function
+// Walk the path tree using the function
+// Every file found will call the function
 func fsWalk(fname string, linkName string, walkFn filepath.WalkFunc) error {
 	fsWalkFunc := func(path string, info os.FileInfo, err error) error {
 		if err != nil {
@@ -215,7 +219,7 @@ func fsWalk(fname string, linkName string, walkFn filepath.WalkFunc) error {
 
 		path = filepath.Join(linkName, name)
 
-		if err == nil && info.Mode()&os.ModeSymlink == os.ModeSymlink {
+		if err == nil && info.Mode() & os.ModeSymlink == os.ModeSymlink {
 			var symlinkPath string
 			symlinkPath, err = filepath.EvalSymlinks(path)
 			if err != nil {
@@ -305,9 +309,13 @@ func Exists(filename string) bool {
 // empty returns true if the given directory is empty.
 // the directory must exist.
 func Empty(dirname string) bool {
+	if !DirExists(dirname) {
+		return true
+	}
 	dir, err := os.Open(dirname)
 	if err != nil {
 		Logger.Infof("error opening directory: %s", err)
+		return false
 	}
 	defer func() {
 		_ = dir.Close()
@@ -317,49 +325,71 @@ func Empty(dirname string) bool {
 }
 
 // Find the full source dir for the import path, uses the build.Default.GOPATH to search for the directory
-func FindSrcPaths(appImportPath, revelImportPath string, packageResolver func(pkgName string) error) (appSourcePath, revelSourcePath string, err error) {
-	var (
-		gopaths = filepath.SplitList(build.Default.GOPATH)
-		goroot  = build.Default.GOROOT
-	)
-
-	if len(gopaths) == 0 {
-		err = errors.New("GOPATH environment variable is not set. " +
-			"Please refer to http://golang.org/doc/code.html to configure your Go environment.")
-		return
-	}
-
-	if ContainsString(gopaths, goroot) {
-		err = fmt.Errorf("GOPATH (%s) must not include your GOROOT (%s). "+
-			"Please refer to http://golang.org/doc/code.html to configure your Go environment. ",
-			build.Default.GOPATH, goroot)
-		return
-
-	}
-
-	appPkgDir := ""
-	appPkgSrcDir := ""
-	if len(appImportPath)>0 {
-		Logger.Info("Seeking app package","app",appImportPath)
-		appPkg, err := build.Import(appImportPath, "", build.FindOnly)
-		if err != nil {
-			err = fmt.Errorf("Failed to import " + appImportPath + " with error %s", err.Error())
-			return "","",err
+func FindSrcPaths(appPath string, packageList []string, packageResolver func(pkgName string) error) (sourcePathsmap map[string]string, err error) {
+	sourcePathsmap, missingList, err := findSrcPaths(appPath, packageList)
+	if err != nil && packageResolver != nil || len(missingList) > 0 {
+		Logger.Info("Failed to find package, attempting to call resolver for missing packages", "missing packages", missingList)
+		for _, item := range missingList {
+			if err = packageResolver(item); err != nil {
+				return
+			}
 		}
-		appPkgDir,appPkgSrcDir =appPkg.Dir, appPkg.SrcRoot
+		sourcePathsmap, missingList, err = findSrcPaths(appPath, packageList)
 	}
-	Logger.Info("Seeking remote package","using",appImportPath, "remote",revelImportPath)
-	revelPkg, err := build.Default.Import(revelImportPath, appPkgDir, build.FindOnly)
-	if err != nil {
-		Logger.Info("Resolved called Seeking remote package","using",appImportPath, "remote",revelImportPath)
-		packageResolver(revelImportPath)
-		revelPkg, err = build.Import(revelImportPath, appPkgDir, build.FindOnly)
-		if err != nil {
-			err = fmt.Errorf("Failed to find Revel with error: %s", err.Error())
-			return
+	if err != nil && len(missingList) > 0 {
+		for _, missing := range missingList {
+			Logger.Error("Unable to import this package", "package", missing)
+		}
+	}
+
+	return
+}
+
+var NO_APP_FOUND = errors.New("No app found")
+var NO_REVEL_FOUND = errors.New("No revel found")
+
+// Find the full source dir for the import path, uses the build.Default.GOPATH to search for the directory
+func findSrcPaths(appPath string, packagesList []string) (sourcePathsmap map[string]string, missingList[] string, err error) {
+	// Use packages to fetch
+	// by not specifying env, we will use the default env
+	config := &packages.Config{
+		Mode: packages.NeedName | packages.NeedFiles,
+		Dir:appPath,
+	}
+	sourcePathsmap = map[string]string{}
+	Logger.Infof("Environment path %s root %s config env %s", os.Getenv("GOPATH"), os.Getenv("GOROOT"), config.Env)
+
+	pkgs, err := packages.Load(config, packagesList...)
+	Logger.Infof("Environment path %s root %s config env %s", os.Getenv("GOPATH"), os.Getenv("GOROOT"), config.Env)
+	Logger.Info("Loaded packages ", "len results", len(pkgs), "error", err, "basedir", appPath)
+	for _, packageName := range packagesList {
+		found := false
+		log := Logger.New("seeking", packageName)
+		for _, pck := range pkgs {
+			log.Info("Found package", "package", pck.ID)
+			if pck.ID == packageName {
+				if pck.Errors != nil && len(pck.Errors) > 0 {
+					log.Error("Error ", "count", len(pck.Errors), "App Import Path", pck.ID, "filesystem path", pck.PkgPath, "errors", pck.Errors)
+					// continue
+
+				}
+				//a,_ := pck.MarshalJSON()
+				log.Info("Found ", "count", len(pck.GoFiles), "App Import Path", pck.ID, "apppath", appPath)
+				if len(pck.GoFiles) > 0 {
+					sourcePathsmap[packageName] = filepath.Dir(pck.GoFiles[0])
+					found = true
+				}
+			}
+		}
+		if !found {
+			if packageName == "github.com/revel/revel" {
+				err = NO_REVEL_FOUND
+			} else {
+				err = NO_APP_FOUND
+			}
+			missingList = append(missingList, packageName)
 		}
 	}
 
-	revelSourcePath, appSourcePath = revelPkg.Dir[:len(revelPkg.Dir)-len(revelImportPath)], appPkgSrcDir
 	return
 }

version.go

@@ -1,16 +1,16 @@
-// Copyright (c) 2012-2017 The Revel Framework Authors, All rights reserved.
+// Copyright (c) 2012-2018 The Revel Framework Authors, All rights reserved.
 // Revel Framework source code and usage is governed by a MIT style
 // license that can be found in the LICENSE file.
 
 package cmd
 
 const (
-	// Version current Revel Command version
-	Version = "0.20.1"
+	// Version current Revel version
+	Version = "1.0.0"
 
 	// BuildDate latest commit/release date
-	BuildDate = "2018-09-30"
+	BuildDate = "2020-07-11"
 
 	// MinimumGoVersion minimum required Go version for Revel
-	MinimumGoVersion = ">= go1.8"
+	MinimumGoVersion = ">= go1.12"
 )

watcher/watcher.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/revel/cmd/model"
 	"github.com/revel/cmd/utils"
-	"gopkg.in/fsnotify/fsnotify.v1"
+	"github.com/fsnotify/fsnotify"
 	"time"
 )
 
@@ -20,7 +20,7 @@ import (
 type Listener interface {
 	// Refresh is invoked by the watcher on relevant filesystem events.
 	// If the listener returns an error, it is served to the user on the current request.
-	Refresh() *utils.Error
+	Refresh() *utils.SourceError
 }
 
 // DiscerningListener allows the receiver to selectively watch files.
@@ -33,7 +33,7 @@ type DiscerningListener interface {
 // Watcher allows listeners to register to be notified of changes under a given
 // directory.
 type Watcher struct {
-	// Parallel arrays of watcher/listener pairs.
+	                                  // Parallel arrays of watcher/listener pairs.
 	watchers            []*fsnotify.Watcher
 	listeners           []Listener
 	forceRefresh        bool
@@ -42,9 +42,9 @@ type Watcher struct {
 	lastError           int
 	notifyMutex         sync.Mutex
 	paths               *model.RevelContainer
-	refreshTimer        *time.Timer // The timer to countdown the next refresh
-	timerMutex          *sync.Mutex // A mutex to prevent concurrent updates
-	refreshChannel      chan *utils.Error
+	refreshTimer        *time.Timer   // The timer to countdown the next refresh
+	timerMutex          *sync.Mutex   // A mutex to prevent concurrent updates
+	refreshChannel      chan *utils.SourceError
 	refreshChannelCount int
 	refreshTimerMS      time.Duration // The number of milliseconds between refreshing builds
 }
@@ -52,16 +52,16 @@ type Watcher struct {
 // Creates a new watched based on the container
 func NewWatcher(paths *model.RevelContainer, eagerRefresh bool) *Watcher {
 	return &Watcher{
-		forceRefresh:   true,
+		forceRefresh:   false,
 		lastError:      -1,
 		paths:          paths,
-		refreshTimerMS: time.Duration(paths.Config.IntDefault("watch.rebuild.delay", 10)),
+		refreshTimerMS: time.Duration(paths.Config.IntDefault("watch.rebuild.delay", 1000)),
 		eagerRefresh: eagerRefresh ||
 			paths.DevMode &&
 				paths.Config.BoolDefault("watch", true) &&
 				paths.Config.StringDefault("watch.mode", "normal") == "eager",
 		timerMutex:          &sync.Mutex{},
-		refreshChannel:      make(chan *utils.Error, 10),
+		refreshChannel:      make(chan *utils.SourceError, 10),
 		refreshChannelCount: 0,
 	}
 }
@@ -85,7 +85,7 @@ func (w *Watcher) Listen(listener Listener, roots ...string) {
 	for _, p := range roots {
 		// is the directory / file a symlink?
 		f, err := os.Lstat(p)
-		if err == nil && f.Mode()&os.ModeSymlink == os.ModeSymlink {
+		if err == nil && f.Mode() & os.ModeSymlink == os.ModeSymlink {
 			var realPath string
 			realPath, err = filepath.EvalSymlinks(p)
 			if err != nil {
@@ -178,7 +178,7 @@ func (w *Watcher) NotifyWhenUpdated(listener Listener, watcher *fsnotify.Watcher
 
 // Notify causes the watcher to forward any change events to listeners.
 // It returns the first (if any) error returned.
-func (w *Watcher) Notify() *utils.Error {
+func (w *Watcher) Notify() *utils.SourceError {
 	if w.serial {
 		// Serialize Notify() calls.
 		w.notifyMutex.Lock()
@@ -200,14 +200,15 @@ func (w *Watcher) Notify() *utils.Error {
 			case <-watcher.Errors:
 				continue
 			default:
-				// No events left to pull
+			// No events left to pull
 			}
 			break
 		}
 
-		utils.Logger.Info("Watcher:Notify refresh state", "Current Index", i, " last error index", w.lastError)
+		utils.Logger.Info("Watcher:Notify refresh state", "Current Index", i, " last error index", w.lastError,
+			"force", w.forceRefresh, "refresh", refresh, "lastError", w.lastError == i)
 		if w.forceRefresh || refresh || w.lastError == i {
-			var err *utils.Error
+			var err *utils.SourceError
 			if w.serial {
 				err = listener.Refresh()
 			} else {
@@ -229,7 +230,7 @@ func (w *Watcher) Notify() *utils.Error {
 
 // Build a queue for refresh notifications
 // this will not return until one of the queue completes
-func (w *Watcher) notifyInProcess(listener Listener) (err *utils.Error) {
+func (w *Watcher) notifyInProcess(listener Listener) (err *utils.SourceError) {
 	shouldReturn := false
 	// This code block ensures that either a timer is created
 	// or that a process would be added the the h.refreshChannel
@@ -285,22 +286,10 @@ func (w *Watcher) rebuildRequired(ev fsnotify.Event, listener Listener) bool {
 	}
 
 	if dl, ok := listener.(DiscerningListener); ok {
-		if !dl.WatchFile(ev.Name) || ev.Op&fsnotify.Chmod == fsnotify.Chmod {
+		if !dl.WatchFile(ev.Name) || ev.Op & fsnotify.Chmod == fsnotify.Chmod {
 			return false
 		}
 	}
 	return true
 }
 
-/*
-var WatchFilter = func(c *Controller, fc []Filter) {
-	if MainWatcher != nil {
-		err := MainWatcher.Notify()
-		if err != nil {
-			c.Result = c.RenderError(err)
-			return
-		}
-	}
-	fc[0](c, fc[1:])
-}
-*/