diff --git a/common/collections/collections.go b/common/collections/collections.go index 854f705b3..f2dd3071d 100644 --- a/common/collections/collections.go +++ b/common/collections/collections.go @@ -24,5 +24,5 @@ type Grouper interface { // in collections.Slice template func to get types such as Pages, PageGroups etc. // instead of the less useful []interface{}. type Slicer interface { - Slice(items []interface{}) (interface{}, error) + Slice(items interface{}) (interface{}, error) } diff --git a/go.sum b/go.sum index a8b935672..5a71e5d76 100644 --- a/go.sum +++ b/go.sum @@ -65,6 +65,7 @@ github.com/magefile/mage v1.4.0 h1:RI7B1CgnPAuu2O9lWszwya61RLmfL0KCdo+QyyI/Bhk= github.com/magefile/mage v1.4.0/go.mod h1:IUDi13rsHje59lecXokTfGX0QIzO45uVPlXnJYsXepA= github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/markbates/inflect v0.0.0-20171215194931-a12c3aec81a6 h1:LZhVjIISSbj8qLf2qDPP0D8z0uvOWAW5C85ly5mJW6c= github.com/markbates/inflect v0.0.0-20171215194931-a12c3aec81a6/go.mod h1:oTeZL2KHA7CUX6X+fovmK9OvIOFuqu0TwdQrZjLTh88= github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs= github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= diff --git a/hugolib/collections.go b/hugolib/collections.go index 56830d8e6..b9992c425 100644 --- a/hugolib/collections.go +++ b/hugolib/collections.go @@ -16,14 +16,17 @@ package hugolib import ( "fmt" + "github.com/gohugoio/hugo/resource" + "github.com/gohugoio/hugo/common/collections" ) var ( - _ collections.Grouper = (*Page)(nil) - _ collections.Slicer = (*Page)(nil) - _ collections.Slicer = PageGroup{} - _ collections.Slicer = WeightedPage{} + _ collections.Grouper = (*Page)(nil) + _ collections.Slicer = (*Page)(nil) + _ collections.Slicer = PageGroup{} + _ collections.Slicer = WeightedPage{} + _ resource.ResourcesConverter = Pages{} ) // collections.Slicer implementations below. We keep these bridge implementations @@ -32,36 +35,50 @@ var ( // Slice is not meant to be used externally. It's a bridge function // for the template functions. See collections.Slice. -func (p *Page) Slice(items []interface{}) (interface{}, error) { +func (p *Page) Slice(items interface{}) (interface{}, error) { return toPages(items) } // Slice is not meant to be used externally. It's a bridge function // for the template functions. See collections.Slice. -func (p PageGroup) Slice(items []interface{}) (interface{}, error) { - groups := make(PagesGroup, len(items)) - for i, v := range items { - g, ok := v.(PageGroup) - if !ok { - return nil, fmt.Errorf("type %T is not a PageGroup", v) +func (p PageGroup) Slice(in interface{}) (interface{}, error) { + switch items := in.(type) { + case PageGroup: + return items, nil + case []interface{}: + groups := make(PagesGroup, len(items)) + for i, v := range items { + g, ok := v.(PageGroup) + if !ok { + return nil, fmt.Errorf("type %T is not a PageGroup", v) + } + groups[i] = g } - groups[i] = g + return groups, nil + default: + return nil, fmt.Errorf("invalid slice type %T", items) } - return groups, nil } // Slice is not meant to be used externally. It's a bridge function // for the template functions. See collections.Slice. -func (p WeightedPage) Slice(items []interface{}) (interface{}, error) { - weighted := make(WeightedPages, len(items)) - for i, v := range items { - g, ok := v.(WeightedPage) - if !ok { - return nil, fmt.Errorf("type %T is not a WeightedPage", v) +func (p WeightedPage) Slice(in interface{}) (interface{}, error) { + switch items := in.(type) { + case WeightedPages: + return items, nil + case []interface{}: + weighted := make(WeightedPages, len(items)) + for i, v := range items { + g, ok := v.(WeightedPage) + if !ok { + return nil, fmt.Errorf("type %T is not a WeightedPage", v) + } + weighted[i] = g } - weighted[i] = g + return weighted, nil + default: + return nil, fmt.Errorf("invalid slice type %T", items) } - return weighted, nil } // collections.Grouper implementations below @@ -76,3 +93,12 @@ func (p *Page) Group(key interface{}, in interface{}) (interface{}, error) { } return PageGroup{Key: key, Pages: pages}, nil } + +// ToResources wraps resource.ResourcesConverter +func (pages Pages) ToResources() resource.Resources { + r := make(resource.Resources, len(pages)) + for i, p := range pages { + r[i] = p + } + return r +} diff --git a/hugolib/collections_test.go b/hugolib/collections_test.go index 124a6ede7..9cf328a05 100644 --- a/hugolib/collections_test.go +++ b/hugolib/collections_test.go @@ -86,3 +86,57 @@ tags_weight: %d "pageGroups:2:hugolib.PagesGroup:Page(/page1.md)/Page(/page2.md)", `weightedPages:2::hugolib.WeightedPages:[WeightedPage(10,"Page") WeightedPage(20,"Page")]`) } + +func TestAppendFunc(t *testing.T) { + assert := require.New(t) + + pageContent := ` +--- +title: "Page" +tags: ["blue", "green"] +tags_weight: %d +--- + +` + b := newTestSitesBuilder(t) + b.WithSimpleConfigFile(). + WithContent("page1.md", fmt.Sprintf(pageContent, 10), "page2.md", fmt.Sprintf(pageContent, 20)). + WithTemplatesAdded("index.html", ` + +{{ $p1 := index .Site.RegularPages 0 }}{{ $p2 := index .Site.RegularPages 1 }} + +{{ $pages := slice }} + +{{ if true }} + {{ $pages = $pages | append $p2 $p1 }} +{{ end }} +{{ $appendPages := .Site.Pages | append .Site.RegularPages }} +{{ $appendStrings := slice "a" "b" | append "c" "d" "e" }} +{{ $appendStringsSlice := slice "a" "b" "c" | append (slice "c" "d") }} + +{{ printf "pages:%d:%T:%v/%v" (len $pages) $pages (index $pages 0) (index $pages 1) }} +{{ printf "appendPages:%d:%T:%v/%v" (len $appendPages) $appendPages (index $appendPages 0).Kind (index $appendPages 8).Kind }} +{{ printf "appendStrings:%T:%v" $appendStrings $appendStrings }} +{{ printf "appendStringsSlice:%T:%v" $appendStringsSlice $appendStringsSlice }} + +{{/* add some slightly related funcs to check what types we get */}} +{{ $u := $appendStrings | union $appendStringsSlice }} +{{ $i := $appendStrings | intersect $appendStringsSlice }} +{{ printf "union:%T:%v" $u $u }} +{{ printf "intersect:%T:%v" $i $i }} + +`) + b.CreateSites().Build(BuildCfg{}) + + assert.Equal(1, len(b.H.Sites)) + require.Len(t, b.H.Sites[0].RegularPages, 2) + + b.AssertFileContent("public/index.html", + "pages:2:hugolib.Pages:Page(/page2.md)/Page(/page1.md)", + "appendPages:9:hugolib.Pages:home/page", + "appendStrings:[]string:[a b c d e]", + "appendStringsSlice:[]string:[a b c c d]", + "union:[]string:[a b c d e]", + "intersect:[]string:[a b c d]", + ) +} diff --git a/resource/resource.go b/resource/resource.go index 9a974e912..dd9cbbd41 100644 --- a/resource/resource.go +++ b/resource/resource.go @@ -28,6 +28,7 @@ import ( "github.com/gohugoio/hugo/output" "github.com/gohugoio/hugo/tpl" + "github.com/gohugoio/hugo/common/collections" "github.com/gohugoio/hugo/common/hugio" "github.com/gohugoio/hugo/common/loggers" @@ -49,6 +50,7 @@ var ( _ Cloner = (*genericResource)(nil) _ ResourcesLanguageMerger = (*Resources)(nil) _ permalinker = (*genericResource)(nil) + _ collections.Slicer = (*genericResource)(nil) ) var noData = make(map[string]interface{}) @@ -150,6 +152,11 @@ type ReadSeekCloserResource interface { // I.e. both pages and images etc. type Resources []Resource +// ResourcesConverter converts a given slice of Resource objects to Resources. +type ResourcesConverter interface { + ToResources() Resources +} + // ByType returns resources of a given resource type (ie. "image"). func (r Resources) ByType(tp string) Resources { var filtered Resources @@ -550,6 +557,7 @@ func (l *publishOnce) publish(s Source) error { // genericResource represents a generic linkable resource. type genericResource struct { + commonResource resourcePathDescriptor title string @@ -586,6 +594,9 @@ type genericResource struct { *publishOnce } +type commonResource struct { +} + func (l *genericResource) Data() interface{} { return noData } @@ -621,6 +632,27 @@ func (l genericResource) WithNewBase(base string) Resource { return &l } +// Slice is not meant to be used externally. It's a bridge function +// for the template functions. See collections.Slice. +func (commonResource) Slice(in interface{}) (interface{}, error) { + switch items := in.(type) { + case Resources: + return items, nil + case []interface{}: + groups := make(Resources, len(items)) + for i, v := range items { + g, ok := v.(Resource) + if !ok { + return nil, fmt.Errorf("type %T is not a Resource", v) + } + groups[i] = g + } + return groups, nil + default: + return nil, fmt.Errorf("invalid slice type %T", items) + } +} + func (l *genericResource) initHash() error { var err error l.hashInit.Do(func() { diff --git a/resource/transform.go b/resource/transform.go index 9e6215b9e..01b05b73e 100644 --- a/resource/transform.go +++ b/resource/transform.go @@ -19,6 +19,7 @@ import ( "strconv" "strings" + "github.com/gohugoio/hugo/common/collections" "github.com/gohugoio/hugo/common/errors" "github.com/gohugoio/hugo/common/hugio" "github.com/gohugoio/hugo/helpers" @@ -37,6 +38,7 @@ import ( var ( _ ContentResource = (*transformedResource)(nil) _ ReadSeekCloserResource = (*transformedResource)(nil) + _ collections.Slicer = (*transformedResource)(nil) ) func (s *Spec) Transform(r Resource, t ResourceTransformation) (Resource, error) { @@ -166,6 +168,8 @@ type transformedResourceMetadata struct { } type transformedResource struct { + commonResource + cache *ResourceCache // This is the filename inside resources/_gen/assets diff --git a/tpl/collections/append.go b/tpl/collections/append.go new file mode 100644 index 000000000..20afa0e72 --- /dev/null +++ b/tpl/collections/append.go @@ -0,0 +1,74 @@ +// 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" +) + +// Append appends the arguments up to the last one to the slice in the last argument. +// This construct allows template constructs like this: +// {{ $pages = $pages | append $p2 $p1 }} +// Note that with 2 arguments where both are slices of the same type, +// the first slice will be appended to the second: +// {{ $pages = $pages | append .Site.RegularPages }} +func (ns *Namespace) Append(args ...interface{}) (interface{}, error) { + if len(args) < 2 { + return nil, errors.New("need at least 2 arguments to append") + } + + to := args[len(args)-1] + from := args[:len(args)-1] + + tov, toIsNil := indirect(reflect.ValueOf(to)) + + toIsNil = toIsNil || to == nil + var tot reflect.Type + + if !toIsNil { + if tov.Kind() != reflect.Slice { + return nil, fmt.Errorf("expected a slice, got %T", to) + } + + tot = tov.Type().Elem() + toIsNil = tov.Len() == 0 + + if len(from) == 1 { + // If we get []string []string, we append the from slice to to + fromv := reflect.ValueOf(from[0]) + if fromv.Kind() == reflect.Slice { + fromt := reflect.TypeOf(from[0]).Elem() + if tot == fromt { + return reflect.AppendSlice(tov, fromv).Interface(), nil + } + } + } + } + + if toIsNil { + return ns.Slice(from...), nil + } + + for _, f := range from { + fv := reflect.ValueOf(f) + if tot != fv.Type() { + return nil, fmt.Errorf("append element type mismatch: expected %v, got %v", tot, fv.Type()) + } + tov = reflect.Append(tov, fv) + } + + return tov.Interface(), nil +} diff --git a/tpl/collections/append_test.go b/tpl/collections/append_test.go new file mode 100644 index 000000000..b0a751fb8 --- /dev/null +++ b/tpl/collections/append_test.go @@ -0,0 +1,77 @@ +// 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/alecthomas/assert" + "github.com/gohugoio/hugo/deps" + "github.com/stretchr/testify/require" +) + +func TestAppend(t *testing.T) { + t.Parallel() + + ns := New(&deps.Deps{}) + + for i, test := range []struct { + start interface{} + addend []interface{} + expected interface{} + }{ + {[]string{"a", "b"}, []interface{}{"c"}, []string{"a", "b", "c"}}, + {[]string{"a", "b"}, []interface{}{"c", "d", "e"}, []string{"a", "b", "c", "d", "e"}}, + {[]string{"a", "b"}, []interface{}{[]string{"c", "d", "e"}}, []string{"a", "b", "c", "d", "e"}}, + {nil, []interface{}{"a", "b"}, []string{"a", "b"}}, + {nil, []interface{}{nil}, []interface{}{nil}}, + {tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}, + []interface{}{&tstSlicer{"c"}}, + tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}, &tstSlicer{"c"}}}, + {&tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}, + []interface{}{&tstSlicer{"c"}}, + tstSlicers{&tstSlicer{"a"}, + &tstSlicer{"b"}, + &tstSlicer{"c"}}}, + // Errors + {"", []interface{}{[]string{"a", "b"}}, false}, + {[]string{"a", "b"}, []interface{}{}, false}, + // No string concatenation. + {"ab", + []interface{}{"c"}, + false}, + } { + + errMsg := fmt.Sprintf("[%d]", i) + + args := append(test.addend, test.start) + + result, err := ns.Append(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) + } + } + + assert.Len(t, ns.Slice(), 0) +} diff --git a/tpl/collections/collections.go b/tpl/collections/collections.go index 5ae0fffe1..4400a26b2 100644 --- a/tpl/collections/collections.go +++ b/tpl/collections/collections.go @@ -1,4 +1,4 @@ -// Copyright 2017 The Hugo Authors. All rights reserved. +// 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. @@ -520,10 +520,11 @@ func (ns *Namespace) Slice(args ...interface{}) interface{} { } first := args[0] - allTheSame := true - if len(args) > 1 { + firstType := reflect.TypeOf(first) + + allTheSame := firstType != nil + if allTheSame && len(args) > 1 { // This can be a mix of types. - firstType := reflect.TypeOf(first) for i := 1; i < len(args); i++ { if firstType != reflect.TypeOf(args[i]) { allTheSame = false @@ -538,6 +539,12 @@ func (ns *Namespace) Slice(args ...interface{}) interface{} { if err == nil { return v } + } else { + slice := reflect.MakeSlice(reflect.SliceOf(firstType), len(args), len(args)) + for i, arg := range args { + slice.Index(i).Set(reflect.ValueOf(arg)) + } + return slice.Interface() } } diff --git a/tpl/collections/collections_test.go b/tpl/collections/collections_test.go index c771d571f..c2d4cacbf 100644 --- a/tpl/collections/collections_test.go +++ b/tpl/collections/collections_test.go @@ -1,4 +1,4 @@ -// Copyright 2017 The Hugo Authors. All rights reserved. +// 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. @@ -647,7 +647,8 @@ type tstSlicer struct { name string } -func (p *tstSlicer) Slice(items []interface{}) (interface{}, error) { +func (p *tstSlicer) Slice(in interface{}) (interface{}, error) { + items := in.([]interface{}) result := make(tstSlicers, len(items)) for i, v := range items { result[i] = v.(*tstSlicer) @@ -666,13 +667,13 @@ func TestSlice(t *testing.T) { args []interface{} expected interface{} }{ - {[]interface{}{"a", "b"}, []interface{}{"a", "b"}}, + {[]interface{}{"a", "b"}, []string{"a", "b"}}, {[]interface{}{&tstSlicer{"a"}, &tstSlicer{"b"}}, tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}}, {[]interface{}{&tstSlicer{"a"}, "b"}, []interface{}{&tstSlicer{"a"}, "b"}}, {[]interface{}{}, []interface{}{}}, {[]interface{}{nil}, []interface{}{nil}}, {[]interface{}{5, "b"}, []interface{}{5, "b"}}, - {[]interface{}{tstNoStringer{}}, []interface{}{tstNoStringer{}}}, + {[]interface{}{tstNoStringer{}}, []tstNoStringer{tstNoStringer{}}}, } { errMsg := fmt.Sprintf("[%d] %v", i, test.args) diff --git a/tpl/collections/init.go b/tpl/collections/init.go index ad4f6f207..879e4738c 100644 --- a/tpl/collections/init.go +++ b/tpl/collections/init.go @@ -138,6 +138,11 @@ func init() { [][2]string{}, ) + ns.AddMethodMapping(ctx.Append, + []string{"append"}, + [][2]string{}, + ) + ns.AddMethodMapping(ctx.Group, []string{"group"}, [][2]string{}, diff --git a/tpl/path/path.go b/tpl/path/path.go index fabf15018..f975726cc 100644 --- a/tpl/path/path.go +++ b/tpl/path/path.go @@ -121,6 +121,10 @@ func (ns *Namespace) Join(elements ...interface{}) (string, error) { var pathElements []string for _, elem := range elements { switch v := elem.(type) { + case []string: + for _, e := range v { + pathElements = append(pathElements, filepath.ToSlash(e)) + } case []interface{}: for _, e := range v { elemStr, err := cast.ToStringE(e) diff --git a/tpl/resources/resources.go b/tpl/resources/resources.go index 5f375a06b..883afbcd7 100644 --- a/tpl/resources/resources.go +++ b/tpl/resources/resources.go @@ -88,22 +88,11 @@ func (ns *Namespace) Concat(targetPathIn interface{}, r interface{}) (resource.R var rr resource.Resources switch v := r.(type) { - // This is what we get from the slice func. - case []interface{}: - rr = make([]resource.Resource, len(v)) - for i := 0; i < len(v); i++ { - rv, ok := v[i].(resource.Resource) - if !ok { - return nil, fmt.Errorf("cannot concat type %T", v[i]) - } - rr[i] = rv - } - // This is what we get from .Resources.Match etc. case resource.Resources: rr = v + case resource.ResourcesConverter: + rr = v.ToResources() default: - // We may support Page collections at one point, but we need to think about ... - // what to acutually concatenate. return nil, fmt.Errorf("slice %T not supported in concat", r) }