Add config option "disablePathToLower"

Enabling this prevents lowercasing of the path/url.

Fixes #557

diff --git a/commands/hugo.go b/commands/hugo.go
index 734dc38e3bf40697f559fcaef2150caa20e9906a..9e62924b30bd56f78382de71d4d0b565cdaf54c8 100644 (file)
--- a/commands/hugo.go
+++ b/commands/hugo.go
@@ -160,6 +160,7 @@ func LoadDefaultSettings() {
        viper.SetDefault("Blackfriday", helpers.NewBlackfriday())
        viper.SetDefault("RSSUri", "index.xml")
        viper.SetDefault("SectionPagesMenu", "")
+       viper.SetDefault("DisablePathToLower", false)
 }
 
 // InitializeConfig initializes a config file with sensible default configuration flags.

diff --git a/docs/content/overview/configuration.md b/docs/content/overview/configuration.md
index fc3d9b445d8bb7ae4a84782f44cdb8039f11dfd7..af1851b67a28aa1115649a4ed838486735e74531 100644 (file)
--- a/docs/content/overview/configuration.md
+++ b/docs/content/overview/configuration.md
@@ -133,6 +133,8 @@ Following is a list of Hugo-defined variables that you can configure and their c
     title:                      ""
     # if true, use /filename.html instead of /filename/
     uglyURLs:                   false
+    # Do not make the url/path to lowercase
+    disablePathToLower:         false
     # verbose output
     verbose:                    false
     # verbose logging

diff --git a/helpers/path.go b/helpers/path.go
index a9d488469cd6d267a8b9ab011a0bd081e2fe02a7..fc326247344fcdd7f0df437000428f3e90bc19d7 100644 (file)
--- a/helpers/path.go
+++ b/helpers/path.go
@@ -78,11 +78,13 @@ func MakePath(s string) string {
        return UnicodeSanitize(strings.Replace(strings.TrimSpace(s), " ", "-", -1))
 }
 
-// MakePathToLower creates a Unicode-sanitized string, with the spaces replaced,
-// and transformed to lower case.
-// E.g. Social Media -> social-media
-func MakePathToLower(s string) string {
-       return strings.ToLower(MakePath(s))
+// MakePathSanitized creates a Unicode-sanitized string, with the spaces replaced
+func MakePathSanitized(s string) string {
+       if viper.GetBool("DisablePathToLower") {
+               return MakePath(s)
+       } else {
+               return strings.ToLower(MakePath(s))
+       }
 }
 
 func MakeTitle(inpath string) string {

diff --git a/helpers/path_test.go b/helpers/path_test.go
index 85e4e0f107055428bb9c3cc4d2fa67173fbcebec..95171165f3c430243cb6e16ed14572eee3a8812e 100644 (file)
--- a/helpers/path_test.go
+++ b/helpers/path_test.go
@@ -42,7 +42,10 @@ func TestMakePath(t *testing.T) {
        }
 }
 
-func TestMakePathToLower(t *testing.T) {
+func TestMakePathSanitized(t *testing.T) {
+       viper.Reset()
+       defer viper.Reset()
+
        tests := []struct {
                input    string
                expected string
@@ -54,8 +57,34 @@ func TestMakePathToLower(t *testing.T) {
                {"трям/трям", "трям/трям"},
                {"은행", "은행"},
        }
+
+       for _, test := range tests {
+               output := MakePathSanitized(test.input)
+               if output != test.expected {
+                       t.Errorf("Expected %#v, got %#v\n", test.expected, output)
+               }
+       }
+}
+
+func TestMakePathSanitizedDisablePathToLower(t *testing.T) {
+       viper.Reset()
+       defer viper.Reset()
+       viper.Set("DisablePathToLower", true)
+
+       tests := []struct {
+               input    string
+               expected string
+       }{
+               {"  FOO bar  ", "FOO-bar"},
+               {"Foo.Bar/fOO_bAr-Foo", "Foo.Bar/fOO_bAr-Foo"},
+               {"FOO,bar:Foo%Bar", "FOObarFooBar"},
+               {"foo/BAR.HTML", "foo/BAR.HTML"},
+               {"трям/трям", "трям/трям"},
+               {"은행", "은행"},
+       }
+
        for _, test := range tests {
-               output := MakePathToLower(test.input)
+               output := MakePathSanitized(test.input)
                if output != test.expected {
                        t.Errorf("Expected %#v, got %#v\n", test.expected, output)
                }

diff --git a/helpers/url.go b/helpers/url.go
index 415f11b74e32f7330db5c0c3253dbd6af8af8eb2..c3365d0b83949a6ced01feb6ec7abf1b7503c836 100644 (file)
--- a/helpers/url.go
+++ b/helpers/url.go
@@ -102,7 +102,7 @@ func SanitizeURLKeepTrailingSlash(in string) string {
 //     uri: Vim (text editor)
 //     urlize: vim-text-editor
 func URLize(uri string) string {
-       sanitized := MakePathToLower(uri)
+       sanitized := MakePathSanitized(uri)
 
        // escape unicode letters
        parsedUri, err := url.Parse(sanitized)

diff --git a/hugolib/site.go b/hugolib/site.go
index a8ca835ef8a6f0a016b59bf690338e1795a68d24..3ac00d0d726398580ba049d3e4d9ff030c1b1975 100644 (file)
--- a/hugolib/site.go
+++ b/hugolib/site.go
@@ -1045,7 +1045,7 @@ func (s *Site) newTaxonomyNode(t taxRenderInfo) (*Node, string) {
        key := t.key
        n := s.NewNode()
        if s.Info.preserveTaxonomyNames {
-               key = helpers.MakePathToLower(key)
+               key = helpers.MakePathSanitized(key)
                // keep as is, just make sure the first char is upper
                n.Title = helpers.FirstUpper(t.key)
        } else {
@@ -1188,7 +1188,7 @@ func (s *Site) RenderSectionLists() error {
                        []string{"section/" + section + ".html", "_default/section.html", "_default/list.html", "indexes/" + section + ".html", "_default/indexes.html"})
 
                if s.Info.preserveTaxonomyNames {
-                       section = helpers.MakePathToLower(section)
+                       section = helpers.MakePathSanitized(section)
                }
 
                n := s.newSectionListNode(sectionName, section, data)

diff --git a/hugolib/taxonomy.go b/hugolib/taxonomy.go
index 22cdfbbb36b1c44725c58ce584631129ba972b3e..1fd34cadb82886cbbc0b175277998c0927c7222b 100644 (file)
--- a/hugolib/taxonomy.go
+++ b/hugolib/taxonomy.go
@@ -60,7 +60,7 @@ type OrderedTaxonomyEntry struct {
 
 // KeyPrep... Taxonomies should be case insensitive. Can make it easily conditional later.
 func kp(in string) string {
-       return helpers.MakePathToLower(in)
+       return helpers.MakePathSanitized(in)
 }
 
 func (i Taxonomy) Get(key string) WeightedPages { return i[kp(key)] }