X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/1082d3a6535c5c2a777ae64a3067e9f8657bd32c..3ae313fd1dc8b811482668344cf2f863bbc97ecc:/app/assets/javascripts/router.js

diff --git a/app/assets/javascripts/router.js b/app/assets/javascripts/router.js
index fbad1e28c..d890f38a4 100644
--- a/app/assets/javascripts/router.js
+++ b/app/assets/javascripts/router.js
@@ -1,115 +1,185 @@
-OSM.Router = function(map, rts) {
-  var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
+/*
+  OSM.Router implements pushState-based navigation for the main page and
+  other pages that use a sidebar+map based layout (export, search results,
+  history, and browse pages).
+
+  For browsers without pushState, it falls back to full page loads, which all
+  of the above pages support.
+
+  The router is initialized with a set of routes: a mapping of URL path templates
+  to route controller objects. Path templates can contain placeholders
+  (`/note/:id`) and optional segments (`/:type/:id(/history)`).
+
+  Route controller objects can define four methods that are called at defined
+  times during routing:
+
+     * The `load` method is called by the router when a path which matches the
+       route's path template is loaded via a normal full page load. It is passed
+       as arguments the URL path plus any matching arguments for placeholders
+       in the path template.
+
+     * The `pushstate` method is called when a page which matches the route's path
+       template is loaded via pushState. It is passed the same arguments as `load`.
+
+     * The `popstate` method is called when returning to a previously
+       pushState-loaded page via popstate (i.e. browser back/forward buttons).
+
+     * The `unload` method is called on the exiting route controller when navigating
+       via pushState or popstate to another route.
+
+   Note that while `load` is not called by the router for pushState-based loads,
+   it's frequently useful for route controllers to call it manually inside their
+   definition of the `pushstate` and `popstate` methods.
+
+   An instance of OSM.Router is assigned to `OSM.router`. To navigate to a new page
+   via pushState (with automatic full-page load fallback), call `OSM.router.route`:
+
+       OSM.router.route('/way/1234');
+
+   If `route` is passed a path that matches one of the path templates, it performs
+   the appropriate actions and returns true. Otherwise it returns false.
+
+   OSM.Router also handles updating the hash portion of the URL containing transient
+   map state such as the position and zoom level. Some route controllers may wish to
+   temporarily suppress updating the hash (for example, to omit the hash on pages
+   such as `/way/1234` unless the map is moved). This can be done by using
+   `OSM.router.withoutMoveListener` to run a block of code that may update
+   move the map without the hash changing.
+ */
+OSM.Router = function (map, rts) {
+  var escapeRegExp = /[-{}[\]+?.,\\^$|#\s]/g;
   var optionalParam = /\((.*?)\)/g;
-  var namedParam    = /(\(\?)?:\w+/g;
-  var splatParam    = /\*\w+/g;
+  var namedParam = /(\(\?)?:\w+/g;
+  var splatParam = /\*\w+/g;
 
   function Route(path, controller) {
-    var regexp = new RegExp('^' +
-      path.replace(escapeRegExp, '\\$&')
-        .replace(optionalParam, '(?:$1)?')
-        .replace(namedParam, function(match, optional){
-          return optional ? match : '([^\/]+)';
+    var regexp = new RegExp("^" +
+      path.replace(escapeRegExp, "\\$&")
+        .replace(optionalParam, "(?:$1)?")
+        .replace(namedParam, function (match, optional) {
+          return optional ? match : "([^/]+)";
         })
-        .replace(splatParam, '(.*?)') + '(?:\\?.*)?$');
+        .replace(splatParam, "(.*?)") + "(?:\\?.*)?$");
 
     var route = {};
 
-    route.match = function(path) {
+    route.match = function (path) {
       return regexp.test(path);
     };
 
-    route.run = function(action, path) {
+    route.run = function (action, path) {
       var params = [];
 
       if (path) {
-        params = regexp.exec(path).map(function(param, i) {
+        params = regexp.exec(path).map(function (param, i) {
           return (i > 0 && param) ? decodeURIComponent(param) : param;
         });
       }
 
-      (controller[action] || $.noop).apply(controller, params);
+      params = params.concat(Array.prototype.slice.call(arguments, 2));
+
+      return (controller[action] || $.noop).apply(controller, params);
     };
 
     return route;
   }
 
   var routes = [];
-  for (var r in rts)
-    routes.push(Route(r, rts[r]));
+  for (var r in rts) {
+    routes.push(new Route(r, rts[r]));
+  }
 
-  routes.recognize = function(path) {
+  routes.recognize = function (path) {
     for (var i = 0; i < this.length; i++) {
       if (this[i].match(path)) return this[i];
     }
   };
 
-  var currentPath = window.location.pathname + window.location.search,
-    currentRoute = routes.recognize(currentPath),
-    currentHash = location.hash || OSM.formatHash(map);
+  var currentPath = window.location.pathname.replace(/(.)\/$/, "$1") + window.location.search,
+      currentRoute = routes.recognize(currentPath),
+      currentHash = location.hash || OSM.formatHash(map);
+
+  var router = {};
+
+  $(window).on("popstate", function (e) {
+    if (!e.originalEvent.state) return; // Is it a real popstate event or just a hash change?
+    var path = window.location.pathname + window.location.search,
+        route = routes.recognize(path);
+    if (path === currentPath) return;
+    currentRoute.run("unload", null, route === currentRoute);
+    currentPath = path;
+    currentRoute = route;
+    currentRoute.run("popstate", currentPath);
+    map.setState(e.originalEvent.state, { animate: false });
+  });
 
-  currentRoute.run('load', currentPath);
+  router.route = function (url) {
+    var path = url.replace(/#.*/, ""),
+        route = routes.recognize(path);
+    if (!route) return false;
+    currentRoute.run("unload", null, route === currentRoute);
+    var state = OSM.parseHash(url);
+    map.setState(state);
+    window.history.pushState(state, document.title, url);
+    currentPath = path;
+    currentRoute = route;
+    currentRoute.run("pushstate", currentPath);
+    return true;
+  };
 
-  var stateChange;
+  router.replace = function (url) {
+    window.history.replaceState(OSM.parseHash(url), document.title, url);
+  };
 
-  map.on('moveend baselayerchange overlaylayerchange', function() {
+  router.stateChange = function (state) {
+    if (state.center) {
+      window.history.replaceState(state, document.title, OSM.formatHash(state));
+    } else {
+      window.history.replaceState(state, document.title, window.location);
+    }
+  };
+
+  router.updateHash = function () {
     var hash = OSM.formatHash(map);
     if (hash === currentHash) return;
     currentHash = hash;
-    stateChange(OSM.parseHash(hash), hash);
-  });
+    router.stateChange(OSM.parseHash(hash));
+  };
 
-  $(window).on('hashchange', function() {
+  router.hashUpdated = function () {
     var hash = location.hash;
     if (hash === currentHash) return;
     currentHash = hash;
     var state = OSM.parseHash(hash);
-    if (!state) return;
-    map.setView(state.center, state.zoom);
-    map.updateLayers(state.layers);
-    stateChange(state, hash);
-  });
-
-  if (window.history && window.history.pushState) {
-    stateChange = function(state, hash) {
-      window.history.replaceState(state, document.title, hash);
-    };
+    map.setState(state);
+    router.stateChange(state, hash);
+  };
 
-    // Set a non-null initial state, so that the e.originalEvent.state
-    // check below works correctly when going back to the initial page.
-    stateChange(OSM.parseHash(currentHash), currentPath + currentHash);
-
-    $(window).on('popstate', function(e) {
-      if (!e.originalEvent.state) return; // Is it a real popstate event or just a hash change?
-      var path = window.location.pathname + window.location.search;
-      if (path === currentPath) return;
-      currentRoute.run('unload');
-      currentPath = path;
-      currentRoute = routes.recognize(currentPath);
-      currentRoute.run('popstate', currentPath);
-      var state = e.originalEvent.state;
-      map.setView(state.center, state.zoom, {animate: false});
-      map.updateLayers(state.layers);
-    });
-
-    return function (url) {
-      var path = url.replace(/#.*/, ''),
-        route = routes.recognize(path);
-      if (!route) return false;
-      window.history.pushState(OSM.parseHash(url) || {}, document.title, url);
-      currentRoute.run('unload');
-      currentPath = path;
-      currentRoute = route;
-      currentRoute.run('pushstate', currentPath);
-      return true;
+  router.withoutMoveListener = function (callback) {
+    function disableMoveListener() {
+      map.off("moveend", router.updateHash);
+      map.once("moveend", function () {
+        map.on("moveend", router.updateHash);
+      });
     }
-  } else {
-    stateChange = function(state, hash) {
-      window.location.replace(hash);
-    };
 
-    return function (url) {
-      window.location.assign(url);
-    }
-  }
+    map.once("movestart", disableMoveListener);
+    callback();
+    map.off("movestart", disableMoveListener);
+  };
+
+  router.load = function () {
+    var loadState = currentRoute.run("load", currentPath);
+    router.stateChange(loadState || {});
+  };
+
+  router.setCurrentPath = function (path) {
+    currentPath = path;
+    currentRoute = routes.recognize(currentPath);
+  };
+
+  map.on("moveend baselayerchange overlaylayerchange", router.updateHash);
+  $(window).on("hashchange", router.hashUpdated);
+
+  return router;
 };