🔖 Released v0.1.0

Just parsing io.Reader to get Node tree

doc.go

@@ -0,0 +1,14 @@
+/*
+Package tree is a subset of a class of languages called two dimensional
+languages.
+
+One dimensional languages assume a one dimensional array of bits with a single
+read head moving in order.
+
+Two dimensional languages break those assumptions. There may be multiple read
+heads that can move not just on the x axis but on the y axis as well.
+
+Tree Notation is a middle ground that utilitizes ideas from the two dimensional
+language world using present day technology.
+*/
+package tree

testdata/html.tree

@@ -0,0 +1,3 @@
+html
+ body
+  div おはようございます

testdata/math.tree

@@ -0,0 +1,3 @@
+multiply
+ add 1 1
+ add 2 2

testdata/nursinos.tree

@@ -0,0 +1,6 @@
+title Nursinos Services Offerered
+paragraph Here is a list of home nursing services we offer
+table
+ Service Price
+ BloodPressureCheck $10
+ TemperatureCheck $5

testdata/package.tree

@@ -0,0 +1,6 @@
+name mypackage
+version 2.1.1
+description A package
+repository
+ type git
+ url git://github.com/username/mypackage

testdata/print.tree

@@ -0,0 +1,2 @@
+if true
+ print Hello world

tree.go

@@ -0,0 +1,113 @@
+package tree
+
+import (
+	"bufio"
+	"io"
+	"strings"
+)
+
+// Node represent a single data structure.
+type Node struct {
+	Parent   *Node
+	Children []*Node
+	Value    string
+}
+
+const (
+	// nodeBreakSymbol delimits nodes (lines).
+	nodeBreakSymbol rune = '\n'
+
+	// wordBreakSymbol delimits words (cells).
+	wordBreakSymbol rune = ' '
+
+	// edgeSymbol is used to indicate the parent/child relationship between
+	// nodes.
+	//
+	// TODO(toby3d): allow clients to change this to '\t' for example.
+	edgeSymbol rune = wordBreakSymbol
+)
+
+// Parse parses the data into a Tree Notation nodes.
+//
+// Note what all documents are valid Tree Notation documents. Like binary
+// notation, there are no syntax errors in Tree Notation.
+func Parse(data io.Reader) (root *Node) {
+	stack := make([]*Node, 0)
+
+	scanner := bufio.NewScanner(data)
+	for scanner.Scan() {
+		node := &Node{
+			Parent:   nil,
+			Children: nil,
+			Value:    scanner.Text(),
+		}
+
+		if root == nil {
+			root = node
+			stack = append(stack, root)
+
+			continue
+		}
+
+		if lenIndent(node.Value) <= lenIndent(root.Value) && len(stack) > 0 {
+			root = stack[len(stack)-1]
+			stack = stack[:len(stack)-1]
+		}
+
+		if root.Children == nil {
+			root.Children = make([]*Node, 0)
+		}
+
+		node.Parent = root
+		root.Children = append(root.Children, node)
+		stack = append(stack, node)
+		root = stack[len(stack)-1]
+	}
+
+	if root == nil {
+		return nil
+	}
+
+	for root.Parent != nil {
+		root = root.Parent
+	}
+
+	return root
+}
+
+// Satisfies the fmt.Stringer interface to print node line passed in as an
+// operand to any format that accepts a string, or to an unformatted printer
+// such as fmt.Print.
+func (n Node) String() string {
+	return strings.TrimLeft(n.Value, string(edgeSymbol))
+}
+
+// GoString satisfies the fmt.GoStringer interface to print values passed as an
+// operand to a %#v format.
+func (n Node) GoString() (result string) {
+	result += n.Value
+
+	for i := range n.Children {
+		result += string(nodeBreakSymbol)
+		result += n.Children[i].GoString()
+	}
+
+	return result
+}
+
+// lenIndent count egdeSymbol prefixes in line.
+//
+// Returns 0 if line starts from any word character.
+func lenIndent(v string) int {
+	count := 0
+
+	for i := range v {
+		if rune(v[i]) != edgeSymbol {
+			break
+		}
+
+		count++
+	}
+
+	return count
+}

tree_test.go

@@ -0,0 +1,120 @@
+package tree_test
+
+import (
+	"bytes"
+	"embed"
+	"fmt"
+	"log"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"source.toby3d.me/toby3d/tree"
+)
+
+//go:embed testdata/*
+var testData embed.FS
+
+func Example() {
+	file, err := testData.Open(filepath.Join(".", "testdata", "html.tree"))
+	if err != nil {
+		log.Fatalf("cannot open file: %v", err)
+	}
+	defer file.Close()
+
+	tree := tree.Parse(file)
+	fmt.Printf("%#v", tree)
+	// Output:
+	// html
+	//  body
+	//   div おはようございます
+}
+
+func TestParse(t *testing.T) {
+	t.Parallel()
+
+	//nolint: paralleltest // testName used as range value
+	for testName, filePath := range map[string]string{
+		"html":     filepath.Join(".", "testdata", "html.tree"),
+		"math":     filepath.Join(".", "testdata", "math.tree"),
+		"nursinos": filepath.Join(".", "testdata", "nursinos.tree"),
+		"package":  filepath.Join(".", "testdata", "package.tree"),
+		"print":    filepath.Join(".", "testdata", "print.tree"),
+	} {
+		testName, filePath := testName, filePath
+
+		t.Run(testName, func(t *testing.T) {
+			t.Parallel()
+
+			src, err := testData.ReadFile(filePath)
+			if err != nil {
+				t.Fatalf("cannot open testing file: %v", err)
+			}
+
+			result := tree.Parse(bytes.NewReader(src))
+			if string(src) == fmt.Sprintf("%#v", result) {
+				return
+			}
+
+			t.Fatalf(`'%#v' is not equal '%s'`, result, string(src))
+		})
+	}
+}
+
+func TestNode_String(t *testing.T) {
+	t.Parallel()
+
+	node := &tree.Node{
+		Parent:   nil,
+		Value:    "print Hello world",
+		Children: nil,
+	}
+
+	const expResult string = "print Hello world"
+	if node.String() == expResult {
+		return
+	}
+
+	t.Fatalf(`'%s' is not equal '%s'`, node.String(), expResult)
+}
+
+func TestNode_GoString(t *testing.T) {
+	t.Parallel()
+
+	root := &tree.Node{
+		Parent:   nil,
+		Children: make([]*tree.Node, 0),
+		Value:    "multiply",
+	}
+	root.Children = append(root.Children, []*tree.Node{{
+		Parent:   root,
+		Children: nil,
+		Value:    " add 1 1",
+	}, {
+		Parent:   root,
+		Children: nil,
+		Value:    " add 2 2",
+	}}...)
+
+	const expResult string = "multiply\n add 1 1\n add 2 2"
+	if root.GoString() == expResult {
+		return
+	}
+
+	t.Fatalf(`'%s' is not equal '%s'`, root.GoString(), expResult)
+}
+
+func BenchmarkParse(b *testing.B) {
+	input := strings.NewReader("title Nursinos Services Offerered\n" +
+		"paragraph Here is a list of home nursing services we offer\n" +
+		"table\n" +
+		" Service Price\n" +
+		" BloodPressureCheck $10\n" +
+		" TemperatureCheck $5")
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_ = tree.Parse(input)
+	}
+}