go vendor

vendor/github.com/revel/modules/template-engine/ace/app/controllers/ace.go

@@ -0,0 +1,13 @@
+package controllers
+
+import "github.com/revel/revel"
+
+type AceController struct {
+	*revel.Controller
+}
+
+// Called to render the ace template inner
+func (c *AceController) RenderAceTemplate(base, inner string) revel.Result {
+	c.ViewArgs["ace_inner"] = inner
+	return c.RenderTemplate(base)
+}

vendor/github.com/revel/modules/template-engine/ace/app/init.go

@@ -0,0 +1,139 @@
+package app
+
+import (
+	"fmt"
+	"github.com/revel/revel"
+	"github.com/yosssi/ace"
+	"html/template"
+	"io"
+	"strings"
+)
+
+const ACE_TEMPLATE = "ace"
+
+// Adapter for Go Templates.
+type AceTemplate struct {
+	*template.Template
+	engine *AceEngine
+	*revel.TemplateView
+	File  *ace.File
+	Inner *ace.File
+}
+
+// A bit trick of an implementation
+// If the arg contains an ace_inner field then that will be used
+// to fetch a new template
+func (acetmpl AceTemplate) Render(wr io.Writer, arg interface{}) error {
+	// We can redirect this render to another template if the arguments contain ace_content in them
+	if argmap, ok := arg.(map[string]interface{}); ok {
+		if acecontentraw, ok := argmap["ace-inner"]; ok {
+			acecontent := acecontentraw.(string)
+			newtemplatename := acetmpl.TemplateName + "-" + acecontent
+			// Now lookup the template again
+			if _, ok := acetmpl.engine.templatesByName[newtemplatename]; !ok {
+				if inner, ok := acetmpl.engine.templatesByName[acecontent]; !ok {
+					return fmt.Errorf("Inner content %s not found in ace templates", acecontent)
+				} else {
+					acetmpl.engine.templatesByName[newtemplatename] = &AceTemplate{
+						File:         acetmpl.File,
+						Inner:        inner.File,
+						engine:       acetmpl.engine,
+						TemplateView: acetmpl.TemplateView}
+				}
+
+			}
+			return acetmpl.engine.templatesByName[newtemplatename].renderInternal(wr, arg)
+		}
+	}
+	return acetmpl.renderInternal(wr, arg)
+}
+
+func (acetmpl AceTemplate) renderInternal(wr io.Writer, arg interface{}) error {
+	if acetmpl.Template == nil {
+		// Compile the template first
+		if acetmpl.Inner == nil {
+			acetmpl.Inner = ace.NewFile("", nil)
+		}
+		source := ace.NewSource(acetmpl.File, acetmpl.Inner, acetmpl.engine.files)
+		result, err := ace.ParseSource(source, acetmpl.engine.Options)
+
+		if err != nil {
+			return err
+		}
+		if gtemplate, err := ace.CompileResult(acetmpl.TemplateName, result, acetmpl.engine.Options); err != nil {
+			return err
+		} else {
+			acetmpl.Template = gtemplate
+		}
+	}
+	return acetmpl.Execute(wr, arg)
+}
+
+type AceEngine struct {
+	loader          *revel.TemplateLoader
+	templatesByName map[string]*AceTemplate
+	files           []*ace.File
+	Options         *ace.Options
+	CaseInsensitive bool
+}
+
+func (i *AceEngine) ConvertPath(path string) string {
+	if i.CaseInsensitive {
+		return strings.ToLower(path)
+	}
+	return path
+}
+
+func (i *AceEngine) Handles(templateView *revel.TemplateView) bool {
+	return revel.EngineHandles(i, templateView)
+}
+
+func (engine *AceEngine) ParseAndAdd(baseTemplate *revel.TemplateView) error {
+
+	// Ace templates must only render views specified for it (no trial and error)
+	if baseTemplate.EngineType != ACE_TEMPLATE {
+		return &revel.Error{
+			Title:       "Template Compilation Error",
+			Path:        baseTemplate.FilePath,
+			Description: "Not correct template for engine",
+			Line:        1,
+			SourceLines: baseTemplate.Content(),
+		}
+	}
+
+	baseTemplate.TemplateName = engine.ConvertPath(baseTemplate.TemplateName)
+	file := ace.NewFile(baseTemplate.TemplateName, baseTemplate.FileBytes)
+	engine.files = append(engine.files, file)
+	engine.templatesByName[baseTemplate.TemplateName] = &AceTemplate{File: file, engine: engine, TemplateView: baseTemplate}
+	return nil
+}
+
+func (engine *AceEngine) Lookup(templateName string) revel.Template {
+	if tpl, found := engine.templatesByName[engine.ConvertPath(templateName)]; found {
+
+		return tpl
+	}
+	return nil
+}
+
+func (engine *AceEngine) Name() string {
+	return ACE_TEMPLATE
+}
+
+func (engine *AceEngine) Event(action int, i interface{}) {
+	if action == revel.TEMPLATE_REFRESH_REQUESTED {
+		engine.templatesByName = map[string]*AceTemplate{}
+		engine.CaseInsensitive = revel.Config.BoolDefault("ace.template.caseinsensitive", true)
+	}
+}
+
+func init() {
+	revel.RegisterTemplateLoader(ACE_TEMPLATE, func(loader *revel.TemplateLoader) (revel.TemplateEngine, error) {
+
+		return &AceEngine{
+			loader:          loader,
+			templatesByName: map[string]*AceTemplate{},
+			Options:         &ace.Options{FuncMap: revel.TemplateFuncs},
+		}, nil
+	})
+}

vendor/github.com/revel/modules/template-engine/ace/app/views/errors/403.ace.html

@@ -0,0 +1,9 @@
+= doctype html
+html lang=en
+  head
+    meta charset=utf-8
+    title Forbidden
+  body
+    h1 Base Template : {{.Error.Title}}
+    p : {{.Error.Description}}
+

vendor/github.com/revel/modules/template-engine/ace/app/views/errors/403.json

@@ -0,0 +1,4 @@
+{
+    "title": "{{Error.Title|escapejs}}",
+    "description": "{{Error.Description|escapejs}}"
+}

vendor/github.com/revel/modules/template-engine/ace/app/views/errors/403.txt

@@ -0,0 +1,3 @@
+{{.Error.Title}}
+
+{{.Error.Description}}