Merge pull request #34 from phelmkamp/chain

add `chain` option

Author: phelmkamp

README.md

@@ -53,9 +53,13 @@ Always uses pointer receiver.
 `filter` (slice only)
 
 Generates a method that returns a copy of the slice, omitting elements that are rejected by the given function.
-Method name is `Filter`, followed by the name of the field unless `omitfield` is specified.
+Method name is `Filter` followed by the name of the field.
 Uses value receiver by default.
 
+Options
+* `omitfield`: exclude field name from method (i.e. just `Filter`) 
+* `chain`: store result in-place and return the receiver (facilitates method chaining)
+
 `mapper,$type` (slice only)
 
 Generates a method that returns the result of mapping all elements to the specified type using the given function.
@@ -67,7 +71,11 @@ Uses value receiver by default.
 Generates `Len` and `Swap` methods to implement [sort.Interface](https://golang.org/pkg/sort/#Interface), along with a `Sort` convenience method. Include the `stringer` option to generate a `Less` method that compares elements by their string representations. Otherwise, a `Less` method must be implemented separately.
 Uses value receivers by default.
 
-Tip: Wrap the slice in a struct to take full advantage. See [person.Persons](internal/testdata/person/person.go) for an example.
+`wrapper` (slice only)
+
+Indicates that the struct is a "wrapper" for the given slice. Enables `omitfield` and `chain` options for all subsequent directives.
+
+See [person.Persons](internal/testdata/person/person.go) for an example.
 
 `stringer`
 

directive/directive.go

@@ -13,6 +13,7 @@ const (
 	optOmitField = "omitfield"
 	optStringer  = "stringer"
 	optReflect   = "reflect"
+	optChain     = "chain"
 )
 
 var (
@@ -35,6 +36,7 @@ type Target struct {
 	RcvName, RcvType string
 	FldNames         []string
 	FldType          string
+	DfltOpts         []string
 }
 
 type runFunc func(*Target, []string)
@@ -48,9 +50,17 @@ func RunAll(ds []string, tgt *Target) {
 
 // Run runs the given directive.
 func Run(d string, tgt *Target) {
+	if d == "wrapper" {
+		// enable options and continue
+		tgt.DfltOpts = append(tgt.DfltOpts, optOmitField)
+		tgt.DfltOpts = append(tgt.DfltOpts, optChain)
+		return
+	}
+
 	opts := strings.Split(d, ",")
 	d = opts[0]
 	opts = opts[1:]
+	opts = append(opts, tgt.DfltOpts...)
 
 	run, ok := runFuncs[d]
 	if !ok {
@@ -120,12 +130,10 @@ func setter(tgt *Target, opts []string) {
 func filter(tgt *Target, opts []string) {
 	elemType := strings.TrimPrefix(tgt.FldType, "[]")
 
-	var isOmitField bool
+	var isOmitField, isChain bool
 	for i := range opts {
-		if opts[i] == optOmitField {
-			isOmitField = true
-			break
-		}
+		isOmitField = isOmitField || opts[i] == optOmitField
+		isChain = isChain || opts[i] == optChain
 	}
 
 	for _, fldNm := range tgt.FldNames {
@@ -135,15 +143,22 @@ func filter(tgt *Target, opts []string) {
 			method += upperFirst(fldNm)
 		}
 
+		retVals, retStmt := tgt.FldType, "return result"
+		if isChain {
+			retVals = tgt.RcvType
+			retStmt = fmt.Sprintf("%s.%s = result\n\treturn %s", tgt.RcvName, fldNm, tgt.RcvName)
+		}
+
 		log.Printf("Adding method: %s\n", method)
 		filter := meta.Method{
 			RcvName: tgt.RcvName,
 			RcvType: tgt.RcvType,
 			Name:    method,
 			ArgType: elemType,
-			RetVals: tgt.FldType,
+			RetVals: retVals,
 			FldName: fldNm,
 			FldType: tgt.FldType,
+			Misc:    map[string]interface{}{"RetStmt": retStmt},
 			Tmpl:    "filter",
 		}
 		tgt.MetaFile.Methods = append(tgt.MetaFile.Methods, &filter)

internal/testdata/foobar/foo_meta.go

@@ -4,9 +4,9 @@
 package foobar
 
 import (
+	"fmt"
 	"reflect"
 	"time"
-	"fmt"
 )
 
 // NewFoo creates a new Foo with the given initial values.
@@ -64,7 +64,7 @@ func (f Foo) FilterLabels(fn func(string) bool, n int) []string {
 	for i := range f.labels {
 		if fn(f.labels[i]) {
 			if result = append(result, f.labels[i]); len(result) >= cap {
-				return result
+				break
 			}
 		}
 	}
@@ -156,7 +156,7 @@ func (b Bar) FilterTimes(fn func(time.Time) bool, n int) []time.Time {
 	for i := range b.times {
 		if fn(b.times[i]) {
 			if result = append(result, b.times[i]); len(result) >= cap {
-				return result
+				break
 			}
 		}
 	}

internal/testdata/person/person.go

@@ -8,5 +8,5 @@ type Person struct {
 }
 
 type Persons struct {
-	Ps []Person `meta:"filter,omitfield;mapper,int,omitfield;sort,stringer"`
+	result []Person `meta:"wrapper;new;filter;mapper,int;sort,stringer;getter"`
 }

internal/testdata/person/person_meta.go

@@ -13,50 +13,64 @@ func (p Person) String() string {
 	return fmt.Sprintf("%v", p.Name)
 }
 
-// Filter returns a copy of Ps, omitting elements that are rejected by the given function.
+// NewPersons creates a new Persons with the given initial values.
+func NewPersons(result []Person) Persons {
+	return Persons{
+		result: result,
+	}
+}
+
+// Filter returns a copy of result, omitting elements that are rejected by the given function.
 // The n argument determines the maximum number of elements to return (n < 1: all elements).
-func (p Persons) Filter(fn func(Person) bool, n int) []Person {
+func (p Persons) Filter(fn func(Person) bool, n int) Persons {
 	cap := n
 	if n < 1 {
-		cap = len(p.Ps)
+		cap = len(p.result)
 	}
 	result := make([]Person, 0, cap)
-	for i := range p.Ps {
-		if fn(p.Ps[i]) {
-			if result = append(result, p.Ps[i]); len(result) >= cap {
-				return result
+	for i := range p.result {
+		if fn(p.result[i]) {
+			if result = append(result, p.result[i]); len(result) >= cap {
+				break
 			}
 		}
 	}
-	return result
+	p.result = result
+	return p
 }
 
-// MapToInt returns a new slice with the results of calling the given function for each element of Ps.
+// MapToInt returns a new slice with the results of calling the given function for each element of result.
 func (p Persons) MapToInt(fn func(Person) int) []int {
-	result := make([]int, len(p.Ps))
-	for i := range p.Ps {
-		result[i] = fn(p.Ps[i])
+	result := make([]int, len(p.result))
+	for i := range p.result {
+		result[i] = fn(p.result[i])
 	}
 	return result
 }
 
 // Len is the number of elements in the collection.
 func (p Persons) Len() int {
-	return len(p.Ps)
+	return len(p.result)
 }
 
 // Swap swaps the elements with indexes i and j.
 func (p Persons) Swap(i, j int) {
-	p.Ps[i], p.Ps[j] = p.Ps[j], p.Ps[i]
+	p.result[i], p.result[j] = p.result[j], p.result[i]
 }
 
 // Sort is a convenience method.
-func (p Persons) Sort() {
+func (p Persons) Sort() Persons {
 	sort.Sort(p)
+	return p
 }
 
 // Less reports whether the element with
 // index i should sort before the element with index j.
 func (p Persons) Less(i, j int) bool {
-	return p.Ps[i].String() < p.Ps[j].String()
+	return p.result[i].String() < p.result[j].String()
+}
+
+// Result returns the value of result.
+func (p Persons) Result() []Person {
+	return p.result
 }

internal/testdata/person/person_meta_test.go

@@ -8,47 +8,47 @@ import (
 )
 
 func Example() {
-	persons := Persons{[]Person{
+	ps := []Person{
 		{
-			Name:      "Ann",
-			Birthdate: time.Date(1983, time.February, 12, 0, 0, 0, 0, time.Local),
+			Name:      "Charlie",
+			Birthdate: time.Date(1994, time.June, 28, 0, 0, 0, 0, time.Local),
 		},
 		{
 			Name:      "Bob",
 			Birthdate: time.Date(2007, time.August, 8, 0, 0, 0, 0, time.Local),
 		},
 		{
-			Name:      "Charlie",
-			Birthdate: time.Date(1994, time.June, 28, 0, 0, 0, 0, time.Local),
+			Name:      "Ann",
+			Birthdate: time.Date(1983, time.February, 12, 0, 0, 0, 0, time.Local),
 		},
-	}}
+	}
 
 	var name string
 	hasName := func(p Person) bool { return p.Name == name }
 
 	name = "David"
-	if found := persons.Filter(hasName, 1); len(found) > 0 {
+	if found := NewPersons(ps).Filter(hasName, 1).Result(); len(found) > 0 {
 		// contains David
 		fmt.Println(found[0])
 	}
 
 	name = "Bob"
-	if found := persons.Filter(hasName, 1); len(found) > 0 {
+	if found := NewPersons(ps).Filter(hasName, 1).Result(); len(found) > 0 {
 		// contains Bob
 		fmt.Println(found[0])
 	}
 
-	// exludes Bob
-	found := persons.Filter(func(p Person) bool { return p.Name != name }, -1)
-	fmt.Println(found)
-
-	// map to ages
-	ages := persons.MapToInt(func(p Person) int { return time.Now().Year() - p.Birthdate.Year() })
+	ages := NewPersons(ps).
+		// exclude Bob
+		Filter(func(p Person) bool { return p.Name != name }, -1).
+		// sort by name
+		Sort().
+		// map to ages
+		MapToInt(func(p Person) int { return time.Now().Year() - p.Birthdate.Year() })
 	fmt.Println(ages)
 
 	// Output: Bob
-	// [Ann Charlie]
-	// [36 12 25]
+	// [36 25]
 }
 
 func TestPersons_Sort(t *testing.T) {
@@ -59,11 +59,13 @@ func TestPersons_Sort(t *testing.T) {
 	}{
 		{
 			name: "abc",
-			p: Persons{[]Person{
-				{Name: "b"},
-				{Name: "c"},
-				{Name: "a"},
-			}},
+			p: NewPersons(
+				[]Person{
+					{Name: "b"},
+					{Name: "c"},
+					{Name: "a"},
+				},
+			),
 			want: []Person{
 				{Name: "a"},
 				{Name: "b"},
@@ -74,8 +76,8 @@ func TestPersons_Sort(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			tt.p.Sort()
-			if !reflect.DeepEqual(tt.p.Ps, tt.want) {
-				t.Errorf("got = %v, want %v", tt.p.Ps, tt.want)
+			if !reflect.DeepEqual(tt.p.Result(), tt.want) {
+				t.Errorf("got = %v, want %v", tt.p.Result(), tt.want)
 			}
 		})
 	}

templates/bindata.go

@@ -34,7 +34,7 @@ func equal_tmpl() ([]byte, error) {
 	)
 }
 
-var _filter_tmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x91\x31\x6f\xa4\x30\x14\x84\x6b\x90\xf8\x0f\x53\x82\x84\xe0\xae\xdd\x3b\x4e\xba\x26\x65\x8a\xd5\x2a\x4d\x94\xc2\x0b\x0f\xd6\x89\xfd\x8c\x8c\x59\x65\x85\xf8\xef\x91\x6d\x92\xcd\x16\x9b\x06\xc9\x9e\x79\xef\x9b\xc1\x75\x8d\x65\xa9\x1e\x85\xa6\x75\x85\x25\x37\x5b\x9e\x20\xd0\x9a\xf1\x02\xd3\x7b\xed\x41\x75\x51\x2e\x61\xb4\x74\x4e\xf2\x00\x52\xa4\x89\xdd\x04\x77\x12\x0e\xc2\x12\x2c\xbd\x52\xeb\xa8\xc3\xf1\x02\x77\x22\x0c\xf2\x4c\x8c\x7e\xe6\xd6\x49\xc3\x55\x96\xd6\x35\x0e\x27\x02\x43\xd8\x61\xf6\xc3\xe8\xc8\x91\xd5\x92\x69\x0a\x13\x5a\xbc\x4b\x3d\x6b\xf0\xac\x8f\x64\x3d\xfc\x4a\x31\x5b\x34\xe4\x8c\xbf\xf8\xbd\x83\x50\xea\x4b\x2e\xaa\x2c\xf5\x20\xe4\xcb\x52\xed\xdb\xf3\x56\x26\x1e\x0e\x97\x91\xd6\xb5\xb8\x96\xcc\xfb\x18\xcb\x9b\xff\xdb\xe1\x53\x3f\x1a\xa3\x4a\x30\x24\xbb\x60\xde\x93\x7b\x12\x6a\xf2\x7b\xb2\x34\x69\xc5\x88\x5d\x03\xce\xd2\x44\xf6\x08\x19\xc2\x7d\x10\x1a\x28\xe2\x1b\x76\xf5\xfd\xb7\x15\x59\x9a\xac\x59\x9a\x58\x9a\x66\xe5\xfc\x1a\x2d\xde\x28\x8f\x96\x88\x2f\xf1\xab\x44\x2b\x46\x6f\xed\x8d\x85\xf4\x2e\x2b\x78\x20\xdc\x5d\x1b\xf9\xb2\x47\xff\x03\xfb\x59\xbe\x14\xd1\xe8\x9d\x5b\x82\x06\x62\x1c\x89\xbb\x3c\x9e\xcb\xfb\x0c\x3f\xfe\x27\xb4\x8b\xd6\x02\xff\x1a\x9f\x73\x5b\x99\x6c\x8f\x12\xc5\x70\xe5\x8b\x86\x4f\x6c\x7c\x23\xaf\x1f\x01\x00\x00\xff\xff\x33\x60\x08\x76\x6c\x02\x00\x00")
+var _filter_tmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x90\x41\xef\x94\x30\x14\xc4\xcf\x90\xf0\x1d\xe6\x08\x09\x01\xbd\xfe\x15\x13\x2f\xde\xf4\xb0\x6e\xbc\x18\x0f\x05\x1e\x6c\xdd\xf6\x95\x94\xb2\x71\x43\xfa\xdd\x4d\x5b\x74\xf5\xb0\xff\x03\x84\x32\xf3\xde\x6f\xa6\x6d\x8b\x7d\x6f\xbe\x08\x4d\xde\xc3\x92\xdb\x2c\xaf\x10\x18\xcc\x72\x87\x99\x82\xf6\x49\x8d\x49\xae\x61\xb4\x74\x4e\xf2\x0c\x52\xa4\x89\xdd\x0a\x77\x11\x0e\xc2\x12\x2c\xfd\xa4\xc1\xd1\x88\xfe\x0e\x77\x21\xcc\xf2\x46\x8c\x69\xe3\xc1\x49\xc3\x4d\x91\xb7\x2d\xce\x17\x02\x43\xd8\x79\x0b\xc3\x18\xc9\x91\xd5\x92\x69\x8d\x13\x5a\xfc\x92\x7a\xd3\xe0\x4d\xf7\x64\x03\xfc\x41\x31\x47\x34\x94\x8c\xf7\x78\xfb\x02\xa1\xd4\x5f\xb9\x6a\x8a\x3c\x80\x50\xee\x7b\x73\x1a\x6e\x47\x99\x74\x38\xdf\x17\xf2\xbe\x7a\x94\x2c\xa7\x14\x2b\x98\x3f\xda\xf9\x8f\xde\x1b\xa3\x6a\x30\x24\xbb\x68\x3e\x91\xfb\x26\xd4\x1a\xf6\x14\x79\x36\x88\x05\x2f\x1d\xb8\xc8\x33\x39\x21\x66\x88\xff\xa3\xd0\x41\x11\xff\xc7\x6e\xfe\xbd\xb6\xaa\xc8\x33\x5f\xe4\x99\xa5\x75\x53\x2e\xac\xd1\xe2\x4a\x65\xb2\x24\x7c\x8d\x37\x35\x06\xb1\x04\xeb\x64\x2c\x64\x70\x59\xc1\x33\xe1\xe9\xda\xc4\x97\x13\xa6\x57\xd8\xdf\xe5\x8f\x2a\x19\x83\xf3\x48\xd0\x41\x2c\x0b\xf1\x58\xa6\x73\xfd\x9c\x11\xc6\xdf\xc5\x76\xc9\x5a\xe1\x43\x17\x72\x1e\x2b\xb3\xde\x92\xb8\xc6\xcf\x50\x30\xbe\xc2\xb3\xef\xcd\x67\xb9\x0e\xe1\x0e\xbf\x3a\xed\xbc\x2f\x72\xff\x3b\x00\x00\xff\xff\x56\x40\xed\xe4\x68\x02\x00\x00")
 
 func filter_tmpl() ([]byte, error) {
 	return bindata_read(
@@ -88,7 +88,7 @@ func setter_tmpl() ([]byte, error) {
 	)
 }
 
-var _sort_tmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x90\xc1\x6a\xb4\x40\x10\x84\xcf\xbf\xe0\x3b\xd4\x51\x61\xd1\x27\xf8\xaf\x39\x85\x1c\x92\xdc\x82\x07\x33\xf6\x62\xcb\xd8\x23\x33\xed\x9a\x30\xcc\xbb\x87\x51\x08\x9b\xc3\x2e\x7b\x2c\xaa\xbb\xf8\xaa\xda\x16\xcf\x24\xe0\x00\x1d\x09\xb2\xce\x9f\xe4\xe1\xce\x20\x4b\x33\x89\x06\xb0\xec\x8e\x71\xd6\x92\x51\x76\xd2\x94\xc5\x79\x15\x83\x2a\xc6\xe6\xd5\x5c\x5e\xfa\x99\x52\xc2\x21\xde\xbf\x17\x4a\xa9\xce\x91\x55\x0d\x16\x45\x2c\x8b\x7f\x9e\x74\xf5\x02\x4b\xf2\xe7\xa7\x89\xb1\x79\xb2\xc3\x21\xea\xb2\x48\x65\x51\x16\x6d\x8b\xb7\xad\x5f\x10\xb6\x7e\x39\x98\x7e\x49\x36\xd6\x11\x2c\x03\x7d\x51\x00\xa3\x97\x01\xd3\x23\x30\x39\xaf\xe2\x13\xa6\x0c\x54\xef\x44\x37\x31\x3e\xb8\x3b\xe1\xb6\x3b\x75\xf8\x7f\xd7\xbe\xf7\xcc\xdd\x55\x47\xe7\x35\x8f\xde\xc3\x38\xb9\x90\x30\x89\x21\xcc\xa4\xa3\x1b\x1e\xea\xe4\xbc\x56\x47\x97\xe0\xbc\x36\xbb\xbe\xbe\xcf\x7b\xfe\x04\x00\x00\xff\xff\xc7\x64\x49\x85\xdc\x01\x00\x00")
+var _sort_tmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x91\xc1\x6a\xac\x40\x10\x45\xd7\xaf\xa1\xff\xe1\x2e\x6d\x18\xf4\x0b\xde\x36\xab\x90\x45\x92\x5d\x70\x61\xda\x1a\x2c\xd1\x6a\x69\xcb\x31\x41\xfa\xdf\x83\x0a\x89\xb3\x98\x61\x96\x55\x87\x5b\x9c\xdb\x5d\x14\x78\x26\x01\x8f\xd0\x86\x20\x53\xff\x49\x11\xe1\x0c\xea\xa8\x27\xd1\x11\x2c\x1b\xf1\xa1\xeb\xc8\x2b\x07\xc9\xad\x39\x4f\xe2\x91\x2d\x4b\xfe\xea\x2f\x2f\x55\x4f\x29\x61\x1f\xde\xbf\x07\x4a\xc9\xad\x27\x33\x07\x16\xc5\x62\xcd\xbf\x48\x3a\x45\x41\x47\x72\x95\xc9\x97\x25\x7f\xea\xea\x7d\x70\xd6\x24\x6b\xac\x29\x0a\xbc\xcd\xd5\x80\x71\xae\x86\xdd\xe9\xd7\x64\x66\x6d\xc0\x52\xd3\x17\x8d\x60\x54\x52\xa3\x7d\x44\x66\xbd\x97\xf1\x09\xed\x2a\xe4\x36\xa3\x9b\x1a\x1f\x5c\x9e\x70\x9b\xb6\x25\xfe\xdf\xc5\xf7\xc2\x5c\x1e\x3a\x86\xa8\xeb\xa3\x57\xf0\x41\x2e\x24\x4c\xe2\x09\x3d\x69\x13\xea\x87\x3a\x85\xa8\x99\xbb\x5a\x6e\xc5\xc6\x10\x35\xdf\xe0\x31\xec\xfe\x3e\xe1\xb8\xb6\x26\xfd\x04\x00\x00\xff\xff\x4b\xe9\xb7\x0f\xff\x01\x00\x00")
 
 func sort_tmpl() ([]byte, error) {
 	return bindata_read(

templates/filter.tmpl

@@ -9,9 +9,9 @@ func ({{.RcvName}} {{.RcvType}}) {{.Name}}(fn func({{.ArgType}}) bool, n int) {{
 	for i := range {{.RcvName}}.{{.FldName}} {
 		if fn({{.RcvName}}.{{.FldName}}[i]) {
 			if result = append(result, {{.RcvName}}.{{.FldName}}[i]); len(result) >= cap {
-				return result
+				break
 			}
 		}
 	}
-	return result
+	{{.Misc.RetStmt}}
 }

templates/sort.tmpl

@@ -9,6 +9,7 @@ func ({{.RcvName}} {{.RcvType}}) Swap(i, j int) {
 }
 
 // Sort is a convenience method.
-func ({{.RcvName}} {{.RcvType}}) Sort() {
+func ({{.RcvName}} {{.RcvType}}) Sort() {{.RcvType}} {
 	sort.Sort({{.RcvName}})
+	return {{.RcvName}}
 }