Move vagrant provisioning script to a better location.

[rails.git] / app / assets / javascripts / router.js

diff --git a/app/assets/javascripts/router.js b/app/assets/javascripts/router.js
index 7b2e9954622d40255298a839c177354ea1fb2578..9657549b1abdb893c304049b76ec894038a21402 100644 (file)
--- a/app/assets/javascripts/router.js
+++ b/app/assets/javascripts/router.js
@@ -1,4 +1,51 @@
-OSM.Router = function(rts) {
+/*
+  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 calling
+   `OSM.router.moveListenerOff` and `OSM.router.moveListenerOn`.
+ */
+OSM.Router = function(map, rts) {

   var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
   var optionalParam = /\((.*?)\)/g;
   var namedParam    = /(\(\?)?:\w+/g;
   var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
   var optionalParam = /\((.*?)\)/g;
   var namedParam    = /(\(\?)?:\w+/g;


@@ -11,7 +58,7 @@ OSM.Router = function(rts) {
         .replace(namedParam, function(match, optional){
           return optional ? match : '([^\/]+)';
         })
         .replace(namedParam, function(match, optional){
           return optional ? match : '([^\/]+)';
         })

-        .replace(splatParam, '(.*?)') + '(?:$|[?#])');
+        .replace(splatParam, '(.*?)') + '(?:\\?.*)?$');

 
     var route = {};
 
 
     var route = {};
 


@@ -28,7 +75,7 @@ OSM.Router = function(rts) {
         });
       }
 
         });
       }
 

-      (controller[action] || $.noop).apply(controller, params);
+      return (controller[action] || $.noop).apply(controller, params);

     };
 
     return route;
     };
 
     return route;


@@ -44,35 +91,89 @@ OSM.Router = function(rts) {
     }
   };
 
     }
   };
 

-  var currentPath = window.location.pathname,
-    currentRoute = routes.recognize(currentPath);
+  var currentPath = window.location.pathname.replace(/(.)\/$/, '$1') + window.location.search,
+    currentRoute = routes.recognize(currentPath),
+    currentHash = location.hash || OSM.formatHash(map);

 
 

-  currentRoute.run('load', currentPath);
+  var router = {};

 
   if (window.history && window.history.pushState) {
 
   if (window.history && window.history.pushState) {

-    $(window).on('popstate', function() {
-      var path = window.location.pathname;
+    $(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);
       if (path === currentPath) return;
       currentRoute.run('unload');
       currentPath = path;
       currentRoute = routes.recognize(currentPath);
       currentRoute.run('popstate', currentPath);

+      map.setState(e.originalEvent.state, {animate: false});

     });
 
     });
 

-    return function (url) {
+    router.route = function (url) {

       var path = url.replace(/#.*/, ''),
         route = routes.recognize(path);
       if (!route) return false;
       var path = url.replace(/#.*/, ''),
         route = routes.recognize(path);
       if (!route) return false;

-      window.history.pushState({}, document.title, url);

       currentRoute.run('unload');
       currentRoute.run('unload');

+      window.history.pushState(OSM.parseHash(url), document.title, url);

       currentPath = path;
       currentRoute = route;
       currentRoute.run('pushstate', currentPath);
       return true;
       currentPath = path;
       currentRoute = route;
       currentRoute.run('pushstate', currentPath);
       return true;

-    }
+    };
+
+    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);
+      }
+    };

   } else {
   } else {

-    return function (url) {
+    router.route = function (url) {

       window.location.assign(url);
       window.location.assign(url);

-    }
+    };
+
+    router.stateChange = function(state) {
+      if (state.center) window.location.replace(OSM.formatHash(state));
+    };

   }
   }

+
+  router.updateHash = function() {
+    var hash = OSM.formatHash(map);
+    if (hash === currentHash) return;
+    currentHash = hash;
+    router.stateChange(OSM.parseHash(hash));
+  };
+
+  router.hashUpdated = function() {
+    var hash = location.hash;
+    if (hash === currentHash) return;
+    currentHash = hash;
+    var state = OSM.parseHash(hash);
+    map.setState(state);
+    router.stateChange(state, hash);
+  };
+
+  router.moveListenerOn = function() {
+    map.on('moveend', router.updateHash);
+  };
+
+  router.moveListenerOff = function() {
+    map.off('moveend', router.updateHash);
+  };
+
+  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;

 };
 };