upjs-rails 0.1.0 → 0.2.0

data/dist/up.js

@@ -0,0 +1,2552 @@
+
+/**
+@module up
+ */
+
+(function() {
+  window.up = {};
+
+}).call(this);
+
+/**
+Utility functions
+=================
+  
+All methods in this module are for internal use by the Up.js framework
+and will frequently change between releases.
+  
+If you use them in your own code, you will get hurt.  
+  
+@protected
+@class up.util
+ */
+
+(function() {
+  var __slice = [].slice;
+
+  up.util = (function() {
+    var $createElementFromSelector, ajax, castsToFalse, castsToTrue, clientSize, contains, copy, copyAttributes, createElement, createElementFromHtml, createSelectorFromElement, cssAnimate, detect, each, error, escapePressed, extend, findWithSelf, get, ifGiven, isArray, isBlank, isDefined, isFunction, isGiven, isHash, isJQuery, isMissing, isNull, isObject, isPresent, isPromise, isStandardPort, isString, isUndefined, last, measure, merge, nextFrame, normalizeUrl, option, options, prependGhost, presence, presentAttr, select, temporaryCss, unwrap;
+    get = function(url, options) {
+      options = options || {};
+      options.url = url;
+      return ajax(options);
+    };
+    ajax = function(options) {
+      if (options.selector) {
+        options.headers = {
+          "X-Up-Selector": options.selector
+        };
+      }
+      return $.ajax(options);
+    };
+
+    /**
+    @method up.util.isStandardPort
+    @private
+     */
+    isStandardPort = function(protocol, port) {
+      return ((port === "" || port === "80") && protocol === 'http:') || (port === "443" && protocol === 'https:');
+    };
+
+    /**
+    Normalizes URLs, relative paths and absolute paths to a full URL
+    that can be checked for equality with other normalized URL.
+    
+    By default hashes are ignored, search queries are included.
+    
+    @method up.util.normalizeUrl
+    @param {Boolean} [options.hash=false]
+    @param {Boolean} [options.search=true]
+    @protected
+     */
+    normalizeUrl = function(urlOrAnchor, options) {
+      var anchor, normalized;
+      anchor = isString(urlOrAnchor) ? $('<a>').attr({
+        href: urlOrAnchor
+      }).get(0) : unwrap(urlOrAnchor);
+      normalized = anchor.protocol + "//" + anchor.hostname;
+      if (!isStandardPort(anchor.protocol, anchor.port)) {
+        normalized += ":" + anchor.port;
+      }
+      normalized += anchor.pathname;
+      if ((options != null ? options.hash : void 0) === true) {
+        normalized += anchor.hash;
+      }
+      if ((options != null ? options.search : void 0) !== false) {
+        normalized += anchor.search;
+      }
+      return normalized;
+    };
+    $createElementFromSelector = function(selector) {
+      var $element, $parent, $root, classes, conjunction, depthSelector, expression, html, id, iteration, path, tag, _i, _j, _len, _len1;
+      path = selector.split(/[ >]/);
+      $root = null;
+      for (iteration = _i = 0, _len = path.length; _i < _len; iteration = ++_i) {
+        depthSelector = path[iteration];
+        conjunction = depthSelector.match(/(^|\.|\#)[A-Za-z0-9\-_]+/g);
+        tag = "div";
+        classes = [];
+        id = null;
+        for (_j = 0, _len1 = conjunction.length; _j < _len1; _j++) {
+          expression = conjunction[_j];
+          switch (expression[0]) {
+            case ".":
+              classes.push(expression.substr(1));
+              break;
+            case "#":
+              id = expression.substr(1);
+              break;
+            default:
+              tag = expression;
+          }
+        }
+        html = "<" + tag;
+        if (classes.length) {
+          html += " class=\"" + classes.join(" ") + "\"";
+        }
+        if (id) {
+          html += " id=\"" + id + "\"";
+        }
+        html += ">";
+        $element = $(html);
+        if ($parent) {
+          $element.appendTo($parent);
+        }
+        if (iteration === 0) {
+          $root = $element;
+        }
+        $parent = $element;
+      }
+      return $root;
+    };
+    createElement = function(tagName, html) {
+      var element;
+      element = document.createElement(tagName);
+      element.innerHTML = html;
+      return element;
+    };
+    error = function() {
+      var args, message;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      message = args.length === 1 && up.util.isString(args[0]) ? args[0] : JSON.stringify(args);
+      console.log.apply(console, ["[UP] Error: " + message].concat(__slice.call(args)));
+      alert(message);
+      throw message;
+    };
+    createSelectorFromElement = function($element) {
+      var classString, classes, id, klass, selector, _i, _len;
+      console.log("Creating selector from element", $element);
+      classes = (classString = $element.attr("class")) ? classString.split(" ") : [];
+      id = $element.attr("id");
+      selector = $element.prop("tagName").toLowerCase();
+      if (id) {
+        selector += "#" + id;
+      }
+      for (_i = 0, _len = classes.length; _i < _len; _i++) {
+        klass = classes[_i];
+        selector += "." + klass;
+      }
+      return selector;
+    };
+    createElementFromHtml = function(html) {
+      var htmlElementPattern, innerHtml, match;
+      htmlElementPattern = /<html>((?:.|\n)*)<\/html>/i;
+      innerHtml = void 0;
+      if (match = html.match(htmlElementPattern)) {
+        innerHtml = match[1];
+      } else {
+        innerHtml = "<html><body>" + html + "</body></html>";
+      }
+      return createElement('html', innerHtml);
+    };
+    extend = $.extend;
+    each = function(collection, block) {
+      var index, item, _i, _len, _results;
+      _results = [];
+      for (index = _i = 0, _len = collection.length; _i < _len; index = ++_i) {
+        item = collection[index];
+        _results.push(block(item, index));
+      }
+      return _results;
+    };
+    isNull = function(object) {
+      return object === null;
+    };
+    isUndefined = function(object) {
+      return object === void(0);
+    };
+    isDefined = function(object) {
+      return !isUndefined(object);
+    };
+    isMissing = function(object) {
+      return isUndefined(object) || isNull(object);
+    };
+    isGiven = function(object) {
+      return !isMissing(object);
+    };
+    isBlank = function(object) {
+      return isMissing(object) || (object.length === 0);
+    };
+    presence = function(object, checker) {
+      if (checker == null) {
+        checker = isPresent;
+      }
+      if (checker(object)) {
+        return object;
+      } else {
+        return null;
+      }
+    };
+    isPresent = function(object) {
+      return !isBlank(object);
+    };
+    isFunction = function(object) {
+      return typeof object === 'function';
+    };
+    isString = function(object) {
+      return typeof object === 'string';
+    };
+    isHash = function(object) {
+      return typeof object === 'object' && !!object;
+    };
+    isObject = function(object) {
+      return isHash(object) || (typeof object === 'function');
+    };
+    isJQuery = function(object) {
+      return object instanceof jQuery;
+    };
+    isPromise = function(object) {
+      return isFunction(object.then);
+    };
+    ifGiven = function(object) {
+      if (isGiven(object)) {
+        return object;
+      }
+    };
+    isArray = Array.isArray;
+    copy = function(object) {
+      if (isArray(object)) {
+        return object.slice();
+      } else {
+        return extend({}, object);
+      }
+    };
+    unwrap = function(object) {
+      if (isJQuery(object)) {
+        return object.get(0);
+      } else {
+        return object;
+      }
+    };
+    merge = function(object, otherObject) {
+      return extend(copy(object), otherObject);
+    };
+    options = function(object, defaults) {
+      var defaultValue, key, merged, value;
+      merged = object ? copy(object) : {};
+      if (defaults) {
+        for (key in defaults) {
+          defaultValue = defaults[key];
+          value = merged[key];
+          if (!isGiven(value)) {
+            merged[key] = defaultValue;
+          } else if (isObject(defaultValue) && isObject(value)) {
+            merged[key] = options(value, defaultValue);
+          }
+        }
+      }
+      return merged;
+    };
+
+    /**
+    Returns the first argument that is considered present.
+    If an argument is a function, it is called and the value is checked for presence.
+    
+    This function is useful when you have multiple option sources and the value can be boolean.
+    In that case you cannot change the sources with a `||` operator
+    (since that doesn't short-circuit at `false`).
+    
+    @method up.util.option
+    @param {Array} args...
+     */
+    option = function() {
+      var args;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      return detect(args, function(arg) {
+        var value;
+        value = arg;
+        if (isFunction(value)) {
+          value = value();
+        }
+        return isPresent(value);
+      });
+    };
+    detect = function(array, tester) {
+      var match;
+      match = null;
+      array.every(function(element) {
+        if (tester(element)) {
+          match = element;
+          return false;
+        } else {
+          return true;
+        }
+      });
+      return match;
+    };
+    select = function(array, tester) {
+      var matches;
+      matches = [];
+      each(array, function(element) {
+        if (tester(element)) {
+          return matches.push(element);
+        }
+      });
+      return matches;
+    };
+    presentAttr = function() {
+      var $element, attrName, attrNames, values;
+      $element = arguments[0], attrNames = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      values = (function() {
+        var _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = attrNames.length; _i < _len; _i++) {
+          attrName = attrNames[_i];
+          _results.push($element.attr(attrName));
+        }
+        return _results;
+      })();
+      return detect(values, isPresent);
+    };
+    nextFrame = function(block) {
+      return setTimeout(block, 0);
+    };
+    last = function(array) {
+      return array[array.length - 1];
+    };
+    clientSize = function() {
+      var element;
+      element = document.documentElement;
+      return {
+        width: element.clientWidth,
+        height: element.clientHeight
+      };
+    };
+    temporaryCss = function($element, css, block) {
+      var memo, oldCss;
+      oldCss = $element.css(Object.keys(css));
+      $element.css(css);
+      memo = function() {
+        return $element.css(oldCss);
+      };
+      if (block) {
+        block();
+        return memo();
+      } else {
+        return memo;
+      }
+    };
+
+    /**
+    Animates the given element's CSS properties using CSS transitions.
+    
+    @method up.util.cssAnimate
+    @param {Element|jQuery|String} elementOrSelector
+      The element to animate.
+    @param {Object} lastFrame
+      The CSS properties that should be transitioned to.
+    @param {Number} [opts.duration=300]
+      The duration of the animation, in milliseconds.
+    @param {Number} [opts.delay=0]
+      The delay before the animation starts, in milliseconds.
+    @param {String} [opts.easing='ease']
+      The timing function that controls the animation's acceleration.
+      See [W3C documentation](http://www.w3.org/TR/css3-transitions/#transition-timing-function)
+      for a list of pre-defined timing functions.
+    @return
+      A promise for the animation's end.
+     */
+    cssAnimate = function(elementOrSelector, lastFrame, opts) {
+      var $element, deferred, transition, withoutTransition;
+      opts = options(opts, {
+        duration: 300,
+        delay: 0,
+        easing: 'ease'
+      });
+      $element = $(elementOrSelector);
+      deferred = $.Deferred();
+      transition = {
+        'transition-property': Object.keys(lastFrame).join(', '),
+        'transition-duration': opts.duration + "ms",
+        'transition-delay': opts.delay + "ms",
+        'transition-timing-function': opts.easing
+      };
+      withoutTransition = temporaryCss($element, transition);
+      $element.css(lastFrame);
+      deferred.then(withoutTransition);
+      setTimeout((function() {
+        return deferred.resolve();
+      }), opts.duration + opts.delay);
+      return deferred.promise();
+    };
+    measure = function($element, options) {
+      var box, offset, viewport;
+      offset = $element.offset();
+      box = {
+        left: offset.left,
+        top: offset.top,
+        width: $element.outerWidth(),
+        height: $element.outerHeight()
+      };
+      if (options != null ? options.full : void 0) {
+        viewport = clientSize();
+        box.right = viewport.width - (box.left + box.width);
+        box.bottom = viewport.height - (box.top + box.height);
+      }
+      return box;
+    };
+    copyAttributes = function($source, $target) {
+      var attr, _i, _len, _ref, _results;
+      _ref = $source.get(0).attributes;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        attr = _ref[_i];
+        if (attr.specified) {
+          _results.push($target.attr(attr.name, attr.value));
+        } else {
+          _results.push(void 0);
+        }
+      }
+      return _results;
+    };
+    prependGhost = function($element) {
+      var $ghost, dimensions;
+      dimensions = measure($element);
+      $ghost = $element.clone();
+      $ghost.find('script').remove();
+      $ghost.css({
+        right: '',
+        bottom: '',
+        margin: 0,
+        position: 'absolute'
+      });
+      $ghost.css(dimensions);
+      $ghost.addClass('up-ghost');
+      return $ghost.prependTo(document.body);
+    };
+    findWithSelf = function($element, selector) {
+      return $element.find(selector).addBack(selector);
+    };
+    escapePressed = function(event) {
+      return event.keyCode === 27;
+    };
+    contains = function(array, element) {
+      return array.indexOf(element) >= 0;
+    };
+    castsToTrue = function(object) {
+      return String(object) === "true";
+    };
+    castsToFalse = function(object) {
+      return String(object) === "false";
+    };
+    return {
+      presentAttr: presentAttr,
+      createElement: createElement,
+      normalizeUrl: normalizeUrl,
+      createElementFromHtml: createElementFromHtml,
+      $createElementFromSelector: $createElementFromSelector,
+      createSelectorFromElement: createSelectorFromElement,
+      get: get,
+      ajax: ajax,
+      extend: extend,
+      copy: copy,
+      merge: merge,
+      options: options,
+      option: option,
+      error: error,
+      each: each,
+      detect: detect,
+      select: select,
+      last: last,
+      isNull: isNull,
+      isDefined: isDefined,
+      isUndefined: isUndefined,
+      isGiven: isGiven,
+      isMissing: isMissing,
+      isPresent: isPresent,
+      isBlank: isBlank,
+      presence: presence,
+      isObject: isObject,
+      isFunction: isFunction,
+      isString: isString,
+      isJQuery: isJQuery,
+      isPromise: isPromise,
+      isHash: isHash,
+      ifGiven: ifGiven,
+      unwrap: unwrap,
+      nextFrame: nextFrame,
+      measure: measure,
+      temporaryCss: temporaryCss,
+      cssAnimate: cssAnimate,
+      prependGhost: prependGhost,
+      escapePressed: escapePressed,
+      copyAttributes: copyAttributes,
+      findWithSelf: findWithSelf,
+      contains: contains,
+      isArray: isArray,
+      castsToTrue: castsToTrue,
+      castsToFalse: castsToFalse
+    };
+  })();
+
+}).call(this);
+
+/**
+Browser interface
+=================
+  
+@class up.browser
+ */
+
+(function() {
+  up.browser = (function() {
+    var url;
+    url = function() {
+      return location.href;
+    };
+    return {
+      url: url
+    };
+  })();
+
+}).call(this);
+
+/**
+Framework events
+================
+  
+TODO: Write some documentation  
+
+This class is kind-of internal and in flux.
+This might eventually be rolled into regular document events.
+
+- `app:ready`
+- `fragment:ready` with arguments `($fragment)`
+- `fragment:destroy` with arguments `($fragment)`
+
+@class up.bus
+ */
+
+(function() {
+  var __slice = [].slice;
+
+  up.bus = (function() {
+    var callbacksByEvent, callbacksFor, defaultCallbacksByEvent, emit, listen, reset, snapshot;
+    callbacksByEvent = {};
+    defaultCallbacksByEvent = {};
+    callbacksFor = function(event) {
+      return callbacksByEvent[event] || (callbacksByEvent[event] = []);
+    };
+
+    /**
+    Makes a snapshot of the currently registered bus listeners,
+    to later be restored through [`up.bus.reset`](/up.bus#up.bus.reset)
+    
+    @private
+    @method up.bus.snapshot
+     */
+    snapshot = function() {
+      var callbacks, event, _results;
+      defaultCallbacksByEvent = {};
+      _results = [];
+      for (event in callbacksByEvent) {
+        callbacks = callbacksByEvent[event];
+        _results.push(defaultCallbacksByEvent[event] = up.util.copy(callbacks));
+      }
+      return _results;
+    };
+
+    /**
+    Resets the list of registered event listeners to the
+    moment when the framework was booted.
+    
+    @private
+    @method up.bus.reset
+     */
+    reset = function() {
+      return callbacksByEvent = up.util.copy(defaultCallbacksByEvent);
+    };
+
+    /**
+    Registers an event handler to be called when the given
+    event is triggered.
+    
+    @method up.bus.listen
+    @param {String} eventName
+      The event name to match.
+    @param {Function} handler
+      The event handler to be called with the event arguments.
+     */
+    listen = function(eventName, handler) {
+      return callbacksFor(eventName).push(handler);
+    };
+
+    /**
+    Triggers an event.
+    
+    @method up.bus.emit
+    @param {String} eventName
+      The name of the event.
+    @param {Anything...} args
+      The arguments that describe the event.
+     */
+    emit = function() {
+      var args, callbacks, eventName;
+      eventName = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      console.log("bus emitting", eventName, args);
+      callbacks = callbacksFor(eventName);
+      return up.util.each(callbacks, function(callback) {
+        return callback.apply(null, args);
+      });
+    };
+    listen('framework:ready', snapshot);
+    listen('framework:reset', reset);
+    return {
+      on: listen,
+      emit: emit
+    };
+  })();
+
+}).call(this);
+
+/**
+Changing page fragments programmatically
+========================================
+
+TODO: Write some documentation
+
+
+@class up.flow
+ */
+
+(function() {
+  up.flow = (function() {
+    var autofocus, destroy, elementsInserted, implant, implantSteps, reload, replace, reset, setSource, source, swapElements, u;
+    u = up.util;
+    setSource = function(element, sourceUrl) {
+      var $element;
+      $element = $(element);
+      if (u.isPresent(sourceUrl)) {
+        sourceUrl = u.normalizeUrl(sourceUrl);
+      }
+      return $element.attr("up-source", sourceUrl);
+    };
+    source = function(element) {
+      var $element;
+      $element = $(element).closest("[up-source]");
+      return u.presence($element.attr("up-source")) || up.browser.url();
+    };
+
+    /**
+    Replaces elements on the current page with corresponding elements
+    from a new page fetched from the server.
+    
+    The current and new elements must have the same CSS selector.
+    
+    @method up.replace
+    @param {String|Element|jQuery} selectorOrElement
+      The CSS selector to update. You can also pass a DOM element or jQuery element
+      here, in which case a selector will be inferred from the element's class and ID.
+    @param {String} url
+      The URL to fetch from the server.
+    @param {String} [options.title]
+    @param {String|Boolean} [options.history=true]
+      If a `String` is given, it is used as the URL the browser's location bar and history.
+      If omitted or true, the `url` argument will be used.
+      If set to `false`, the history will remain unchanged.
+    @param {String|Boolean} [options.source=true]
+    @param {String} [options.transition]
+    @param {String} [options.historyMethod='push']
+     */
+    replace = function(selectorOrElement, url, options) {
+      var selector;
+      options = u.options(options);
+      selector = u.presence(selectorOrElement) ? selectorOrElement : u.createSelectorFromElement($(selectorOrElement));
+      if (u.isMissing(options.history) || u.castsToTrue(options.history)) {
+        options.history = url;
+      }
+      if (u.isMissing(options.source) || u.castsToTrue(options.source)) {
+        options.source = url;
+      }
+      return u.get(url, {
+        selector: selector
+      }).done(function(html) {
+        return implant(selector, html, options);
+      }).fail(u.error);
+    };
+
+    /**
+    Replaces the given selector with the same selector from the given HTML string.
+    
+    @method up.flow.implant
+    @protected
+    @param {String} selector
+    @param {String} html
+    @param {String} [options.title]
+    @param {String} [options.source]
+    @param {Object} [options.transition]
+    @param {String} [options.history]
+    @param {String} [options.historyMethod='push']
+     */
+    implant = function(selector, html, options) {
+      var $new, $old, fragment, htmlElement, step, _i, _len, _ref, _ref1, _results;
+      options = u.options(options, {
+        historyMethod: 'push'
+      });
+      htmlElement = u.createElementFromHtml(html);
+      options.title || (options.title = (_ref = htmlElement.querySelector("title")) != null ? _ref.textContent : void 0);
+      _ref1 = implantSteps(selector, options);
+      _results = [];
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        step = _ref1[_i];
+        $old = u.presence($(".up-popup " + step.selector)) || u.presence($(".up-modal " + step.selector)) || u.presence($(step.selector));
+        if (fragment = htmlElement.querySelector(step.selector)) {
+          $new = $(fragment);
+          _results.push(swapElements($old, $new, step.pseudoClass, step.transition, options));
+        } else {
+          _results.push(u.error("Could not find selector (" + step.selector + ") in response (" + html + ")"));
+        }
+      }
+      return _results;
+    };
+    elementsInserted = function($new, options) {
+      return $new.each(function() {
+        var $element;
+        $element = $(this);
+        if (typeof options.insert === "function") {
+          options.insert($element);
+        }
+        if (options.history) {
+          if (options.title) {
+            document.title = options.title;
+          }
+          up.history[options.historyMethod](options.history);
+        }
+        setSource($element, u.presence(options.source) || options.history);
+        autofocus($element);
+        return up.ready($element);
+      });
+    };
+    swapElements = function($old, $new, pseudoClass, transition, options) {
+      var $addedChildren, insertionMethod;
+      transition || (transition = 'none');
+      if (pseudoClass) {
+        insertionMethod = pseudoClass === 'before' ? 'prepend' : 'append';
+        $addedChildren = $new.children();
+        $old[insertionMethod]($new.contents());
+        u.copyAttributes($new, $old);
+        elementsInserted($addedChildren, options);
+        return up.animate($new, transition);
+      } else {
+        return destroy($old, {
+          animation: function() {
+            $new.insertAfter($old);
+            elementsInserted($new, options);
+            if ($old.is('body') && transition !== 'none') {
+              u.error('Cannot apply transitions to body-elements', transition);
+            }
+            return up.morph($old, $new, transition);
+          }
+        });
+      }
+    };
+    implantSteps = function(selector, options) {
+      var comma, disjunction, i, selectorAtom, selectorParts, transition, transitionString, transitions, _i, _len, _results;
+      transitionString = options.transition || options.animation || 'none';
+      comma = /\ *,\ */;
+      disjunction = selector.split(comma);
+      if (u.isPresent(transitionString)) {
+        transitions = transitionString.split(comma);
+      }
+      _results = [];
+      for (i = _i = 0, _len = disjunction.length; _i < _len; i = ++_i) {
+        selectorAtom = disjunction[i];
+        selectorParts = selectorAtom.match(/^(.+?)(?:\:(before|after))?$/);
+        transition = transitions[i] || u.last(transitions);
+        _results.push({
+          selector: selectorParts[1],
+          pseudoClass: selectorParts[2],
+          transition: transition
+        });
+      }
+      return _results;
+    };
+    autofocus = function($element) {
+      var $control, selector;
+      selector = '[autofocus]:last';
+      $control = u.findWithSelf($element, selector);
+      if ($control.length && $control.get(0) !== document.activeElement) {
+        return $control.focus();
+      }
+    };
+
+    /**
+    Destroys the given element or selector.
+    Takes care that all destructors, if any, are called.
+    
+    @method up.destroy
+    @param {String|Element|jQuery} selectorOrElement 
+    @param {String|Function|Object} [options.animation]
+    @param {String} [options.url]
+    @param {String} [options.title]
+     */
+    destroy = function(selectorOrElement, options) {
+      var $element, animationPromise;
+      $element = $(selectorOrElement);
+      options = u.options(options, {
+        animation: 'none'
+      });
+      $element.addClass('up-destroying');
+      if (u.isPresent(options.url)) {
+        up.history.push(options.url);
+      }
+      if (u.isPresent(options.title)) {
+        document.title = options.title;
+      }
+      up.bus.emit('fragment:destroy', $element);
+      animationPromise = u.presence(options.animation, u.isPromise) || up.motion.animate($element, options.animation);
+      return animationPromise.then(function() {
+        return $element.remove();
+      });
+    };
+
+    /**
+    Replaces the given selector or element with a fresh copy
+    fetched from the server.
+    
+    @method up.reload
+    @param {String|Element|jQuery} selectorOrElement
+     */
+    reload = function(selectorOrElement) {
+      var sourceUrl;
+      sourceUrl = source(selectorOrElement);
+      return replace(selectorOrElement, sourceUrl);
+    };
+
+    /**
+    Resets Up.js to the state when it was booted.
+    All custom event handlers, animations, etc. that have been registered
+    will be discarded.
+    
+    This is an internal method for to enable unit testing.
+    Don't use this in production.
+    
+    @protected
+    @method up.reset
+     */
+    reset = function() {
+      return up.bus.emit('framework:reset');
+    };
+    up.bus.on('app:ready', function() {
+      return setSource(document.body, up.browser.url());
+    });
+    return {
+      replace: replace,
+      reload: reload,
+      destroy: destroy,
+      implant: implant,
+      reset: reset
+    };
+  })();
+
+  up.replace = up.flow.replace;
+
+  up.reload = up.flow.reload;
+
+  up.destroy = up.flow.destroy;
+
+  up.reset = up.flow.reset;
+
+}).call(this);
+
+/**
+Registering behavior and custom elements
+========================================
+  
+TODO: Write some documentation  
+  
+@class up.magic
+ */
+
+(function() {
+  up.magic = (function() {
+    var DESTROYABLE_CLASS, DESTROYER_KEY, awaken, awakeners, compile, defaultAwakeners, defaultLiveDescriptions, destroy, live, liveDescriptions, onEscape, ready, reset, snapshot, util;
+    util = up.util;
+    DESTROYABLE_CLASS = 'up-destroyable';
+    DESTROYER_KEY = 'up-destroyer';
+
+    /**
+    Binds an event handler to the document,
+    which will be executed whenever the given event
+    is triggered on the given selector.
+    
+    @method up.on
+    @param {String} events
+      A space-separated list of event names to bind.
+    @param {String} selector
+      The selector an on which the event must be triggered.
+    @param {Function} behavior
+      The handler that should be called.
+     */
+    liveDescriptions = [];
+    defaultLiveDescriptions = null;
+    live = function(events, selector, behavior) {
+      var description, _ref;
+      description = [
+        events, selector, function(event) {
+          return behavior.apply(this, [event, $(this)]);
+        }
+      ];
+      liveDescriptions.push(description);
+      return (_ref = $(document)).on.apply(_ref, description);
+    };
+
+    /**
+    Registers a function to be called whenever an element with
+    the given selector is inserted into the DOM through Up.js.
+    
+    @method up.awaken
+    @param {String} selector
+      The selector to match.
+    @param {Function($element)} awakener
+      The function to call when a matching element is inserted.
+      The function takes the new element as the first argument (as a jQuery object).
+    
+      The function may return another function that destroys the awakened
+      object when it is removed from the DOM, by clearing global state such as
+      time-outs and event handlers bound to the document.
+     */
+    awakeners = [];
+    defaultAwakeners = null;
+    awaken = function(selector, awakener) {
+      return awakeners.push({
+        selector: selector,
+        callback: awakener
+      });
+    };
+    compile = function($fragment) {
+      var awakener, _i, _len, _results;
+      console.log("Compiling fragment", $fragment, "with", awakeners);
+      _results = [];
+      for (_i = 0, _len = awakeners.length; _i < _len; _i++) {
+        awakener = awakeners[_i];
+        console.log("running", awakener.selector, "on", $fragment);
+        _results.push(util.findWithSelf($fragment, awakener.selector).each(function() {
+          var $element, destroyer;
+          $element = $(this);
+          destroyer = awakener.callback.apply(this, [$element]);
+          console.log("got destroyer", destroyer);
+          if (util.isFunction(destroyer)) {
+            $element.addClass(DESTROYABLE_CLASS);
+            return $element.data(DESTROYER_KEY, destroyer);
+          }
+        }));
+      }
+      return _results;
+    };
+    destroy = function($fragment) {
+      return util.findWithSelf($fragment, "." + DESTROYABLE_CLASS).each(function() {
+        var $element, destroyer;
+        $element = $(this);
+        destroyer = $element.data(DESTROYER_KEY);
+        return destroyer();
+      });
+    };
+
+    /**
+    Makes a snapshot of the currently registered event listeners,
+    to later be restored through [`up.bus.reset`](/up.bus#up.bus.reset).
+    
+    @private
+    @method up.magic.snapshot
+     */
+    snapshot = function() {
+      defaultLiveDescriptions = util.copy(liveDescriptions);
+      return defaultAwakeners = util.copy(awakeners);
+    };
+
+    /**
+    Resets the list of registered event listeners to the
+    moment when the framework was booted.
+    
+    @private
+    @method up.magic.reset
+     */
+    reset = function() {
+      var description, _i, _len, _ref;
+      for (_i = 0, _len = liveDescriptions.length; _i < _len; _i++) {
+        description = liveDescriptions[_i];
+        if (!util.contains(defaultLiveDescriptions, description)) {
+          (_ref = $(document)).off.apply(_ref, description);
+        }
+      }
+      liveDescriptions = util.copy(defaultLiveDescriptions);
+      return awakeners = util.copy(defaultAwakeners);
+    };
+
+    /**
+    Sends a notification that the given element has been inserted
+    into the DOM. This causes Up.js to compile the fragment (apply
+    event listeners, etc.).
+    
+    This method is called automatically if you change elements through
+    other Up.js methods. You will only need to call this if you
+    manipulate the DOM without going through Up.js.
+    
+    @method up.ready
+    @param {String|Element|jQuery} selectorOrFragment
+     */
+    ready = function(selectorOrFragment) {
+      var $fragment;
+      $fragment = $(selectorOrFragment);
+      up.bus.emit('fragment:ready', $fragment);
+      return $fragment;
+    };
+    onEscape = function(handler) {
+      return live('keydown', 'body', function(event) {
+        if (util.escapePressed(event)) {
+          return handler(event);
+        }
+      });
+    };
+    up.bus.on('app:ready', (function() {
+      return ready(document.body);
+    }));
+    up.bus.on('fragment:ready', compile);
+    up.bus.on('fragment:destroy', destroy);
+    up.bus.on('framework:ready', snapshot);
+    up.bus.on('framework:reset', reset);
+    return {
+      awaken: awaken,
+      on: live,
+      ready: ready,
+      onEscape: onEscape
+    };
+  })();
+
+  up.awaken = up.magic.awaken;
+
+  up.on = up.magic.on;
+
+  up.ready = up.magic.ready;
+
+}).call(this);
+
+/**
+Manipulating the browser history
+=======
+  
+TODO: Write some documentation
+  
+@class up.history
+ */
+
+(function() {
+  up.history = (function() {
+    var isCurrentUrl, manipulate, pop, push, replace, u;
+    u = up.util;
+    isCurrentUrl = function(url) {
+      return u.normalizeUrl(url, {
+        hash: true
+      }) === u.normalizeUrl(up.browser.url(), {
+        hash: true
+      });
+    };
+
+    /**
+    @method up.history.replace
+    @param {String} url
+    @protected
+     */
+    replace = function(url) {
+      if (!isCurrentUrl(url)) {
+        return manipulate("replace", url);
+      }
+    };
+
+    /**
+    @method up.history.push  
+    @param {String} url
+    @protected
+     */
+    push = function(url) {
+      if (!isCurrentUrl(url)) {
+        return manipulate("push", url);
+      }
+    };
+    manipulate = function(method, url) {
+      method += "State";
+      return window.history[method]({
+        fromUp: true
+      }, '', url);
+    };
+    pop = function(event) {
+      var state;
+      state = event.originalEvent.state;
+      console.log("popping state", state);
+      console.log("current href", up.browser.url());
+      if (state != null ? state.fromUp : void 0) {
+        return up.visit(up.browser.url(), {
+          historyMethod: 'replace'
+        });
+      } else {
+        return console.log("null state");
+      }
+    };
+    setTimeout((function() {
+      $(window).on("popstate", pop);
+      return replace(up.browser.url());
+    }), 200);
+    return {
+      push: push,
+      replace: replace
+    };
+  })();
+
+}).call(this);
+
+/**
+Animation and transitions
+=========================
+  
+TODO: Write some documentation.
+  
+@class up.motion
+ */
+
+(function() {
+  up.motion = (function() {
+    var animate, animation, animations, assertIsPromise, defaultAnimations, defaultOptions, defaultTransitions, findAnimation, morph, none, reset, snapshot, transition, transitions, u, withGhosts;
+    u = up.util;
+    defaultOptions = {
+      duration: 300,
+      delay: 0,
+      easing: 'ease'
+    };
+    animations = {};
+    defaultAnimations = {};
+    transitions = {};
+    defaultTransitions = {};
+
+    /**
+    Animates an element.
+    
+    The following animations are pre-registered:
+    
+    - `fade-in`
+    - `fade-out`
+    - `move-to-top`
+    - `move-from-top`
+    - `move-to-bottom`
+    - `move-from-bottom`
+    - `move-to-left`
+    - `move-from-left`
+    - `move-to-right`
+    - `move-from-right`
+    - `none`
+    
+    @method up.animate
+    @param {Element|jQuery|String} elementOrSelector
+    @param {String|Function|Object} animation
+    @param {Number} [options.duration]
+    @param {String} [options.easing]
+    @param {Number} [options.delay]
+    @return {Promise}
+      A promise for the animation's end.
+     */
+    animate = function(elementOrSelector, animation, options) {
+      var $element;
+      $element = $(elementOrSelector);
+      options = u.options(options, defaultOptions);
+      if (u.isFunction(animation)) {
+        return assertIsPromise(animation($element, options), ["Animation did not return a Promise", animation]);
+      } else if (u.isString(animation)) {
+        return animate($element, findAnimation(animation), options);
+      } else if (u.isHash(animation)) {
+        return u.cssAnimate($element, animation, options);
+      } else {
+        return u.error("Unknown animation type", animation);
+      }
+    };
+    findAnimation = function(name) {
+      return animations[name] || u.error("Unknown animation", animation);
+    };
+    withGhosts = function($old, $new, block) {
+      var $newGhost, $oldGhost, newCssMemo, promise;
+      $oldGhost = null;
+      $newGhost = null;
+      u.temporaryCss($new, {
+        display: 'none'
+      }, function() {
+        return $oldGhost = u.prependGhost($old).addClass('up-destroying');
+      });
+      u.temporaryCss($old, {
+        display: 'none'
+      }, function() {
+        return $newGhost = u.prependGhost($new);
+      });
+      $old.css({
+        visibility: 'hidden'
+      });
+      newCssMemo = u.temporaryCss($new, {
+        display: 'none'
+      });
+      promise = block($oldGhost, $newGhost);
+      return promise.then(function() {
+        $oldGhost.remove();
+        $newGhost.remove();
+        $old.css({
+          display: 'none'
+        });
+        return newCssMemo();
+      });
+    };
+    assertIsPromise = function(object, messageParts) {
+      u.isPromise(object) || u.error.apply(u, messageParts);
+      return object;
+    };
+
+    /**
+    Performs a transition between two elements.
+    
+    The following transitions  are pre-registered:
+    
+    - `cross-fade`
+    - `move-top`
+    - `move-bottom`
+    - `move-left`
+    - `move-right`
+    - `none`
+    
+    You can also compose a transition from two animation names
+    separated by a slash character (`/`):
+    
+    - `move-to-bottom/fade-in`
+    - `move-to-left/move-from-top`
+    
+    @method up.morph
+    @param {Element|jQuery|String} source
+    @param {Element|jQuery|String} target
+    @param {Function|String} transitionOrName
+    @param {Number} [options.duration]
+    @param {String} [options.easing]
+    @param {Number} [options.delay]
+    @return {Promise}
+      A promise for the transition's end.
+     */
+    morph = function(source, target, transitionOrName, options) {
+      var $new, $old, animation, parts, transition;
+      options = u.options(defaultOptions);
+      $old = $(source);
+      $new = $(target);
+      transition = u.presence(transitionOrName, u.isFunction) || transitions[transitionOrName];
+      if (transition) {
+        return withGhosts($old, $new, function($oldGhost, $newGhost) {
+          return assertIsPromise(transition($oldGhost, $newGhost, options), ["Transition did not return a promise", transitionOrName]);
+        });
+      } else if (animation = animations[transitionOrName]) {
+        $old.hide();
+        return animate($new, animation, options);
+      } else if (u.isString(transitionOrName) && transitionOrName.indexOf('/') >= 0) {
+        parts = transitionOrName.split('/');
+        transition = function($old, $new, options) {
+          return $.when(animate($old, parts[0], options), animate($new, parts[1], options));
+        };
+        return morph($old, $new, transition, options);
+      } else {
+        return u.error("Unknown transition: " + transitionOrName);
+      }
+    };
+
+    /**
+    Defines a named transition.
+    
+    @method up.transition
+    @param {String} name
+    @param {Function} transition
+     */
+    transition = function(name, transition) {
+      return transitions[name] = transition;
+    };
+
+    /**
+    Defines a named animation.
+    
+    @method up.animation
+    @param {String} name
+    @param {Function} animation
+     */
+    animation = function(name, animation) {
+      return animations[name] = animation;
+    };
+    snapshot = function() {
+      defaultAnimations = u.copy(animations);
+      return defaultTransitions = u.copy(transitions);
+    };
+    reset = function() {
+      animations = u.copy(defaultAnimations);
+      return transitions = u.copy(defaultTransitions);
+    };
+
+    /**
+    Returns a no-op animation or transition which has no visual effects
+    and completes instantly.
+    
+    @method up.motion.none
+    @return {Promise}
+      A resolved promise
+     */
+    none = function() {
+      var deferred;
+      deferred = $.Deferred();
+      deferred.resolve();
+      return deferred.promise();
+    };
+    animation('none', none);
+    animation('fade-in', function($ghost, options) {
+      $ghost.css({
+        opacity: 0
+      });
+      return animate($ghost, {
+        opacity: 1
+      }, options);
+    });
+    animation('fade-out', function($ghost, options) {
+      $ghost.css({
+        opacity: 1
+      });
+      return animate($ghost, {
+        opacity: 0
+      }, options);
+    });
+    animation('move-to-top', function($ghost, options) {
+      $ghost.css({
+        'margin-top': '0%'
+      });
+      return animate($ghost, {
+        'margin-top': '-100%'
+      }, options);
+    });
+    animation('move-from-top', function($ghost, options) {
+      $ghost.css({
+        'margin-top': '-100%'
+      });
+      return animate($ghost, {
+        'margin-top': '0%'
+      }, options);
+    });
+    animation('move-to-bottom', function($ghost, options) {
+      $ghost.css({
+        'margin-top': '0%'
+      });
+      return animate($ghost, {
+        'margin-top': '100%'
+      }, options);
+    });
+    animation('move-from-bottom', function($ghost, options) {
+      $ghost.css({
+        'margin-top': '100%'
+      });
+      return animate($ghost, {
+        'margin-top': '0%'
+      }, options);
+    });
+    animation('move-to-left', function($ghost, options) {
+      $ghost.css({
+        'margin-left': '0%'
+      });
+      return animate($ghost, {
+        'margin-left': '-100%'
+      }, options);
+    });
+    animation('move-from-left', function($ghost, options) {
+      $ghost.css({
+        'margin-left': '-100%'
+      });
+      return animate($ghost, {
+        'margin-left': '0%'
+      }, options);
+    });
+    animation('move-to-right', function($ghost, options) {
+      $ghost.css({
+        'margin-left': '0%'
+      });
+      return animate($ghost, {
+        'margin-left': '100%'
+      }, options);
+    });
+    animation('move-from-right', function($ghost, options) {
+      $ghost.css({
+        'margin-left': '100%'
+      });
+      return animate($ghost, {
+        'margin-left': '0%'
+      }, options);
+    });
+    animation('roll-down', function($ghost, options) {
+      var fullHeight, styleMemo;
+      fullHeight = $ghost.height();
+      styleMemo = u.temporaryCss($ghost, {
+        height: '0px',
+        overflow: 'hidden'
+      });
+      return animate($ghost, {
+        height: fullHeight + "px"
+      }, options).then(styleMemo);
+    });
+    transition('none', none);
+    transition('move-left', function($old, $new, options) {
+      return $.when(animate($old, 'move-to-left', options), animate($new, 'move-from-right', options));
+    });
+    transition('move-right', function($old, $new, options) {
+      return $.when(animate($old, 'move-to-right', options), animate($new, 'move-from-left', options));
+    });
+    transition('move-up', function($old, $new, options) {
+      return $.when(animate($old, 'move-to-top', options), animate($new, 'move-from-bottom', options));
+    });
+    transition('move-down', function($old, $new, options) {
+      return $.when(animate($old, 'move-to-bottom', options), animate($new, 'move-from-top', options));
+    });
+    transition('cross-fade', function($old, $new, options) {
+      return $.when(animate($old, 'fade-out', options), animate($new, 'fade-in', options));
+    });
+    up.bus.on('framework:ready', snapshot);
+    up.bus.on('framework:reset', reset);
+    return {
+      morph: morph,
+      animate: animate,
+      transition: transition,
+      animation: animation,
+      none: none
+    };
+  })();
+
+  up.transition = up.motion.transition;
+
+  up.animation = up.motion.animation;
+
+  up.morph = up.motion.morph;
+
+  up.animate = up.motion.animate;
+
+}).call(this);
+
+/**
+Linking to page fragments
+=========================
+
+Just like in a classical web application, an Up.js app renders a series of *full HTML pages* on the server.
+
+Let's say we are rendering three pages with a tabbed navigation to switch between screens:
+
+```
+  /pages/a                /pages/b                /pages/c
+
++---+---+---+           +---+---+---+           +---+---+---+
+| A | B | C |           | A | B | C |           | A | B | C |
+|   +--------  (click)  +---+   +----  (click)  +---+---+   |
+|           |  ======>  |           |  ======>  |           |
+|  Page A   |           |  Page B   |           |  Page C   |
+|           |           |           |           |           |
++-----------|           +-----------|           +-----------|
+```
+
+Your HTML could look like this:
+
+```
+<nav>
+  <a href="/pages/a">A</a>
+  <a href="/pages/b">B</a>
+  <a href="/pages/b">C</a>
+</nav>
+
+<article>
+  Page A
+</article>
+```
+
+Slow, full page loads. White flash during loading.
+
+
+Smoother flow by updating fragments
+-----------------------------------
+
+In Up.js you annotate navigation links with an `up-target` attribute.
+The value of this attribute is a CSS selector that indicates which page
+fragment to update.
+
+Since we only want to update the `<article>` tag, we will use `up-target="article"`:
+
+
+```
+<nav>
+  <a href="/pages/a" up-target="article">A</a>
+  <a href="/pages/b" up-target="article">B</a>
+  <a href="/pages/b" up-target="article">C</a>
+</nav>
+```
+
+Instead of `article` you can use any other CSS selector (e. g.  `#main .article`).
+
+With these `up-target` annotations Up.js only updates the targeted part of the screen.
+Javascript will not be reloaded, no white flash during a full page reload.
+
+
+Read on
+-------
+- You can [animate page transitions](/up.motion) by definining animations for fragments as they enter or leave the screen.
+- The `up-target` mechanism also works with [forms](/up.form).
+- As you switch through pages, Up.js will [update your browser's location bar and history](/up.history)
+- You can [open fragments in popups or modal dialogs](/up.modal).
+- You can give users [immediate feedback](/up.navigation) when a link is clicked or becomes current, without waiting for the server.
+- [Controlling Up.js pragmatically through Javascript](/up.flow)
+- [Defining custom tags and event handlers](/up.magic)
+
+  
+@class up.link
+ */
+
+(function() {
+  up.link = (function() {
+    var follow, resolve, resolveUrl, u, visit;
+    u = up.util;
+
+    /**
+    Visits the given URL without a full page load.
+    This is done by fetching `url` through an AJAX request
+    and replacing the current `<body>` element with the response's `<body>` element.
+    
+    @method up.visit
+    @param {String} url
+      The URL to visit.
+    @param {Object} options
+      See options for [`up.replace`](/up.flow#up.replace)
+    @example
+        up.visit('/users')
+     */
+    visit = function(url, options) {
+      console.log("up.visit", url);
+      return up.replace('body', url, options);
+    };
+
+    /**
+    Follows the given link via AJAX and replaces a CSS selector in the current page
+    with corresponding elements from a new page fetched from the server.
+    
+    @method up.follow
+    @param {Element|jQuery|String} link
+      An element or selector which resolves to an `<a>` tag
+      or any element that is marked up with an `up-follow` attribute.
+    @param {String} [options.target]
+      The selector to replace.
+      Defaults to the `up-target` attribute on `link`,
+      or to `body` if such an attribute does not exist.
+    @param {Function|String} [options.transition]
+      A transition function or name.
+     */
+    follow = function(link, options) {
+      var $link, selector, url;
+      $link = $(link);
+      options = u.options(options);
+      url = u.option($link.attr('href'), $link.attr('up-follow'));
+      selector = u.option(options.target, $link.attr('up-target'), 'body');
+      options.transition = u.option(options.transition, $link.attr('up-transition'), $link.attr('up-animation'));
+      options.history = u.option(options.history, $link.attr('up-history'));
+      return up.replace(selector, url, options);
+    };
+    resolve = function(element) {
+      var $element;
+      $element = $(element);
+      if ($element.is('a') || u.presentAttr($element, 'up-follow')) {
+        return $element;
+      } else {
+        return $element.find('a:first');
+      }
+    };
+    resolveUrl = function(element) {
+      var $link;
+      if ($link = resolve(element)) {
+        return u.option($link.attr('href'), $link.attr('up-follow'));
+      }
+    };
+
+    /**
+    Follows this link via AJAX and replaces a CSS selector in the current page
+    with corresponding elements from a new page fetched from the server.
+    
+        <a href="/users" up-target=".main">User list</a>
+    
+    @method a[up-target]
+    @ujs
+    @param {String} up-target
+      The CSS selector to replace
+     */
+    up.on('click', 'a[up-target]', function(event, $link) {
+      event.preventDefault();
+      return follow($link);
+    });
+
+    /**
+    If applied on a link, Follows this link via AJAX and replaces the
+    current `<body>` element with the response's `<body>` element
+    
+        <a href="/users" up-follow>User list</a>
+    
+    You can also apply `[up-follow]` to any element that contains a link
+    in order to enlarge the link's click area:
+    
+        <div class="notification" up-follow>
+           Record was saved!
+           <a href="/records">Close</a>
+        </div>
+    
+    In the example above, clicking anywhere within `.notification` element
+    would follow the `Close` link.
+    
+    @method [up-follow]
+    @ujs
+    @param {String} [up-follow]
+     */
+    up.on('click', '[up-follow]', function(event, $element) {
+      var childLinkClicked;
+      childLinkClicked = function() {
+        var $target, $targetLink;
+        $target = $(event.target);
+        $targetLink = $target.closest('a, [up-follow]');
+        return $targetLink.length && $element.find($targetLink).length;
+      };
+      if (!childLinkClicked()) {
+        event.preventDefault();
+        return follow(resolve($element));
+      }
+    });
+    return {
+      visit: visit,
+      follow: follow,
+      resolve: resolve,
+      resolveUrl: resolveUrl
+    };
+  })();
+
+  up.visit = up.link.visit;
+
+  up.follow = up.link.follow;
+
+}).call(this);
+
+/**
+Forms and controls
+==================
+  
+TODO: Write some documentation
+  
+@class up.form
+ */
+
+(function() {
+  up.form = (function() {
+    var observe, submit, u;
+    u = up.util;
+
+    /**
+    Submits a form using the Up.js flow:
+    
+        up.submit('form.new_user')
+    
+    @method up.submit
+    @param {Element|jQuery|String} formOrSelector
+      A reference or selector for the form to submit.
+      If the argument points to an element that is not a form,
+      Up.js will search its ancestors for the closest form.
+    @param {String} [options.target]
+    @param {String} [options.failTarget]
+    @param {Boolean|String} [options.history=true]
+      Successful form submissions will add a history entry and change the browser's
+      location bar if the form either uses the `GET` method or the response redirected
+      to another page (this requires the `upjs-rails` gem).
+      If want to prevent history changes in any case, set this to `false`.
+      If you pass a `String`, it is used as the URL for the browser history.
+    @param {String} [options.transition]
+    @param {String} [options.failTransition]
+    @return {Promise}
+      A promise for the AJAX response
+     */
+    submit = function(formOrSelector, options) {
+      var $form, failureSelector, failureTransition, historyOption, request, successSelector, successTransition, successUrl, _ref;
+      $form = $(formOrSelector).closest('form');
+      options = u.options(options);
+      successSelector = u.option(options.target, $form.attr('up-target'), 'body');
+      failureSelector = u.option(options.failTarget, $form.attr('up-fail-target'), function() {
+        return u.createSelectorFromElement($form);
+      });
+      historyOption = u.option(options.history, $form.attr('up-history'), true);
+      successTransition = u.option(options.transition, $form.attr('up-transition'));
+      failureTransition = u.option(options.failTransition, $form.attr('up-fail-transition'));
+      $form.addClass('up-active');
+      request = {
+        url: $form.attr('action') || up.browser.url(),
+        type: ((_ref = $form.attr('method')) != null ? _ref.toUpperCase() : void 0) || 'POST',
+        data: $form.serialize(),
+        selector: successSelector
+      };
+      successUrl = function(xhr) {
+        var redirectLocation, url;
+        url = historyOption ? u.isString(historyOption) ? historyOption : (redirectLocation = xhr.getResponseHeader('X-Up-Previous-Redirect-Location')) ? redirectLocation : request.type === 'GET' ? request.url + '?' + request.data : void 0 : void 0;
+        return u.option(url, false);
+      };
+      return u.ajax(request).always(function() {
+        return $form.removeClass('up-active');
+      }).done(function(html, textStatus, xhr) {
+        return up.flow.implant(successSelector, html, {
+          history: successUrl(xhr),
+          transition: successTransition
+        });
+      }).fail(function(xhr, textStatus, errorThrown) {
+        var html;
+        html = xhr.responseText;
+        return up.flow.implant(failureSelector, html, {
+          transition: failureTransition
+        });
+      });
+    };
+
+    /**
+    Observes an input field by periodic polling its value.
+    Executes code when the value changes.
+    
+        up.observe('input', { change: function(value, $input) {
+          up.submit($input)
+        } });
+    
+    This is useful for observing text fields while the user is typing,
+    since browsers will only fire a `change` event once the user
+    blurs the text field.
+    
+    @method up.observe
+    @param {Element|jQuery|String} fieldOrSelector
+    @param {Function(value, $field)|String} options.change
+      The callback to execute when the field's value changes.
+      If given as a function, it must take two arguments (`value`, `$field`).
+      If given as a string, it will be evaled as Javascript code in a context where
+      (`value`, `$field`) are set.
+    @param {Number} [options.frequency=500]
+     */
+    observe = function(fieldOrSelector, options) {
+      var $field, callback, check, clearTimer, codeOnChange, knownValue, resetTimer, startTimer, timer;
+      $field = $(fieldOrSelector);
+      options = u.options(options, {
+        frequency: 500
+      });
+      knownValue = null;
+      timer = null;
+      callback = null;
+      if (codeOnChange = $field.attr('up-observe')) {
+        callback = function(value, $field) {
+          return eval(codeOnChange);
+        };
+      } else if (options.change) {
+        callback = options.change;
+      } else {
+        u.error('observe: No change callback given');
+      }
+      check = function() {
+        var skipCallback, value;
+        value = $field.val();
+        skipCallback = _.isNull(knownValue);
+        if (knownValue !== value) {
+          knownValue = value;
+          if (!skipCallback) {
+            return callback.apply($field.get(0), [value, $field]);
+          }
+        }
+      };
+      resetTimer = function() {
+        if (timer) {
+          clearTimer();
+          return startTimer();
+        }
+      };
+      clearTimer = function() {
+        clearInterval(timer);
+        return timer = null;
+      };
+      startTimer = function() {
+        return timer = setInterval(check, options.frequency);
+      };
+      $field.bind("keyup click mousemove", resetTimer);
+      check();
+      startTimer();
+      return clearTimer;
+    };
+
+    /**
+    Submits the form through AJAX, searches the response for the selector
+    given in `up-target` and replaces the selector content in the current page:
+    
+        <form method="POST" action="/users" up-target=".main">
+          ...
+        </form>
+    
+    @method form[up-target]
+    @ujs
+    @param {String} up-target
+    @param {String} [up-fail-target]
+    @param {String} [up-history]
+    @param {String} [up-transition]
+    @param {String} [up-fail-transition]
+     */
+    up.on('submit', 'form[up-target]', function(event, $form) {
+      event.preventDefault();
+      return submit($form);
+    });
+
+    /**
+    Observes this form control by periodically polling its value.
+    Executes the given Javascript if the value changes:
+    
+        <form method="GET" action="/search">
+          <input type="query" up-observe="up.form.submit(this)">
+        </form>
+    
+    This is useful for observing text fields while the user is typing,
+    since browsers will only fire a `change` event once the user
+    blurs the text field.
+    
+    @method input[up-observe]
+    @ujs
+    @param {String} up-observe
+     */
+    up.awaken('[up-observe]', function($field) {
+      return observe($field);
+    });
+    return {
+      submit: submit,
+      observe: observe
+    };
+  })();
+
+  up.submit = up.form.submit;
+
+  up.observe = up.form.observe;
+
+}).call(this);
+
+/**
+Pop-up overlays
+===============
+  
+For modal dialogs see [up.modal](/up.modal).
+  
+@class up.popup
+ */
+
+(function() {
+  up.popup = (function() {
+    var autoclose, close, config, createHiddenPopup, defaults, ensureInViewport, open, position, source, u, updated;
+    u = up.util;
+    config = {
+      openAnimation: 'fade-in',
+      closeAnimation: 'fade-out',
+      origin: 'bottom-right'
+    };
+
+    /**
+    @method up.popup.defaults
+    @param {String} options.animation
+    @param {String} options.origin
+     */
+    defaults = function(options) {
+      return u.extend(config, options);
+    };
+    position = function($link, $popup, origin) {
+      var css, linkBox;
+      linkBox = u.measure($link, {
+        full: true
+      });
+      css = (function() {
+        switch (origin) {
+          case "bottom-right":
+            return {
+              right: linkBox.right,
+              top: linkBox.top + linkBox.height
+            };
+          case "bottom-left":
+            return {
+              left: linkBox.left,
+              top: linkBox.bottom + linkBox.height
+            };
+          case "top-right":
+            return {
+              right: linkBox.right,
+              bottom: linkBox.top
+            };
+          case "top-left":
+            return {
+              left: linkBox.left,
+              bottom: linkBox.top
+            };
+          default:
+            return u.error("Unknown origin", origin);
+        }
+      })();
+      $popup.attr('up-origin', origin);
+      $popup.css(css);
+      return ensureInViewport($popup);
+    };
+    ensureInViewport = function($popup) {
+      var bottom, box, errorX, errorY, left, right, top;
+      box = u.measure($popup, {
+        full: true
+      });
+      errorX = null;
+      errorY = null;
+      if (box.right < 0) {
+        errorX = -box.right;
+      }
+      if (box.bottom < 0) {
+        errorY = -box.bottom;
+      }
+      if (box.left < 0) {
+        errorX = box.left;
+      }
+      if (box.top < 0) {
+        errorY = box.top;
+      }
+      if (errorX) {
+        if (left = parseInt($popup.css('left'))) {
+          $popup.css('left', left - errorX);
+        } else if (right = parseInt($popup.css('right'))) {
+          $popup.css('right', right + errorX);
+        }
+      }
+      if (errorY) {
+        if (top = parseInt($popup.css('top'))) {
+          return $popup.css('top', top - errorY);
+        } else if (bottom = parseInt($popup.css('bottom'))) {
+          return $popup.css('bottom', bottom + errorY);
+        }
+      }
+    };
+    createHiddenPopup = function($link, selector, sticky) {
+      var $placeholder, $popup;
+      $popup = u.$createElementFromSelector('.up-popup');
+      if (sticky) {
+        $popup.attr('up-sticky', '');
+      }
+      $popup.attr('up-previous-url', up.browser.url());
+      $popup.attr('up-previous-title', document.title);
+      $placeholder = u.$createElementFromSelector(selector);
+      $placeholder.appendTo($popup);
+      $popup.appendTo(document.body);
+      $popup.hide();
+      return $popup;
+    };
+    updated = function($link, $popup, origin, animation) {
+      $popup.show();
+      position($link, $popup, origin);
+      return up.animate($popup, animation);
+    };
+
+    /**
+    Opens a popup overlay.
+    
+    @method up.popup.open
+    @param {Element|jQuery|String} elementOrSelector
+    @param {String} [options.origin='bottom-right']
+    @param {String} [options.animation]
+    @param {Boolean} [options.sticky=false]
+      If set to `true`, the popup remains
+      open even if the page changes in the background.
+    @param {Object} [options.history=false]
+     */
+    open = function(linkOrSelector, options) {
+      var $link, $popup, animation, history, origin, selector, sticky, url;
+      $link = $(linkOrSelector);
+      options = u.options(options);
+      url = u.option($link.attr('href'));
+      selector = u.option(options.target, $link.attr('up-popup'), 'body');
+      origin = u.option(options.origin, $link.attr('up-origin'), config.origin);
+      animation = u.option(options.animation, $link.attr('up-animation'), config.openAnimation);
+      sticky = u.option(options.sticky, $link.is('[up-sticky]'));
+      history = u.option(options.history, $link.attr('up-history'), false);
+      close();
+      $popup = createHiddenPopup($link, selector, sticky);
+      return up.replace(selector, url, {
+        history: history,
+        insert: function() {
+          return updated($link, $popup, origin, animation);
+        }
+      });
+    };
+
+    /**
+    Returns the source URL for the fragment displayed
+    in the current popup overlay, or `undefined` if no
+    popup is open.
+    
+    @method up.popup.source
+    @return {String}
+      the source URL
+     */
+    source = function() {
+      var $popup;
+      $popup = $('.up-popup');
+      if (!$popup.is('.up-destroying')) {
+        return $popup.find('[up-source]').attr('up-source');
+      }
+    };
+
+    /**
+    Closes a currently opened popup overlay.
+    Does nothing if no popup is currently open.
+    
+    @method up.popup.close
+    @param {Object} options
+      See options for [`up.animate`](/up.motion#up.animate).
+     */
+    close = function(options) {
+      var $popup;
+      $popup = $('.up-popup');
+      if ($popup.length) {
+        options = u.options(options, {
+          animation: config.closeAnimation,
+          url: $popup.attr('up-previous-url'),
+          title: $popup.attr('up-previous-title')
+        });
+        return up.destroy($popup, options);
+      }
+    };
+    autoclose = function() {
+      if (!$('.up-popup').is('[up-sticky]')) {
+        return close();
+      }
+    };
+
+    /**
+    Opens the target of this link in a popup overlay:
+    
+        <a href="/decks" up-modal=".deck_list">Switch deck</a>
+    
+    If the `up-sticky` attribute is set, the dialog does not auto-close
+    if a page fragment below the popup overlay updates:
+    
+        <a href="/decks" up-popup=".deck_list">Switch deck</a>
+        <a href="/settings" up-popup=".options" up-sticky>Settings</a>
+    
+    @method a[up-popup]
+    @ujs
+    @param up-target
+    @param [up-sticky]
+    @param [up-origin]
+     */
+    up.on('click', 'a[up-popup]', function(event, $link) {
+      event.preventDefault();
+      if ($link.is('.up-current')) {
+        return close();
+      } else {
+        return open($link);
+      }
+    });
+    up.on('click', 'body', function(event, $body) {
+      var $target;
+      $target = $(event.target);
+      if (!($target.closest('.up-popup').length || $target.closest('[up-popup]').length)) {
+        return close();
+      }
+    });
+    up.bus.on('fragment:ready', function($fragment) {
+      if (!$fragment.closest('.up-popup').length) {
+        return autoclose();
+      }
+    });
+    up.magic.onEscape(function() {
+      return close();
+    });
+
+    /**
+    When an element with this attribute is clicked,
+    a currently open popup is closed. 
+    
+    @method [up-close]
+    @ujs
+     */
+    up.on('click', '[up-close]', function(event, $element) {
+      if ($element.closest('.up-popup')) {
+        return close();
+      }
+    });
+    return {
+      open: open,
+      close: close,
+      source: source,
+      defaults: defaults
+    };
+  })();
+
+}).call(this);
+
+/**
+Modal dialogs
+=============
+
+TODO: Write some documentation
+
+@class up.modal
+ */
+
+(function() {
+  up.modal = (function() {
+    var autoclose, close, config, createHiddenModal, defaults, open, source, templateHtml, u, updated;
+    u = up.util;
+    config = {
+      width: 'auto',
+      height: 'auto',
+      openAnimation: 'fade-in',
+      closeAnimation: 'fade-out',
+      closeLabel: 'X',
+      template: function(config) {
+        return "<div class=\"up-modal\">\n  <div class=\"up-modal-dialog\">\n    <div class=\"up-modal-close\" up-close>" + config.closeLabel + "</div>\n    <div class=\"up-modal-content\"></div>\n  </div>\n</div>";
+      }
+    };
+
+    /**
+    @method up.modal.defaults
+    @param {Number} options.width
+    @param {Number} options.height
+    @param {String|Function(config)} options.template
+    @param {String} options.closeLabel
+    @param {String} options.openAnimation
+    @param {String} options.closeAnimation
+     */
+    defaults = function(options) {
+      return u.extend(config, options);
+    };
+    templateHtml = function() {
+      var template;
+      template = config.template;
+      if (u.isFunction(template)) {
+        return template(config);
+      } else {
+        return template;
+      }
+    };
+    createHiddenModal = function(selector, width, height, sticky) {
+      var $content, $dialog, $modal, $placeholder;
+      $modal = $(templateHtml());
+      if (sticky) {
+        $modal.attr('up-sticky', '');
+      }
+      $modal.attr('up-previous-url', up.browser.url());
+      $modal.attr('up-previous-title', document.title);
+      $dialog = $modal.find('.up-modal-dialog');
+      if (u.isPresent(width)) {
+        $dialog.css('width', width);
+      }
+      if (u.isPresent(height)) {
+        $dialog.css('height', height);
+      }
+      $content = $dialog.find('.up-modal-content');
+      $placeholder = u.$createElementFromSelector(selector);
+      $placeholder.appendTo($content);
+      $modal.appendTo(document.body);
+      $modal.hide();
+      return $modal;
+    };
+    updated = function($modal, animation) {
+      $modal.show();
+      return up.animate($modal, animation);
+    };
+
+    /**
+    Opens a modal overlay.
+    
+    @method up.modal.open
+    @param {Element|jQuery|String} elementOrSelector
+    @param {Number} [options.width]
+    @param {Number} [options.height]
+    @param {String} [options.origin='bottom-right']
+    @param {String} [options.animation]
+    @param {Boolean} [options.sticky=false]
+      If set to `true`, the modal remains
+      open even if the page changes in the background.
+    @param {Object} [options.history=true]
+     */
+    open = function(linkOrSelector, options) {
+      var $link, $modal, animation, height, history, selector, sticky, url, width;
+      $link = $(linkOrSelector);
+      options = u.options(options);
+      url = u.option($link.attr('href'));
+      selector = u.option(options.target, $link.attr('up-modal'), 'body');
+      width = u.option(options.width, $link.attr('up-width'), config.width);
+      height = u.option(options.height, $link.attr('up-height'), config.height);
+      animation = u.option(options.animation, $link.attr('up-animation'), config.openAnimation);
+      sticky = u.option(options.sticky, $link.is('[up-sticky]'));
+      history = u.option(options.history, $link.attr('up-history'), true);
+      close();
+      $modal = createHiddenModal(selector, width, height, sticky);
+      return up.replace(selector, url, {
+        history: history,
+        insert: function() {
+          return updated($modal, animation);
+        }
+      });
+    };
+
+    /**
+    Returns the source URL for the fragment displayed
+    in the current modal overlay, or `undefined` if no
+    modal is open.
+    
+    @method up.modal.source
+    @return {String}
+      the source URL
+     */
+    source = function() {
+      var $modal;
+      $modal = $('.up-modal');
+      if (!$modal.is('.up-destroying')) {
+        return $modal.find('[up-source]').attr('up-source');
+      }
+    };
+
+    /**
+    Closes a currently opened modal overlay.
+    Does nothing if no modal is currently open.
+    
+    @method up.modal.close
+    @param {Object} options
+      See options for [`up.animate`](/up.motion#up.animate)
+     */
+    close = function(options) {
+      var $modal;
+      $modal = $('.up-modal');
+      if ($modal.length) {
+        options = u.options(options, {
+          animation: config.closeAnimation,
+          url: $modal.attr('up-previous-url'),
+          title: $modal.attr('up-previous-title')
+        });
+        return up.destroy($modal, options);
+      }
+    };
+    autoclose = function() {
+      if (!$('.up-modal').is('[up-sticky]')) {
+        return close();
+      }
+    };
+
+    /**
+    Opens the target of this link in a modal dialog:
+    
+        <a href="/decks" up-modal=".deck_list">Switch deck</a>
+    
+    If the `up-sticky` attribute is set, the dialog does not auto-close
+    if a page fragment below the dialog updates:
+    
+        <a href="/settings" up-modal=".options" up-sticky>Settings</a>
+    
+    @method a[up-modal]
+    @ujs
+    @param up-target
+    @param [up-sticky]
+     */
+    up.on('click', 'a[up-modal]', function(event, $link) {
+      event.preventDefault();
+      if ($link.is('.up-current')) {
+        return close();
+      } else {
+        return open($link);
+      }
+    });
+    up.on('click', 'body', function(event, $body) {
+      var $target;
+      $target = $(event.target);
+      if (!($target.closest('.up-dialog').length || $target.closest('[up-modal]').length)) {
+        return close();
+      }
+    });
+    up.bus.on('fragment:ready', function($fragment) {
+      if (!$fragment.closest('.up-modal').length) {
+        return autoclose();
+      }
+    });
+    up.magic.onEscape(function() {
+      return close();
+    });
+
+    /**
+    When this element is clicked, closes a currently open dialog.
+    
+    @method [up-close]
+    @ujs
+     */
+    up.on('click', '[up-close]', function(event, $element) {
+      if ($element.closest('.up-modal')) {
+        return close();
+      }
+    });
+    return {
+      open: open,
+      close: close,
+      source: source,
+      defaults: defaults
+    };
+  })();
+
+}).call(this);
+
+/**
+Tooltips
+========
+  
+TODO: Write some documentation.
+
+@class up.tooltip
+ */
+
+(function() {
+  up.tooltip = (function() {
+    var close, createElement, open, position, u;
+    u = up.util;
+    position = function($link, $tooltip, origin) {
+      var css, linkBox, tooltipBox;
+      linkBox = u.measure($link);
+      tooltipBox = u.measure($tooltip);
+      css = (function() {
+        switch (origin) {
+          case "top":
+            return {
+              left: linkBox.left + 0.5 * (linkBox.width - tooltipBox.width),
+              top: linkBox.top - tooltipBox.height
+            };
+          case "bottom":
+            return {
+              left: linkBox.left + 0.5 * (linkBox.width - tooltipBox.width),
+              top: linkBox.top + linkBox.height
+            };
+          default:
+            return u.error("Unknown origin", origin);
+        }
+      })();
+      $tooltip.attr('up-origin', origin);
+      return $tooltip.css(css);
+    };
+    createElement = function(html) {
+      return u.$createElementFromSelector('.up-tooltip').html(html).appendTo(document.body);
+    };
+
+    /**
+    Opens a tooltip.
+    
+    @method up.tooltip.open
+    @param {Element|jQuery|String} elementOrSelector
+    @param {String} html
+    @param {String} [options.origin='top']
+    @param {String} [options.animation]
+     */
+    open = function(linkOrSelector, options) {
+      var $link, $tooltip, animation, html, origin;
+      if (options == null) {
+        options = {};
+      }
+      $link = $(linkOrSelector);
+      html = u.option(options.html, $link.attr('up-tooltip'));
+      origin = u.option(options.origin, $link.attr('up-origin'), 'top');
+      animation = u.option(options.animation, $link.attr('up-animation'), 'fade-in');
+      close();
+      $tooltip = createElement(html);
+      position($link, $tooltip, origin);
+      return up.animate($tooltip, animation, options);
+    };
+
+    /**
+    Closes a currently shown tooltip.
+    Does nothing if no tooltip is currently shown.
+    
+    @method up.tooltip.close
+    @param {Object} options
+      See options for See options for [`up.animate`](/up.motion#up.animate).
+     */
+    close = function(options) {
+      var $tooltip;
+      $tooltip = $('.up-tooltip');
+      if ($tooltip.length) {
+        options = u.options(options, {
+          animation: 'fade-out'
+        });
+        return up.destroy($tooltip, options);
+      }
+    };
+
+    /**
+    Displays a tooltip when hovering the mouse over this element:
+    
+        <a href="/decks" up-tooltip="Show all decks">Decks</a>
+    
+    @method [up-tooltip]
+    @ujs
+     */
+    up.awaken('[up-tooltip]', function($link) {
+      $link.on('mouseover', function() {
+        return open($link);
+      });
+      return $link.on('mouseout', function() {
+        return close();
+      });
+    });
+    up.on('click', 'body', function(event, $body) {
+      return close();
+    });
+    up.magic.onEscape(function() {
+      return close();
+    });
+    return {
+      open: open,
+      close: close
+    };
+  })();
+
+}).call(this);
+
+/**
+Fast interaction feedback
+=========================
+  
+This module marks up link elements with classes indicating that
+they are currently loading (class `up-active`) or linking
+to the current location (class `up-current`).
+
+This dramatically improves the perceived speed of your user interface
+by providing instant feedback for user interactions.
+
+The classes are added and removed automatically whenever
+a page fragment is added, changed or destroyed through Up.js.
+
+How Up.js computes the current location
+---------------------------------------
+
+From Up's point of view the "current" location is either:
+  
+- the URL displayed in the browser window's location bar
+- the source URL of a currently opened [modal dialog](/up.modal)
+- the source URL of a currently opened [popup overlay](/up.popup)
+
+@class up.navigation
+ */
+
+(function() {
+  up.navigation = (function() {
+    var CLASS_ACTIVE, CLASS_CURRENT, SELECTOR_ACTIVE, SELECTOR_SECTION, enlargeClickArea, locationChanged, sectionClicked, unmarkActive;
+    CLASS_ACTIVE = 'up-active';
+    CLASS_CURRENT = 'up-current';
+    SELECTOR_SECTION = 'a[href], a[up-target], [up-follow], [up-modal], [up-popup]';
+    SELECTOR_ACTIVE = "." + CLASS_ACTIVE;
+    locationChanged = function() {
+      var modalLocation, popupLocation, windowLocation;
+      windowLocation = up.util.normalizeUrl(up.browser.url(), {
+        search: false
+      });
+      modalLocation = up.modal.source();
+      popupLocation = up.popup.source();
+      return up.util.each($(SELECTOR_SECTION), function(section) {
+        var $section, url;
+        $section = $(section);
+        url = up.link.resolveUrl($section);
+        url = up.util.normalizeUrl(url, {
+          search: false
+        });
+        if (url === windowLocation || url === modalLocation || url === popupLocation) {
+          return $section.addClass(CLASS_CURRENT);
+        } else {
+          return $section.removeClass(CLASS_CURRENT);
+        }
+      });
+    };
+    sectionClicked = function($section) {
+      unmarkActive();
+      $section = enlargeClickArea($section);
+      return $section.addClass(CLASS_ACTIVE);
+    };
+    enlargeClickArea = function($section) {
+      return up.util.presence($section.parents(SELECTOR_SECTION)) || $section;
+    };
+    unmarkActive = function() {
+      return $(SELECTOR_ACTIVE).removeClass(CLASS_ACTIVE);
+    };
+    up.on('click', SELECTOR_SECTION, function(event, $section) {
+      return sectionClicked($section);
+    });
+    up.bus.on('fragment:ready', function() {
+      unmarkActive();
+      return locationChanged();
+    });
+    return up.bus.on('fragment:destroy', function($fragment) {
+      if ($fragment.is('.up-modal, .up-popup')) {
+        return locationChanged();
+      }
+    });
+  })();
+
+}).call(this);
+
+/**
+Markers
+=======
+  
+TODO: Write some documentation
+  
+@class up.marker
+ */
+
+(function() {
+  up.marker = (function() {
+    var check, hasContent;
+    hasContent = function($marker) {
+      return $marker.html().trim() !== '';
+    };
+    check = function($element) {
+      return up.util.findWithSelf($element, '[up-marker]').each(function() {
+        var $marker;
+        $marker = $(this);
+        if (!hasContent($marker)) {
+          return $marker.hide();
+        }
+      });
+    };
+
+    /**
+    Use this attribute to mark up empty element containers that
+    you plan to update with content in the future.
+    
+    An element with this attribute is automatically hidden
+    if it has no content, and is re-shown if it is updated with
+    content.
+    
+    This is useful to prevent the element from applying unwanted
+    margins to the surrounding page flow.
+    
+    @method [up-marker]
+    @ujs
+     */
+    return up.bus.on('fragment:ready', check);
+  })();
+
+}).call(this);
+(function() {
+  up.bus.emit('framework:ready');
+
+  $(document).on('ready', function() {
+    return up.bus.emit('app:ready');
+  });
+
+}).call(this);