diff --git a/commands/server.go b/commands/server.go index 0709d263f..c80440c5c 100644 --- a/commands/server.go +++ b/commands/server.go @@ -17,6 +17,7 @@ import ( "fmt" "net" "net/http" + "net/url" "os" "strconv" "strings" @@ -54,10 +55,6 @@ func init() { func server(cmd *cobra.Command, args []string) { InitializeConfig() - if BaseUrl == "" { - BaseUrl = "http://localhost" - } - if cmd.Flags().Lookup("disableLiveReload").Changed { viper.Set("DisableLiveReload", disableLiveReload) } @@ -66,10 +63,6 @@ func server(cmd *cobra.Command, args []string) { viper.Set("Watch", true) } - if !strings.HasPrefix(BaseUrl, "http://") { - BaseUrl = "http://" + BaseUrl - } - l, err := net.Listen("tcp", ":"+strconv.Itoa(serverPort)) if err == nil { l.Close() @@ -85,11 +78,11 @@ func server(cmd *cobra.Command, args []string) { viper.Set("port", serverPort) - if serverAppend { - viper.Set("BaseUrl", strings.TrimSuffix(BaseUrl, "/")+":"+strconv.Itoa(serverPort)) - } else { - viper.Set("BaseUrl", strings.TrimSuffix(BaseUrl, "/")) + BaseUrl, err := fixUrl(BaseUrl) + if err != nil { + jww.ERROR.Fatal(err) } + viper.Set("BaseUrl", BaseUrl) build(serverWatch) @@ -110,10 +103,57 @@ func serve(port int) { jww.FEEDBACK.Printf("Web Server is available at %s\n", viper.GetString("BaseUrl")) fmt.Println("Press ctrl+c to stop") - http.Handle("/", http.FileServer(http.Dir(helpers.AbsPathify(viper.GetString("PublishDir"))))) - err := http.ListenAndServe(":"+strconv.Itoa(port), nil) + fileserver := http.FileServer(http.Dir(helpers.AbsPathify(viper.GetString("PublishDir")))) + + u, err := url.Parse(viper.GetString("BaseUrl")) + if err != nil { + jww.ERROR.Fatalf("Invalid BaseUrl: %s", err) + } + if u.Path == "" || u.Path == "/" { + http.Handle("/", fileserver) + } else { + http.Handle(u.Path+"/", http.StripPrefix(u.Path+"/", fileserver)) + } + + err = http.ListenAndServe(":"+strconv.Itoa(port), nil) if err != nil { jww.ERROR.Printf("Error: %s\n", err.Error()) os.Exit(1) } } + +func fixUrl(s string) (string, error) { + useLocalhost := false + if s == "" { + s = viper.GetString("BaseUrl") + useLocalhost = true + } + if !strings.HasPrefix(s, "http://") { + s = "http://" + s + } + u, err := url.Parse(s) + if err != nil { + return "", err + } + + if serverAppend { + if useLocalhost { + u.Host = fmt.Sprintf("localhost:%d", serverPort) + return u.String(), nil + } + host := u.Host + if strings.Contains(host, ":") { + host, _, err = net.SplitHostPort(u.Host) + if err != nil { + return "", fmt.Errorf("Failed to split BaseUrl hostpost: %s", err) + } + } + u.Host = fmt.Sprintf("%s:%d", host, serverPort) + return u.String(), nil + } + + if useLocalhost { + u.Host = "localhost" + } + return u.String(), nil +} diff --git a/commands/server_test.go b/commands/server_test.go new file mode 100644 index 000000000..d84579642 --- /dev/null +++ b/commands/server_test.go @@ -0,0 +1,42 @@ +package commands + +import ( + "testing" + + "github.com/spf13/viper" +) + +func TestFixUrl(t *testing.T) { + type data struct { + TestName string + CliBaseUrl string + CfgBaseUrl string + AppendPort bool + Port int + Result string + } + tests := []data{ + {"Basic localhost", "", "http://foo.com", true, 1313, "http://localhost:1313"}, + {"Basic subdir", "", "http://foo.com/bar", true, 1313, "http://localhost:1313/bar"}, + {"Basic production", "http://foo.com", "http://foo.com", false, 80, "http://foo.com"}, + {"Production subdir", "http://foo.com/bar", "http://foo.com/bar", false, 80, "http://foo.com/bar"}, + {"No http", "", "foo.com", true, 1313, "http://localhost:1313"}, + {"Override configured port", "", "foo.com:2020", true, 1313, "http://localhost:1313"}, + {"No http production", "foo.com", "foo.com", false, 80, "http://foo.com"}, + {"No http production with port", "foo.com", "foo.com", true, 2020, "http://foo.com:2020"}, + } + + for i, test := range tests { + BaseUrl = test.CliBaseUrl + viper.Set("BaseUrl", test.CfgBaseUrl) + serverAppend = test.AppendPort + serverPort = test.Port + result, err := fixUrl(BaseUrl) + if err != nil { + t.Errorf("Test #%d %s: unexpected error %s", err) + } + if result != test.Result { + t.Errorf("Test #%d %s: expected %q, got %q", i, test.TestName, test.Result, result) + } + } +} diff --git a/helpers/helpers_test.go b/helpers/helpers_test.go index 822783025..6d3993be4 100644 --- a/helpers/helpers_test.go +++ b/helpers/helpers_test.go @@ -97,3 +97,25 @@ func TestUrlize(t *testing.T) { } } } + +func TestMakePermalink(t *testing.T) { + type test struct { + host, link, output string + } + + data := []test{ + {"http://abc.com/foo", "post/bar", "http://abc.com/foo/post/bar"}, + {"http://abc.com/foo/", "post/bar", "http://abc.com/foo/post/bar"}, + {"http://abc.com", "post/bar", "http://abc.com/post/bar"}, + {"http://abc.com", "bar", "http://abc.com/bar"}, + {"http://abc.com/foo/bar", "post/bar", "http://abc.com/foo/bar/post/bar"}, + {"http://abc.com/foo/bar", "post/bar/", "http://abc.com/foo/bar/post/bar/"}, + } + + for i, d := range data { + output := MakePermalink(d.host, d.link).String() + if d.output != output { + t.Errorf("Test #%d failed. Expected %q got %q", i, d.output, output) + } + } +} diff --git a/helpers/url.go b/helpers/url.go index d7f99f4f5..8a33c5b86 100644 --- a/helpers/url.go +++ b/helpers/url.go @@ -14,8 +14,10 @@ package helpers import ( + "fmt" "net/url" "path" + "strings" "github.com/PuerkitoBio/purell" ) @@ -57,11 +59,23 @@ func MakePermalink(host, plink string) *url.URL { panic(err) } - path, err := url.Parse(plink) + p, err := url.Parse(plink) if err != nil { panic(err) } - return base.ResolveReference(path) + + if p.Host != "" { + panic(fmt.Errorf("Can't make permalink from absolute link %q", plink)) + } + + base.Path = path.Join(base.Path, p.Path) + + // path.Join will strip off the last /, so put it back if it was there. + if strings.HasSuffix(p.Path, "/") && !strings.HasSuffix(base.Path, "/") { + base.Path = base.Path + "/" + } + + return base } func UrlPrep(ugly bool, in string) string { diff --git a/hugolib/page_permalink_test.go b/hugolib/page_permalink_test.go index 51306fade..be88c2faf 100644 --- a/hugolib/page_permalink_test.go +++ b/hugolib/page_permalink_test.go @@ -33,7 +33,7 @@ func TestPermalink(t *testing.T) { {"x/y/z/boofar.md", "x/y/z", "", "", "/z/y/q/", false, "/z/y/q/", "/z/y/q/"}, } - for _, test := range tests { + for i, test := range tests { viper.Set("uglyurls", test.uglyurls) p := &Page{ Node: Node{ @@ -56,22 +56,22 @@ func TestPermalink(t *testing.T) { u, err := p.Permalink() if err != nil { - t.Errorf("Unable to process permalink: %s", err) + t.Errorf("Test %d: Unable to process permalink: %s", i, err) } expected := test.expectedAbs if u != expected { - t.Errorf("Expected abs url: %s, got: %s", expected, u) + t.Errorf("Test %d: Expected abs url: %s, got: %s", i, expected, u) } u, err = p.RelPermalink() if err != nil { - t.Errorf("Unable to process permalink: %s", err) + t.Errorf("Test %d: Unable to process permalink: %s", i, err) } expected = test.expectedRel if u != expected { - t.Errorf("Expected abs url: %s, got: %s", expected, u) + t.Errorf("Test %d: Expected abs url: %s, got: %s", i, expected, u) } } }