use go 1.12

Signed-off-by: hongming <talonwan@yunify.com>

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 preparses 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_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()
+}