TUN-528: Move cloudflared into a separate repo

vendor/github.com/mholt/caddy/caddyhttp/markdown/metadata/metadata.go

@@ -0,0 +1,160 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package metadata
+
+import (
+	"bufio"
+	"bytes"
+	"time"
+)
+
+var (
+	// Date format YYYY-MM-DD HH:MM:SS or YYYY-MM-DD
+	timeLayout = []string{
+		`2006-01-02 15:04:05-0700`,
+		`2006-01-02 15:04:05`,
+		`2006-01-02`,
+	}
+)
+
+// Metadata stores a page's metadata
+type Metadata struct {
+	// Page title
+	Title string
+
+	// Page template
+	Template string
+
+	// Publish date
+	Date time.Time
+
+	// Variables to be used with Template
+	Variables map[string]interface{}
+}
+
+// NewMetadata returns a new Metadata struct, loaded with the given map
+func NewMetadata(parsedMap map[string]interface{}) Metadata {
+	md := Metadata{
+		Variables: make(map[string]interface{}),
+	}
+	md.load(parsedMap)
+
+	return md
+}
+
+// load loads parsed values in parsedMap into Metadata
+func (m *Metadata) load(parsedMap map[string]interface{}) {
+
+	// Pull top level things out
+	if title, ok := parsedMap["title"]; ok {
+		m.Title, _ = title.(string)
+	}
+	if template, ok := parsedMap["template"]; ok {
+		m.Template, _ = template.(string)
+	}
+	if date, ok := parsedMap["date"].(string); ok {
+		for _, layout := range timeLayout {
+			if t, err := time.Parse(layout, date); err == nil {
+				m.Date = t
+				break
+			}
+		}
+	}
+
+	m.Variables = parsedMap
+}
+
+// Parser is a an interface that must be satisfied by each parser
+type Parser interface {
+	// Initialize a parser
+	Init(b *bytes.Buffer) bool
+
+	// Type of metadata
+	Type() string
+
+	// Parsed metadata.
+	Metadata() Metadata
+
+	// Raw markdown.
+	Markdown() []byte
+}
+
+// GetParser returns a parser for the given data
+func GetParser(buf []byte) Parser {
+	for _, p := range parsers() {
+		b := bytes.NewBuffer(buf)
+		if p.Init(b) {
+			return p
+		}
+	}
+
+	return nil
+}
+
+// parsers returns all available parsers
+func parsers() []Parser {
+	return []Parser{
+		&TOMLParser{},
+		&YAMLParser{},
+		&JSONParser{},
+
+		// This one must be last
+		&NoneParser{},
+	}
+}
+
+// Split out prefixed/suffixed metadata with given delimiter
+func splitBuffer(b *bytes.Buffer, delim string) (*bytes.Buffer, *bytes.Buffer) {
+	scanner := bufio.NewScanner(b)
+
+	// Read and check first line
+	if !scanner.Scan() {
+		return nil, nil
+	}
+	if string(bytes.TrimSpace(scanner.Bytes())) != delim {
+		return nil, nil
+	}
+
+	// Accumulate metadata, until delimiter
+	meta := bytes.NewBuffer(nil)
+	for scanner.Scan() {
+		if string(bytes.TrimSpace(scanner.Bytes())) == delim {
+			break
+		}
+		if _, err := meta.Write(scanner.Bytes()); err != nil {
+			return nil, nil
+		}
+		if _, err := meta.WriteRune('\n'); err != nil {
+			return nil, nil
+		}
+	}
+	// Make sure we saw closing delimiter
+	if string(bytes.TrimSpace(scanner.Bytes())) != delim {
+		return nil, nil
+	}
+
+	// The rest is markdown
+	markdown := new(bytes.Buffer)
+	for scanner.Scan() {
+		if _, err := markdown.Write(scanner.Bytes()); err != nil {
+			return nil, nil
+		}
+		if _, err := markdown.WriteRune('\n'); err != nil {
+			return nil, nil
+		}
+	}
+
+	return meta, markdown
+}

vendor/github.com/mholt/caddy/caddyhttp/markdown/metadata/metadata_json.go

@@ -0,0 +1,70 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package metadata
+
+import (
+	"bytes"
+	"encoding/json"
+)
+
+// JSONParser is the MetadataParser for JSON
+type JSONParser struct {
+	metadata Metadata
+	markdown *bytes.Buffer
+}
+
+// Type returns the kind of metadata parser implemented by this struct.
+func (j *JSONParser) Type() string {
+	return "JSON"
+}
+
+// Init prepares the metadata metadata/markdown file and parses it
+func (j *JSONParser) Init(b *bytes.Buffer) bool {
+	m := make(map[string]interface{})
+
+	err := json.Unmarshal(b.Bytes(), &m)
+	if err != nil {
+		var offset int
+
+		jerr, ok := err.(*json.SyntaxError)
+		if !ok {
+			return false
+		}
+
+		offset = int(jerr.Offset)
+
+		m = make(map[string]interface{})
+		err = json.Unmarshal(b.Next(offset-1), &m)
+		if err != nil {
+			return false
+		}
+	}
+
+	j.metadata = NewMetadata(m)
+	j.markdown = bytes.NewBuffer(b.Bytes())
+
+	return true
+}
+
+// Metadata returns parsed metadata.  It should be called
+// only after a call to Parse returns without error.
+func (j *JSONParser) Metadata() Metadata {
+	return j.metadata
+}
+
+// Markdown returns the markdown text.  It should be called only after a call to Parse returns without error.
+func (j *JSONParser) Markdown() []byte {
+	return j.markdown.Bytes()
+}

vendor/github.com/mholt/caddy/caddyhttp/markdown/metadata/metadata_none.go

@@ -0,0 +1,56 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package metadata
+
+import (
+	"bytes"
+)
+
+// NoneParser is the parser for plaintext markdown with no metadata.
+type NoneParser struct {
+	metadata Metadata
+	markdown *bytes.Buffer
+}
+
+// Type returns the kind of parser this struct is.
+func (n *NoneParser) Type() string {
+	return "None"
+}
+
+// Init prepases and parses the metadata and markdown file
+func (n *NoneParser) Init(b *bytes.Buffer) bool {
+	m := make(map[string]interface{})
+	n.metadata = NewMetadata(m)
+	n.markdown = bytes.NewBuffer(b.Bytes())
+
+	return true
+}
+
+// Parse the metadata
+func (n *NoneParser) Parse(b []byte) ([]byte, error) {
+	return nil, nil
+}
+
+// Metadata returns parsed metadata.  It should be called
+// only after a call to Parse returns without error.
+func (n *NoneParser) Metadata() Metadata {
+	return n.metadata
+}
+
+// Markdown returns parsed markdown.  It should be called
+// only after a call to Parse returns without error.
+func (n *NoneParser) Markdown() []byte {
+	return n.markdown.Bytes()
+}

vendor/github.com/mholt/caddy/caddyhttp/markdown/metadata/metadata_test.go

@@ -0,0 +1,297 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package metadata
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func check(t *testing.T, err error) {
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+var TOML = [5]string{`
+title = "A title"
+template = "default"
+name = "value"
+positive = true
+negative = false
+number = 1410
+float = 1410.07
+`,
+	`+++
+title = "A title"
+template = "default"
+name = "value"
+positive = true
+negative = false
+number = 1410
+float = 1410.07
++++
+Page content
+	`,
+	`+++
+title = "A title"
+template = "default"
+name = "value"
+positive = true
+negative = false
+number = 1410
+float = 1410.07
+	`,
+	`title = "A title" template = "default" [variables] name = "value"`,
+	`+++
+title = "A title"
+template = "default"
+name = "value"
+positive = true
+negative = false
+number = 1410
+float = 1410.07
++++
+`,
+}
+
+var YAML = [5]string{`
+title : A title
+template : default
+name : value
+positive : true
+negative : false
+number : 1410
+float : 1410.07
+`,
+	`---
+title : A title
+template : default
+name : value
+positive : true
+negative : false
+number : 1410
+float : 1410.07
+---
+	Page content
+	`,
+	`---
+title : A title
+template : default
+name : value
+number : 1410
+float : 1410.07
+	`,
+	`title : A title template : default variables : name : value : positive : true : negative : false`,
+	`---
+title : A title
+template : default
+name : value
+positive : true
+negative : false
+number : 1410
+float : 1410.07
+---
+`,
+}
+
+var JSON = [5]string{`
+	"title" : "A title",
+	"template" : "default",
+	"name" : "value",
+	"positive" : true,
+	"negative" : false,
+	"number": 1410,
+	"float": 1410.07
+`,
+	`{
+	"title" : "A title",
+	"template" : "default",
+	"name" : "value",
+	"positive" : true,
+	"negative" : false,
+	"number" : 1410,
+	"float": 1410.07
+}
+Page content
+	`,
+	`
+{
+	"title" : "A title",
+	"template" : "default",
+	"name" : "value",
+	"positive" : true,
+	"negative" : false,
+	"number" : 1410,
+	"float": 1410.07
+	`,
+	`
+{
+	"title" :: "A title",
+	"template" : "default",
+	"name" : "value",
+	"positive" : true,
+	"negative" : false,
+	"number" : 1410,
+	"float": 1410.07
+}
+	`,
+	`{
+	"title" : "A title",
+	"template" : "default",
+	"name" : "value",
+	"positive" : true,
+	"negative" : false,
+	"number" : 1410,
+	"float": 1410.07
+}
+`,
+}
+
+func TestParsers(t *testing.T) {
+	expected := Metadata{
+		Title:    "A title",
+		Template: "default",
+		Variables: map[string]interface{}{
+			"name":     "value",
+			"title":    "A title",
+			"template": "default",
+			"number":   1410,
+			"float":    1410.07,
+			"positive": true,
+			"negative": false,
+		},
+	}
+	compare := func(m Metadata) bool {
+		if m.Title != expected.Title {
+			return false
+		}
+		if m.Template != expected.Template {
+			return false
+		}
+		for k, v := range m.Variables {
+			if fmt.Sprintf("%v", v) != fmt.Sprintf("%v", expected.Variables[k]) {
+				return false
+			}
+		}
+
+		varLenOK := len(m.Variables) == len(expected.Variables)
+		return varLenOK
+	}
+
+	data := []struct {
+		parser   Parser
+		testData [5]string
+		name     string
+	}{
+		{&JSONParser{}, JSON, "JSON"},
+		{&YAMLParser{}, YAML, "YAML"},
+		{&TOMLParser{}, TOML, "TOML"},
+	}
+
+	for _, v := range data {
+		// metadata without identifiers
+		if v.parser.Init(bytes.NewBufferString(v.testData[0])) {
+			t.Fatalf("Expected error for invalid metadata for %v", v.name)
+		}
+
+		// metadata with identifiers
+		if !v.parser.Init(bytes.NewBufferString(v.testData[1])) {
+			t.Fatalf("Metadata failed to initialize, type %v", v.parser.Type())
+		}
+		md := v.parser.Markdown()
+		if !compare(v.parser.Metadata()) {
+			t.Fatalf("Expected %v, found %v for %v", expected, v.parser.Metadata(), v.name)
+		}
+		if "Page content" != strings.TrimSpace(string(md)) {
+			t.Fatalf("Expected %v, found %v for %v", "Page content", string(md), v.name)
+		}
+		// Check that we find the correct metadata parser type
+		if p := GetParser([]byte(v.testData[1])); p.Type() != v.name {
+			t.Fatalf("Wrong parser found, expected %v, found %v", v.name, p.Type())
+		}
+
+		// metadata without closing identifier
+		if v.parser.Init(bytes.NewBufferString(v.testData[2])) {
+			t.Fatalf("Expected error for missing closing identifier for %v parser", v.name)
+		}
+
+		// invalid metadata
+		if v.parser.Init(bytes.NewBufferString(v.testData[3])) {
+			t.Fatalf("Expected error for invalid metadata for %v", v.name)
+		}
+
+		// front matter but no body
+		if !v.parser.Init(bytes.NewBufferString(v.testData[4])) {
+			t.Fatalf("Unexpected error for valid metadata but no body for %v", v.name)
+		}
+	}
+}
+
+func TestLargeBody(t *testing.T) {
+
+	var JSON = `{
+"template": "chapter"
+}
+
+Mycket olika byggnader har man i de nordiska rikena: pyramidformiga, kilformiga, välvda, runda och fyrkantiga. De pyramidformiga består helt enkelt av träribbor, som upptill löper samman och nedtill bildar en vidare krets; de är avsedda att användas av hantverkarna under sommaren, för att de inte ska plågas av solen, på samma gång som de besväras av rök och eld. De kilformiga husen är i regel försedda med höga tak, för att de täta och tunga snömassorna fortare ska kunna blåsa av och inte tynga ned taken. Dessa är täckta av björknäver, tegel eller kluvet spån av furu - för kådans skull -, gran, ek eller bok; taken på de förmögnas hus däremot med plåtar av koppar eller bly, i likhet med kyrktaken. Valvbyggnaderna uppförs ganska konstnärligt till skydd mot våldsamma vindar och snöfall, görs av sten eller trä, och är avsedda för olika alldagliga viktiga ändamål. Liknande byggnader kan finnas i stormännens gårdar där de används som förvaringsrum för husgeråd och jordbruksredskap. De runda byggnaderna - som för övrigt är de högst sällsynta - används av konstnärer, som vid sitt arbete behöver ett jämnt fördelat ljus från taket. Vanligast är de fyrkantiga husen, vars grova bjälkar är synnerligen väl hopfogade i hörnen - ett sant mästerverk av byggnadskonst; även dessa har fönster högt uppe i taken, för att dagsljuset skall kunna strömma in och ge alla därinne full belysning. Stenhusen har dörröppningar i förhållande till byggnadens storlek, men smala fönstergluggar, som skydd mot den stränga kölden, frosten och snön. Vore de större och vidare, såsom fönstren i Italien, skulle husen i följd av den fint yrande snön, som röres upp av den starka blåsten, precis som dammet av virvelvinden, snart nog fyllas med massor av snö och inte kunna stå emot dess tryck, utan störta samman.
+
+	`
+	var TOML = `+++
+template = "chapter"
++++
+
+Mycket olika byggnader har man i de nordiska rikena: pyramidformiga, kilformiga, välvda, runda och fyrkantiga. De pyramidformiga består helt enkelt av träribbor, som upptill löper samman och nedtill bildar en vidare krets; de är avsedda att användas av hantverkarna under sommaren, för att de inte ska plågas av solen, på samma gång som de besväras av rök och eld. De kilformiga husen är i regel försedda med höga tak, för att de täta och tunga snömassorna fortare ska kunna blåsa av och inte tynga ned taken. Dessa är täckta av björknäver, tegel eller kluvet spån av furu - för kådans skull -, gran, ek eller bok; taken på de förmögnas hus däremot med plåtar av koppar eller bly, i likhet med kyrktaken. Valvbyggnaderna uppförs ganska konstnärligt till skydd mot våldsamma vindar och snöfall, görs av sten eller trä, och är avsedda för olika alldagliga viktiga ändamål. Liknande byggnader kan finnas i stormännens gårdar där de används som förvaringsrum för husgeråd och jordbruksredskap. De runda byggnaderna - som för övrigt är de högst sällsynta - används av konstnärer, som vid sitt arbete behöver ett jämnt fördelat ljus från taket. Vanligast är de fyrkantiga husen, vars grova bjälkar är synnerligen väl hopfogade i hörnen - ett sant mästerverk av byggnadskonst; även dessa har fönster högt uppe i taken, för att dagsljuset skall kunna strömma in och ge alla därinne full belysning. Stenhusen har dörröppningar i förhållande till byggnadens storlek, men smala fönstergluggar, som skydd mot den stränga kölden, frosten och snön. Vore de större och vidare, såsom fönstren i Italien, skulle husen i följd av den fint yrande snön, som röres upp av den starka blåsten, precis som dammet av virvelvinden, snart nog fyllas med massor av snö och inte kunna stå emot dess tryck, utan störta samman.
+
+	`
+	var YAML = `---
+template : chapter
+---
+
+Mycket olika byggnader har man i de nordiska rikena: pyramidformiga, kilformiga, välvda, runda och fyrkantiga. De pyramidformiga består helt enkelt av träribbor, som upptill löper samman och nedtill bildar en vidare krets; de är avsedda att användas av hantverkarna under sommaren, för att de inte ska plågas av solen, på samma gång som de besväras av rök och eld. De kilformiga husen är i regel försedda med höga tak, för att de täta och tunga snömassorna fortare ska kunna blåsa av och inte tynga ned taken. Dessa är täckta av björknäver, tegel eller kluvet spån av furu - för kådans skull -, gran, ek eller bok; taken på de förmögnas hus däremot med plåtar av koppar eller bly, i likhet med kyrktaken. Valvbyggnaderna uppförs ganska konstnärligt till skydd mot våldsamma vindar och snöfall, görs av sten eller trä, och är avsedda för olika alldagliga viktiga ändamål. Liknande byggnader kan finnas i stormännens gårdar där de används som förvaringsrum för husgeråd och jordbruksredskap. De runda byggnaderna - som för övrigt är de högst sällsynta - används av konstnärer, som vid sitt arbete behöver ett jämnt fördelat ljus från taket. Vanligast är de fyrkantiga husen, vars grova bjälkar är synnerligen väl hopfogade i hörnen - ett sant mästerverk av byggnadskonst; även dessa har fönster högt uppe i taken, för att dagsljuset skall kunna strömma in och ge alla därinne full belysning. Stenhusen har dörröppningar i förhållande till byggnadens storlek, men smala fönstergluggar, som skydd mot den stränga kölden, frosten och snön. Vore de större och vidare, såsom fönstren i Italien, skulle husen i följd av den fint yrande snön, som röres upp av den starka blåsten, precis som dammet av virvelvinden, snart nog fyllas med massor av snö och inte kunna stå emot dess tryck, utan störta samman.
+
+	`
+	var NONE = `
+
+Mycket olika byggnader har man i de nordiska rikena: pyramidformiga, kilformiga, välvda, runda och fyrkantiga. De pyramidformiga består helt enkelt av träribbor, som upptill löper samman och nedtill bildar en vidare krets; de är avsedda att användas av hantverkarna under sommaren, för att de inte ska plågas av solen, på samma gång som de besväras av rök och eld. De kilformiga husen är i regel försedda med höga tak, för att de täta och tunga snömassorna fortare ska kunna blåsa av och inte tynga ned taken. Dessa är täckta av björknäver, tegel eller kluvet spån av furu - för kådans skull -, gran, ek eller bok; taken på de förmögnas hus däremot med plåtar av koppar eller bly, i likhet med kyrktaken. Valvbyggnaderna uppförs ganska konstnärligt till skydd mot våldsamma vindar och snöfall, görs av sten eller trä, och är avsedda för olika alldagliga viktiga ändamål. Liknande byggnader kan finnas i stormännens gårdar där de används som förvaringsrum för husgeråd och jordbruksredskap. De runda byggnaderna - som för övrigt är de högst sällsynta - används av konstnärer, som vid sitt arbete behöver ett jämnt fördelat ljus från taket. Vanligast är de fyrkantiga husen, vars grova bjälkar är synnerligen väl hopfogade i hörnen - ett sant mästerverk av byggnadskonst; även dessa har fönster högt uppe i taken, för att dagsljuset skall kunna strömma in och ge alla därinne full belysning. Stenhusen har dörröppningar i förhållande till byggnadens storlek, men smala fönstergluggar, som skydd mot den stränga kölden, frosten och snön. Vore de större och vidare, såsom fönstren i Italien, skulle husen i följd av den fint yrande snön, som röres upp av den starka blåsten, precis som dammet av virvelvinden, snart nog fyllas med massor av snö och inte kunna stå emot dess tryck, utan störta samman.
+
+	`
+	var expectedBody = `Mycket olika byggnader har man i de nordiska rikena: pyramidformiga, kilformiga, välvda, runda och fyrkantiga. De pyramidformiga består helt enkelt av träribbor, som upptill löper samman och nedtill bildar en vidare krets; de är avsedda att användas av hantverkarna under sommaren, för att de inte ska plågas av solen, på samma gång som de besväras av rök och eld. De kilformiga husen är i regel försedda med höga tak, för att de täta och tunga snömassorna fortare ska kunna blåsa av och inte tynga ned taken. Dessa är täckta av björknäver, tegel eller kluvet spån av furu - för kådans skull -, gran, ek eller bok; taken på de förmögnas hus däremot med plåtar av koppar eller bly, i likhet med kyrktaken. Valvbyggnaderna uppförs ganska konstnärligt till skydd mot våldsamma vindar och snöfall, görs av sten eller trä, och är avsedda för olika alldagliga viktiga ändamål. Liknande byggnader kan finnas i stormännens gårdar där de används som förvaringsrum för husgeråd och jordbruksredskap. De runda byggnaderna - som för övrigt är de högst sällsynta - används av konstnärer, som vid sitt arbete behöver ett jämnt fördelat ljus från taket. Vanligast är de fyrkantiga husen, vars grova bjälkar är synnerligen väl hopfogade i hörnen - ett sant mästerverk av byggnadskonst; även dessa har fönster högt uppe i taken, för att dagsljuset skall kunna strömma in och ge alla därinne full belysning. Stenhusen har dörröppningar i förhållande till byggnadens storlek, men smala fönstergluggar, som skydd mot den stränga kölden, frosten och snön. Vore de större och vidare, såsom fönstren i Italien, skulle husen i följd av den fint yrande snön, som röres upp av den starka blåsten, precis som dammet av virvelvinden, snart nog fyllas med massor av snö och inte kunna stå emot dess tryck, utan störta samman.
+`
+
+	data := []struct {
+		pType    string
+		testData string
+	}{
+		{"JSON", JSON},
+		{"TOML", TOML},
+		{"YAML", YAML},
+		{"None", NONE},
+	}
+	for _, v := range data {
+		p := GetParser([]byte(v.testData))
+		if v.pType != p.Type() {
+			t.Fatalf("Wrong parser type, expected %v, got %v", v.pType, p.Type())
+		}
+		md := p.Markdown()
+		if strings.TrimSpace(string(md)) != strings.TrimSpace(expectedBody) {
+			t.Log("Provided:", v.testData)
+			t.Log("Returned:", p.Markdown())
+			t.Fatalf("Error, mismatched body in expected type %v, matched type %v", v.pType, p.Type())
+		}
+	}
+}

vendor/github.com/mholt/caddy/caddyhttp/markdown/metadata/metadata_toml.go

@@ -0,0 +1,60 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package metadata
+
+import (
+	"bytes"
+
+	"github.com/naoina/toml"
+)
+
+// TOMLParser is the Parser for TOML
+type TOMLParser struct {
+	metadata Metadata
+	markdown *bytes.Buffer
+}
+
+// Type returns the kind of parser this struct is.
+func (t *TOMLParser) Type() string {
+	return "TOML"
+}
+
+// Init prepares and parses the metadata and markdown file itself
+func (t *TOMLParser) Init(b *bytes.Buffer) bool {
+	meta, data := splitBuffer(b, "+++")
+	if meta == nil || data == nil {
+		return false
+	}
+	t.markdown = data
+
+	m := make(map[string]interface{})
+	if err := toml.Unmarshal(meta.Bytes(), &m); err != nil {
+		return false
+	}
+	t.metadata = NewMetadata(m)
+
+	return true
+}
+
+// Metadata returns parsed metadata.  It should be called
+// only after a call to Parse returns without error.
+func (t *TOMLParser) Metadata() Metadata {
+	return t.metadata
+}
+
+// Markdown returns parser markdown.  It should be called only after a call to Parse returns without error.
+func (t *TOMLParser) Markdown() []byte {
+	return t.markdown.Bytes()
+}

vendor/github.com/mholt/caddy/caddyhttp/markdown/metadata/metadata_yaml.go

@@ -0,0 +1,60 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package metadata
+
+import (
+	"bytes"
+
+	"gopkg.in/yaml.v2"
+)
+
+// YAMLParser is the Parser for YAML
+type YAMLParser struct {
+	metadata Metadata
+	markdown *bytes.Buffer
+}
+
+// Type returns the kind of metadata parser.
+func (y *YAMLParser) Type() string {
+	return "YAML"
+}
+
+// Init prepares the metadata parser for parsing.
+func (y *YAMLParser) Init(b *bytes.Buffer) bool {
+	meta, data := splitBuffer(b, "---")
+	if meta == nil || data == nil {
+		return false
+	}
+	y.markdown = data
+
+	m := make(map[string]interface{})
+	if err := yaml.Unmarshal(meta.Bytes(), &m); err != nil {
+		return false
+	}
+	y.metadata = NewMetadata(m)
+
+	return true
+}
+
+// Metadata returns parsed metadata.  It should be called
+// only after a call to Parse returns without error.
+func (y *YAMLParser) Metadata() Metadata {
+	return y.metadata
+}
+
+// Markdown renders the text as a byte array
+func (y *YAMLParser) Markdown() []byte {
+	return y.markdown.Bytes()
+}