Rename 's/AssembleDirectly/AssembleEntry/g'.

codec/dagcbor/roundtrip_test.go

@@ -11,17 +11,17 @@ import (
 )
 
 var n = fluent.MustBuildMap(basicnode.Style__Map{}, 4, func(na fluent.MapAssembler) {
-	na.AssembleDirectly("plain").AssignString("olde string")
-	na.AssembleDirectly("map").CreateMap(2, func(na fluent.MapAssembler) {
-		na.AssembleDirectly("one").AssignInt(1)
-		na.AssembleDirectly("two").AssignInt(2)
+	na.AssembleEntry("plain").AssignString("olde string")
+	na.AssembleEntry("map").CreateMap(2, func(na fluent.MapAssembler) {
+		na.AssembleEntry("one").AssignInt(1)
+		na.AssembleEntry("two").AssignInt(2)
 	})
-	na.AssembleDirectly("list").CreateList(2, func(na fluent.ListAssembler) {
+	na.AssembleEntry("list").CreateList(2, func(na fluent.ListAssembler) {
 		na.AssembleValue().AssignString("three")
 		na.AssembleValue().AssignString("four")
 	})
-	na.AssembleDirectly("nested").CreateMap(1, func(na fluent.MapAssembler) {
-		na.AssembleDirectly("deeper").CreateList(1, func(na fluent.ListAssembler) {
+	na.AssembleEntry("nested").CreateMap(1, func(na fluent.MapAssembler) {
+		na.AssembleEntry("deeper").CreateList(1, func(na fluent.ListAssembler) {
 			na.AssembleValue().AssignString("things")
 		})
 	})

codec/dagcbor/unmarshal.go

@@ -70,7 +70,7 @@ func unmarshal(na ipld.NodeAssembler, tokSrc shared.TokenSource, tk *tok.Token)
 			if observedLen > expectLen {
 				return fmt.Errorf("unexpected continuation of map elements beyond declared length")
 			}
-			mva, err := ma.AssembleDirectly(tk.Str)
+			mva, err := ma.AssembleEntry(tk.Str)
 			if err != nil { // return in error if the key was rejected
 				return err
 			}

codec/dagjson/roundtrip_test.go

@@ -11,17 +11,17 @@ import (
 )
 
 var n = fluent.MustBuildMap(basicnode.Style__Map{}, 4, func(na fluent.MapAssembler) {
-	na.AssembleDirectly("plain").AssignString("olde string")
-	na.AssembleDirectly("map").CreateMap(2, func(na fluent.MapAssembler) {
-		na.AssembleDirectly("one").AssignInt(1)
-		na.AssembleDirectly("two").AssignInt(2)
+	na.AssembleEntry("plain").AssignString("olde string")
+	na.AssembleEntry("map").CreateMap(2, func(na fluent.MapAssembler) {
+		na.AssembleEntry("one").AssignInt(1)
+		na.AssembleEntry("two").AssignInt(2)
 	})
-	na.AssembleDirectly("list").CreateList(2, func(na fluent.ListAssembler) {
+	na.AssembleEntry("list").CreateList(2, func(na fluent.ListAssembler) {
 		na.AssembleValue().AssignString("three")
 		na.AssembleValue().AssignString("four")
 	})
-	na.AssembleDirectly("nested").CreateMap(1, func(na fluent.MapAssembler) {
-		na.AssembleDirectly("deeper").CreateList(1, func(na fluent.ListAssembler) {
+	na.AssembleEntry("nested").CreateMap(1, func(na fluent.MapAssembler) {
+		na.AssembleEntry("deeper").CreateList(1, func(na fluent.ListAssembler) {
 			na.AssembleValue().AssignString("things")
 		})
 	})

codec/dagjson/unmarshal.go

@@ -161,7 +161,7 @@ func (st *unmarshalState) unmarshal(na ipld.NodeAssembler, tokSrc shared.TokenSo
 			default:
 				return fmt.Errorf("unexpected %s token while expecting map key", st.tk[0].Type)
 			}
-			mva, err := ma.AssembleDirectly(st.tk[0].Str)
+			mva, err := ma.AssembleEntry(st.tk[0].Str)
 			if err != nil { // return in error if the key was rejected
 				return err
 			}

codec/unmarshal.go

@@ -85,7 +85,7 @@ func unmarshal(na ipld.NodeAssembler, tokSrc shared.TokenSource, tk *tok.Token)
 			if observedLen > expectLen {
 				return fmt.Errorf("unexpected continuation of map elements beyond declared length")
 			}
-			mva, err := ma.AssembleDirectly(tk.Str)
+			mva, err := ma.AssembleEntry(tk.Str)
 			if err != nil { // return in error if the key was rejected
 				return err
 			}

fluent/fluentBuilder.go

@@ -58,7 +58,7 @@ type MapAssembler interface {
 	AssembleKey() NodeAssembler
 	AssembleValue() NodeAssembler
 
-	AssembleDirectly(k string) NodeAssembler
+	AssembleEntry(k string) NodeAssembler
 
 	KeyStyle() ipld.NodeStyle
 	ValueStyle(k string) ipld.NodeStyle
@@ -153,8 +153,8 @@ func (fma *mapNodeAssembler) AssembleKey() NodeAssembler {
 func (fma *mapNodeAssembler) AssembleValue() NodeAssembler {
 	return &nodeAssembler{fma.ma.AssembleValue()}
 }
-func (fma *mapNodeAssembler) AssembleDirectly(k string) NodeAssembler {
-	va, err := fma.ma.AssembleDirectly(k)
+func (fma *mapNodeAssembler) AssembleEntry(k string) NodeAssembler {
+	va, err := fma.ma.AssembleEntry(k)
 	if err != nil {
 		panic(Error{err})
 	}

fluent/fluentBuilder_test.go

@@ -24,12 +24,12 @@ func TestBuild(t *testing.T) {
 	t.Run("map build should work", func(t *testing.T) {
 		n := fluent.MustBuild(basicnode.Style__Map{}, func(fna fluent.NodeAssembler) {
 			fna.CreateMap(3, func(fma fluent.MapAssembler) {
-				fma.AssembleDirectly("k1").AssignString("fine")
-				fma.AssembleDirectly("k2").AssignString("super")
-				fma.AssembleDirectly("k3").CreateMap(3, func(fma fluent.MapAssembler) {
-					fma.AssembleDirectly("k31").AssignString("thanks")
-					fma.AssembleDirectly("k32").AssignString("for")
-					fma.AssembleDirectly("k33").AssignString("asking")
+				fma.AssembleEntry("k1").AssignString("fine")
+				fma.AssembleEntry("k2").AssignString("super")
+				fma.AssembleEntry("k3").CreateMap(3, func(fma fluent.MapAssembler) {
+					fma.AssembleEntry("k31").AssignString("thanks")
+					fma.AssembleEntry("k32").AssignString("for")
+					fma.AssembleEntry("k33").AssignString("asking")
 				})
 			})
 		})

node/basic/list.go

@@ -308,8 +308,8 @@ type plainList__ValueAssemblerMap struct {
 // just embedding plainMap__Assembler also behaves correctly,
 //  but causes a lot of unnecessary autogenerated functions in the final binary.
 
-func (ma *plainList__ValueAssemblerMap) AssembleDirectly(k string) (ipld.NodeAssembler, error) {
-	return ma.ca.AssembleDirectly(k)
+func (ma *plainList__ValueAssemblerMap) AssembleEntry(k string) (ipld.NodeAssembler, error) {
+	return ma.ca.AssembleEntry(k)
 }
 func (ma *plainList__ValueAssemblerMap) AssembleKey() ipld.NodeAssembler {
 	return ma.ca.AssembleKey()

node/basic/map.go

@@ -237,9 +237,9 @@ func (plainMap__Assembler) Style() ipld.NodeStyle {
 
 // -- MapAssembler -->
 
-// AssembleDirectly is part of conforming to MapAssembler, which we do on
+// AssembleEntry is part of conforming to MapAssembler, which we do on
 // plainMap__Assembler so that BeginMap can just return a retyped pointer rather than new object.
-func (ma *plainMap__Assembler) AssembleDirectly(k string) (ipld.NodeAssembler, error) {
+func (ma *plainMap__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) {
 	// Sanity check, then update, assembler state.
 	if ma.state != maState_initial {
 		panic("misuse")
@@ -419,8 +419,8 @@ type plainMap__ValueAssemblerMap struct {
 // just embedding plainMap__Assembler also behaves correctly,
 //  but causes a lot of unnecessary autogenerated functions in the final binary.
 
-func (ma *plainMap__ValueAssemblerMap) AssembleDirectly(k string) (ipld.NodeAssembler, error) {
-	return ma.ca.AssembleDirectly(k)
+func (ma *plainMap__ValueAssemblerMap) AssembleEntry(k string) (ipld.NodeAssembler, error) {
+	return ma.ca.AssembleEntry(k)
 }
 func (ma *plainMap__ValueAssemblerMap) AssembleKey() ipld.NodeAssembler {
 	return ma.ca.AssembleKey()

node/basic/map_test.go

@@ -14,8 +14,8 @@ func TestMap(t *testing.T) {
 func BenchmarkMapStrInt_3n_AssembleStandard(b *testing.B) {
 	tests.SpecBenchmarkMapStrInt_3n_AssembleStandard(b, Style__Map{})
 }
-func BenchmarkMapStrInt_3n_AssembleDirectly(b *testing.B) {
-	tests.SpecBenchmarkMapStrInt_3n_AssembleDirectly(b, Style__Map{})
+func BenchmarkMapStrInt_3n_AssembleEntry(b *testing.B) {
+	tests.SpecBenchmarkMapStrInt_3n_AssembleEntry(b, Style__Map{})
 }
 func BenchmarkMapStrInt_3n_Iteration(b *testing.B) {
 	tests.SpecBenchmarkMapStrInt_3n_Iteration(b, Style__Map{})
@@ -24,8 +24,8 @@ func BenchmarkMapStrInt_3n_Iteration(b *testing.B) {
 func BenchmarkMapStrInt_25n_AssembleStandard(b *testing.B) {
 	tests.SpecBenchmarkMapStrInt_25n_AssembleStandard(b, Style__Map{})
 }
-func BenchmarkMapStrInt_25n_AssembleDirectly(b *testing.B) {
-	tests.SpecBenchmarkMapStrInt_25n_AssembleDirectly(b, Style__Map{})
+func BenchmarkMapStrInt_25n_AssembleEntry(b *testing.B) {
+	tests.SpecBenchmarkMapStrInt_25n_AssembleEntry(b, Style__Map{})
 }
 func BenchmarkMapStrInt_25n_Iteration(b *testing.B) {
 	tests.SpecBenchmarkMapStrInt_25n_Iteration(b, Style__Map{})

node/gendemo/map_K2_T2.go

@@ -150,7 +150,7 @@ func (ta *_K2__Assembler) AssignNode(v ipld.Node) error {
 }
 func (_K2__Assembler) Style() ipld.NodeStyle { panic("later") }
 
-func (ma *_K2__Assembler) AssembleDirectly(k string) (ipld.NodeAssembler, error) {
+func (ma *_K2__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) {
 	// Sanity check, then update, assembler state.
 	if ma.state != maState_initial {
 		panic("misuse")
@@ -183,7 +183,7 @@ func (ma *_K2__Assembler) AssembleKey() ipld.NodeAssembler {
 		panic("misuse")
 	}
 	ma.state = maState_midKey
-	// TODO return a fairly dummy assembler which just contains a string switch (probably sharing code with AssembleDirectly).
+	// TODO return a fairly dummy assembler which just contains a string switch (probably sharing code with AssembleEntry).
 	panic("todo")
 }
 func (ma *_K2__Assembler) AssembleValue() ipld.NodeAssembler {
@@ -333,7 +333,7 @@ func (ta *_T2__Assembler) AssignNode(v ipld.Node) error {
 }
 func (_T2__Assembler) Style() ipld.NodeStyle { panic("later") }
 
-func (ta *_T2__Assembler) AssembleDirectly(string) (ipld.NodeAssembler, error) {
+func (ta *_T2__Assembler) AssembleEntry(string) (ipld.NodeAssembler, error) {
 	// this'll be fun
 	panic("soon")
 }

node/gendemo/map_K_T.go

@@ -161,8 +161,8 @@ type _T__ReprAssembler struct {
 
 func (_T__Assembler) BeginMap(_ int) (ipld.MapAssembler, error)   { panic("no") }
 func (_T__Assembler) BeginList(_ int) (ipld.ListAssembler, error) { panic("no") }
-func (_T__Assembler) AssignNull() error                               { panic("no") }
-func (_T__Assembler) AssignBool(bool) error                           { panic("no") }
+func (_T__Assembler) AssignNull() error                           { panic("no") }
+func (_T__Assembler) AssignBool(bool) error                       { panic("no") }
 func (ta *_T__Assembler) AssignInt(v int) error {
 	ta.w.x = v
 	return nil
@@ -371,7 +371,7 @@ func (ta *_Map_K_T__Assembler) AssignNode(v ipld.Node) error {
 }
 func (_Map_K_T__Assembler) Style() ipld.NodeStyle { panic("later") }
 
-func (ma *_Map_K_T__Assembler) AssembleDirectly(k string) (ipld.NodeAssembler, error) {
+func (ma *_Map_K_T__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) {
 	// Sanity check, then update, assembler state.
 	if ma.state != maState_initial {
 		panic("misuse")

node/gendemo/map_K_T_test.go

@@ -13,8 +13,8 @@ func TestGennedMapStrInt(t *testing.T) {
 func BenchmarkMapStrInt_3n_AssembleStandard(b *testing.B) {
 	tests.SpecBenchmarkMapStrInt_3n_AssembleStandard(b, Type__Map_K_T{})
 }
-func BenchmarkMapStrInt_3n_AssembleDirectly(b *testing.B) {
-	tests.SpecBenchmarkMapStrInt_3n_AssembleDirectly(b, Type__Map_K_T{})
+func BenchmarkMapStrInt_3n_AssembleEntry(b *testing.B) {
+	tests.SpecBenchmarkMapStrInt_3n_AssembleEntry(b, Type__Map_K_T{})
 }
 func BenchmarkMapStrInt_3n_Iteration(b *testing.B) {
 	tests.SpecBenchmarkMapStrInt_3n_Iteration(b, Type__Map_K_T{})
@@ -23,8 +23,8 @@ func BenchmarkMapStrInt_3n_Iteration(b *testing.B) {
 func BenchmarkMapStrInt_25n_AssembleStandard(b *testing.B) {
 	tests.SpecBenchmarkMapStrInt_25n_AssembleStandard(b, Type__Map_K_T{})
 }
-func BenchmarkMapStrInt_25n_AssembleDirectly(b *testing.B) {
-	tests.SpecBenchmarkMapStrInt_25n_AssembleDirectly(b, Type__Map_K_T{})
+func BenchmarkMapStrInt_25n_AssembleEntry(b *testing.B) {
+	tests.SpecBenchmarkMapStrInt_25n_AssembleEntry(b, Type__Map_K_T{})
 }
 func BenchmarkMapStrInt_25n_Iteration(b *testing.B) {
 	tests.SpecBenchmarkMapStrInt_25n_Iteration(b, Type__Map_K_T{})

node/tests/mapBenchmarks.go

@@ -13,24 +13,24 @@ func SpecBenchmarkMapStrInt_3n_AssembleStandard(b *testing.B, ns ipld.NodeStyle)
 	}
 }
 
-func SpecBenchmarkMapStrInt_3n_AssembleDirectly(b *testing.B, ns ipld.NodeStyle) {
+func SpecBenchmarkMapStrInt_3n_AssembleEntry(b *testing.B, ns ipld.NodeStyle) {
 	for i := 0; i < b.N; i++ {
 		nb := ns.NewBuilder()
 		ma, err := nb.BeginMap(3)
 		if err != nil {
 			panic(err)
 		}
-		if va, err := ma.AssembleDirectly("whee"); err != nil {
+		if va, err := ma.AssembleEntry("whee"); err != nil {
 			panic(err)
 		} else {
 			must.NotError(va.AssignInt(1))
 		}
-		if va, err := ma.AssembleDirectly("woot"); err != nil {
+		if va, err := ma.AssembleEntry("woot"); err != nil {
 			panic(err)
 		} else {
 			must.NotError(va.AssignInt(2))
 		}
-		if va, err := ma.AssembleDirectly("waga"); err != nil {
+		if va, err := ma.AssembleEntry("waga"); err != nil {
 			panic(err)
 		} else {
 			must.NotError(va.AssignInt(3))
@@ -60,15 +60,15 @@ func SpecBenchmarkMapStrInt_25n_AssembleStandard(b *testing.B, ns ipld.NodeStyle
 	}
 }
 
-func SpecBenchmarkMapStrInt_25n_AssembleDirectly(b *testing.B, ns ipld.NodeStyle) {
+func SpecBenchmarkMapStrInt_25n_AssembleEntry(b *testing.B, ns ipld.NodeStyle) {
 	for i := 0; i < b.N; i++ {
 		nb := ns.NewBuilder()
 		ma, err := nb.BeginMap(25)
 		if err != nil {
 			panic(err)
 		}
 		for i := 1; i <= 25; i++ {
-			if va, err := ma.AssembleDirectly(tableStrInt[i-1].s); err != nil {
+			if va, err := ma.AssembleEntry(tableStrInt[i-1].s); err != nil {
 				panic(err)
 			} else {
 				must.NotError(va.AssignInt(tableStrInt[i-1].i))

nodeBuilder.go

@@ -59,7 +59,7 @@ type MapAssembler interface {
 	AssembleKey() NodeAssembler   // must be followed by call to AssembleValue.
 	AssembleValue() NodeAssembler // must be called immediately after AssembleKey.
 
-	AssembleDirectly(k string) (NodeAssembler, error) // shortcut combining AssembleKey and AssembleValue into one step; valid when the key is a string kind.
+	AssembleEntry(k string) (NodeAssembler, error) // shortcut combining AssembleKey and AssembleValue into one step; valid when the key is a string kind.
 
 	Finish() error
 

schema/tests/testsForStructs.go

@@ -27,16 +27,16 @@ func TestFoo(t *testing.T, newNb func(typ schema.Type) ipld.NodeBuilder) {
 			ma, err := nb.BeginMap(3)
 			Wish(t, err, ShouldEqual, nil)
 			// Set 'f1' to a valid string.
-			va, err := ma.AssembleDirectly("f1")
+			va, err := ma.AssembleEntry("f1")
 			Wish(t, err, ShouldEqual, nil)
 			Wish(t, va.AssignString("asdf"), ShouldEqual, nil)
 			// Skip setting 'f2' -- it's optional.
 			// Set 'f3' to null.  Nulls aren't typed.
-			va, err = ma.AssembleDirectly("f3")
+			va, err = ma.AssembleEntry("f3")
 			Wish(t, err, ShouldEqual, nil)
 			Wish(t, va.AssignNull(), ShouldEqual, nil)
 			// Set 'f4' to a valid string.
-			va, err = ma.AssembleDirectly("f4")
+			va, err = ma.AssembleEntry("f4")
 			Wish(t, err, ShouldEqual, nil)
 			Wish(t, va.AssignString("qwer"), ShouldEqual, nil)
 			Wish(t, ma.Finish(), ShouldEqual, nil)

traversal/focus_test.go

@@ -29,11 +29,11 @@ var (
 	leafAlpha, leafAlphaLnk         = encode(basicnode.NewString("alpha"))
 	leafBeta, leafBetaLnk           = encode(basicnode.NewString("beta"))
 	middleMapNode, middleMapNodeLnk = encode(fluent.MustBuildMap(basicnode.Style__Map{}, 3, func(na fluent.MapAssembler) {
-		na.AssembleDirectly("foo").AssignBool(true)
-		na.AssembleDirectly("bar").AssignBool(false)
-		na.AssembleDirectly("nested").CreateMap(2, func(na fluent.MapAssembler) {
-			na.AssembleDirectly("alink").AssignLink(leafAlphaLnk)
-			na.AssembleDirectly("nonlink").AssignString("zoo")
+		na.AssembleEntry("foo").AssignBool(true)
+		na.AssembleEntry("bar").AssignBool(false)
+		na.AssembleEntry("nested").CreateMap(2, func(na fluent.MapAssembler) {
+			na.AssembleEntry("alink").AssignLink(leafAlphaLnk)
+			na.AssembleEntry("nonlink").AssignString("zoo")
 		})
 	}))
 	middleListNode, middleListNodeLnk = encode(fluent.MustBuildList(basicnode.Style__List{}, 4, func(na fluent.ListAssembler) {
@@ -43,10 +43,10 @@ var (
 		na.AssembleValue().AssignLink(leafAlphaLnk)
 	}))
 	rootNode, rootNodeLnk = encode(fluent.MustBuildMap(basicnode.Style__Map{}, 4, func(na fluent.MapAssembler) {
-		na.AssembleDirectly("plain").AssignString("olde string")
-		na.AssembleDirectly("linkedString").AssignLink(leafAlphaLnk)
-		na.AssembleDirectly("linkedMap").AssignLink(middleMapNodeLnk)
-		na.AssembleDirectly("linkedList").AssignLink(middleListNodeLnk)
+		na.AssembleEntry("plain").AssignString("olde string")
+		na.AssembleEntry("linkedString").AssignLink(leafAlphaLnk)
+		na.AssembleEntry("linkedMap").AssignLink(middleMapNodeLnk)
+		na.AssembleEntry("linkedList").AssignLink(middleListNodeLnk)
 	}))
 )