}
}
- switch x.Kind() {
- case reflect.String:
- return x.String()
- case reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8, reflect.Int:
- return x.Int()
- default:
- return x
- }
+ return x.Interface()
}
// for testing (mostly), so any change here will break tests!
var params interface{}
switch v := sc.params.(type) {
- case map[string]string:
+ case map[string]interface{}:
// sort the keys so test assertions won't fail
var keys []string
for k := range v {
keys = append(keys, k)
}
sort.Strings(keys)
- var tmp = make([]string, len(keys))
+ var tmp = make(map[string]interface{})
- for i, k := range keys {
- tmp[i] = k + ":" + v[k]
+ for _, k := range keys {
+ tmp[k] = v[k]
}
params = tmp
} else if pt.Peek().IsShortcodeParamVal() {
// named params
if sc.params == nil {
- params := make(map[string]string)
- params[currItem.ValStr()] = pt.Next().ValStr()
+ params := make(map[string]interface{})
+ params[currItem.ValStr()] = pt.Next().ValTyped()
sc.params = params
} else {
- if params, ok := sc.params.(map[string]string); ok {
- params[currItem.ValStr()] = pt.Next().ValStr()
+ if params, ok := sc.params.(map[string]interface{}); ok {
+ params[currItem.ValStr()] = pt.Next().ValTyped()
} else {
return sc, errShortCodeIllegalState
}
} else {
// positional params
if sc.params == nil {
- var params []string
- params = append(params, currItem.ValStr())
+ var params []interface{}
+ params = append(params, currItem.ValTyped())
sc.params = params
} else {
- if params, ok := sc.params.([]string); ok {
- params = append(params, currItem.ValStr())
+ if params, ok := sc.params.([]interface{}); ok {
+ params = append(params, currItem.ValTyped())
sc.params = params
} else {
return sc, errShortCodeIllegalState
)
func CheckShortCodeMatch(t *testing.T, input, expected string, withTemplate func(templ tpl.TemplateHandler) error) {
+ t.Helper()
CheckShortCodeMatchAndError(t, input, expected, withTemplate, false)
}
func CheckShortCodeMatchAndError(t *testing.T, input, expected string, withTemplate func(templ tpl.TemplateHandler) error, expectError bool) {
-
+ t.Helper()
cfg, fs := newTestCfg()
c := qt.New(t)
"test/hello: test/hello",
)
}
+
+func TestShortcodeTypedParams(t *testing.T) {
+ t.Parallel()
+ c := qt.New(t)
+
+ builder := newTestSitesBuilder(t).WithSimpleConfigFile()
+
+ builder.WithContent("page.md", `---
+title: "Hugo Rocks!"
+---
+
+# doc
+
+types positional: {{< hello true false 33 3.14 >}}
+types named: {{< hello b1=true b2=false i1=33 f1=3.14 >}}
+types string: {{< hello "true" trues "33" "3.14" >}}
+
+
+`).WithTemplatesAdded(
+ "layouts/shortcodes/hello.html",
+ `{{ range $i, $v := .Params }}
+- {{ printf "%v: %v (%T)" $i $v $v }}
+{{ end }}
+{{ $b1 := .Get "b1" }}
+Get: {{ printf "%v (%T)" $b1 $b1 | safeHTML }}
+`).Build(BuildCfg{})
+
+ s := builder.H.Sites[0]
+ c.Assert(len(s.RegularPages()), qt.Equals, 1)
+
+ builder.AssertFileContent("public/page/index.html",
+ "types positional: - 0: true (bool) - 1: false (bool) - 2: 33 (int) - 3: 3.14 (float64)",
+ "types named: - b1: true (bool) - b2: false (bool) - f1: 3.14 (float64) - i1: 33 (int) Get: true (bool) ",
+ "types string: - 0: true (string) - 1: trues (string) - 2: 33 (string) - 3: 3.14 (string) ",
+ )
+}
import (
"bytes"
"fmt"
+ "regexp"
+ "strconv"
)
type Item struct {
- Type ItemType
- Pos int
- Val []byte
+ Type ItemType
+ Pos int
+ Val []byte
+ isString bool
}
type Items []Item
return string(i.Val)
}
+func (i Item) ValTyped() interface{} {
+ str := i.ValStr()
+ if i.isString {
+ // A quoted value that is a string even if it looks like a number etc.
+ return str
+ }
+
+ if boolRe.MatchString(str) {
+ return str == "true"
+ }
+
+ if intRe.MatchString(str) {
+ num, err := strconv.Atoi(str)
+ if err != nil {
+ return str
+ }
+ return num
+ }
+
+ if floatRe.MatchString(str) {
+ num, err := strconv.ParseFloat(str, 64)
+ if err != nil {
+ return str
+ }
+ return num
+ }
+
+ return str
+}
+
func (i Item) IsText() bool {
return i.Type == tText
}
// preserved for later - keywords come after this
tKeywordMarker
)
+
+var (
+ boolRe = regexp.MustCompile(`^(true$)|(false$)`)
+ intRe = regexp.MustCompile(`^[-+]?\d+$`)
+ floatRe = regexp.MustCompile(`^[-+]?\d*\.\d+$`)
+)
--- /dev/null
+// Copyright 2019 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 pageparser
+
+import (
+ "testing"
+
+ qt "github.com/frankban/quicktest"
+)
+
+func TestItemValTyped(t *testing.T) {
+ c := qt.New(t)
+
+ c.Assert(Item{Val: []byte("3.14")}.ValTyped(), qt.Equals, float64(3.14))
+ c.Assert(Item{Val: []byte(".14")}.ValTyped(), qt.Equals, float64(.14))
+ c.Assert(Item{Val: []byte("314")}.ValTyped(), qt.Equals, 314)
+ c.Assert(Item{Val: []byte("314x")}.ValTyped(), qt.Equals, "314x")
+ c.Assert(Item{Val: []byte("314 ")}.ValTyped(), qt.Equals, "314 ")
+ c.Assert(Item{Val: []byte("314"), isString: true}.ValTyped(), qt.Equals, "314")
+ c.Assert(Item{Val: []byte("true")}.ValTyped(), qt.Equals, true)
+ c.Assert(Item{Val: []byte("false")}.ValTyped(), qt.Equals, false)
+ c.Assert(Item{Val: []byte("trues")}.ValTyped(), qt.Equals, "trues")
+
+}
// sends an item back to the client.
func (l *pageLexer) emit(t ItemType) {
- l.items = append(l.items, Item{t, l.start, l.input[l.start:l.pos]})
+ l.items = append(l.items, Item{t, l.start, l.input[l.start:l.pos], false})
+ l.start = l.pos
+}
+
+// sends a string item back to the client.
+func (l *pageLexer) emitString(t ItemType) {
+ l.items = append(l.items, Item{t, l.start, l.input[l.start:l.pos], true})
l.start = l.pos
}
}
// special case, do not send '\\' back to client
-func (l *pageLexer) ignoreEscapesAndEmit(t ItemType) {
+func (l *pageLexer) ignoreEscapesAndEmit(t ItemType, isString bool) {
val := bytes.Map(func(r rune) rune {
if r == '\\' {
return -1
}
return r
}, l.input[l.start:l.pos])
- l.items = append(l.items, Item{t, l.start, val})
+ l.items = append(l.items, Item{t, l.start, val, isString})
l.start = l.pos
}
// nil terminates the parser
func (l *pageLexer) errorf(format string, args ...interface{}) stateFunc {
- l.items = append(l.items, Item{tError, l.start, []byte(fmt.Sprintf(format, args...))})
+ l.items = append(l.items, Item{tError, l.start, []byte(fmt.Sprintf(format, args...)), true})
return nil
}
}
}
+func (l *pageLexer) consumeToSpace() {
+ for {
+ r := l.next()
+ if r == eof || unicode.IsSpace(r) {
+ l.backup()
+ return
+ }
+ }
+}
+
func (l *pageLexer) consumeSpace() {
for {
r := l.next()
break
}
- if !isAlphaNumericOrHyphen(r) {
+ if !isAlphaNumericOrHyphen(r) && r != '.' { // Floats have period
l.backup()
break
}
}
+func lexShortcodeParamVal(l *pageLexer) stateFunc {
+ l.consumeToSpace()
+ l.emit(tScParamVal)
+ return lexInsideShortcode
+}
+
func lexShortcodeQuotedParamVal(l *pageLexer, escapedQuotedValuesAllowed bool, typ ItemType) stateFunc {
openQuoteFound := false
escapedInnerQuoteFound := false
}
if escapedInnerQuoteFound {
- l.ignoreEscapesAndEmit(typ)
+ l.ignoreEscapesAndEmit(typ, true)
} else {
- l.emit(typ)
+ l.emitString(typ)
}
r := l.next()
case isSpace(r), isEndOfLine(r):
l.ignore()
case r == '=':
+ l.consumeSpace()
l.ignore()
- return lexShortcodeQuotedParamVal(l, l.peek() != '\\', tScParamVal)
+ peek := l.peek()
+ if peek == '"' || peek == '\\' {
+ return lexShortcodeQuotedParamVal(l, peek != '\\', tScParamVal)
+ }
+ return lexShortcodeParamVal
case r == '/':
if l.currShortcodeName == "" {
return l.errorf("got closing shortcode, but none is open")
return t.l.Input()
}
-var errIndexOutOfBounds = Item{tError, 0, []byte("no more tokens")}
+var errIndexOutOfBounds = Item{tError, 0, []byte("no more tokens"), true}
// Current will repeatably return the current item.
func (t *Iterator) Current() Item {
}
func nti(tp ItemType, val string) Item {
- return Item{tp, 0, []byte(val)}
+ return Item{tp, 0, []byte(val), false}
}
var (
if i1[k].Type != i2[k].Type {
return false
}
+
if !reflect.DeepEqual(i1[k].Val, i2[k].Val) {
return false
}
import "testing"
var (
- tstEOF = nti(tEOF, "")
- tstLeftNoMD = nti(tLeftDelimScNoMarkup, "{{<")
- tstRightNoMD = nti(tRightDelimScNoMarkup, ">}}")
- tstLeftMD = nti(tLeftDelimScWithMarkup, "{{%")
- tstRightMD = nti(tRightDelimScWithMarkup, "%}}")
- tstSCClose = nti(tScClose, "/")
- tstSC1 = nti(tScName, "sc1")
- tstSC1Inline = nti(tScNameInline, "sc1.inline")
- tstSC2Inline = nti(tScNameInline, "sc2.inline")
- tstSC2 = nti(tScName, "sc2")
- tstSC3 = nti(tScName, "sc3")
- tstSCSlash = nti(tScName, "sc/sub")
- tstParam1 = nti(tScParam, "param1")
- tstParam2 = nti(tScParam, "param2")
- tstVal = nti(tScParamVal, "Hello World")
- tstText = nti(tText, "Hello World")
+ tstEOF = nti(tEOF, "")
+ tstLeftNoMD = nti(tLeftDelimScNoMarkup, "{{<")
+ tstRightNoMD = nti(tRightDelimScNoMarkup, ">}}")
+ tstLeftMD = nti(tLeftDelimScWithMarkup, "{{%")
+ tstRightMD = nti(tRightDelimScWithMarkup, "%}}")
+ tstSCClose = nti(tScClose, "/")
+ tstSC1 = nti(tScName, "sc1")
+ tstSC1Inline = nti(tScNameInline, "sc1.inline")
+ tstSC2Inline = nti(tScNameInline, "sc2.inline")
+ tstSC2 = nti(tScName, "sc2")
+ tstSC3 = nti(tScName, "sc3")
+ tstSCSlash = nti(tScName, "sc/sub")
+ tstParam1 = nti(tScParam, "param1")
+ tstParam2 = nti(tScParam, "param2")
+ tstParamBoolTrue = nti(tScParam, "true")
+ tstParamBoolFalse = nti(tScParam, "false")
+ tstParamInt = nti(tScParam, "32")
+ tstParamFloat = nti(tScParam, "3.14")
+ tstVal = nti(tScParamVal, "Hello World")
+ tstText = nti(tText, "Hello World")
)
var shortCodeLexerTests = []lexerTest{
{"close with extra keyword", `{{< sc1 >}}{{< /sc1 keyword>}}`, []Item{
tstLeftNoMD, tstSC1, tstRightNoMD, tstLeftNoMD, tstSCClose, tstSC1,
nti(tError, "unclosed shortcode")}},
+ {"float param, positional", `{{< sc1 3.14 >}}`, []Item{
+ tstLeftNoMD, tstSC1, nti(tScParam, "3.14"), tstRightNoMD, tstEOF}},
+ {"float param, named", `{{< sc1 param1=3.14 >}}`, []Item{
+ tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, "3.14"), tstRightNoMD, tstEOF}},
+ {"float param, named, space before", `{{< sc1 param1= 3.14 >}}`, []Item{
+ tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, "3.14"), tstRightNoMD, tstEOF}},
{"Youtube id", `{{< sc1 -ziL-Q_456igdO-4 >}}`, []Item{
tstLeftNoMD, tstSC1, nti(tScParam, "-ziL-Q_456igdO-4"), tstRightNoMD, tstEOF}},
{"non-alphanumerics param quoted", `{{< sc1 "-ziL-.%QigdO-4" >}}`, []Item{
{{- if $pc.Simple -}}
{{ template "_internal/shortcodes/twitter_simple.html" . }}
{{- else -}}
-{{- $url := printf "https://api.twitter.com/1/statuses/oembed.json?id=%s&dnt=%t" (index .Params 0) $pc.EnableDNT -}}
+{{- $url := printf "https://api.twitter.com/1/statuses/oembed.json?id=%v&dnt=%t" (index .Params 0) $pc.EnableDNT -}}
{{- $json := getJSON $url -}}
{{ $json.html | safeHTML }}
{{- end -}}
{{- if $pc.Simple -}}
{{ template "_internal/shortcodes/twitter_simple.html" . }}
{{- else -}}
-{{- $url := printf "https://api.twitter.com/1/statuses/oembed.json?id=%s&dnt=%t" (index .Params 0) $pc.EnableDNT -}}
+{{- $url := printf "https://api.twitter.com/1/statuses/oembed.json?id=%v&dnt=%t" (index .Params 0) $pc.EnableDNT -}}
{{- $json := getJSON $url -}}
{{ $json.html | safeHTML }}
{{- end -}}
s string
of string
)
- switch v := args.(type) {
+
+ v := args
+ if _, ok := v.([]interface{}); ok {
+ v = cast.ToStringSlice(v)
+ }
+
+ switch v := v.(type) {
case map[string]interface{}:
return v, nil
case map[string]string:
}
}
+
return map[string]interface{}{
"path": s,
"outputFormat": of,
projects / brevno-suite / hugo / commitdiff