helpers: apply some Golint rules - hugo - [fork] hugo port for 9front
 (HTM) git clone git@git.drkhsh.at/hugo.git
 (DIR) Log
 (DIR) Files
 (DIR) Refs
 (DIR) Submodules
 (DIR) README
 (DIR) LICENSE
       ---
 (DIR) commit bd2b679eaf45669e23a724a5dacd5421c5ec61e1
 (DIR) parent e685dfc0c607b3051dbac29e1209900e58de1605
 (HTM) Author: bep <bjorn.erik.pedersen@gmail.com>
       Date:   Sat,  7 Mar 2015 00:02:06 +0100
       
       helpers: apply some Golint rules
       
       Diffstat:
         M helpers/general.go                  |       5 +++--
         M helpers/general_test.go             |       6 +++---
         M helpers/path.go                     |      27 +++++++++++----------------
         M helpers/url.go                      |      45 +++++++++++++++-----------------
       
       4 files changed, 38 insertions(+), 45 deletions(-)
       ---
 (DIR) diff --git a/helpers/general.go b/helpers/general.go
       @@ -31,6 +31,7 @@ import (
        // Filepath separator defined by os.Separator.
        const FilePathSeparator = string(filepath.Separator)
        
       +// FindAvailablePort returns an available and valid TCP port.
        func FindAvailablePort() (*net.TCPAddr, error) {
                l, err := net.Listen("tcp", ":0")
                if err == nil {
       @@ -100,6 +101,7 @@ func BytesToReader(in []byte) io.Reader {
                return bytes.NewReader(in)
        }
        
       +// ThemeSet checks whether a theme is in use or not.
        func ThemeSet() bool {
                return viper.GetString("theme") != ""
        }
       @@ -193,9 +195,8 @@ func DoArithmetic(a, b interface{}, op rune) (interface{}, error) {
                        if bv.Kind() == reflect.String && op == '+' {
                                bs := bv.String()
                                return as + bs, nil
       -                } else {
       -                        return nil, errors.New("Can't apply the operator to the values")
                        }
       +                return nil, errors.New("Can't apply the operator to the values")
                default:
                        return nil, errors.New("Can't apply the operator to the values")
                }
 (DIR) diff --git a/helpers/general_test.go b/helpers/general_test.go
       @@ -110,13 +110,13 @@ func TestSliceToLowerNonDestructive(t *testing.T) {
                // This assignment actually copies the content
                // of input into a new object.
                // Otherwise, the test would not make sense...
       -        input_copy := input
       +        inputCopy := input
        
                SliceToLower(input)
        
                for i, e := range input {
       -                if e != input_copy[i] {
       -                        t.Errorf("TestSliceToLowerNonDestructive failed. Expected element #%d of input slice to be %s. Found %s.", i, input_copy[i], input[i])
       +                if e != inputCopy[i] {
       +                        t.Errorf("TestSliceToLowerNonDestructive failed. Expected element #%d of input slice to be %s. Found %s.", i, inputCopy[i], input[i])
                        }
                }
        }
 (DIR) diff --git a/helpers/path.go b/helpers/path.go
       @@ -28,7 +28,7 @@ import (
                "github.com/spf13/viper"
        )
        
       -// Bridge for common functionality in filepath vs path
       +// FilepathPathBridge is a bridge for common functionality in filepath vs path
        type FilepathPathBridge interface {
                Base(in string) string
                Clean(in string) string
       @@ -149,9 +149,8 @@ func IsEmpty(path string, fs afero.Fs) (bool, error) {
                        list, err := f.Readdir(-1)
                        // f.Close() - see bug fix above
                        return len(list) == 0, nil
       -        } else {
       -                return fi.Size() == 0, nil
                }
       +        return fi.Size() == 0, nil
        }
        
        // Check if a file or directory exists.
       @@ -317,9 +316,8 @@ func GuessSection(in string) string {
                if parts[0] == "content" {
                        if len(parts) > 2 {
                                return parts[1]
       -                } else {
       -                        return ""
                        }
       +                return ""
                }
        
                return parts[0]
       @@ -328,9 +326,8 @@ func GuessSection(in string) string {
        func PathPrep(ugly bool, in string) string {
                if ugly {
                        return Uglify(in)
       -        } else {
       -                return PrettifyPath(in)
                }
       +        return PrettifyPath(in)
        }
        
        // Same as PrettifyUrlPath() but for file paths.
       @@ -348,16 +345,14 @@ func PrettiyPath(in string, b FilepathPathBridge) string {
                                return b.Separator()
                        }
                        return b.Join(b.Clean(in), "index.html")
       -        } else {
       -                name, ext := FileAndExt(in, b)
       -                if name == "index" {
       -                        // /section/name/index.html -> /section/name/index.html
       -                        return b.Clean(in)
       -                } else {
       -                        // /section/name.html -> /section/name/index.html
       -                        return b.Join(b.Dir(in), name, "index"+ext)
       -                }
                }
       +        name, ext := FileAndExt(in, b)
       +        if name == "index" {
       +                // /section/name/index.html -> /section/name/index.html
       +                return b.Clean(in)
       +        }
       +        // /section/name.html -> /section/name/index.html
       +        return b.Join(b.Dir(in), name, "index"+ext)
        }
        
        // FindCWD returns the current working directory from where the Hugo
 (DIR) diff --git a/helpers/url.go b/helpers/url.go
       @@ -172,18 +172,17 @@ func UrlPrep(ugly bool, in string) string {
                if ugly {
                        x := Uglify(SanitizeUrl(in))
                        return x
       -        } else {
       -                x := PrettifyUrl(SanitizeUrl(in))
       -                if path.Ext(x) == ".xml" {
       -                        return x
       -                }
       -                url, err := purell.NormalizeURLString(x, purell.FlagAddTrailingSlash)
       -                if err != nil {
       -                        fmt.Printf("ERROR returned by NormalizeURLString. Returning in = %q\n", in)
       -                        return in
       -                }
       -                return url
                }
       +        x := PrettifyUrl(SanitizeUrl(in))
       +        if path.Ext(x) == ".xml" {
       +                return x
       +        }
       +        url, err := purell.NormalizeURLString(x, purell.FlagAddTrailingSlash)
       +        if err != nil {
       +                fmt.Printf("ERROR returned by NormalizeURLString. Returning in = %q\n", in)
       +                return in
       +        }
       +        return url
        }
        
        // PrettifyUrl takes a URL string and returns a semantic, clean URL.
       @@ -221,19 +220,17 @@ func Uglify(in string) string {
                        }
                        // /section/name/  -> /section/name.html
                        return path.Clean(in) + ".html"
       -        } else {
       -                name, ext := FileAndExt(in, pathBridge)
       -                if name == "index" {
       -                        // /section/name/index.html -> /section/name.html
       -                        d := path.Dir(in)
       -                        if len(d) > 1 {
       -                                return d + ext
       -                        } else {
       -                                return in
       -                        }
       -                } else {
       -                        // /section/name.html -> /section/name.html
       -                        return path.Clean(in)
       +        }
       +
       +        name, ext := FileAndExt(in, pathBridge)
       +        if name == "index" {
       +                // /section/name/index.html -> /section/name.html
       +                d := path.Dir(in)
       +                if len(d) > 1 {
       +                        return d + ext
                        }
       +                return in
                }
       +        // /section/name.html -> /section/name.html
       +        return path.Clean(in)
        }