Permalink
Browse files

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
  • Loading branch information...
moorereason authored and bep committed Dec 7, 2018
1 parent 4b5f743 commit c84f506f8ef1f2ca94ab96718a22ba6e290235ac
@@ -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
```
@@ -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
```
@@ -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)
}
@@ -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())
}
@@ -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
}
@@ -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)
}
}

0 comments on commit c84f506

Please sign in to comment.