Rename bootstrap to wbnf

Author: marcelocantos

.gitignore

@@ -11,7 +11,6 @@
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 dist/
-wbnf
 
 # Dependency directories (remove the comment below to include it)
 # vendor/

ast/counter.go

@@ -3,7 +3,7 @@ package ast
 import (
 	"fmt"
 
-	"github.com/arr-ai/wbnf/bootstrap"
+	"github.com/arr-ai/wbnf/wbnf"
 )
 
 type counter struct {
@@ -14,7 +14,7 @@ func newCounter(lo, hi int) counter {
 	return counter{lo: lo, hi: hi}
 }
 
-func newCounterFromQuant(q bootstrap.Quant) counter {
+func newCounterFromQuant(q wbnf.Quant) counter {
 	max := q.Max
 	if max == 0 {
 		max = 2
@@ -49,7 +49,7 @@ func (c counter) union(d counter) counter {
 
 type counters map[string]counter
 
-func newCounters(t bootstrap.Term) counters {
+func newCounters(t wbnf.Term) counters {
 	result := counters{}
 	result.termCountChildren(t, oneOne)
 	return result
@@ -83,28 +83,28 @@ func (ctrs counters) union(o counters) {
 	}
 }
 
-func (ctrs counters) termCountChildren(term bootstrap.Term, parent counter) {
+func (ctrs counters) termCountChildren(term wbnf.Term, parent counter) {
 	switch t := term.(type) {
-	case bootstrap.S, bootstrap.RE, bootstrap.REF:
+	case wbnf.S, wbnf.RE, wbnf.REF:
 		ctrs.count("", parent)
-	case bootstrap.Rule:
+	case wbnf.Rule:
 		ctrs.count(string(t), parent)
-	case bootstrap.Seq:
+	case wbnf.Seq:
 		for _, child := range t {
 			ctrs.termCountChildren(child, parent)
 		}
-	case bootstrap.Oneof:
+	case wbnf.Oneof:
 		ds := counters{}
 		for _, child := range t {
 			ds.union(newCounters(child))
 		}
 		ctrs.mul(ds, parent)
-	case bootstrap.Delim:
+	case wbnf.Delim:
 		ctrs.termCountChildren(t.Term, parent.mul(oneOrMore))
 		ctrs.termCountChildren(t.Sep, parent.mul(zeroOrMore))
-	case bootstrap.Quant:
+	case wbnf.Quant:
 		ctrs.termCountChildren(t.Term, parent.mul(newCounterFromQuant(t)))
-	case bootstrap.Named:
+	case wbnf.Named:
 		ctrs.count(t.Name, parent)
 	default:
 		panic(fmt.Errorf("unexpected term type: %v %[1]T", t))

ast/node.go

@@ -7,7 +7,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/arr-ai/wbnf/bootstrap"
+	"github.com/arr-ai/wbnf/wbnf"
 	"github.com/arr-ai/wbnf/errors"
 	"github.com/arr-ai/wbnf/parser"
 )
@@ -19,18 +19,18 @@ const (
 	quantTag = "?"
 )
 
-func ParserNodeToNode(g bootstrap.Grammar, v interface{}) Branch {
-	rule := bootstrap.NodeRule(v)
+func ParserNodeToNode(g wbnf.Grammar, v interface{}) Branch {
+	rule := wbnf.NodeRule(v)
 	term := g[rule]
 	result := Branch{}
 	result.one("@rule", Extra{extra: rule})
 	result.fromTerm(g, term, newCounters(term), v)
 	return result
 }
 
-func NodeToParserNode(g bootstrap.Grammar, branch Branch) interface{} {
+func NodeToParserNode(g wbnf.Grammar, branch Branch) interface{} {
 	branch = branch.clone().(Branch)
-	rule := branch.pullOne("@rule").(Extra).extra.(bootstrap.Rule)
+	rule := branch.pullOne("@rule").(Extra).extra.(wbnf.Rule)
 	term := g[rule]
 	ctrs := newCounters(term)
 	return relabelNode(string(rule), branch.toTerm(g, term, ctrs))
@@ -162,43 +162,43 @@ func (n Branch) singular() Children {
 	return nil
 }
 
-func (n Branch) fromTerm(g bootstrap.Grammar, term bootstrap.Term, ctrs counters, v interface{}) {
+func (n Branch) fromTerm(g wbnf.Grammar, term wbnf.Term, ctrs counters, v interface{}) {
 	switch t := term.(type) {
-	case bootstrap.S, bootstrap.RE, bootstrap.REF:
+	case wbnf.S, wbnf.RE, wbnf.REF:
 		n.add("", 0, Leaf(v.(parser.Scanner)), ctrs[""], nil)
-	case bootstrap.Rule:
+	case wbnf.Rule:
 		term := g[t]
 		ctrs2 := newCounters(term)
 		b := Branch{}
 		b.fromTerm(g, term, ctrs2, v)
 		unleveled, level := unlevel(string(t))
 		n.add(unleveled, level, b, ctrs[string(t)], ctrs2)
-	case bootstrap.Seq:
+	case wbnf.Seq:
 		node := v.(parser.Node)
 		for i, child := range node.Children {
 			n.fromTerm(g, t[i], ctrs, child)
 		}
-	case bootstrap.Oneof:
+	case wbnf.Oneof:
 		node := v.(parser.Node)
 		n.many("@choice", Extra{extra: node.Extra.(int)})
 		n.fromTerm(g, t[node.Extra.(int)], ctrs, node.Children[0])
-	case bootstrap.Delim:
+	case wbnf.Delim:
 		node := v.(parser.Node)
-		if node.Extra.(bootstrap.Associativity) != bootstrap.NonAssociative {
+		if node.Extra.(wbnf.Associativity) != wbnf.NonAssociative {
 			panic(errors.Unfinished)
 		}
 		L, R := t.LRTerms(node)
-		terms := [2]bootstrap.Term{L, t.Sep}
+		terms := [2]wbnf.Term{L, t.Sep}
 		for i, child := range node.Children {
 			n.fromTerm(g, terms[i%2], ctrs, child)
 			terms[0] = R
 		}
-	case bootstrap.Quant:
+	case wbnf.Quant:
 		node := v.(parser.Node)
 		for _, child := range node.Children {
 			n.fromTerm(g, t.Term, ctrs, child)
 		}
-	case bootstrap.Named:
+	case wbnf.Named:
 		b := Branch{}
 		ctrs2 := newCounters(t.Term)
 		b.fromTerm(g, t.Term, ctrs2, v)
@@ -271,23 +271,23 @@ func (n Branch) pullMany(name string) Node {
 	return nil
 }
 
-func (n Branch) toTerm(g bootstrap.Grammar, term bootstrap.Term, ctrs counters) (out interface{}) {
+func (n Branch) toTerm(g wbnf.Grammar, term wbnf.Term, ctrs counters) (out interface{}) {
 	// defer enterf("%T %[1]v %v", term, ctrs).exitf("%v", &out)
 	switch t := term.(type) {
-	case bootstrap.S, bootstrap.RE:
+	case wbnf.S, wbnf.RE:
 		if node := n.pull("", 0, ctrs[""], nil); node != nil {
 			return parser.Scanner(node.(Leaf))
 		}
 		return nil
-	case bootstrap.Rule:
+	case wbnf.Rule:
 		term := g[t]
 		ctrs2 := newCounters(term)
 		unleveled, level := unlevel(string(t))
 		if b := n.pull(unleveled, level, ctrs[string(t)], ctrs2); b != nil {
 			return relabelNode(string(t), b.(Branch).toTerm(g, term, ctrs2))
 		}
 		return nil
-	case bootstrap.Seq:
+	case wbnf.Seq:
 		result := parser.Node{Tag: seqTag}
 		for _, child := range t {
 			if node := n.toTerm(g, child, ctrs); node != nil {
@@ -297,19 +297,19 @@ func (n Branch) toTerm(g bootstrap.Grammar, term bootstrap.Term, ctrs counters)
 			}
 		}
 		return result
-	case bootstrap.Oneof:
+	case wbnf.Oneof:
 		extra := n.pullMany("@choice").(Extra).extra.(int)
 		return parser.Node{
 			Tag:      oneofTag,
 			Extra:    extra,
 			Children: []interface{}{n.toTerm(g, t[extra], ctrs)},
 		}
-	case bootstrap.Delim:
+	case wbnf.Delim:
 		v := parser.Node{
 			Tag:   delimTag,
-			Extra: bootstrap.NonAssociative,
+			Extra: wbnf.NonAssociative,
 		}
-		terms := [2]bootstrap.Term{t.Term, t.Sep}
+		terms := [2]wbnf.Term{t.Term, t.Sep}
 		i := 0
 		for ; ; i++ {
 			if child := n.toTerm(g, terms[i%2], ctrs); child != nil {
@@ -322,7 +322,7 @@ func (n Branch) toTerm(g bootstrap.Grammar, term bootstrap.Term, ctrs counters)
 			panic(errors.Inconceivable)
 		}
 		return v
-	case bootstrap.Quant:
+	case wbnf.Quant:
 		result := parser.Node{Tag: quantTag}
 		for {
 			if v := n.toTerm(g, t.Term, ctrs); v != nil {
@@ -335,7 +335,7 @@ func (n Branch) toTerm(g bootstrap.Grammar, term bootstrap.Term, ctrs counters)
 			panic(errors.Inconceivable)
 		}
 		return result
-	case bootstrap.Named:
+	case wbnf.Named:
 		ctrs2 := newCounters(t.Term)
 		if b := n.pull(t.Name, 0, ctrs[t.Name], ctrs2); b != nil {
 			return relabelNode(t.Name, b.(Branch).toTerm(g, t.Term, ctrs2))

ast/node_test.go

@@ -4,21 +4,21 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/arr-ai/wbnf/bootstrap"
+	"github.com/arr-ai/wbnf/wbnf"
 	"github.com/arr-ai/wbnf/parser"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestParserNodeToNode(t *testing.T) {
-	p := bootstrap.Core()
-	v := p.MustParse(bootstrap.GrammarRule, parser.NewScanner(`expr -> @:op="+" ^ @:op="*" ^ /{\d+};`)).(parser.Node)
+	p := wbnf.Core()
+	v := p.MustParse(wbnf.GrammarRule, parser.NewScanner(`expr -> @:op="+" ^ @:op="*" ^ /{\d+};`)).(parser.Node)
 	g := p.Grammar()
 	n := ParserNodeToNode(g, v)
 	u := NodeToParserNode(g, n).(parser.Node)
 	parser.AssertEqualNodes(t, v, u)
 
-	p = bootstrap.NewFromNode(v).Compile()
-	v = p.MustParse(bootstrap.Rule("expr"), parser.NewScanner(`1+2*3`)).(parser.Node)
+	p = wbnf.NewFromNode(v).Compile()
+	v = p.MustParse(wbnf.Rule("expr"), parser.NewScanner(`1+2*3`)).(parser.Node)
 	g = p.Grammar()
 	n = ParserNodeToNode(g, v)
 	u = NodeToParserNode(g, n).(parser.Node)
@@ -28,15 +28,15 @@ func TestParserNodeToNode(t *testing.T) {
 func TestTinyXmlGrammar(t *testing.T) {
 	t.Parallel()
 
-	v, err := bootstrap.Core().Parse(bootstrap.GrammarRule, parser.NewScanner(`
+	v, err := wbnf.Core().Parse(wbnf.GrammarRule, parser.NewScanner(`
 		xml  -> s "<" s NAME attr* s ">" xml* "</" s NAME s ">" | CDATA=/{[^<]+};
 		attr -> s NAME s "=" s value=/{"[^"]*"};
 		NAME -> /{[A-Za-z_:][-A-Za-z0-9._:]*};
 		s    -> /{\s*};
 	`))
 	assert.NoError(t, err)
 
-	xmlParser := bootstrap.NewFromNode(v.(parser.Node)).Compile()
+	xmlParser := wbnf.NewFromNode(v.(parser.Node)).Compile()
 
 	src := parser.NewScanner(`<a x="1">hello <b>world!</b></a>`)
 	orig := *src
@@ -49,14 +49,14 @@ func TestTinyXmlGrammar(t *testing.T) {
 		return Leaf(*orig.Slice(offset, end))
 	}
 
-	xml, err := xmlParser.Parse(bootstrap.Rule("xml"), src)
+	xml, err := xmlParser.Parse(wbnf.Rule("xml"), src)
 	assert.NoError(t, err)
 
 	ast := ParserNodeToNode(xmlParser.Grammar(), xml)
 
 	assert.EqualValues(t,
 		Branch{
-			"@rule":   One{Extra{bootstrap.Rule("xml")}},
+			"@rule":   One{Extra{wbnf.Rule("xml")}},
 			"@choice": Many{Extra{0}},
 			"":        Many{s(0, `<`), s(8, `>`), s(28, `</`), s(31, `>`)},
 			"s":       Many{s(0, ``), s(1, ``), s(8, ``), s(30, ``), s(31, ``)},

cmd/codegen.go

@@ -6,7 +6,7 @@ import (
 	"io/ioutil"
 	"strings"
 
-	"github.com/arr-ai/wbnf/bootstrap"
+	"github.com/arr-ai/wbnf/wbnf"
 	"github.com/arr-ai/wbnf/parser"
 	"github.com/urfave/cli"
 )
@@ -49,9 +49,9 @@ func codegen(c *cli.Context) error {
 	}
 
 	scanner := parser.NewScanner(string(buf))
-	g := bootstrap.Core()
+	g := wbnf.Core()
 
-	tree, err := g.Parse(bootstrap.RootRule, scanner)
+	tree, err := g.Parse(wbnf.RootRule, scanner)
 	if err != nil {
 		return err
 	}
@@ -60,21 +60,21 @@ func codegen(c *cli.Context) error {
 		return err
 	}
 
-	ast := bootstrap.NewFromNode2(tree.(parser.Node))
+	ast := wbnf.NewFromNode2(tree.(parser.Node))
 	if ast == nil {
 		return nil
 	} /*
 		text := ast.Dump()
 
-		newg := bootstrap.NewFromNode(tree.(parser.Node)).Compile()
+		newg := wbnf.NewFromNode(tree.(parser.Node)).Compile()
 
 		scanner = parser.NewScanner(text)
-		_, err := newg.Parse(bootstrap.RootRule, scanner)
+		_, err := newg.Parse(wbnf.RootRule, scanner)
 		if err != nil {
 			return err
 		}
 	*/
-	fmt.Print(bootstrap.Codegen(ast))
+	fmt.Print(wbnf.Codegen(ast))
 
 	return nil
 }

cmd/test.go

@@ -6,7 +6,7 @@ import (
 	"os"
 
 	"github.com/arr-ai/wbnf/ast"
-	"github.com/arr-ai/wbnf/bootstrap"
+	"github.com/arr-ai/wbnf/wbnf"
 	"github.com/arr-ai/wbnf/parser"
 
 	"github.com/urfave/cli"
@@ -44,12 +44,12 @@ var testCommand = cli.Command{
 	},
 }
 
-func loadTestGrammar() bootstrap.Parsers {
+func loadTestGrammar() wbnf.Parsers {
 	text, err := ioutil.ReadFile(inGrammarFile)
 	if err != nil {
 		panic(err)
 	}
-	return bootstrap.MustCompile(string(text))
+	return wbnf.MustCompile(string(text))
 }
 
 func test(c *cli.Context) error {
@@ -72,7 +72,7 @@ func test(c *cli.Context) error {
 	}
 
 	g := loadTestGrammar()
-	tree, err := g.Parse(bootstrap.Rule(startingRule), parser.NewScanner(input))
+	tree, err := g.Parse(wbnf.Rule(startingRule), parser.NewScanner(input))
 	if err != nil {
 		return err
 	}

bootstrap/compile.go renamed to wbnf/compile.go

@@ -1,12 +1,12 @@
-package bootstrap
+package wbnf
 
 import (
 	"fmt"
 	"regexp"
 	"strconv"
 	"strings"
 
-	"github.com/arr-ai/wbnf/bootstrap/internal"
+	"github.com/arr-ai/wbnf/wbnf/internal"
 	"github.com/arr-ai/wbnf/errors"
 
 	"github.com/arr-ai/wbnf/parser"

bootstrap/copygrammar.sh renamed to wbnf/copygrammar.sh

@@ -3,7 +3,7 @@
 out=wbnfgrammar.go
 echo Generating $out
 cat > $out <<EOF
-package bootstrap
+package wbnf
 
 var grammarGrammarSrc = unfakeBackquote(\`
 $(sed 's/`/‵/g' ../examples/wbnf.txt)

bootstrap/diff.go renamed to wbnf/diff.go

@@ -1,4 +1,4 @@
-package bootstrap
+package wbnf
 
 import (
 	"fmt"