pretender-rails 0.0.2

data/vendor/assets/javascripts/pretender.js

@@ -0,0 +1,367 @@
+(function(window){
+
+var isNode = typeof process !== 'undefined' && process.toString() === '[object process]';
+var RouteRecognizer = isNode ? require('route-recognizer')['default'] : window.RouteRecognizer;
+var FakeXMLHttpRequest = isNode ? require('./bower_components/FakeXMLHttpRequest/fake_xml_http_request') : window.FakeXMLHttpRequest;
+var slice = [].slice;
+
+
+/**
+ * parseURL - decompose a URL into its parts
+ * @param  {String} url a URL
+ * @return {Object} parts of the URL, including the following
+ *
+ * 'https://www.yahoo.com:1234/mypage?test=yes#abc'
+ *
+ * {
+ *   host: 'www.yahoo.com:1234',
+ *   protocol: 'https:',
+ *   search: '?test=yes',
+ *   hash: '#abc',
+ *   href: 'https://www.yahoo.com:1234/mypage?test=yes#abc',
+ *   pathname: '/mypage',
+ *   fullpath: '/mypage?test=yes'
+ * }
+ */
+function parseURL(url) {
+  // TODO: something for when document isn't present... #yolo
+  var anchor = document.createElement('a');
+  anchor.href = url;
+  anchor.fullpath = anchor.pathname + (anchor.search || '') + (anchor.hash || '');
+  return anchor;
+}
+
+
+/**
+ * Registry
+ *
+ * A registry is a map of HTTP verbs to route recognizers.
+ */
+
+function Registry(host) {
+  this.verbs = {
+    GET: new RouteRecognizer(),
+    PUT: new RouteRecognizer(),
+    POST: new RouteRecognizer(),
+    DELETE: new RouteRecognizer(),
+    PATCH: new RouteRecognizer(),
+    HEAD: new RouteRecognizer(),
+    OPTIONS: new RouteRecognizer()
+  };
+}
+
+/**
+ * Hosts
+ *
+ * a map of hosts to Registries, ultimately allowing
+ * a per-host-and-port, per HTTP verb lookup of RouteRecognizers
+ */
+function Hosts() {
+  this._registries = {};
+}
+
+/**
+ * Hosts#forURL - retrieve a map of HTTP verbs to RouteRecognizers
+ *                for a given URL
+ *
+ * @param  {String} url a URL
+ * @return {Registry}   a map of HTTP verbs to RouteRecognizers
+ *                      corresponding to the provided URL's
+ *                      hostname and port
+ */
+Hosts.prototype.forURL = function(url) {
+  var host = parseURL(url).host;
+  var registry = this._registries[host];
+
+  if (registry === undefined) {
+    registry = (this._registries[host] = new Registry(host));
+  }
+
+  return registry.verbs;
+}
+
+function Pretender(/* routeMap1, routeMap2, ...*/){
+  maps = slice.call(arguments);
+  // Herein we keep track of RouteRecognizer instances
+  // keyed by HTTP method. Feel free to add more as needed.
+  this.hosts = new Hosts();
+
+  this.handlers = [];
+  this.handledRequests = [];
+  this.passthroughRequests = [];
+  this.unhandledRequests = [];
+  this.requestReferences = [];
+
+  // reference the native XMLHttpRequest object so
+  // it can be restored later
+  this._nativeXMLHttpRequest = window.XMLHttpRequest;
+
+  // capture xhr requests, channeling them into
+  // the route map.
+  window.XMLHttpRequest = interceptor(this);
+
+  // "start" the server
+  this.running = true;
+
+  // trigger the route map DSL.
+  for(var i=0; i < arguments.length; i++){
+    this.map(arguments[i]);
+  }
+}
+
+function interceptor(pretender) {
+  function FakeRequest(){
+    // super()
+    FakeXMLHttpRequest.call(this);
+  }
+  // extend
+  var proto = new FakeXMLHttpRequest();
+  proto.send = function send(){
+    if (!pretender.running) {
+      throw new Error('You shut down a Pretender instance while there was a pending request. '+
+            'That request just tried to complete. Check to see if you accidentally shut down '+
+            'a pretender earlier than you intended to');
+    }
+
+    FakeXMLHttpRequest.prototype.send.apply(this, arguments);
+    if (!pretender.checkPassthrough(this)) {
+      pretender.handleRequest(this);
+    }
+    else {
+      var xhr = createPassthrough(this);
+      xhr.send.apply(xhr, arguments);
+    }
+  };
+
+  // passthrough handling
+  var evts = ['error', 'timeout', 'progress', 'abort'];
+  var lifecycleProps = ['readyState', 'responseText', 'responseXML', 'status', 'statusText'];
+  function createPassthrough(fakeXHR) {
+    var xhr = fakeXHR._passthroughRequest = new pretender._nativeXMLHttpRequest();
+
+    // use onload instead of onreadystatechange if the browser supports it
+    if ('onload' in xhr) {
+      evts.push('load');
+    } else {
+      evts.push('readystatechange');
+    }
+
+    // listen to all events to update lifecycle properties
+    for (var i = 0; i < evts.length; i++) (function(evt) {
+      xhr['on' + evt] = function(e) {
+        // update lifecycle props on each event
+        for (var i = 0; i < lifecycleProps.length; i++) {
+          var prop = lifecycleProps[i];
+          if (xhr[prop]) {
+            fakeXHR[prop] = xhr[prop];
+          }
+        }
+        // fire fake events where applicable
+        fakeXHR.dispatchEvent(evt, e);
+        if (fakeXHR['on' + evt]) {
+          fakeXHR['on' + evt](e);
+        }
+      };
+    })(evts[i]);
+    xhr.open(fakeXHR.method, fakeXHR.url, fakeXHR.async, fakeXHR.username, fakeXHR.password);
+    xhr.timeout = fakeXHR.timeout;
+    xhr.withCredentials = fakeXHR.withCredentials;
+    for (var h in fakeXHR.requestHeaders) {
+      xhr.setRequestHeader(h, fakeXHR.requestHeaders[h]);
+    }
+    return xhr;
+  }
+  proto._passthroughCheck = function(method, arguments) {
+    if (this._passthroughRequest) {
+      return this._passthroughRequest[method].apply(this._passthroughRequest, arguments);
+    }
+    return FakeXMLHttpRequest.prototype[method].apply(this, arguments);
+  }
+  proto.abort = function abort(){
+    return this._passthroughCheck('abort', arguments);
+  }
+  proto.getResponseHeader = function getResponseHeader(){
+    return this._passthroughCheck('getResponseHeader', arguments);
+  }
+  proto.getAllResponseHeaders = function getAllResponseHeaders(){
+    return this._passthroughCheck('getAllResponseHeaders', arguments);
+  }
+
+  FakeRequest.prototype = proto;
+  return FakeRequest;
+}
+
+function verbify(verb){
+  return function(path, handler, async){
+    this.register(verb, path, handler, async);
+  };
+}
+
+function scheduleProgressEvent(request, startTime, totalTime) {
+  setTimeout(function() {
+    if (!request.aborted && !request.status) {
+      var ellapsedTime = new Date().getTime() - startTime.getTime();
+      request.upload._progress(true, ellapsedTime, totalTime);
+      request._progress(true, ellapsedTime, totalTime);
+      scheduleProgressEvent(request, startTime, totalTime);
+    }
+  }, 50);
+}
+
+var PASSTHROUGH = {};
+
+Pretender.prototype = {
+  get: verbify('GET'),
+  post: verbify('POST'),
+  put: verbify('PUT'),
+  'delete': verbify('DELETE'),
+  patch: verbify('PATCH'),
+  head: verbify('HEAD'),
+  map: function(maps){
+    maps.call(this);
+  },
+  register: function register(verb, url, handler, async){
+    if (!handler) {
+      throw new Error("The function you tried passing to Pretender to handle " + verb + " " + url + " is undefined or missing.");
+    }
+
+    handler.numberOfCalls = 0;
+    handler.async = async;
+    this.handlers.push(handler);
+
+    var registry = this.hosts.forURL(url)[verb];
+
+    registry.add([{
+      path: parseURL(url).fullpath,
+      handler: handler
+    }]);
+  },
+  passthrough: PASSTHROUGH,
+  checkPassthrough: function checkPassthrough(request) {
+    var verb = request.method.toUpperCase();
+
+    var path = parseURL(request.url).fullpath;
+
+    verb = verb.toUpperCase();
+
+    var recognized = this.hosts.forURL(request.url)[verb].recognize(path);
+    var match = recognized && recognized[0];
+    if (match && match.handler == PASSTHROUGH) {
+      this.passthroughRequests.push(request);
+      this.passthroughRequest(verb, path, request);
+      return true;
+    }
+
+    return false;
+  },
+  handleRequest: function handleRequest(request){
+    var verb = request.method.toUpperCase();
+    var path = request.url;
+
+    var handler = this._handlerFor(verb, path, request);
+
+    if (handler) {
+      handler.handler.numberOfCalls++;
+      var async = handler.handler.async;
+      this.handledRequests.push(request);
+
+      try {
+        var statusHeadersAndBody = handler.handler(request),
+            status = statusHeadersAndBody[0],
+            headers = this.prepareHeaders(statusHeadersAndBody[1]),
+            body = this.prepareBody(statusHeadersAndBody[2]),
+            pretender = this;
+
+        this.handleResponse(request, async, function() {
+          request.respond(status, headers, body);
+          pretender.handledRequest(verb, path, request);
+        });
+      } catch (error) {
+        this.erroredRequest(verb, path, request, error);
+        this.resolve(request);
+      }
+    } else {
+      this.unhandledRequests.push(request);
+      this.unhandledRequest(verb, path, request);
+    }
+  },
+  handleResponse: function handleResponse(request, strategy, callback) {
+    var delay = typeof strategy === 'function' ? strategy() : strategy;
+    delay = typeof delay === 'boolean' || typeof delay === 'number' ? delay : 0;
+
+    if (delay === false) {
+      callback();
+    } else {
+      var pretender = this;
+      pretender.requestReferences.push({
+        request: request,
+        callback: callback
+      });
+
+      if (delay !== true) {
+        scheduleProgressEvent(request, new Date(), delay);
+        setTimeout(function() {
+          pretender.resolve(request);
+        }, delay);
+      }
+    }
+  },
+  resolve: function resolve(request) {
+    for(var i = 0, len = this.requestReferences.length; i < len; i++) {
+      var res = this.requestReferences[i];
+      if (res.request === request) {
+        res.callback();
+        this.requestReferences.splice(i, 1);
+        break;
+      }
+    }
+  },
+  requiresManualResolution: function(verb, path) {
+    var handler = this._handlerFor(verb.toUpperCase(), path, {});
+    if (!handler) { return false; }
+
+    var async = handler.handler.async;
+    return typeof async === 'function' ? async() === true : async === true;
+  },
+  prepareBody: function(body) { return body; },
+  prepareHeaders: function(headers) { return headers; },
+  handledRequest: function(verb, path, request) { /* no-op */},
+  passthroughRequest: function(verb, path, request) { /* no-op */},
+  unhandledRequest: function(verb, path, request) {
+    throw new Error("Pretender intercepted "+verb+" "+path+" but no handler was defined for this type of request");
+  },
+  erroredRequest: function(verb, path, request, error){
+    error.message = "Pretender intercepted "+verb+" "+path+" but encountered an error: " + error.message;
+    throw error;
+  },
+  _handlerFor: function(verb, url, request){
+    var registry = this.hosts.forURL(url)[verb];
+    var matches = registry.recognize(parseURL(url).fullpath);
+
+    var match = matches ? matches[0] : null;
+    if (match) {
+      request.params = match.params;
+      request.queryParams = matches.queryParams;
+    }
+
+    return match;
+  },
+  shutdown: function shutdown(){
+    window.XMLHttpRequest = this._nativeXMLHttpRequest;
+
+    // "stop" the server
+    this.running = false;
+  }
+};
+
+Pretender.parseURL = parseURL;
+Pretender.Hosts = Hosts;
+Pretender.Registry = Registry;
+
+if (isNode) {
+  module.exports = Pretender;
+} else {
+  window.Pretender = Pretender;
+}
+
+})(window);

data/vendor/assets/javascripts/route-recognizer.js

@@ -0,0 +1,653 @@
+(function() {
+    "use strict";
+    function $$route$recognizer$dsl$$Target(path, matcher, delegate) {
+      this.path = path;
+      this.matcher = matcher;
+      this.delegate = delegate;
+    }
+
+    $$route$recognizer$dsl$$Target.prototype = {
+      to: function(target, callback) {
+        var delegate = this.delegate;
+
+        if (delegate && delegate.willAddRoute) {
+          target = delegate.willAddRoute(this.matcher.target, target);
+        }
+
+        this.matcher.add(this.path, target);
+
+        if (callback) {
+          if (callback.length === 0) { throw new Error("You must have an argument in the function passed to `to`"); }
+          this.matcher.addChild(this.path, target, callback, this.delegate);
+        }
+        return this;
+      }
+    };
+
+    function $$route$recognizer$dsl$$Matcher(target) {
+      this.routes = {};
+      this.children = {};
+      this.target = target;
+    }
+
+    $$route$recognizer$dsl$$Matcher.prototype = {
+      add: function(path, handler) {
+        this.routes[path] = handler;
+      },
+
+      addChild: function(path, target, callback, delegate) {
+        var matcher = new $$route$recognizer$dsl$$Matcher(target);
+        this.children[path] = matcher;
+
+        var match = $$route$recognizer$dsl$$generateMatch(path, matcher, delegate);
+
+        if (delegate && delegate.contextEntered) {
+          delegate.contextEntered(target, match);
+        }
+
+        callback(match);
+      }
+    };
+
+    function $$route$recognizer$dsl$$generateMatch(startingPath, matcher, delegate) {
+      return function(path, nestedCallback) {
+        var fullPath = startingPath + path;
+
+        if (nestedCallback) {
+          nestedCallback($$route$recognizer$dsl$$generateMatch(fullPath, matcher, delegate));
+        } else {
+          return new $$route$recognizer$dsl$$Target(startingPath + path, matcher, delegate);
+        }
+      };
+    }
+
+    function $$route$recognizer$dsl$$addRoute(routeArray, path, handler) {
+      var len = 0;
+      for (var i=0, l=routeArray.length; i<l; i++) {
+        len += routeArray[i].path.length;
+      }
+
+      path = path.substr(len);
+      var route = { path: path, handler: handler };
+      routeArray.push(route);
+    }
+
+    function $$route$recognizer$dsl$$eachRoute(baseRoute, matcher, callback, binding) {
+      var routes = matcher.routes;
+
+      for (var path in routes) {
+        if (routes.hasOwnProperty(path)) {
+          var routeArray = baseRoute.slice();
+          $$route$recognizer$dsl$$addRoute(routeArray, path, routes[path]);
+
+          if (matcher.children[path]) {
+            $$route$recognizer$dsl$$eachRoute(routeArray, matcher.children[path], callback, binding);
+          } else {
+            callback.call(binding, routeArray);
+          }
+        }
+      }
+    }
+
+    var $$route$recognizer$dsl$$default = function(callback, addRouteCallback) {
+      var matcher = new $$route$recognizer$dsl$$Matcher();
+
+      callback($$route$recognizer$dsl$$generateMatch("", matcher, this.delegate));
+
+      $$route$recognizer$dsl$$eachRoute([], matcher, function(route) {
+        if (addRouteCallback) { addRouteCallback(this, route); }
+        else { this.add(route); }
+      }, this);
+    };
+
+    var $$route$recognizer$$specials = [
+      '/', '.', '*', '+', '?', '|',
+      '(', ')', '[', ']', '{', '}', '\\'
+    ];
+
+    var $$route$recognizer$$escapeRegex = new RegExp('(\\' + $$route$recognizer$$specials.join('|\\') + ')', 'g');
+
+    function $$route$recognizer$$isArray(test) {
+      return Object.prototype.toString.call(test) === "[object Array]";
+    }
+
+    // A Segment represents a segment in the original route description.
+    // Each Segment type provides an `eachChar` and `regex` method.
+    //
+    // The `eachChar` method invokes the callback with one or more character
+    // specifications. A character specification consumes one or more input
+    // characters.
+    //
+    // The `regex` method returns a regex fragment for the segment. If the
+    // segment is a dynamic of star segment, the regex fragment also includes
+    // a capture.
+    //
+    // A character specification contains:
+    //
+    // * `validChars`: a String with a list of all valid characters, or
+    // * `invalidChars`: a String with a list of all invalid characters
+    // * `repeat`: true if the character specification can repeat
+
+    function $$route$recognizer$$StaticSegment(string) { this.string = string; }
+    $$route$recognizer$$StaticSegment.prototype = {
+      eachChar: function(callback) {
+        var string = this.string, ch;
+
+        for (var i=0, l=string.length; i<l; i++) {
+          ch = string.charAt(i);
+          callback({ validChars: ch });
+        }
+      },
+
+      regex: function() {
+        return this.string.replace($$route$recognizer$$escapeRegex, '\\$1');
+      },
+
+      generate: function() {
+        return this.string;
+      }
+    };
+
+    function $$route$recognizer$$DynamicSegment(name) { this.name = name; }
+    $$route$recognizer$$DynamicSegment.prototype = {
+      eachChar: function(callback) {
+        callback({ invalidChars: "/", repeat: true });
+      },
+
+      regex: function() {
+        return "([^/]+)";
+      },
+
+      generate: function(params) {
+        return params[this.name];
+      }
+    };
+
+    function $$route$recognizer$$StarSegment(name) { this.name = name; }
+    $$route$recognizer$$StarSegment.prototype = {
+      eachChar: function(callback) {
+        callback({ invalidChars: "", repeat: true });
+      },
+
+      regex: function() {
+        return "(.+)";
+      },
+
+      generate: function(params) {
+        return params[this.name];
+      }
+    };
+
+    function $$route$recognizer$$EpsilonSegment() {}
+    $$route$recognizer$$EpsilonSegment.prototype = {
+      eachChar: function() {},
+      regex: function() { return ""; },
+      generate: function() { return ""; }
+    };
+
+    function $$route$recognizer$$parse(route, names, specificity) {
+      // normalize route as not starting with a "/". Recognition will
+      // also normalize.
+      if (route.charAt(0) === "/") { route = route.substr(1); }
+
+      var segments = route.split("/"), results = [];
+
+      // A routes has specificity determined by the order that its different segments
+      // appear in. This system mirrors how the magnitude of numbers written as strings
+      // works.
+      // Consider a number written as: "abc". An example would be "200". Any other number written
+      // "xyz" will be smaller than "abc" so long as `a > z`. For instance, "199" is smaller
+      // then "200", even though "y" and "z" (which are both 9) are larger than "0" (the value
+      // of (`b` and `c`). This is because the leading symbol, "2", is larger than the other
+      // leading symbol, "1".
+      // The rule is that symbols to the left carry more weight than symbols to the right
+      // when a number is written out as a string. In the above strings, the leading digit
+      // represents how many 100's are in the number, and it carries more weight than the middle
+      // number which represents how many 10's are in the number.
+      // This system of number magnitude works well for route specificity, too. A route written as
+      // `a/b/c` will be more specific than `x/y/z` as long as `a` is more specific than
+      // `x`, irrespective of the other parts.
+      // Because of this similarity, we assign each type of segment a number value written as a
+      // string. We can find the specificity of compound routes by concatenating these strings
+      // together, from left to right. After we have looped through all of the segments,
+      // we convert the string to a number.
+      specificity.val = '';
+
+      for (var i=0, l=segments.length; i<l; i++) {
+        var segment = segments[i], match;
+
+        if (match = segment.match(/^:([^\/]+)$/)) {
+          results.push(new $$route$recognizer$$DynamicSegment(match[1]));
+          names.push(match[1]);
+          specificity.val += '3';
+        } else if (match = segment.match(/^\*([^\/]+)$/)) {
+          results.push(new $$route$recognizer$$StarSegment(match[1]));
+          specificity.val += '2';
+          names.push(match[1]);
+        } else if(segment === "") {
+          results.push(new $$route$recognizer$$EpsilonSegment());
+          specificity.val += '1';
+        } else {
+          results.push(new $$route$recognizer$$StaticSegment(segment));
+          specificity.val += '4';
+        }
+      }
+
+      specificity.val = +specificity.val;
+
+      return results;
+    }
+
+    // A State has a character specification and (`charSpec`) and a list of possible
+    // subsequent states (`nextStates`).
+    //
+    // If a State is an accepting state, it will also have several additional
+    // properties:
+    //
+    // * `regex`: A regular expression that is used to extract parameters from paths
+    //   that reached this accepting state.
+    // * `handlers`: Information on how to convert the list of captures into calls
+    //   to registered handlers with the specified parameters
+    // * `types`: How many static, dynamic or star segments in this route. Used to
+    //   decide which route to use if multiple registered routes match a path.
+    //
+    // Currently, State is implemented naively by looping over `nextStates` and
+    // comparing a character specification against a character. A more efficient
+    // implementation would use a hash of keys pointing at one or more next states.
+
+    function $$route$recognizer$$State(charSpec) {
+      this.charSpec = charSpec;
+      this.nextStates = [];
+    }
+
+    $$route$recognizer$$State.prototype = {
+      get: function(charSpec) {
+        var nextStates = this.nextStates;
+
+        for (var i=0, l=nextStates.length; i<l; i++) {
+          var child = nextStates[i];
+
+          var isEqual = child.charSpec.validChars === charSpec.validChars;
+          isEqual = isEqual && child.charSpec.invalidChars === charSpec.invalidChars;
+
+          if (isEqual) { return child; }
+        }
+      },
+
+      put: function(charSpec) {
+        var state;
+
+        // If the character specification already exists in a child of the current
+        // state, just return that state.
+        if (state = this.get(charSpec)) { return state; }
+
+        // Make a new state for the character spec
+        state = new $$route$recognizer$$State(charSpec);
+
+        // Insert the new state as a child of the current state
+        this.nextStates.push(state);
+
+        // If this character specification repeats, insert the new state as a child
+        // of itself. Note that this will not trigger an infinite loop because each
+        // transition during recognition consumes a character.
+        if (charSpec.repeat) {
+          state.nextStates.push(state);
+        }
+
+        // Return the new state
+        return state;
+      },
+
+      // Find a list of child states matching the next character
+      match: function(ch) {
+        // DEBUG "Processing `" + ch + "`:"
+        var nextStates = this.nextStates,
+            child, charSpec, chars;
+
+        // DEBUG "  " + debugState(this)
+        var returned = [];
+
+        for (var i=0, l=nextStates.length; i<l; i++) {
+          child = nextStates[i];
+
+          charSpec = child.charSpec;
+
+          if (typeof (chars = charSpec.validChars) !== 'undefined') {
+            if (chars.indexOf(ch) !== -1) { returned.push(child); }
+          } else if (typeof (chars = charSpec.invalidChars) !== 'undefined') {
+            if (chars.indexOf(ch) === -1) { returned.push(child); }
+          }
+        }
+
+        return returned;
+      }
+
+      /** IF DEBUG
+      , debug: function() {
+        var charSpec = this.charSpec,
+            debug = "[",
+            chars = charSpec.validChars || charSpec.invalidChars;
+
+        if (charSpec.invalidChars) { debug += "^"; }
+        debug += chars;
+        debug += "]";
+
+        if (charSpec.repeat) { debug += "+"; }
+
+        return debug;
+      }
+      END IF **/
+    };
+
+    /** IF DEBUG
+    function debug(log) {
+      console.log(log);
+    }
+
+    function debugState(state) {
+      return state.nextStates.map(function(n) {
+        if (n.nextStates.length === 0) { return "( " + n.debug() + " [accepting] )"; }
+        return "( " + n.debug() + " <then> " + n.nextStates.map(function(s) { return s.debug() }).join(" or ") + " )";
+      }).join(", ")
+    }
+    END IF **/
+
+    // Sort the routes by specificity
+    function $$route$recognizer$$sortSolutions(states) {
+      return states.sort(function(a, b) {
+        return b.specificity.val - a.specificity.val;
+      });
+    }
+
+    function $$route$recognizer$$recognizeChar(states, ch) {
+      var nextStates = [];
+
+      for (var i=0, l=states.length; i<l; i++) {
+        var state = states[i];
+
+        nextStates = nextStates.concat(state.match(ch));
+      }
+
+      return nextStates;
+    }
+
+    var $$route$recognizer$$oCreate = Object.create || function(proto) {
+      function F() {}
+      F.prototype = proto;
+      return new F();
+    };
+
+    function $$route$recognizer$$RecognizeResults(queryParams) {
+      this.queryParams = queryParams || {};
+    }
+    $$route$recognizer$$RecognizeResults.prototype = $$route$recognizer$$oCreate({
+      splice: Array.prototype.splice,
+      slice:  Array.prototype.slice,
+      push:   Array.prototype.push,
+      length: 0,
+      queryParams: null
+    });
+
+    function $$route$recognizer$$findHandler(state, path, queryParams) {
+      var handlers = state.handlers, regex = state.regex;
+      var captures = path.match(regex), currentCapture = 1;
+      var result = new $$route$recognizer$$RecognizeResults(queryParams);
+
+      for (var i=0, l=handlers.length; i<l; i++) {
+        var handler = handlers[i], names = handler.names, params = {};
+
+        for (var j=0, m=names.length; j<m; j++) {
+          params[names[j]] = captures[currentCapture++];
+        }
+
+        result.push({ handler: handler.handler, params: params, isDynamic: !!names.length });
+      }
+
+      return result;
+    }
+
+    function $$route$recognizer$$addSegment(currentState, segment) {
+      segment.eachChar(function(ch) {
+        var state;
+
+        currentState = currentState.put(ch);
+      });
+
+      return currentState;
+    }
+
+    function $$route$recognizer$$decodeQueryParamPart(part) {
+      // http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1
+      part = part.replace(/\+/gm, '%20');
+      return decodeURIComponent(part);
+    }
+
+    // The main interface
+
+    var $$route$recognizer$$RouteRecognizer = function() {
+      this.rootState = new $$route$recognizer$$State();
+      this.names = {};
+    };
+
+
+    $$route$recognizer$$RouteRecognizer.prototype = {
+      add: function(routes, options) {
+        var currentState = this.rootState, regex = "^",
+            specificity = {},
+            handlers = [], allSegments = [], name;
+
+        var isEmpty = true;
+
+        for (var i=0, l=routes.length; i<l; i++) {
+          var route = routes[i], names = [];
+
+          var segments = $$route$recognizer$$parse(route.path, names, specificity);
+
+          allSegments = allSegments.concat(segments);
+
+          for (var j=0, m=segments.length; j<m; j++) {
+            var segment = segments[j];
+
+            if (segment instanceof $$route$recognizer$$EpsilonSegment) { continue; }
+
+            isEmpty = false;
+
+            // Add a "/" for the new segment
+            currentState = currentState.put({ validChars: "/" });
+            regex += "/";
+
+            // Add a representation of the segment to the NFA and regex
+            currentState = $$route$recognizer$$addSegment(currentState, segment);
+            regex += segment.regex();
+          }
+
+          var handler = { handler: route.handler, names: names };
+          handlers.push(handler);
+        }
+
+        if (isEmpty) {
+          currentState = currentState.put({ validChars: "/" });
+          regex += "/";
+        }
+
+        currentState.handlers = handlers;
+        currentState.regex = new RegExp(regex + "$");
+        currentState.specificity = specificity;
+
+        if (name = options && options.as) {
+          this.names[name] = {
+            segments: allSegments,
+            handlers: handlers
+          };
+        }
+      },
+
+      handlersFor: function(name) {
+        var route = this.names[name], result = [];
+        if (!route) { throw new Error("There is no route named " + name); }
+
+        for (var i=0, l=route.handlers.length; i<l; i++) {
+          result.push(route.handlers[i]);
+        }
+
+        return result;
+      },
+
+      hasRoute: function(name) {
+        return !!this.names[name];
+      },
+
+      generate: function(name, params) {
+        var route = this.names[name], output = "";
+        if (!route) { throw new Error("There is no route named " + name); }
+
+        var segments = route.segments;
+
+        for (var i=0, l=segments.length; i<l; i++) {
+          var segment = segments[i];
+
+          if (segment instanceof $$route$recognizer$$EpsilonSegment) { continue; }
+
+          output += "/";
+          output += segment.generate(params);
+        }
+
+        if (output.charAt(0) !== '/') { output = '/' + output; }
+
+        if (params && params.queryParams) {
+          output += this.generateQueryString(params.queryParams, route.handlers);
+        }
+
+        return output;
+      },
+
+      generateQueryString: function(params, handlers) {
+        var pairs = [];
+        var keys = [];
+        for(var key in params) {
+          if (params.hasOwnProperty(key)) {
+            keys.push(key);
+          }
+        }
+        keys.sort();
+        for (var i = 0, len = keys.length; i < len; i++) {
+          key = keys[i];
+          var value = params[key];
+          if (value == null) {
+            continue;
+          }
+          var pair = encodeURIComponent(key);
+          if ($$route$recognizer$$isArray(value)) {
+            for (var j = 0, l = value.length; j < l; j++) {
+              var arrayPair = key + '[]' + '=' + encodeURIComponent(value[j]);
+              pairs.push(arrayPair);
+            }
+          } else {
+            pair += "=" + encodeURIComponent(value);
+            pairs.push(pair);
+          }
+        }
+
+        if (pairs.length === 0) { return ''; }
+
+        return "?" + pairs.join("&");
+      },
+
+      parseQueryString: function(queryString) {
+        var pairs = queryString.split("&"), queryParams = {};
+        for(var i=0; i < pairs.length; i++) {
+          var pair      = pairs[i].split('='),
+              key       = $$route$recognizer$$decodeQueryParamPart(pair[0]),
+              keyLength = key.length,
+              isArray = false,
+              value;
+          if (pair.length === 1) {
+            value = 'true';
+          } else {
+            //Handle arrays
+            if (keyLength > 2 && key.slice(keyLength -2) === '[]') {
+              isArray = true;
+              key = key.slice(0, keyLength - 2);
+              if(!queryParams[key]) {
+                queryParams[key] = [];
+              }
+            }
+            value = pair[1] ? $$route$recognizer$$decodeQueryParamPart(pair[1]) : '';
+          }
+          if (isArray) {
+            queryParams[key].push(value);
+          } else {
+            queryParams[key] = value;
+          }
+        }
+        return queryParams;
+      },
+
+      recognize: function(path) {
+        var states = [ this.rootState ],
+            pathLen, i, l, queryStart, queryParams = {},
+            isSlashDropped = false;
+
+        queryStart = path.indexOf('?');
+        if (queryStart !== -1) {
+          var queryString = path.substr(queryStart + 1, path.length);
+          path = path.substr(0, queryStart);
+          queryParams = this.parseQueryString(queryString);
+        }
+
+        path = decodeURI(path);
+
+        // DEBUG GROUP path
+
+        if (path.charAt(0) !== "/") { path = "/" + path; }
+
+        pathLen = path.length;
+        if (pathLen > 1 && path.charAt(pathLen - 1) === "/") {
+          path = path.substr(0, pathLen - 1);
+          isSlashDropped = true;
+        }
+
+        for (i=0, l=path.length; i<l; i++) {
+          states = $$route$recognizer$$recognizeChar(states, path.charAt(i));
+          if (!states.length) { break; }
+        }
+
+        // END DEBUG GROUP
+
+        var solutions = [];
+        for (i=0, l=states.length; i<l; i++) {
+          if (states[i].handlers) { solutions.push(states[i]); }
+        }
+
+        states = $$route$recognizer$$sortSolutions(solutions);
+
+        var state = solutions[0];
+
+        if (state && state.handlers) {
+          // if a trailing slash was dropped and a star segment is the last segment
+          // specified, put the trailing slash back
+          if (isSlashDropped && state.regex.source.slice(-5) === "(.+)$") {
+            path = path + "/";
+          }
+          return $$route$recognizer$$findHandler(state, path, queryParams);
+        }
+      }
+    };
+
+    $$route$recognizer$$RouteRecognizer.prototype.map = $$route$recognizer$dsl$$default;
+
+    $$route$recognizer$$RouteRecognizer.VERSION = '0.1.9';
+
+    var $$route$recognizer$$default = $$route$recognizer$$RouteRecognizer;
+
+    /* global define:true module:true window: true */
+    if (typeof define === 'function' && define['amd']) {
+      define('route-recognizer', function() { return $$route$recognizer$$default; });
+    } else if (typeof module !== 'undefined' && module['exports']) {
+      module['exports'] = $$route$recognizer$$default;
+    } else if (typeof this !== 'undefined') {
+      this['RouteRecognizer'] = $$route$recognizer$$default;
+    }
+}).call(this);
+
+//# sourceMappingURL=route-recognizer.js.map