Merge pull request revel#1238 from notzippy/pre-release

notzippy · web-flow · commit 8e257757aecf · 2017-09-21T14:17:41.000-07:00
Added template read and population
diff --git a/.codebeatsettings b/.codebeatsettings
@@ -1,5 +1,8 @@
 {
   "GOLANG": {
+  "ABC":[15, 25, 50, 70],
+  "BLOCK_NESTING":[5, 6, 7, 8],
+  "CYCLO":[20, 30, 45, 60],
     "TOO_MANY_IVARS": [15, 18, 20, 25],
     "TOO_MANY_FUNCTIONS": [20, 30, 40, 50],
     "TOTAL_COMPLEXITY": [150, 250, 400, 500],
diff --git a/controller.go b/controller.go
@@ -208,6 +208,11 @@ func (c *Controller) RenderTemplate(templatePath string) Result {
 	}
 }
 
+// TemplateOutput returns the result of the template rendered using the controllers ViewArgs.
+func (c *Controller) TemplateOutput(templatePath string) (data []byte,err error)  {
+	return TemplateOutputArgs(templatePath,c.ViewArgs)
+}
+
 // RenderJSON uses encoding/json.Marshal to return JSON to the client.
 func (c *Controller) RenderJSON(o interface{}) Result {
 	c.setStatusIfNil(http.StatusOK)
diff --git a/logger/handlers.go b/logger/handlers.go
@@ -78,8 +78,18 @@ func NilHandler() LogHandler {
 	})
 }
 
-// Rather then chaining multiple filter handlers, process all here
+// Match all values in map to log
 func MatchMapHandler(matchMap map[string]interface{}, a LogHandler) LogHandler {
+	return matchMapHandler(matchMap, false, a)
+}
+
+// Match !(Match all values in map to log) The inverse of MatchMapHandler
+func NotMatchMapHandler(matchMap map[string]interface{}, a LogHandler) LogHandler {
+	return matchMapHandler(matchMap, true, a)
+}
+
+// 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
@@ -89,6 +99,10 @@ func MatchMapHandler(matchMap map[string]interface{}, a LogHandler) LogHandler {
 			}
 		}
 		if len(checkMap) == len(matchMap) {
+			if !inverse {
+				return a.Log(r)
+			}
+		} else if inverse {
 			return a.Log(r)
 		}
 		return nil
@@ -232,7 +246,7 @@ func (h *CompositeMultiHandler) SetHandler(handler LogHandler, replace bool, lev
 		if ll, found := (*source).(*ListLogHandler); found {
 			ll.Add(handler)
 		} else {
-			*source = NewListLogHandler(h.CriticalHandler, handler)
+			*source = NewListLogHandler(*source, handler)
 		}
 	} else {
 		*source = handler
diff --git a/logger/utils.go b/logger/utils.go
@@ -44,13 +44,19 @@ func GetLogger(name string, logger MultiLogger) (l *log.Logger) {
 func InitializeFromConfig(basePath string, config *config.Context) (c *CompositeMultiHandler) {
 	// 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)
-	initRequestLog(c, basePath, config)
-	// Check to see if critical handler needs to be assigned to the error handler
 	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
 }
 
@@ -62,19 +68,57 @@ func initAllLog(c *CompositeMultiHandler, basePath string, config *config.Contex
 			log.Printf("Adding standard handler for levels to >%s< ", output)
 			initHandlerFor(c, output, basePath, NewLogOptions(config, true, nil, LvlAllList...))
 		}
-		optionList := config.Options("log.all.filter")
-		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]
-			}
+	}
+}
 
-			log.Printf("Adding key map handler to all %s output %s", option, config.StringDefault(option, ""))
-			phandler := NewParentLogHandler(func(child LogHandler) LogHandler {
-				return MatchMapHandler(keyMap, child)
-			})
-			initHandlerFor(c, config.StringDefault(option, ""), basePath, NewLogOptions(config, false, phandler))
+// Init the filter options
+// log.all.filter ....
+// log.error.filter ....
+func initFilterLog(c *CompositeMultiHandler, basePath string, config *config.Context) {
+	if config != nil {
+		// 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)
+					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]))
+					}
+				}
+			}
 		}
 	}
 }
@@ -90,23 +134,6 @@ func initLogLevels(c *CompositeMultiHandler, basePath string, config *config.Con
 				log.Printf("Adding standard handler %s output %s", name, output)
 				initHandlerFor(c, output, basePath, NewLogOptions(config, true, nil, toLevel[name]))
 			}
-			// Now check to see if we have any module specific loggers
-			// Names should be module.name or module.name.context.name
-			optionList := config.Options("log." + name + ".filter")
-			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 := NewParentLogHandler(func(child LogHandler) LogHandler {
-					return MatchMapHandler(keyMap, child)
-				})
-				log.Printf("Adding key map handler %s %s output %s", option, name, config.StringDefault(option, ""))
-				initHandlerFor(c, config.StringDefault(option, ""), basePath, NewLogOptions(config, false, phandler, toLevel[name]))
-			}
-
 			// Gets the list of options with said prefix
 		} else {
 			initHandlerFor(c, "stderr", basePath, NewLogOptions(config, true, nil, toLevel[name]))
diff --git a/panic.go b/panic.go
@@ -5,7 +5,6 @@
 package revel
 
 import (
-	"github.com/revel/revel/logger"
 	"net/http"
 	"runtime/debug"
 )
@@ -25,7 +24,7 @@ func PanicFilter(c *Controller, fc []Filter) {
 // It cleans up the stack trace, logs it, and displays an error page.
 func handleInvocationPanic(c *Controller, err interface{}) {
 	error := NewErrorFromPanic(err)
-	utilLog.Error("PanicFilter: Caught panic", "error", err, "trace", logger.NewCallStack())
+	utilLog.Error("PanicFilter: Caught panic", "error", err, "stack", error.Stack)
 	if error == nil && DevMode {
 		// Only show the sensitive information in the debug stack trace in development mode, not production
 		c.Response.SetStatus(http.StatusInternalServerError)
diff --git a/results.go b/results.go
@@ -156,63 +156,20 @@ func (r *RenderTemplateResult) Apply(req *Request, resp *Response) {
 	// error pages distorted by HTML already written)
 	if chunked && !DevMode {
 		resp.WriteHeader(http.StatusOK, "text/html; charset=utf-8")
-		r.render(req, resp, out)
+		if err := r.renderOutput(out); err !=nil {
+			r.renderError(err,req,resp)
+		}
 		return
 	}
 
 	// Render the template into a temporary buffer, to see if there was an error
 	// rendering the template.  If not, then copy it into the response buffer.
 	// Otherwise, template render errors may result in unpredictable HTML (and
 	// would carry a 200 status code)
-	var b bytes.Buffer
-	r.render(req, resp, &b)
-
-	// Trimming the HTML will do the following:
-	// * Remove all leading & trailing whitespace on every line
-	// * Remove all empty lines
-	// * Attempt to keep formatting inside <pre></pre> tags
-	//
-	// This is safe unless white-space: pre; is used in css for formatting.
-	// Since there is no way to detect that, you will have to keep trimming off in these cases.
-	if Config.BoolDefault("results.trim.html", false) {
-		var b2 bytes.Buffer
-		// Allocate length of original buffer, so we can write everything without allocating again
-		b2.Grow(b.Len())
-		insidePre := false
-		for {
-			text, err := b.ReadString('\n')
-			// Convert to lower case for finding <pre> tags.
-			tl := strings.ToLower(text)
-			if strings.Contains(tl, "<pre>") {
-				insidePre = true
-			}
-			// Trim if not inside a <pre> statement
-			if !insidePre {
-				// Cut trailing/leading whitespace
-				text = strings.Trim(text, " \t\r\n")
-				if len(text) > 0 {
-					if _, err = b2.WriteString(text); err != nil {
-						resultsLog.Error("Apply: ", "error", err)
-					}
-					if _, err = b2.WriteString("\n"); err != nil {
-						resultsLog.Error("Apply: ", "error", err)
-					}
-				}
-			} else {
-				if _, err = b2.WriteString(text); err != nil {
-					resultsLog.Error("Apply: ", "error", err)
-				}
-			}
-			if strings.Contains(tl, "</pre>") {
-				insidePre = false
-			}
-			// We are finished
-			if err != nil {
-				break
-			}
-		}
-		// Replace the buffer
-		b = b2
+	b, err := r.ToBytes()
+	if err!=nil {
+		r.renderError(err,req,resp)
+		return
 	}
 
 	if !chunked {
@@ -224,12 +181,85 @@ func (r *RenderTemplateResult) Apply(req *Request, resp *Response) {
 	}
 }
 
-func (r *RenderTemplateResult) render(req *Request, resp *Response, wr io.Writer) {
-	err := r.Template.Render(wr, r.ViewArgs)
-	if err == nil {
-		return
+// Return a byte array and or an error object if the template failed to render
+func (r *RenderTemplateResult) ToBytes() (b *bytes.Buffer,err error) {
+	defer func() {
+		if rerr := recover(); rerr != nil {
+			resultsLog.Error("ApplyBytes: panic recovery", "recover-error", rerr)
+			err = fmt.Errorf("Template Execution Panic in %s:\n%s", r.Template.Name(), rerr)
+		}
+	}()
+	b = &bytes.Buffer{}
+	if err = r.renderOutput(b); err==nil {
+		if Config.BoolDefault("results.trim.html", false) {
+			b = r.compressHtml(b)
+		}
+	}
+	return
+}
+
+// Output the template to the writer, catch any panics and return as an error
+func (r *RenderTemplateResult) renderOutput(wr io.Writer) (err error) {
+	defer func() {
+		if rerr := recover(); rerr != nil {
+			resultsLog.Error("ApplyBytes: panic recovery", "recover-error", rerr)
+			err = fmt.Errorf("Template Execution Panic in %s:\n%s", r.Template.Name(), rerr)
+		}
+	}()
+	err = r.Template.Render(wr, r.ViewArgs)
+	return
+}
+
+// Trimming the HTML will do the following:
+// * Remove all leading & trailing whitespace on every line
+// * Remove all empty lines
+// * Attempt to keep formatting inside <pre></pre> tags
+//
+// This is safe unless white-space: pre; is used in css for formatting.
+// Since there is no way to detect that, you will have to keep trimming off in these cases.
+func (r *RenderTemplateResult) compressHtml(b *bytes.Buffer) (b2 *bytes.Buffer) {
+
+	// Allocate length of original buffer, so we can write everything without allocating again
+	b2.Grow(b.Len())
+	insidePre := false
+	for {
+		text, err := b.ReadString('\n')
+		// Convert to lower case for finding <pre> tags.
+		tl := strings.ToLower(text)
+		if strings.Contains(tl, "<pre>") {
+			insidePre = true
+		}
+		// Trim if not inside a <pre> statement
+		if !insidePre {
+			// Cut trailing/leading whitespace
+			text = strings.Trim(text, " \t\r\n")
+			if len(text) > 0 {
+				if _, err = b2.WriteString(text); err != nil {
+					resultsLog.Error("Apply: ", "error", err)
+				}
+				if _, err = b2.WriteString("\n"); err != nil {
+					resultsLog.Error("Apply: ", "error", err)
+				}
+			}
+		} else {
+			if _, err = b2.WriteString(text); err != nil {
+				resultsLog.Error("Apply: ", "error", err)
+			}
+		}
+		if strings.Contains(tl, "</pre>") {
+			insidePre = false
+		}
+		// We are finished
+		if err != nil {
+			break
+		}
 	}
 
+	return
+}
+
+// Render the error in the response
+func (r *RenderTemplateResult) renderError(err error,req *Request, resp *Response) {
 	var templateContent []string
 	templateName, line, description := ParseTemplateError(err)
 	if templateName == "" {
diff --git a/template.go b/template.go
@@ -50,6 +50,25 @@ var invalidSlugPattern = regexp.MustCompile(`[^a-z0-9 _-]`)
 var whiteSpacePattern = regexp.MustCompile(`\s+`)
 var templateLog = RevelLog.New("section", "template")
 
+// TemplateOutputArgs returns the result of the template rendered using the passed in arguments.
+func TemplateOutputArgs(templatePath string, args map[string]interface{}) (data []byte,err error)  {
+	// Get the Template.
+	lang, _ := args[CurrentLocaleViewArg].(string)
+	template, err := MainTemplateLoader.TemplateLang(templatePath, lang)
+	if err != nil {
+		return nil, err
+	}
+	tr :=  &RenderTemplateResult{
+		Template: template,
+		ViewArgs: args,
+	}
+	b,err := tr.ToBytes()
+	if err!=nil {
+		return nil,err
+	}
+	return b.Bytes(), nil
+}
+
 func NewTemplateLoader(paths []string) *TemplateLoader {
 	loader := &TemplateLoader{
 		paths:         paths,

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,8 @@`
`1`	`1`	`{`
`2`	`2`	`"GOLANG": {`
	`3`	`+ "ABC":[15, 25, 50, 70],`
	`4`	`+ "BLOCK_NESTING":[5, 6, 7, 8],`
	`5`	`+ "CYCLO":[20, 30, 45, 60],`
`3`	`6`	`"TOO_MANY_IVARS": [15, 18, 20, 25],`
`4`	`7`	`"TOO_MANY_FUNCTIONS": [20, 30, 40, 50],`
`5`	`8`	`"TOTAL_COMPLEXITY": [150, 250, 400, 500],`
Original file line number	Diff line number	Diff line change
`@@ -208,6 +208,11 @@ func (c *Controller) RenderTemplate(templatePath string) Result {`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
	`211`	`+// TemplateOutput returns the result of the template rendered using the controllers ViewArgs.`
	`212`	`+func (c *Controller) TemplateOutput(templatePath string) (data []byte,err error) {`
	`213`	`+ return TemplateOutputArgs(templatePath,c.ViewArgs)`
	`214`	`+}`
	`215`	`+`
`211`	`216`	`// RenderJSON uses encoding/json.Marshal to return JSON to the client.`
`212`	`217`	`func (c *Controller) RenderJSON(o interface{}) Result {`
`213`	`218`	`c.setStatusIfNil(http.StatusOK)`