tpl: Add reflect namespace

Add a reflect namespace that offers a two boolean functions for
testing if a value is a map or slice.

Fixes #4081
This commit is contained in:
Cameron Moore 2018-12-07 16:29:37 -06:00 committed by Bjørn Erik Pedersen
parent 4b5f743959
commit c84f506f8e
6 changed files with 230 additions and 0 deletions

View file

@ -0,0 +1,25 @@
---
title: reflect.IsMap
description: Reports if a value is a map.
godocref:
date: 2018-11-28
publishdate: 2018-11-28
lastmod: 2018-11-28
categories: [functions]
menu:
docs:
parent: "functions"
keywords: [reflect, reflection, kind]
signature: ["reflect.IsMap INPUT"]
workson: []
hugoversion: "v0.53"
relatedfuncs: [reflect.IsSlice]
deprecated: false
---
`reflect.IsMap` reports if `VALUE` is a map. Returns a boolean.
```
{{ reflect.IsMap (dict "key" "value") }} → true
{{ reflect.IsMap "yo" }} → false
```

View file

@ -0,0 +1,25 @@
---
title: reflect.IsSlice
description: Reports if a value is a slice.
godocref:
date: 2018-11-28
publishdate: 2018-11-28
lastmod: 2018-11-28
categories: [functions]
menu:
docs:
parent: "functions"
keywords: [reflect, reflection, kind]
signature: ["reflect.IsSlice INPUT"]
workson: []
hugoversion: "0.53"
relatedfuncs: [reflect.IsMap]
deprecated: false
---
`reflect.IsSlice` reports if `VALUE` is a slice. Returns a boolean.
```
{{ reflect.IsSlice (slice 1 2 3) }} → true
{{ reflect.IsSlice "yo" }} → false
```

50
tpl/reflect/init.go Normal file
View file

@ -0,0 +1,50 @@
// 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 reflect
import (
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/tpl/internal"
)
const name = "reflect"
func init() {
f := func(d *deps.Deps) *internal.TemplateFuncsNamespace {
ctx := New()
ns := &internal.TemplateFuncsNamespace{
Name: name,
Context: func(args ...interface{}) interface{} { return ctx },
}
ns.AddMethodMapping(ctx.IsMap,
nil,
[][2]string{
{`{{ if reflect.IsMap (dict "a" 1) }}Map{{ end }}`, `Map`},
},
)
ns.AddMethodMapping(ctx.IsSlice,
nil,
[][2]string{
{`{{ if reflect.IsSlice (slice 1 2 3) }}Slice{{ end }}`, `Slice`},
},
)
return ns
}
internal.AddTemplateFuncsNamespace(f)
}

39
tpl/reflect/init_test.go Normal file
View file

@ -0,0 +1,39 @@
// Copyright 2017 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 reflect
import (
"testing"
"github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/tpl/internal"
"github.com/stretchr/testify/require"
)
func TestInit(t *testing.T) {
var found bool
var ns *internal.TemplateFuncsNamespace
for _, nsf := range internal.TemplateFuncsNamespaceRegistry {
ns = nsf(&deps.Deps{Log: loggers.NewErrorLogger()})
if ns.Name == name {
found = true
break
}
}
require.True(t, found)
require.IsType(t, &Namespace{}, ns.Context())
}

36
tpl/reflect/reflect.go Normal file
View file

@ -0,0 +1,36 @@
// 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 reflect
import (
"reflect"
)
// New returns a new instance of the reflect-namespaced template functions.
func New() *Namespace {
return &Namespace{}
}
// Namespace provides template functions for the "reflect" namespace.
type Namespace struct{}
// IsMap reports whether v is a map.
func (ns *Namespace) IsMap(v interface{}) bool {
return reflect.ValueOf(v).Kind() == reflect.Map
}
// IsSlice reports whether v is a slice.
func (ns *Namespace) IsSlice(v interface{}) bool {
return reflect.ValueOf(v).Kind() == reflect.Slice
}

View file

@ -0,0 +1,55 @@
// 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 reflect
import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
)
var ns = New()
type tstNoStringer struct{}
func TestIsMap(t *testing.T) {
for i, test := range []struct {
v interface{}
expect interface{}
}{
{map[int]int{1: 1}, true},
{"foo", false},
{nil, false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
result := ns.IsMap(test.v)
assert.Equal(t, test.expect, result, errMsg)
}
}
func TestIsSlice(t *testing.T) {
for i, test := range []struct {
v interface{}
expect interface{}
}{
{[]int{1, 2}, true},
{"foo", false},
{nil, false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
result := ns.IsSlice(test.v)
assert.Equal(t, test.expect, result, errMsg)
}
}