parser: Spring code cleaning

commands/convert.go

@@ -45,7 +45,7 @@ var toJSONCmd = &cobra.Command{
 	Long: `toJSON converts all front matter in the content directory
 to use JSON for the front matter.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return convertContents(rune([]byte(parser.JSON_LEAD)[0]))
+		return convertContents(rune([]byte(parser.JSONLead)[0]))
 	},
 }
 
@@ -55,7 +55,7 @@ var toTOMLCmd = &cobra.Command{
 	Long: `toTOML converts all front matter in the content directory
 to use TOML for the front matter.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return convertContents(rune([]byte(parser.TOML_LEAD)[0]))
+		return convertContents(rune([]byte(parser.TOMLLead)[0]))
 	},
 }
 
@@ -65,7 +65,7 @@ var toYAMLCmd = &cobra.Command{
 	Long: `toYAML converts all front matter in the content directory
 to use YAML for the front matter.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return convertContents(rune([]byte(parser.YAML_LEAD)[0]))
+		return convertContents(rune([]byte(parser.YAMLLead)[0]))
 	},
 }
 

commands/undraft.go

@@ -121,15 +121,15 @@ L:
 
 	// get the front matter as bytes and split it into lines
 	var lineEnding []byte
-	fmLines := bytes.Split(fm, parser.UnixEnding)
+	fmLines := bytes.Split(fm, []byte("\n"))
 	if len(fmLines) == 1 { // if the result is only 1 element, try to split on dos line endings
-		fmLines = bytes.Split(fm, parser.DosEnding)
+		fmLines = bytes.Split(fm, []byte("\r\n"))
 		if len(fmLines) == 1 {
 			return buff, fmt.Errorf("unable to split FrontMatter into lines")
 		}
-		lineEnding = append(lineEnding, parser.DosEnding...)
+		lineEnding = append(lineEnding, []byte("\r\n")...)
 	} else {
-		lineEnding = append(lineEnding, parser.UnixEnding...)
+		lineEnding = append(lineEnding, []byte("\n")...)
 	}
 
 	// Write the front matter lines to the buffer, replacing as necessary

parser/frontmatter.go

@@ -37,7 +37,7 @@ func InterfaceToConfig(in interface{}, mark rune) ([]byte, error) {
 	b := new(bytes.Buffer)
 
 	switch mark {
-	case rune(YAML_LEAD[0]):
+	case rune(YAMLLead[0]):
 		by, err := yaml.Marshal(in)
 		if err != nil {
 			return nil, err
@@ -48,13 +48,13 @@ func InterfaceToConfig(in interface{}, mark rune) ([]byte, error) {
 			return nil, err
 		}
 		return b.Bytes(), nil
-	case rune(TOML_LEAD[0]):
+	case rune(TOMLLead[0]):
 		err := toml.NewEncoder(b).Encode(in)
 		if err != nil {
 			return nil, err
 		}
 		return b.Bytes(), nil
-	case rune(JSON_LEAD[0]):
+	case rune(JSONLead[0]):
 		by, err := json.MarshalIndent(in, "", "   ")
 		if err != nil {
 			return nil, err
@@ -78,8 +78,8 @@ func InterfaceToFrontMatter(in interface{}, mark rune) ([]byte, error) {
 	b := new(bytes.Buffer)
 
 	switch mark {
-	case rune(YAML_LEAD[0]):
+	case rune(YAMLLead[0]):
-		_, err := b.Write([]byte(YAML_DELIM_UNIX))
+		_, err := b.Write([]byte(YAMLDelimUnix))
 		if err != nil {
 			return nil, err
 		}
@@ -88,13 +88,13 @@ func InterfaceToFrontMatter(in interface{}, mark rune) ([]byte, error) {
 			return nil, err
 		}
 		b.Write(by)
-		_, err = b.Write([]byte(YAML_DELIM_UNIX))
+		_, err = b.Write([]byte(YAMLDelimUnix))
 		if err != nil {
 			return nil, err
 		}
 		return b.Bytes(), nil
-	case rune(TOML_LEAD[0]):
+	case rune(TOMLLead[0]):
-		_, err := b.Write([]byte(TOML_DELIM_UNIX))
+		_, err := b.Write([]byte(TOMLDelimUnix))
 		if err != nil {
 			return nil, err
 		}
@@ -103,12 +103,12 @@ func InterfaceToFrontMatter(in interface{}, mark rune) ([]byte, error) {
 		if err != nil {
 			return nil, err
 		}
-		_, err = b.Write([]byte("\n" + TOML_DELIM_UNIX))
+		_, err = b.Write([]byte("\n" + TOMLDelimUnix))
 		if err != nil {
 			return nil, err
 		}
 		return b.Bytes(), nil
-	case rune(JSON_LEAD[0]):
+	case rune(JSONLead[0]):
 		by, err := json.MarshalIndent(in, "", "   ")
 		if err != nil {
 			return nil, err
@@ -127,11 +127,11 @@ func InterfaceToFrontMatter(in interface{}, mark rune) ([]byte, error) {
 func FormatToLeadRune(kind string) rune {
 	switch FormatSanitize(kind) {
 	case "yaml":
-		return rune([]byte(YAML_LEAD)[0])
+		return rune([]byte(YAMLLead)[0])
 	case "json":
-		return rune([]byte(JSON_LEAD)[0])
+		return rune([]byte(JSONLead)[0])
 	default:
-		return rune([]byte(TOML_LEAD)[0])
+		return rune([]byte(TOMLLead)[0])
 	}
 }
 
@@ -152,9 +152,9 @@ func FormatSanitize(kind string) string {
 func detectFrontMatter(mark rune) (f *frontmatterType) {
 	switch mark {
 	case '-':
-		return &frontmatterType{[]byte(YAML_DELIM), []byte(YAML_DELIM), HandleYAMLMetaData, false}
+		return &frontmatterType{[]byte(YAMLDelim), []byte(YAMLDelim), HandleYAMLMetaData, false}
 	case '+':
-		return &frontmatterType{[]byte(TOML_DELIM), []byte(TOML_DELIM), HandleTOMLMetaData, false}
+		return &frontmatterType{[]byte(TOMLDelim), []byte(TOMLDelim), HandleTOMLMetaData, false}
 	case '{':
 		return &frontmatterType{[]byte{'{'}, []byte{'}'}, HandleJSONMetaData, true}
 	default:
@@ -172,7 +172,7 @@ func HandleTOMLMetaData(datum []byte) (interface{}, error) {
 }
 
 func removeTOMLIdentifier(datum []byte) []byte {
-	return bytes.Replace(datum, []byte(TOML_DELIM), []byte(""), -1)
+	return bytes.Replace(datum, []byte(TOMLDelim), []byte(""), -1)
 }
 
 func HandleYAMLMetaData(datum []byte) (interface{}, error) {

parser/page.go

@@ -1,4 +1,4 @@
-// Copyright 2015 The Hugo Authors. All rights reserved.
+// Copyright 2016n The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -24,50 +24,61 @@ import (
 )
 
 const (
-	HTML_LEAD          = "<"
+	// TODO(bep) Do we really have to export these?
-	YAML_LEAD          = "-"
+
-	YAML_DELIM_UNIX    = "---\n"
+	// HTMLLead identifies the start of HTML documents.
-	YAML_DELIM_DOS     = "---\r\n"
+	HTMLLead = "<"
-	YAML_DELIM         = "---"
+	// YAMLLead identifies the start of YAML frontmatter.
-	TOML_LEAD          = "+"
+	YAMLLead = "-"
-	TOML_DELIM_UNIX    = "+++\n"
+	// YAMLDelimUnix identifies the end of YAML front matter on Unix.
-	TOML_DELIM_DOS     = "+++\r\n"
+	YAMLDelimUnix = "---\n"
-	TOML_DELIM         = "+++"
+	// YAMLDelimDOS identifies the end of YAML front matter on Windows.
-	JSON_LEAD          = "{"
+	YAMLDelimDOS = "---\r\n"
-	HTML_COMMENT_START = "<!--"
+	// YAMLDelim identifies the YAML front matter delimiter.
-	HTML_COMMENT_END   = "-->"
+	YAMLDelim = "---"
+	// TOMLLead identifies the start of TOML front matter.
+	TOMLLead = "+"
+	// TOMLDelimUnix identifies the end of TOML front matter on Unix.
+	TOMLDelimUnix = "+++\n"
+	// TOMLDelimDOS identifies the end of TOML front matter on Windows.
+	TOMLDelimDOS = "+++\r\n"
+	// TOMLDelim identifies the TOML front matter delimiter.
+	TOMLDelim = "+++"
+	// JSONLead identifies the start of JSON frontmatter.
+	JSONLead = "{"
+	// HTMLCommentStart identifies the start of HTML comment.
+	HTMLCommentStart = "<!--"
+	// HTMLCommentEnd identifies the end of HTML comment.
+	HTMLCommentEnd = "-->"
 )
 
 var (
 	delims = regexp.MustCompile(
-		"^(" + regexp.QuoteMeta(YAML_DELIM) + `\s*\n|` + regexp.QuoteMeta(TOML_DELIM) + `\s*\n|` + regexp.QuoteMeta(JSON_LEAD) + ")",
+		"^(" + regexp.QuoteMeta(YAMLDelim) + `\s*\n|` + regexp.QuoteMeta(TOMLDelim) + `\s*\n|` + regexp.QuoteMeta(JSONLead) + ")",
 	)
-
+	unixEnding = []byte("\n")
-	UnixEnding = []byte("\n")
+	dosEnding  = []byte("\r\n")
-	DosEnding  = []byte("\r\n")
 )
 
-type FrontMatter []byte
+// Page represents a parsed content page.
-type Content []byte
-
 type Page interface {
-	FrontMatter() FrontMatter
+	FrontMatter() []byte
-	Content() Content
+	Content() []byte
 	IsRenderable() bool
 	Metadata() (interface{}, error)
 }
 
 type page struct {
 	render      bool
-	frontmatter FrontMatter
+	frontmatter []byte
-	content     Content
+	content     []byte
 }
 
-func (p *page) Content() Content {
+func (p *page) Content() []byte {
 	return p.content
 }
 
-func (p *page) FrontMatter() FrontMatter {
+func (p *page) FrontMatter() []byte {
 	return p.frontmatter
 }
 
@@ -146,14 +157,14 @@ func chompFrontmatterStartComment(r *bufio.Reader) (err error) {
 	}
 
 	str := string(candidate)
-	if strings.HasPrefix(str, HTML_COMMENT_START) {
+	if strings.HasPrefix(str, HTMLCommentStart) {
 		lineEnd := strings.IndexAny(str, "\n")
 		if lineEnd == -1 {
 			//TODO: if we can't find it, Peek more?
 			return nil
 		}
 		testStr := strings.TrimSuffix(str[0:lineEnd], "\r")
-		if strings.Index(testStr, HTML_COMMENT_END) != -1 {
+		if strings.Index(testStr, HTMLCommentEnd) != -1 {
 			return nil
 		}
 		buf := make([]byte, lineEnd)
@@ -180,12 +191,12 @@ func chompFrontmatterEndComment(r *bufio.Reader) (err error) {
 		return nil
 	}
 	testStr := strings.TrimSuffix(str[0:lineEnd], "\r")
-	if strings.Index(testStr, HTML_COMMENT_START) != -1 {
+	if strings.Index(testStr, HTMLCommentStart) != -1 {
 		return nil
 	}
 
 	//TODO: if we can't find it, Peek more?
-	if strings.HasSuffix(testStr, HTML_COMMENT_END) {
+	if strings.HasSuffix(testStr, HTMLCommentEnd) {
 		buf := make([]byte, lineEnd)
 		if _, err = r.Read(buf); err != nil {
 			return
@@ -216,7 +227,7 @@ func shouldRender(lead []byte) (frontmatter bool) {
 		return
 	}
 
-	if bytes.Equal(lead[:1], []byte(HTML_LEAD)) {
+	if bytes.Equal(lead[:1], []byte(HTMLLead)) {
 		return
 	}
 	return true
@@ -231,16 +242,16 @@ func determineDelims(firstLine []byte) (left, right []byte) {
 	case 5:
 		fallthrough
 	case 4:
-		if firstLine[0] == YAML_LEAD[0] {
+		if firstLine[0] == YAMLLead[0] {
-			return []byte(YAML_DELIM), []byte(YAML_DELIM)
+			return []byte(YAMLDelim), []byte(YAMLDelim)
 		}
-		return []byte(TOML_DELIM), []byte(TOML_DELIM)
+		return []byte(TOMLDelim), []byte(TOMLDelim)
 	case 3:
 		fallthrough
 	case 2:
 		fallthrough
 	case 1:
-		return []byte(JSON_LEAD), []byte("}")
+		return []byte(JSONLead), []byte("}")
 	default:
 		panic(fmt.Sprintf("Unable to determine delims from %q", firstLine))
 	}
@@ -249,7 +260,7 @@ func determineDelims(firstLine []byte) (left, right []byte) {
 // extractFrontMatterDelims takes a frontmatter from the content bufio.Reader.
 // Beginning white spaces of the bufio.Reader must be trimmed before call this
 // function.
-func extractFrontMatterDelims(r *bufio.Reader, left, right []byte) (fm FrontMatter, err error) {
+func extractFrontMatterDelims(r *bufio.Reader, left, right []byte) (fm []byte, err error) {
 	var (
 		c         byte
 		buf       bytes.Buffer
@@ -344,7 +355,7 @@ func extractFrontMatterDelims(r *bufio.Reader, left, right []byte) (fm FrontMatt
 	}
 }
 
-func extractContent(r io.Reader) (content Content, err error) {
+func extractContent(r io.Reader) (content []byte, err error) {
 	wr := new(bytes.Buffer)
 	if _, err = wr.ReadFrom(r); err != nil {
 		return