Apply gofmt -s

diff --git a/create/content.go b/create/content.go
index fa37f266649924f3e2356ecda38c76b7351129fd..acb788c631d98063de759f99bc7ef80e0c125289 100644 (file)
--- a/create/content.go
+++ b/create/content.go
@@ -63,7 +63,7 @@ func NewContent(kind, name string) (err error) {
                return err
        }
 
-       for k, _ := range newmetadata {
+       for k := range newmetadata {
                switch strings.ToLower(k) {
                case "date":
                        newmetadata[k] = time.Now()
@@ -73,7 +73,7 @@ func NewContent(kind, name string) (err error) {
        }
 
        caseimatch := func(m map[string]interface{}, key string) bool {
-               for k, _ := range m {
+               for k := range m {
                        if strings.ToLower(k) == strings.ToLower(key) {
                                return true
                        }

diff --git a/hugolib/shortcodeparser_test.go b/hugolib/shortcodeparser_test.go
index 8ebb85d665353baffd14fb2645fafe0136d7d370..46b843936f2f41262efa1ff6e1e3f63eb05b86e3 100644 (file)
--- a/hugolib/shortcodeparser_test.go
+++ b/hugolib/shortcodeparser_test.go
@@ -59,9 +59,9 @@ var shortCodeLexerTests = []shortCodeLexerTest{
                tstLeftNoMD, tstSC1, tstRightNoMD, tstLeftNoMD, tstSCClose, tstSC1,
                {tError, 0, "unclosed shortcode"}}},
        {"Youtube id", `{{< sc1 -ziL-Q_456igdO-4 >}}`, []item{
-               tstLeftNoMD, tstSC1, item{tScParam, 0, "-ziL-Q_456igdO-4"}, tstRightNoMD, tstEOF}},
+               tstLeftNoMD, tstSC1, {tScParam, 0, "-ziL-Q_456igdO-4"}, tstRightNoMD, tstEOF}},
        {"non-alphanumerics param quoted", `{{< sc1 "-ziL-.%QigdO-4" >}}`, []item{
-               tstLeftNoMD, tstSC1, item{tScParam, 0, "-ziL-.%QigdO-4"}, tstRightNoMD, tstEOF}},
+               tstLeftNoMD, tstSC1, {tScParam, 0, "-ziL-.%QigdO-4"}, tstRightNoMD, tstEOF}},
 
        {"two params", `{{< sc1 param1   param2 >}}`, []item{
                tstLeftNoMD, tstSC1, tstParam1, tstParam2, tstRightNoMD, tstEOF}},
@@ -74,21 +74,21 @@ var shortCodeLexerTests = []shortCodeLexerTest{
                tstLeftNoMD, tstSCClose, tstSC1, tstRightNoMD, tstEOF}},
        {"nested complex", `{{< sc1 >}}ab{{% sc2 param1 %}}cd{{< sc3 >}}ef{{< /sc3 >}}gh{{% /sc2 %}}ij{{< /sc1 >}}kl`, []item{
                tstLeftNoMD, tstSC1, tstRightNoMD,
-               item{tText, 0, "ab"},
+               {tText, 0, "ab"},
                tstLeftMD, tstSC2, tstParam1, tstRightMD,
-               item{tText, 0, "cd"},
+               {tText, 0, "cd"},
                tstLeftNoMD, tstSC3, tstRightNoMD,
-               item{tText, 0, "ef"},
+               {tText, 0, "ef"},
                tstLeftNoMD, tstSCClose, tstSC3, tstRightNoMD,
-               item{tText, 0, "gh"},
+               {tText, 0, "gh"},
                tstLeftMD, tstSCClose, tstSC2, tstRightMD,
-               item{tText, 0, "ij"},
+               {tText, 0, "ij"},
                tstLeftNoMD, tstSCClose, tstSC1, tstRightNoMD,
-               item{tText, 0, "kl"}, tstEOF,
+               {tText, 0, "kl"}, tstEOF,
        }},
 
        {"two quoted params", `{{< sc1 "param nr. 1" "param nr. 2" >}}`, []item{
-               tstLeftNoMD, tstSC1, item{tScParam, 0, "param nr. 1"}, item{tScParam, 0, "param nr. 2"}, tstRightNoMD, tstEOF}},
+               tstLeftNoMD, tstSC1, {tScParam, 0, "param nr. 1"}, {tScParam, 0, "param nr. 2"}, tstRightNoMD, tstEOF}},
        {"two named params", `{{< sc1 param1="Hello World" param2="p2Val">}}`, []item{
                tstLeftNoMD, tstSC1, tstParam1, tstVal, tstParam2, {tScParamVal, 0, "p2Val"}, tstRightNoMD, tstEOF}},
        {"escaped quotes", `{{< sc1 param1=\"Hello World\"  >}}`, []item{
@@ -97,13 +97,13 @@ var shortCodeLexerTests = []shortCodeLexerTest{
                tstLeftNoMD, tstSC1, tstParam1, tstRightNoMD, tstEOF}},
        {"escaped quotes inside escaped quotes", `{{< sc1 param1=\"Hello \"escaped\" World\"  >}}`, []item{
                tstLeftNoMD, tstSC1, tstParam1,
-               item{tScParamVal, 0, `Hello `}, {tError, 0, `got positional parameter 'escaped'. Cannot mix named and positional parameters`}}},
+               {tScParamVal, 0, `Hello `}, {tError, 0, `got positional parameter 'escaped'. Cannot mix named and positional parameters`}}},
        {"escaped quotes inside nonescaped quotes",
                `{{< sc1 param1="Hello \"escaped\" World"  >}}`, []item{
-                       tstLeftNoMD, tstSC1, tstParam1, item{tScParamVal, 0, `Hello "escaped" World`}, tstRightNoMD, tstEOF}},
+                       tstLeftNoMD, tstSC1, tstParam1, {tScParamVal, 0, `Hello "escaped" World`}, tstRightNoMD, tstEOF}},
        {"escaped quotes inside nonescaped quotes in positional param",
                `{{< sc1 "Hello \"escaped\" World"  >}}`, []item{
-                       tstLeftNoMD, tstSC1, item{tScParam, 0, `Hello "escaped" World`}, tstRightNoMD, tstEOF}},
+                       tstLeftNoMD, tstSC1, {tScParam, 0, `Hello "escaped" World`}, tstRightNoMD, tstEOF}},
        {"unterminated quote", `{{< sc1 param2="Hello World>}}`, []item{
                tstLeftNoMD, tstSC1, tstParam2, {tError, 0, "unterminated quoted string in shortcode parameter-argument: 'Hello World>}}'"}}},
        {"one named param, one not", `{{< sc1 param1="Hello World" p2 >}}`, []item{
@@ -119,11 +119,11 @@ var shortCodeLexerTests = []shortCodeLexerTest{
                tstLeftNoMD, tstSC1, tstParam1,
                {tError, 0, "got named parameter 'param2'. Cannot mix named and positional parameters"}}},
        {"commented out", `{{</* sc1 */>}}`, []item{
-               item{tText, 0, "{{<"}, item{tText, 0, " sc1 "}, item{tText, 0, ">}}"}, tstEOF}},
+               {tText, 0, "{{<"}, {tText, 0, " sc1 "}, {tText, 0, ">}}"}, tstEOF}},
        {"commented out, missing close", `{{</* sc1 >}}`, []item{
                {tError, 0, "comment must be closed"}}},
        {"commented out, misplaced close", `{{</* sc1 >}}*/`, []item{
-               item{tText, 0, "{{<"}, item{tText, 0, " sc1 >}}"}, {tError, 0, "comment ends before the right shortcode delimiter"}}},
+               {tText, 0, "{{<"}, {tText, 0, " sc1 >}}"}, {tError, 0, "comment ends before the right shortcode delimiter"}}},
 }
 
 func TestShortcodeLexer(t *testing.T) {

diff --git a/hugolib/siteinfo_test.go b/hugolib/siteinfo_test.go
index 562cfa0dd98d5465422b61d19a62a682ba33d36d..7db714d9fc7f1b4f345c8b735bd8e87f87caadbb 100644 (file)
--- a/hugolib/siteinfo_test.go
+++ b/hugolib/siteinfo_test.go
@@ -31,7 +31,7 @@ func TestSiteInfoParams(t *testing.T) {
        }
 }
 
-func TestSiteInfoPermalinks (t *testing.T) {
+func TestSiteInfoPermalinks(t *testing.T) {
        viper.Set("Permalinks", map[string]interface{}{"section": "/:title"})
        s := &Site{}
 

diff --git a/source/content_directory_test.go b/source/content_directory_test.go
index aab3410bbe76e18a90738ae4f9f081f50c62aaec..8f0b21edffefe6719faf7017c1cb106c254455f0 100644 (file)
--- a/source/content_directory_test.go
+++ b/source/content_directory_test.go
@@ -9,8 +9,8 @@ func TestIgnoreDotFilesAndDirectories(t *testing.T) {
                path   string
                ignore bool
        }{
-               {".foobar/", true },
-               {"foobar/.barfoo/", true },
+               {".foobar/", true},
+               {"foobar/.barfoo/", true},
                {"barfoo.md", false},
                {"foobar/barfoo.md", false},
                {"foobar/.barfoo.md", true},

diff --git a/tpl/template_test.go b/tpl/template_test.go
index 6fe1c93288a9b7aaca2b58a2ee83befb8690a8ac..110f6742c5c0d8dfe33608b0b29290d84a76ee46 100644 (file)
--- a/tpl/template_test.go
+++ b/tpl/template_test.go
@@ -474,38 +474,38 @@ func TestWhere(t *testing.T) {
                },
                {
                        sequence: []*map[int]string{
-                               &map[int]string{1: "a", 2: "m"}, &map[int]string{1: "c", 2: "d"}, &map[int]string{1: "e", 3: "m"},
+                               {1: "a", 2: "m"}, {1: "c", 2: "d"}, {1: "e", 3: "m"},
                        },
                        key: 2, match: "m",
                        expect: []*map[int]string{
-                               &map[int]string{1: "a", 2: "m"},
+                               {1: "a", 2: "m"},
                        },
                },
                {
                        sequence: []*TstX{
-                               &TstX{A: "a", B: "b"}, &TstX{A: "c", B: "d"}, &TstX{A: "e", B: "f"},
+                               {A: "a", B: "b"}, {A: "c", B: "d"}, {A: "e", B: "f"},
                        },
                        key: "B", match: "f",
                        expect: []*TstX{
-                               &TstX{A: "e", B: "f"},
+                               {A: "e", B: "f"},
                        },
                },
                {
                        sequence: []*TstX{
-                               &TstX{A: "a", B: "b"}, &TstX{A: "c", B: "d"}, &TstX{A: "e", B: "c"},
+                               {A: "a", B: "b"}, {A: "c", B: "d"}, {A: "e", B: "c"},
                        },
                        key: "TstRp", match: "rc",
                        expect: []*TstX{
-                               &TstX{A: "c", B: "d"},
+                               {A: "c", B: "d"},
                        },
                },
                {
                        sequence: []TstX{
-                               TstX{A: "a", B: "b"}, TstX{A: "c", B: "d"}, TstX{A: "e", B: "c"},
+                               {A: "a", B: "b"}, {A: "c", B: "d"}, {A: "e", B: "c"},
                        },
                        key: "TstRv", match: "rc",
                        expect: []TstX{
-                               TstX{A: "e", B: "c"},
+                               {A: "e", B: "c"},
                        },
                },
                {
@@ -738,19 +738,19 @@ func TestSort(t *testing.T) {
                {map[string]int{"3": 10, "2": 20, "1": 30, "4": 40, "5": 50}, "value", "asc", []interface{}{10, 20, 30, 40, 50}},
                // test map sorting by field value
                {
-                       map[string]ts{"1": ts{10, 10.5, "ten"}, "2": ts{20, 20.5, "twenty"}, "3": ts{30, 30.5, "thirty"}, "4": ts{40, 40.5, "forty"}, "5": ts{50, 50.5, "fifty"}},
+                       map[string]ts{"1": {10, 10.5, "ten"}, "2": {20, 20.5, "twenty"}, "3": {30, 30.5, "thirty"}, "4": {40, 40.5, "forty"}, "5": {50, 50.5, "fifty"}},
                        "MyInt",
                        "asc",
                        []interface{}{ts{10, 10.5, "ten"}, ts{20, 20.5, "twenty"}, ts{30, 30.5, "thirty"}, ts{40, 40.5, "forty"}, ts{50, 50.5, "fifty"}},
                },
                {
-                       map[string]ts{"1": ts{10, 10.5, "ten"}, "2": ts{20, 20.5, "twenty"}, "3": ts{30, 30.5, "thirty"}, "4": ts{40, 40.5, "forty"}, "5": ts{50, 50.5, "fifty"}},
+                       map[string]ts{"1": {10, 10.5, "ten"}, "2": {20, 20.5, "twenty"}, "3": {30, 30.5, "thirty"}, "4": {40, 40.5, "forty"}, "5": {50, 50.5, "fifty"}},
                        "MyFloat",
                        "asc",
                        []interface{}{ts{10, 10.5, "ten"}, ts{20, 20.5, "twenty"}, ts{30, 30.5, "thirty"}, ts{40, 40.5, "forty"}, ts{50, 50.5, "fifty"}},
                },
                {
-                       map[string]ts{"1": ts{10, 10.5, "ten"}, "2": ts{20, 20.5, "twenty"}, "3": ts{30, 30.5, "thirty"}, "4": ts{40, 40.5, "forty"}, "5": ts{50, 50.5, "fifty"}},
+                       map[string]ts{"1": {10, 10.5, "ten"}, "2": {20, 20.5, "twenty"}, "3": {30, 30.5, "thirty"}, "4": {40, 40.5, "forty"}, "5": {50, 50.5, "fifty"}},
                        "MyString",
                        "asc",
                        []interface{}{ts{50, 50.5, "fifty"}, ts{40, 40.5, "forty"}, ts{10, 10.5, "ten"}, ts{30, 30.5, "thirty"}, ts{20, 20.5, "twenty"}},
@@ -786,12 +786,12 @@ func TestReturnWhenSet(t *testing.T) {
                {[]uint{1, 2, 3}, 1, uint64(2)},
                {[]float64{1.1, 2.2, 3.3}, 1, float64(2.2)},
                {[]string{"foo", "bar", "baz"}, 1, "bar"},
-               {[]TstX{TstX{A: "a", B: "b"}, TstX{A: "c", B: "d"}, TstX{A: "e", B: "f"}}, 1, ""},
+               {[]TstX{{A: "a", B: "b"}, {A: "c", B: "d"}, {A: "e", B: "f"}}, 1, ""},
                {map[string]int{"foo": 1, "bar": 2, "baz": 3}, "bar", int64(2)},
                {map[string]uint{"foo": 1, "bar": 2, "baz": 3}, "bar", uint64(2)},
                {map[string]float64{"foo": 1.1, "bar": 2.2, "baz": 3.3}, "bar", float64(2.2)},
                {map[string]string{"foo": "FOO", "bar": "BAR", "baz": "BAZ"}, "bar", "BAR"},
-               {map[string]TstX{"foo": TstX{A: "a", B: "b"}, "bar": TstX{A: "c", B: "d"}, "baz": TstX{A: "e", B: "f"}}, "bar", ""},
+               {map[string]TstX{"foo": {A: "a", B: "b"}, "bar": {A: "c", B: "d"}, "baz": {A: "e", B: "f"}}, "bar", ""},
                {(*[]string)(nil), "bar", ""},
        } {
                result := ReturnWhenSet(this.data, this.key)
@@ -904,7 +904,7 @@ func TestTrim(t *testing.T) {
 func TestDateFormat(t *testing.T) {
        for i, this := range []struct {
                layout string
-               value interface{}
+               value  interface{}
                expect interface{}
        }{
                {"Monday, Jan 2, 2006", "2015-01-21", "Wednesday, Jan 21, 2015"},

diff --git a/utils/utils.go b/utils/utils.go
index eaa6c09a9ceb2b946ec284065f9115e388a15d4e..ea89ec7454ceeb6b0b555352d7b811a7a8abb9f6 100644 (file)
--- a/utils/utils.go
+++ b/utils/utils.go
@@ -45,13 +45,13 @@ func StopOnErr(err error, s ...string) {
 
 // cutUsageMessage splits the incoming string on the beginning of the usage
 // message text. Anything in the first element of the returned slice, trimmed
-// of its Unicode defined spaces, should be returned. The 2nd element of the 
+// of its Unicode defined spaces, should be returned. The 2nd element of the
 // slice will have the usage message  that we wish to elide.
 //
 // This is done because Cobra already prints Hugo's usage message; not eliding
-// would result in the usage output being printed twice, which leads to bug 
+// would result in the usage output being printed twice, which leads to bug
 // reports, more specifically: https://github.com/spf13/hugo/issues/374
 func cutUsageMessage(s string) string {
-       pieces :=  strings.Split(s, "Usage of") 
+       pieces := strings.Split(s, "Usage of")
        return strings.TrimSpace(pieces[0])
 }

diff --git a/utils/utils_test.go b/utils/utils_test.go
index 0bb92dea847ea5e932c836c11ec8053ee150a45a..7c47ef9708787b595f164ac0dd2ca3ba38a396dc 100644 (file)
--- a/utils/utils_test.go
+++ b/utils/utils_test.go
@@ -2,21 +2,19 @@ package utils
 
 import (
        "testing"
-       )
-
-
+)
 
 func TestCutUsageMessage(t *testing.T) {
-       tests := []struct{
-               message string
+       tests := []struct {
+               message    string
                cutMessage string
        }{
                {"", ""},
-                {" Usage of hugo: \n  -b, --baseUrl=...", ""},
-                {"Some error Usage of hugo: \n", "Some error"},
-                {"Usage of hugo: \n -b --baseU", ""},
-                {"CRITICAL error for usage of hugo ", "CRITICAL error for usage of hugo"},
-                {"Invalid short flag a in -abcde", "Invalid short flag a in -abcde"},
+               {" Usage of hugo: \n  -b, --baseUrl=...", ""},
+               {"Some error Usage of hugo: \n", "Some error"},
+               {"Usage of hugo: \n -b --baseU", ""},
+               {"CRITICAL error for usage of hugo ", "CRITICAL error for usage of hugo"},
+               {"Invalid short flag a in -abcde", "Invalid short flag a in -abcde"},
        }
 
        for _, test := range tests {