ref: 42d8dfc8c88af03ea926a59bc2332acc70cca5f6
parent: 47506d164467eb7ddbcada81b767d8df5f9c8786
author: Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
date: Mon Nov 5 13:50:11 EST 2018
tpl/collections: Add collections.Complement Fixes #5400
--- /dev/null
+++ b/tpl/collections/complement.go
@@ -1,0 +1,72 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collections
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+)
+
+// Complement gives the elements in the last element of seqs that are not in
+// any of the others.
+// All elements of seqs must be slices or arrays of comparable types.
+//
+// The reasoning behind this rather clumsy API is so we can do this in the templates:
+// {{ $c := .Pages | complement $last4 }}+func (ns *Namespace) Complement(seqs ...interface{}) (interface{}, error) {+ if len(seqs) < 2 {+ return nil, errors.New("complement needs at least two arguments")+ }
+
+ universe := seqs[len(seqs)-1]
+ as := seqs[:len(seqs)-1]
+
+ aset := make(map[interface{}]struct{})+
+ for _, av := range as {+ v := reflect.ValueOf(av)
+ switch v.Kind() {+ case reflect.Array, reflect.Slice:
+ for i := 0; i < v.Len(); i++ {+ ev, _ := indirectInterface(v.Index(i))
+ if !ev.Type().Comparable() {+ return nil, errors.New("elements in complement must be comparable")+ }
+
+ aset[normalize(ev)] = struct{}{}+ }
+ default:
+ return nil, fmt.Errorf("arguments to complement must be slices or arrays")+ }
+ }
+
+ v := reflect.ValueOf(universe)
+ switch v.Kind() {+ case reflect.Array, reflect.Slice:
+ sl := reflect.MakeSlice(v.Type(), 0, 0)
+ for i := 0; i < v.Len(); i++ {+ ev, _ := indirectInterface(v.Index(i))
+ if !ev.Type().Comparable() {+ return nil, errors.New("elements in complement must be comparable")+ }
+ if _, found := aset[normalize(ev)]; !found {+ sl = reflect.Append(sl, ev)
+ }
+ }
+ return sl.Interface(), nil
+ default:
+ return nil, fmt.Errorf("arguments to complement must be slices or arrays")+ }
+}
--- /dev/null
+++ b/tpl/collections/complement_test.go
@@ -1,0 +1,84 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collections
+
+import (
+ "fmt"
+ "reflect"
+ "testing"
+
+ "github.com/gohugoio/hugo/deps"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestComplement(t *testing.T) {+ t.Parallel()
+
+ assert := require.New(t)
+
+ ns := New(&deps.Deps{})+
+ s1 := []TstX{TstX{A: "a"}, TstX{A: "b"}, TstX{A: "d"}, TstX{A: "e"}}+ s2 := []TstX{TstX{A: "b"}, TstX{A: "e"}}+
+ xa, xd := &TstX{A: "a"}, &TstX{A: "d"}+
+ sp1 := []*TstX{xa, &TstX{A: "b"}, xd, &TstX{A: "e"}}+ sp2 := []*TstX{&TstX{A: "b"}, &TstX{A: "e"}}+
+ for i, test := range []struct {+ s interface{}+ t []interface{}+ expected interface{}+ }{+ {[]string{"a", "b", "c"}, []interface{}{[]string{"c", "d"}}, []string{"a", "b"}},+ {[]string{"a", "b", "c"}, []interface{}{[]string{"c", "d"}, []string{"a", "b"}}, []string{}},+ {[]interface{}{"a", "b", nil}, []interface{}{[]string{"a", "d"}}, []interface{}{"b", nil}},+ {[]int{1, 2, 3, 4, 5}, []interface{}{[]int{1, 3}, []string{"a", "b"}, []int{1, 2}}, []int{4, 5}},+ {[]int{1, 2, 3, 4, 5}, []interface{}{[]int64{1, 3}}, []int{2, 4, 5}},+ {s1, []interface{}{s2}, []TstX{TstX{A: "a"}, TstX{A: "d"}}},+ {sp1, []interface{}{sp2}, []*TstX{xa, xd}},+
+ // Errors
+ {[]string{"a", "b", "c"}, []interface{}{"error"}, false},+ {"error", []interface{}{[]string{"c", "d"}, []string{"a", "b"}}, false},+ {[]string{"a", "b", "c"}, []interface{}{[][]string{[]string{"c", "d"}}}, false},+ {[]interface{}{[][]string{[]string{"c", "d"}}}, []interface{}{[]string{"c", "d"}, []string{"a", "b"}}, false},+ } {+
+ errMsg := fmt.Sprintf("[%d]", i)+
+ args := append(test.t, test.s)
+
+ result, err := ns.Complement(args...)
+
+ if b, ok := test.expected.(bool); ok && !b {+ require.Error(t, err, errMsg)
+ continue
+ }
+
+ require.NoError(t, err, errMsg)
+
+ if !reflect.DeepEqual(test.expected, result) {+ t.Fatalf("%s got\n%T: %v\nexpected\n%T: %v", errMsg, result, result, test.expected, test.expected)+ }
+ }
+
+ _, err := ns.Complement()
+ assert.Error(err)
+ _, err = ns.Complement([]string{"a", "b"})+ assert.Error(err)
+
+}
--- a/tpl/collections/init.go
+++ b/tpl/collections/init.go
@@ -39,6 +39,13 @@
[][2]string{},)
+ ns.AddMethodMapping(ctx.Complement,
+ []string{"complement"},+ [][2]string{+ {`{{ slice "a" "b" "c" "d" "e" "f" | complement (slice "b" "c") (slice "d" "e") }}`, `[a f]`},+ },
+ )
+
ns.AddMethodMapping(ctx.Delimit,
[]string{"delimit"}, [][2]string{--- a/tpl/collections/reflect_helpers.go
+++ b/tpl/collections/reflect_helpers.go
@@ -41,6 +41,24 @@
}
}
+// normalizes different numeric types to make them comparable.
+// If not, any pointer will be unwrapped.
+func normalize(v reflect.Value) interface{} {+ k := v.Kind()
+
+ switch {+ case isNumber(k):
+ f, err := numberToFloat(v)
+ if err == nil {+ return f
+ }
+ case k == reflect.Ptr:
+ v = v.Elem()
+ }
+
+ return v.Interface()
+}
+
// There are potential overflows in this function, but the downconversion of
// int64 etc. into int8 etc. is coming from the synthetic unit tests for Union etc.
// TODO(bep) We should consider normalizing the slices to int64 etc.
--
⑨