relax need for baseURL property and finalize its documentation

Author: Koen Deforche

src/Wt/WApplication.C

@@ -560,45 +560,17 @@ void WApplication::setConfirmCloseMessage(const WString& message)
 
 std::string WApplication::url() const
 {
-  return fixRelativeUrl(session_->applicationUrl());
+  return fixRelativeUrl(session_->applicationName());
 }
 
 std::string WApplication::makeAbsoluteUrl(const std::string& url) const
 {
-  if (url.find("://") != std::string::npos)
-    return url;
-  else {
-    if (!url.empty() && url[0] == '/')
-      return environment().urlScheme() + "://" + environment().hostName() + url;
-    else
-      return session_->absoluteBaseUrl() + url;
-  }
+  return session_->makeAbsoluteUrl(url);
 }
 
 std::string WApplication::fixRelativeUrl(const std::string& url) const
 {
-  if (url.find("://") != std::string::npos)
-    return url;
-
-  if (url.length() > 0 && url[0] == '#')
-    return url;
-
-  if (session_->type() == Application) {
-    if (!environment().javaScript()
-	&& !WebSession::Handler::instance()->request()->pathInfo().empty())
-      // This will break reverse proxies:
-      // We could do a '../path/' trick? we could do this to correct
-      // for the current internal path: as many '../' as there are
-      // internal path folders. but why bother ? we need to fix URLs
-      // in external resources anyway for reverse proxies
-      if (!url.empty() && url[0] == '/')
-	return /*session_->basePath() + url.substr(1) */ url;
-      else
-	return session_->basePath() + url;
-    else
-      return url;
-  } else
-    return makeAbsoluteUrl(url);
+  return session_->fixRelativeUrl(url);
 }
 
 void WApplication::quit()

src/web/WebSession.C

@@ -48,6 +48,18 @@ namespace {
   bool isAbsoluteUrl(const std::string& url) {
     return url.find("://") != std::string::npos;
   }
+
+  std::string host(const std::string& url) {
+    std::size_t pos = 0;
+    for (unsigned i = 0; i < 3; ++i) { 
+      pos = url.find('/', pos);
+      if (pos == std::string::npos)
+	return url;
+      else
+	++pos;
+    }
+    return url.substr(0, pos);
+  }
 }
 
 namespace Wt {
@@ -271,6 +283,13 @@ void WebSession::init(const WebRequest& request)
   }
 #endif
 
+  if (useAbsoluteUrls) {
+    std::string::size_type slashpos = absoluteBaseUrl_.rfind('/');
+    if (slashpos != std::string::npos
+	&& slashpos != absoluteBaseUrl_.length() - 1)
+      absoluteBaseUrl_ = absoluteBaseUrl_.substr(0, slashpos + 1);
+  }
+
   bookmarkUrl_ = applicationName_;
 
   if (applicationName_.empty())
@@ -349,7 +368,7 @@ std::string WebSession::bootstrapUrl(const WebResponse& response,
   }
   case ClearInternalPath: {
     if (!isAbsoluteUrl(applicationUrl_)) {
-      if (WebSession::Handler::instance()->request()->pathInfo().length() > 1)
+      if (pagePathInfo_.length() > 1)
 	return appendSessionQuery(deploymentPath_);
       else
 	return appendSessionQuery(applicationName_);
@@ -364,6 +383,43 @@ std::string WebSession::bootstrapUrl(const WebResponse& response,
   return std::string();
 }
 
+std::string WebSession::fixRelativeUrl(const std::string& url) const
+{
+  if (isAbsoluteUrl(url))
+    return url;
+
+  if (url.length() > 0 && url[0] == '#')
+    return url;
+
+  if (!isAbsoluteUrl(applicationUrl_)) {
+    if (url.empty() || url[0] == '/')
+      return url;
+    else {
+      std::string rel = "";
+
+      for (unsigned i = 0; i < pagePathInfo_.length(); ++i) {
+	if (pagePathInfo_[i] == '/')
+	  rel += "../";
+      }
+
+      return rel + url;
+    }
+  } else
+    return makeAbsoluteUrl(url);
+}
+
+std::string WebSession::makeAbsoluteUrl(const std::string& url) const
+{
+  if (isAbsoluteUrl(url))
+    return url;
+  else {
+    if (url.empty() || url[0] != '/')
+      return absoluteBaseUrl_ + url;
+    else
+      return host(absoluteBaseUrl_) + url;
+  }
+}
+
 std::string WebSession::mostRelativeUrl(const std::string& internalPath) const
 {
   return appendSessionQuery(bookmarkUrl(internalPath));
@@ -1377,8 +1433,13 @@ std::string WebSession::ajaxCanonicalUrl(const WebResponse& request) const
   if (applicationName_.empty())
     hashE = request.getParameter("_");
 
-  if (!request.pathInfo().empty() || (hashE && hashE->length() > 1)) {
-    std::string url = deploymentPath_;
+  if (!pagePathInfo_.empty() || (hashE && hashE->length() > 1)) {
+    std::string url;
+    if (applicationName_.empty()) {
+      url = fixRelativeUrl(".");
+      url = url.substr(0, url.length() - 1);
+    } else
+      url = fixRelativeUrl(applicationName_);
 
     bool firstParameter = true;
     for (Http::ParameterMap::const_iterator i
@@ -1910,12 +1971,14 @@ void WebSession::serveError(Handler& handler, const std::string& e)
 
 void WebSession::serveResponse(Handler& handler)
 {
+  if (handler.response()->responseType() == WebResponse::Page)
+    pagePathInfo_ = handler.request()->pathInfo();
+
   /*
    * If the request is a web socket message, then we should not actually
    * render -- there may be more messages following.
    */
   if (!handler.request()->isWebSocketMessage()) {
-
     /*
      * In any case, flush the style request when we are serving a new
      * page (without Ajax) or the main script (with Ajax).

src/web/WebSession.h

@@ -112,10 +112,8 @@ class WT_API WebSession
    */
 
   const std::string& applicationName() const { return applicationName_; }
-
-  // (http://www.bigapp.com) /myapp/app.wt?wtd=ABCD
-  const std::string applicationUrl() const { return applicationUrl_ + sessionQuery(); }
-
+  const std::string applicationUrl() const
+    { return applicationUrl_ + sessionQuery(); }
   const std::string& deploymentPath() const { return deploymentPath_; }
 
   bool useUglyInternalPaths() const;
@@ -140,18 +138,15 @@ class WT_API WebSession
   std::string bootstrapUrl(const WebResponse& response, BootstrapOption option)
     const;
 
+  std::string fixRelativeUrl(const std::string& url) const;
+  std::string makeAbsoluteUrl(const std::string& url) const;
+
   // (http://www.bigapp.com/myapp/) app.wt/internal_path
   std::string bookmarkUrl(const std::string& internalPath) const;
 
   // tries to figure out the current bookmark url (from the app or otherwise)
   std::string bookmarkUrl() const;
 
-  // http://www.bigapp.com:1234/myapp/
-  const std::string& absoluteBaseUrl() const { return absoluteBaseUrl_; }
-
-  // /myapp/
-  const std::string& basePath() const { return basePath_; }
-
   std::string getCgiValue(const std::string& varName) const;
   std::string getCgiHeader(const std::string& headerName) const;
 
@@ -268,6 +263,7 @@ class WT_API WebSession
   std::string   bookmarkUrl_, basePath_, absoluteBaseUrl_;
   std::string   applicationUrl_, deploymentPath_;
   std::string   redirect_;
+  std::string   pagePathInfo_;
   WebResponse  *asyncResponse_, *bootStyleResponse_;
   bool          canWriteAsyncResponse_, noBootStyleResponse_;
   bool          progressiveBoot_;

wt_config.xml.in

@@ -403,19 +403,31 @@
 	    <!-- baseURL property
 
 	       The absolute URL at which the application is deployed
-	       (known to the user). This may be a reverse-proxified URL
-	       when the app is deployed behind a reverse proxy. This is
-               set as base URL in the HTML so that relative URLs (to e.g.
-	       css, images, etc...) work correctly regardless of the
-               internal path. It is also used as the self-referencing URL,
-	       instead of the relative URLs used by default.
-
-	       Eg. "http://www.webtoolkit.eu/"
-
-	       The default value is empty, in which case the base URL is
-               explicitly set. Note that for most applications (which do
-	       not use internal paths and rely on relative URls) this is
-	       fine.
+	       (known to the user). This is needed only in two scenarios.
+
+	       When you use relative URLs for images, etc... in
+	       fragments of HTML (e.g. in WTemplate) or CSS, which you
+	       would like to resolve against the deployment path of the
+	       application. This will not work as expected in the presence
+	       of an internal application path.
+	       This URL is set as base URL in the HTML, against which
+	       relative URLs are resolved so that these work correctly
+	       regardless of the internal path. It is also used explicitly
+	       in any URL generated by the library.
+
+	       Another situation in which you need to define the baseURL is
+	       when deploying a widgetset mode application behind a reverse
+	       proxy. A widgetset mode application uses only absolute URLs
+	       because it may be hosted in a web page from an entirely
+	       different domain.
+
+	       Eg. "http://www.webtoolkit.eu/wt"
+
+	       The default value is empty, in which case Wt will avoid using
+               absolute URLs. Relative URLs passed in API calls will be
+	       "fixed" so that they resolve against the location of the
+	       application deploy path, even in the presence of an
+	       internal path.
 	      -->
 	    <property name="baseURL"></property>