From 6e1b0e0c00ced52979b8629161e36e45d51a47e6 Mon Sep 17 00:00:00 2001 From: bep Date: Thu, 5 Mar 2015 23:19:10 +0100 Subject: [PATCH] Apply gofmt -s --- create/content.go | 4 ++-- hugolib/shortcodeparser_test.go | 28 ++++++++++++++-------------- hugolib/siteinfo_test.go | 2 +- source/content_directory_test.go | 4 ++-- tpl/template_test.go | 28 ++++++++++++++-------------- utils/utils.go | 6 +++--- utils/utils_test.go | 18 ++++++++---------- 7 files changed, 44 insertions(+), 46 deletions(-) diff --git a/create/content.go b/create/content.go index fa37f2666..acb788c63 100644 --- 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 8ebb85d66..46b843936 100644 --- 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", `{{}}`, []item{ - item{tText, 0, "{{<"}, item{tText, 0, " sc1 "}, item{tText, 0, ">}}"}, tstEOF}}, + {tText, 0, "{{<"}, {tText, 0, " sc1 "}, {tText, 0, ">}}"}, tstEOF}}, {"commented out, missing close", `{{}}`, []item{ {tError, 0, "comment must be closed"}}}, {"commented out, misplaced close", `{{}}*/`, []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 562cfa0dd..7db714d9f 100644 --- 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 aab3410bb..8f0b21edf 100644 --- 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 6fe1c9328..110f6742c 100644 --- 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 eaa6c09a9..ea89ec745 100644 --- 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 0bb92dea8..7c47ef970 100644 --- 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 {