Markdown preprocessor with variable replacement

vardown.go

package main

import (
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"regexp"
	"strings"
)

const (
	pBeginning string = "#vardownBegin"
	pEnd       string = "#vardownEnd"
	pattern           = "(?P<name>.+) = (?P<value>.+)"
)

var r = regexp.MustCompile(pattern)

func main() {
	if len(os.Args) < 2 {
		log.Fatal("missing file path")
	}

	data, err := ioutil.ReadFile(os.Args[1])
	if err != nil {
		log.Fatal(err)
	}

	ss, err := parseVardown(string(data))
	if err != nil {
		log.Fatal(err)
	}

	replacer := strings.NewReplacer(ss...)
	fmt.Println(replacer.Replace(string(data)))
}

func parseVardown(s string) ([]string, error) {
	var ret []string

	foundBeginning := false
	foundEnd := false
	for _, statement := range strings.Split(s, "\n") {
		if statement == pBeginning {
			foundBeginning = true
			continue
		}

		if statement == pEnd {
			foundEnd = true
			break
		}
		ret = append(ret, parseStatement(s).replacer()...)

	}

	if !foundBeginning && !foundEnd {
		return nil, nil
	}

	if !(foundBeginning && foundEnd) {
		return nil, errors.New("invalid vardown preamble declaration")
	}

	return ret, nil
}

type statement struct {
	name  string
	value string
}

func (s statement) replacer() []string {
	return []string{
		"$" + s.name,
		s.value,
	}
}

func parseStatement(s string) statement {
	if !r.MatchString(s) {
		return statement{}
	}

	m := findNamedMatches(r, s)

	return statement{
		name:  m["name"],
		value: m["value"],
	}
}

func findNamedMatches(regex *regexp.Regexp, str string) map[string]string {
	match := regex.FindStringSubmatch(str)

	results := map[string]string{}
	for i, name := range match {
		results[regex.SubexpNames()[i]] = name
	}
	return results
}