use regexputil

main.go

@@ -162,7 +162,7 @@ func main() {
 		log.Fatal(err)
 	}
 
-	meta, err := mark.ExtractMeta(markdown)
+	meta, markdown, err := mark.ExtractMeta(markdown)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -190,7 +190,7 @@ func main() {
 		}
 	}
 
-	macros, markdown, err := macro.LoadMacros(markdown, templates)
+	macros, markdown, err := macro.ExtractMacros(markdown, templates)
 	if err != nil {
 		log.Fatal(err)
 	}

pkg/mark/includes/templates.go

@@ -17,7 +17,12 @@ import (
 
 var (
 	reIncludeDirective = regexp.MustCompile(
-		`(?s)<!--\s*Include:\s*(\S+)(.*?)-->`,
+		// <!-- Include: <template path>
+		//      <optional yaml data> -->
+
+		`(?s)` + // dot capture newlines
+			/**/ `<!--\s*Include:\s*(?P<template>\S+)\s*` +
+			/*   */ `(\n(?P<config>.*?))?-->`,
 	)
 )
 

pkg/mark/macro/macro.go

@@ -10,11 +10,19 @@ import (
 	"github.com/kovetskiy/mark/pkg/log"
 	"github.com/kovetskiy/mark/pkg/mark/includes"
 	"github.com/reconquest/karma-go"
+	"github.com/reconquest/regexputil-go"
 	"gopkg.in/yaml.v2"
 )
 
 var reMacroDirective = regexp.MustCompile(
-	`(?s)<!--\s*Macro:\s*([^\n]+)\n\s*Template:\s*(\S+)(.*?)-->`,
+	// <!-- Macro: <regexp>
+	//      Template: <template path>
+	//      <optional yaml data> -->
+
+	`(?s)` + // dot capture newlines
+		/**/ `<!--\s*Macro:\s*(?P<expr>[^\n]+)\n` +
+		/*    */ `\s*Template:\s*(?P<template>\S+)\s*` +
+		/*   */ `(\n(?P<config>.*?))?-->`,
 )
 
 type Macro struct {
@@ -88,7 +96,7 @@ func (macro *Macro) configure(node interface{}, groups [][]byte) interface{} {
 	return node
 }
 
-func LoadMacros(
+func ExtractMacros(
 	contents []byte,
 	templates *template.Template,
 ) ([]Macro, []byte, error) {
@@ -103,15 +111,17 @@ func LoadMacros(
 				return spec
 			}
 
-			groups := reMacroDirective.FindSubmatch(spec)
+			groups := reMacroDirective.FindStringSubmatch(string(spec))
 
 			var (
-				expr, path, config = groups[1], string(groups[2]), groups[3]
+				expr     = regexputil.Subexp(reMacroDirective, groups, "expr")
+				template = regexputil.Subexp(reMacroDirective, groups, "template")
+				config   = regexputil.Subexp(reMacroDirective, groups, "config")
 
 				macro Macro
 			)
 
-			macro.Template, err = includes.LoadTemplate(path, templates)
+			macro.Template, err = includes.LoadTemplate(template, templates)
 
 			if err != nil {
 				err = karma.Format(err, "unable to load template")
@@ -120,10 +130,10 @@ func LoadMacros(
 			}
 
 			facts := karma.
-				Describe("template", path).
-				Describe("expr", string(expr))
+				Describe("template", template).
+				Describe("expr", expr)
 
-			macro.Regexp, err = regexp.Compile(string(expr))
+			macro.Regexp, err = regexp.Compile(expr)
 			if err != nil {
 				err = facts.
 					Format(
@@ -134,7 +144,7 @@ func LoadMacros(
 				return nil
 			}
 
-			err = yaml.Unmarshal(config, &macro.Config)
+			err = yaml.Unmarshal([]byte(config), &macro.Config)
 			if err != nil {
 				err = facts.
 					Describe("config", string(config)).

pkg/mark/meta.go

@@ -26,25 +26,30 @@ type Meta struct {
 	Attachments []string
 }
 
-func ExtractMeta(data []byte) (*Meta, error) {
 var (
-		headerPatternV1 = regexp.MustCompile(`\[\]:\s*#\s*\(([^:]+):\s*(.*)\)`)
-		headerPatternV2 = regexp.MustCompile(`<!--\s*([^:]+):\s*(.*)\s*-->`)
+	reHeaderPatternV1 = regexp.MustCompile(`\[\]:\s*#\s*\(([^:]+):\s*(.*)\)`)
+	reHeaderPatternV2 = regexp.MustCompile(`<!--\s*([^:]+):\s*(.*)\s*-->`)
 )
 
-	var meta *Meta
+func ExtractMeta(data []byte) (*Meta, []byte, error) {
+	var (
+		meta   *Meta
+		offset int
+	)
 
 	scanner := bufio.NewScanner(bytes.NewBuffer(data))
 	for scanner.Scan() {
 		line := scanner.Text()
 
 		if err := scanner.Err(); err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 
-		matches := headerPatternV2.FindStringSubmatch(line)
+		offset += len(line)
+
+		matches := reHeaderPatternV2.FindStringSubmatch(line)
 		if matches == nil {
-			matches = headerPatternV1.FindStringSubmatch(line)
+			matches = reHeaderPatternV1.FindStringSubmatch(line)
 			if matches == nil {
 				break
 			}
@@ -97,22 +102,22 @@ func ExtractMeta(data []byte) (*Meta, error) {
 	}
 
 	if meta == nil {
-		return nil, nil
+		return nil, data, nil
 	}
 
 	if meta.Space == "" {
-		return nil, fmt.Errorf(
+		return nil, nil, fmt.Errorf(
 			"space key is not set (%s header is not set)",
 			HeaderSpace,
 		)
 	}
 
 	if meta.Title == "" {
-		return nil, fmt.Errorf(
+		return nil, nil, fmt.Errorf(
 			"page title is not set (%s header is not set)",
 			HeaderTitle,
 		)
 	}
 
-	return meta, nil
+	return nil, data[offset+1:], nil
 }

pkg/mark/stdlib/stdlib.go

@@ -40,7 +40,7 @@ func macros(templates *template.Template) ([]macro.Macro, error) {
 		return []byte(strings.Join(line, "\n"))
 	}
 
-	macros, _, err := macro.LoadMacros(
+	macros, _, err := macro.ExtractMacros(
 		[]byte(text(
 			`<!-- Macro: @\{([^}]+)\}`,
 			`     Template: ac:link:user`,