Infrastructure/caddy
0
Fork 0
mirror of https://github.com/caddyserver/caddy.git synced 2025-01-06 22:40:31 -05:00
Code Issues Activity

Add context to markdown template

Browse source 
Created a struct containing middleware.Context, Title, Markdown and the
variables from the user to use to render the template.
The title now can be accessed via {{.Title}}.
The variables can now be accessed via {{.Var.myVariableName}}.
This commit is contained in:
Maxime 2015-07-21 07:58:34 +02:00
parent 2d5320c454
commit 6451e10d3e
7 changed files with 123 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
config/setup/markdown.go
View file

@ -62,7 +62,8 @@ func Markdown(c *Controller) (middleware.Middleware, error) {
reqPath = "/" + reqPath reqPath = "/" + reqPath
// Generate the static file // Generate the static file
_, err = md.Process(cfg, reqPath, body) ctx := middleware.Context{Root: md.FileSys}
_, err = md.Process(cfg, reqPath, body, ctx)
if err != nil { if err != nil {
return err return err
} }

15
middleware/markdown/blog/test.md Normal file
View file

@ -0,0 +1,15 @@
---
title: Markdown test
variables:
sitename: A Caddy website
---
## Welcome on the blog
Body
``` go
func getTrue() bool {
return true
}
```

1
middleware/markdown/header.html Normal file
View file

@ -0,0 +1 @@
<h1>Header</h1>

7
middleware/markdown/markdown.go
View file

@ -119,7 +119,12 @@ func (md Markdown) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error
return http.StatusInternalServerError, err return http.StatusInternalServerError, err
} }
html, err := md.Process(m, fpath, body) ctx := middleware.Context{
Root: md.FileSys,
Req: r,
URL: r.URL,
}
html, err := md.Process(m, fpath, body, ctx)
if err != nil { if err != nil {
return http.StatusInternalServerError, err return http.StatusInternalServerError, err
} }

69
middleware/markdown/markdown_test.go Normal file
View file

@ -0,0 +1,69 @@
package markdown
import (
"net/http"
"net/http/httptest"
"testing"
"github.com/russross/blackfriday"
)
func TestMarkdown(t *testing.T) {
templates := make(map[string]string)
templates[DefaultTemplate] = "markdown_tpl.html"
md := Markdown{
Root: "/blog",
FileSys: http.Dir("."),
Configs: []Config{
Config{
Renderer: blackfriday.HtmlRenderer(0, "", ""),
PathScope: "/blog",
Extensions: []string{"md"},
Styles: []string{},
Scripts: []string{},
Templates: templates,
},
},
IndexFiles: []string{"index.html"},
}
req, err := http.NewRequest("GET", "/blog/test.md", nil)
if err != nil {
t.Fatalf("Could not create HTTP request: %v", err)
}
rec := httptest.NewRecorder()
md.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("Wrong status, expected: %d and got %d", http.StatusOK, rec.Code)
}
respBody := rec.Body.String()
expectedBody := `<!DOCTYPE html>
<html>
<head>
<title>Markdown test</title>
</head>
<body>
<h1>Header</h1>
Welcome to A Caddy website!
<h2>Welcome on the blog</h2>
<p>Body</p>
<p><code>go
func getTrue() bool {
return true
}
</code></p>
</body>
</html>
`
if respBody != expectedBody {
t.Fatalf("Expected body: %v got: %v", expectedBody, respBody)
}
}

11
middleware/markdown/markdown_tpl.html Normal file
View file

@ -0,0 +1,11 @@
<!DOCTYPE html>
<html>
<head>
<title>{{.Title}}</title>
</head>
<body>
{{.Include "header.html"}}
Welcome to {{.Var.sitename}}!
{{.Markdown}}
</body>
</html>

23
middleware/markdown/process.go
View file

@ -9,6 +9,7 @@ import (
"strings" "strings"
"text/template" "text/template"
"github.com/mholt/caddy/middleware"
"github.com/russross/blackfriday" "github.com/russross/blackfriday"
) )
@ -17,9 +18,16 @@ const (
DefaultStaticDir = "generated_site" DefaultStaticDir = "generated_site"
) )
type MarkdownData struct {
middleware.Context
Var map[string]interface{}
Title string
Markdown string
}
// Process processes the contents of a page in b. It parses the metadata // Process processes the contents of a page in b. It parses the metadata
// (if any) and uses the template (if found). // (if any) and uses the template (if found).
func (md Markdown) Process(c Config, requestPath string, b []byte) ([]byte, error) { func (md Markdown) Process(c Config, requestPath string, b []byte, ctx middleware.Context) ([]byte, error) {
var metadata = Metadata{Variables: make(map[string]interface{})} var metadata = Metadata{Variables: make(map[string]interface{})}
var markdown []byte var markdown []byte
var err error var err error
@ -63,12 +71,12 @@ func (md Markdown) Process(c Config, requestPath string, b []byte) ([]byte, erro
// set it as body for template // set it as body for template
metadata.Variables["markdown"] = string(markdown) metadata.Variables["markdown"] = string(markdown)
return md.processTemplate(c, requestPath, tmpl, metadata) return md.processTemplate(c, requestPath, tmpl, metadata, ctx)
} }
// processTemplate processes a template given a requestPath, // processTemplate processes a template given a requestPath,
// template (tmpl) and metadata // template (tmpl) and metadata
func (md Markdown) processTemplate(c Config, requestPath string, tmpl []byte, metadata Metadata) ([]byte, error) { func (md Markdown) processTemplate(c Config, requestPath string, tmpl []byte, metadata Metadata, ctx middleware.Context) ([]byte, error) {
// if template is not specified, // if template is not specified,
// use the default template // use the default template
if tmpl == nil { if tmpl == nil {
@ -81,7 +89,14 @@ func (md Markdown) processTemplate(c Config, requestPath string, tmpl []byte, me
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err = t.Execute(b, metadata.Variables); err != nil { mdData := MarkdownData{
Context: ctx,
Var: metadata.Variables,
Title: metadata.Title,
Markdown: metadata.Variables["markdown"].(string),
}
if err = t.Execute(b, mdData); err != nil {
return nil, err return nil, err
} }