git/gitattr: add a macro processor

When processing .gitattributes files, it's possible to have macros
defined.  Add a macro processor class that takes lists of attribute
lines and expands them using macros, optionally reading in any macros
from the file.  This design allows us to process macros for some files
and not others, like Git does.

Author: bk2204

git/gitattr/macro.go

@@ -0,0 +1,56 @@
+package gitattr
+
+type MacroProcessor struct {
+	macros map[string][]*Attr
+}
+
+// NewMacroProcessor returns a new MacroProcessor object for parsing macros.
+func NewMacroProcessor() *MacroProcessor {
+	macros := make(map[string][]*Attr)
+
+	// This is built into Git.
+	macros["binary"] = []*Attr{
+		&Attr{K: "diff", V: "false"},
+		&Attr{K: "merge", V: "false"},
+		&Attr{K: "text", V: "false"},
+	}
+
+	return &MacroProcessor{
+		macros: macros,
+	}
+}
+
+// ProcessLines reads the specified lines, returning a new set of lines which
+// all have a valid pattern.  If readMacros is true, it additionally loads any
+// macro lines as it reads them.
+func (mp *MacroProcessor) ProcessLines(lines []*Line, readMacros bool) []*Line {
+	result := make([]*Line, 0, len(lines))
+	for _, line := range lines {
+		if line.Pattern != nil {
+			resultLine := Line{
+				Pattern: line.Pattern,
+				Attrs:   make([]*Attr, 0, len(line.Attrs)),
+			}
+			for _, attr := range line.Attrs {
+				macros := mp.macros[attr.K]
+				if attr.V == "true" && macros != nil {
+					resultLine.Attrs = append(
+						resultLine.Attrs,
+						macros...,
+					)
+				}
+
+				// Git copies through aliases as well as
+				// expanding them.
+				resultLine.Attrs = append(
+					resultLine.Attrs,
+					attr,
+				)
+			}
+			result = append(result, &resultLine)
+		} else if readMacros {
+			mp.macros[line.Macro] = line.Attrs
+		}
+	}
+	return result
+}

git/gitattr/macro_test.go

@@ -0,0 +1,126 @@
+package gitattr
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestProcessLinesWithMacros(t *testing.T) {
+	lines, _, err := ParseLines(strings.NewReader(strings.Join([]string{
+		"[attr]lfs filter=lfs diff=lfs merge=lfs -text",
+		"*.dat lfs",
+		"*.txt text"}, "\n")))
+
+	assert.Len(t, lines, 3)
+	assert.NoError(t, err)
+
+	mp := NewMacroProcessor()
+	lines = mp.ProcessLines(lines, true)
+
+	assert.Len(t, lines, 2)
+
+	assert.Equal(t, lines[0].Macro, "")
+	assert.Equal(t, lines[0].Pattern.String(), "*.dat")
+	assert.Len(t, lines[0].Attrs, 5)
+	assert.Equal(t, lines[0].Attrs[0], &Attr{K: "filter", V: "lfs"})
+	assert.Equal(t, lines[0].Attrs[1], &Attr{K: "diff", V: "lfs"})
+	assert.Equal(t, lines[0].Attrs[2], &Attr{K: "merge", V: "lfs"})
+	assert.Equal(t, lines[0].Attrs[3], &Attr{K: "text", V: "false"})
+	assert.Equal(t, lines[0].Attrs[4], &Attr{K: "lfs", V: "true"})
+
+	assert.Equal(t, lines[1].Macro, "")
+	assert.Equal(t, lines[1].Pattern.String(), "*.txt")
+	assert.Len(t, lines[1].Attrs, 1)
+	assert.Equal(t, lines[1].Attrs[0], &Attr{K: "text", V: "true"})
+}
+
+func TestProcessLinesWithMacrosDisabled(t *testing.T) {
+	lines, _, err := ParseLines(strings.NewReader(strings.Join([]string{
+		"[attr]lfs filter=lfs diff=lfs merge=lfs -text",
+		"*.dat lfs",
+		"*.txt text"}, "\n")))
+
+	assert.Len(t, lines, 3)
+	assert.NoError(t, err)
+
+	mp := NewMacroProcessor()
+	lines = mp.ProcessLines(lines, false)
+
+	assert.Len(t, lines, 2)
+
+	assert.Equal(t, lines[0].Macro, "")
+	assert.Equal(t, lines[0].Pattern.String(), "*.dat")
+	assert.Len(t, lines[0].Attrs, 1)
+	assert.Equal(t, lines[0].Attrs[0], &Attr{K: "lfs", V: "true"})
+
+	assert.Equal(t, lines[1].Macro, "")
+	assert.Equal(t, lines[1].Pattern.String(), "*.txt")
+	assert.Len(t, lines[1].Attrs, 1)
+	assert.Equal(t, lines[1].Attrs[0], &Attr{K: "text", V: "true"})
+}
+
+func TestProcessLinesWithBinaryMacros(t *testing.T) {
+	lines, _, err := ParseLines(strings.NewReader(strings.Join([]string{
+		"*.dat binary",
+		"*.txt text"}, "\n")))
+
+	assert.Len(t, lines, 2)
+	assert.NoError(t, err)
+
+	mp := NewMacroProcessor()
+	lines = mp.ProcessLines(lines, true)
+
+	assert.Len(t, lines, 2)
+
+	assert.Equal(t, lines[0].Macro, "")
+	assert.Equal(t, lines[0].Pattern.String(), "*.dat")
+	assert.Len(t, lines[0].Attrs, 4)
+	assert.Equal(t, lines[0].Attrs[0], &Attr{K: "diff", V: "false"})
+	assert.Equal(t, lines[0].Attrs[1], &Attr{K: "merge", V: "false"})
+	assert.Equal(t, lines[0].Attrs[2], &Attr{K: "text", V: "false"})
+	assert.Equal(t, lines[0].Attrs[3], &Attr{K: "binary", V: "true"})
+
+	assert.Equal(t, lines[1].Macro, "")
+	assert.Equal(t, lines[1].Pattern.String(), "*.txt")
+	assert.Len(t, lines[1].Attrs, 1)
+	assert.Equal(t, lines[1].Attrs[0], &Attr{K: "text", V: "true"})
+}
+
+func TestProcessLinesIsStateful(t *testing.T) {
+	lines, _, err := ParseLines(strings.NewReader(strings.Join([]string{
+		"[attr]lfs filter=lfs diff=lfs merge=lfs -text",
+		"*.txt text"}, "\n")))
+
+	assert.Len(t, lines, 2)
+	assert.NoError(t, err)
+
+	mp := NewMacroProcessor()
+	lines = mp.ProcessLines(lines, true)
+
+	assert.Len(t, lines, 1)
+
+	assert.Equal(t, lines[0].Macro, "")
+	assert.Equal(t, lines[0].Pattern.String(), "*.txt")
+	assert.Len(t, lines[0].Attrs, 1)
+	assert.Equal(t, lines[0].Attrs[0], &Attr{K: "text", V: "true"})
+
+	lines2, _, err := ParseLines(strings.NewReader("*.dat lfs\n"))
+
+	assert.Len(t, lines2, 1)
+	assert.NoError(t, err)
+
+	lines2 = mp.ProcessLines(lines2, false)
+
+	assert.Len(t, lines2, 1)
+
+	assert.Equal(t, lines2[0].Macro, "")
+	assert.Equal(t, lines2[0].Pattern.String(), "*.dat")
+	assert.Len(t, lines2[0].Attrs, 5)
+	assert.Equal(t, lines2[0].Attrs[0], &Attr{K: "filter", V: "lfs"})
+	assert.Equal(t, lines2[0].Attrs[1], &Attr{K: "diff", V: "lfs"})
+	assert.Equal(t, lines2[0].Attrs[2], &Attr{K: "merge", V: "lfs"})
+	assert.Equal(t, lines2[0].Attrs[3], &Attr{K: "text", V: "false"})
+	assert.Equal(t, lines2[0].Attrs[4], &Attr{K: "lfs", V: "true"})
+}