Adding support for more front matter types (int, float & date)

diff --git a/hugolib/metadata.go b/hugolib/metadata.go
index 3441a991a4a84b733328b7c2db96ecd41c5f6f84..222edf109ff245311d94fe550ed075ca6b53f944 100644 (file)
--- a/hugolib/metadata.go
+++ b/hugolib/metadata.go
@@ -70,10 +70,40 @@ func interfaceArrayToStringArray(i interface{}) []string {
        return a
 }
 
+func interfaceToFloat64(i interface{}) float64 {
+       switch s := i.(type) {
+       case float64:
+               return s
+       case float32:
+               return float64(s)
+
+       case string:
+               v, err := strconv.ParseFloat(s, 64)
+               if err == nil {
+                       return float64(v)
+               } else {
+                       errorf("Only Floats are supported for this key\nErr:", err)
+               }
+
+       default:
+               errorf("Only Floats are supported for this key")
+       }
+
+       return 0.0
+}
+
 func interfaceToInt(i interface{}) int {
        switch s := i.(type) {
        case int:
                return s
+       case int64:
+               return int(s)
+       case int32:
+               return int(s)
+       case int16:
+               return int(s)
+       case int8:
+               return int(s)
        case string:
                v, err := strconv.ParseInt(s, 0, 0)
                if err == nil {
@@ -88,12 +118,23 @@ func interfaceToInt(i interface{}) int {
        return 0
 }
 
+func interfaceToTime(i interface{}) time.Time {
+       switch s := i.(type) {
+       case time.Time:
+               return s
+       default:
+               errorf("Only Time is supported for this key")
+       }
+
+       return *new(time.Time)
+}
+
 func interfaceToString(i interface{}) string {
        switch s := i.(type) {
        case string:
                return s
        default:
-               errorf("Only Strings are supported for this YAML key")
+               errorf("Only Strings are supported for this key")
        }
 
        return ""

diff --git a/hugolib/page.go b/hugolib/page.go
index 313503a7a771df6221e4c3326d4a05c914f5af2d..4acd902f2fee2f237a9b1138c3be924f6bee7cb1 100644 (file)
--- a/hugolib/page.go
+++ b/hugolib/page.go
@@ -330,7 +330,8 @@ func (page *Page) update(f interface{}) error {
        m := f.(map[string]interface{})
 
        for k, v := range m {
-               switch strings.ToLower(k) {
+               loki := strings.ToLower(k)
+               switch loki {
                case "title":
                        page.Title = interfaceToString(v)
                case "description":
@@ -368,8 +369,14 @@ func (page *Page) update(f interface{}) error {
                default:
                        // If not one of the explicit values, store in Params
                        switch vv := v.(type) {
-                       case string: // handle string values
-                               page.Params[strings.ToLower(k)] = vv
+                       case string:
+                               page.Params[loki] = vv
+                       case int64, int32, int16, int8, int:
+                               page.Params[loki] = vv
+                       case float64, float32:
+                               page.Params[loki] = vv
+                       case time.Time:
+                               page.Params[loki] = vv
                        default: // handle array of strings as well
                                switch vvv := vv.(type) {
                                case []interface{}:
@@ -396,6 +403,12 @@ func (page *Page) GetParam(key string) interface{} {
        switch v.(type) {
        case string:
                return interfaceToString(v)
+       case int64, int32, int16, int8, int:
+               return interfaceToInt(v)
+       case float64, float32:
+               return interfaceToFloat64(v)
+       case time.Time:
+               return interfaceToTime(v)
        case []string:
                return v
        }

diff --git a/hugolib/page_test.go b/hugolib/page_test.go
index 01737c4ff758d808b79b2ae32dc33e0aa9a6d3a9..2a62e35ab72aadd19ba1578fd0569655171c14f5 100644 (file)
--- a/hugolib/page_test.go
+++ b/hugolib/page_test.go
@@ -141,6 +141,14 @@ Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor
 `
 )
 
+var PAGE_WITH_VARIOUS_FRONTMATTER_TYPES = `+++
+a_string = "bar"
+an_integer = 1
+a_float = 1.3
+a_date = 1979-05-27T07:32:00Z
++++
+Front Matter with various frontmatter types`
+
 func checkError(t *testing.T, err error, expected string) {
        if err == nil {
                t.Fatalf("err is nil.  Expected: %s", expected)
@@ -332,6 +340,24 @@ func TestShouldRenderContent(t *testing.T) {
        }
 }
 
+func TestDifferentFrontMatterVarTypes(t *testing.T) {
+       page, _ := ReadFrom(strings.NewReader(PAGE_WITH_VARIOUS_FRONTMATTER_TYPES), "test/file1.md")
+
+       dateval, _ := time.Parse(time.RFC3339, "1979-05-27T07:32:00Z")
+       if page.GetParam("a_string") != "bar" {
+               t.Errorf("frontmatter not handling strings correctly should be %s, got: %s", "bar", page.GetParam("a_string"))
+       }
+       if page.GetParam("an_integer") != 1 {
+               t.Errorf("frontmatter not handling ints correctly should be %s, got: %s", "1", page.GetParam("an_integer"))
+       }
+       if page.GetParam("a_float") != 1.3 {
+               t.Errorf("frontmatter not handling floats correctly should be %s, got: %s", 1.3, page.GetParam("a_float"))
+       }
+       if page.GetParam("a_date") != dateval {
+               t.Errorf("frontmatter not handling dates correctly should be %s, got: %s", dateval, page.GetParam("a_date"))
+       }
+}
+
 func TestDegenerateInvalidFrontMatterLeadingWhitespace(t *testing.T) {
        _, err := ReadFrom(strings.NewReader(INVALID_FRONT_MATTER_LEADING_WS), "invalid/front/matter/leading/ws")
        if err != nil {