middleman-wizard-template 1.0.3 → 1.0.4

data/lib/middleman-wizard-template/template/source/javascripts/_lib/ww/PxLoader/PxLoaderSwiffy.js

@@ -1,68 +0,0 @@
-/**
- * Loader plugin to load swiffy.
- * @constructor
- * @param {String} name Name of the Swiffy.
- * @param {Array} tags Array of tag names.
- * @param {Number} priority Load order.
- */
-ww.LoaderSwiffy = function LoaderSwiffy(name, tags, priority) {
-  var self = this,
-      loader = null,
-      complete = false;
-
-  this.tags = tags;
-  this.priority = priority;
-  var data = null;
-
-  this.start = function(pxloader) {
-    // we need the loader ref so we can notify upon completion
-    loader = pxloader;
-
-    var xhr = new XMLHttpRequest();
-    xhr.open('GET', name, false);
-    xhr.onreadystatechange = function() {
-      if (xhr['readyState'] !== 4) { return; }
-      if (xhr['status'] !== 200) {
-        loader.onError(self);
-        return;
-      }
-
-      var serverResponse = xhr['responseText'];
-      try {
-        data = JSON.parse(serverResponse);
-        loader.onLoad(self);
-      } catch (e) {
-        loader.onError(self);
-      }
-    }
-    xhr.send(null);
-  };
-
-  // called by ww.Loader to check status of image (fallback in case
-  // the event listeners are not triggered).
-  this.checkStatus = function() {
-    if (complete) {
-      loader.onLoad(self);
-    }
-  };
-
-  // called by ww.Loader when it is no longer waiting
-  this.onTimeout = function() {
-    if (complete) {
-      loader.onLoad(self);
-    } else {
-      loader.onTimeout(self);
-    }
-  };
-
-  // returns a name for the resource that can be used in logging
-  this.getName = function() {
-    return name;
-  };
-
-  this.getData = function() {
-    return data;
-  }
-};
-
-goog.exportSymbol('ww.LoaderSwiffy', ww.LoaderSwiffy);

data/lib/middleman-wizard-template/template/source/javascripts/_lib/ww/RouteRecognizer.js

@@ -1,506 +0,0 @@
-goog.provide('ww.RouteRecognizer');
-
-var specials = [
-  '/', '.', '*', '+', '?', '|',
-  '(', ')', '[', ']', '{', '}', '\\'
-];
-
-var escapeRegex = new RegExp('(\\' + specials.join('|\\') + ')', 'g');
-
-// 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 StaticSegment(string) { this.string = string; }
-StaticSegment.prototype = {
-  eachChar: function(callback) {
-    var string = this.string, char;
-
-    for (var i=0, l=string.length; i<l; i++) {
-      char = string.charAt(i);
-      callback({ validChars: char });
-    }
-  },
-
-  regex: function() {
-    return this.string.replace(escapeRegex, '\\$1');
-  },
-
-  generate: function() {
-    return this.string;
-  }
-};
-
-function DynamicSegment(name) { this.name = name; }
-DynamicSegment.prototype = {
-  eachChar: function(callback) {
-    callback({ invalidChars: "/", repeat: true });
-  },
-
-  regex: function() {
-    return "([^/]+)";
-  },
-
-  generate: function(params) {
-    return params[this.name];
-  }
-};
-
-function StarSegment(name) { this.name = name; }
-StarSegment.prototype = {
-  eachChar: function(callback) {
-    callback({ invalidChars: "", repeat: true });
-  },
-
-  regex: function() {
-    return "(.+)";
-  },
-
-  generate: function(params) {
-    return params[this.name];
-  }
-};
-
-function EpsilonSegment() {}
-EpsilonSegment.prototype = {
-  eachChar: function() {},
-  regex: function() { return ""; },
-  generate: function() { return ""; }
-};
-
-function parse(route, names, types) {
-  // normalize route as not starting with a "/". Recognition will
-  // also normalize.
-  if (route.charAt(0) === "/") { route = route.substr(1); }
-
-  var segments = route.split("/"), results = [];
-
-  for (var i=0, l=segments.length; i<l; i++) {
-    var segment = segments[i], match;
-
-    if (match = segment.match(/^:([^\/]+)$/)) {
-      results.push(new DynamicSegment(match[1]));
-      names.push(match[1]);
-      types.dynamics++;
-    } else if (match = segment.match(/^\*([^\/]+)$/)) {
-      results.push(new StarSegment(match[1]));
-      names.push(match[1]);
-      types.stars++;
-    } else if(segment === "") {
-      results.push(new EpsilonSegment());
-    } else {
-      results.push(new StaticSegment(segment));
-      types.statics++;
-    }
-  }
-
-  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 State(charSpec) {
-  this.charSpec = charSpec;
-  this.nextStates = [];
-}
-
-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 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(char) {
-    // DEBUG "Processing `" + char + "`:"
-    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(char) !== -1) { returned.push(child); }
-      } else if (typeof (chars = charSpec.invalidChars) !== 'undefined') {
-        if (chars.indexOf(char) === -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 **/
-
-// This is a somewhat naive strategy, but should work in a lot of cases
-// A better strategy would properly resolve /posts/:id/new and /posts/edit/:id
-function sortSolutions(states) {
-  return states.sort(function(a, b) {
-    if (a.types.stars !== b.types.stars) { return a.types.stars - b.types.stars; }
-    if (a.types.dynamics !== b.types.dynamics) { return a.types.dynamics - b.types.dynamics; }
-    if (a.types.statics !== b.types.statics) { return a.types.statics - b.types.statics; }
-
-    return 0;
-  });
-}
-
-function recognizeChar(states, char) {
-  var nextStates = [];
-
-  for (var i=0, l=states.length; i<l; i++) {
-    var state = states[i];
-
-    nextStates = nextStates.concat(state.match(char));
-  }
-
-  return nextStates;
-}
-
-function findHandler(state, path) {
-  var handlers = state.handlers, regex = state.regex;
-  var captures = path.match(regex), currentCapture = 1;
-  var result = [];
-
-  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 addSegment(currentState, segment) {
-  segment.eachChar(function(char) {
-    var state;
-
-    currentState = currentState.put(char);
-  });
-
-  return currentState;
-}
-
-// The main interface
-
-var RouteRecognizer = function() {
-  this.rootState = new State();
-  this.names = {};
-};
-
-
-RouteRecognizer.prototype = {
-  add: function(routes, options) {
-    var currentState = this.rootState, regex = "^",
-        types = { statics: 0, dynamics: 0, stars: 0 },
-        handlers = [], allSegments = [], name;
-
-    var isEmpty = true;
-
-    for (var i=0, l=routes.length; i<l; i++) {
-      var route = routes[i], names = [];
-
-      var segments = parse(route.path, names, types);
-
-      allSegments = allSegments.concat(segments);
-
-      for (var j=0, m=segments.length; j<m; j++) {
-        var segment = segments[j];
-
-        if (segment instanceof 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 = addSegment(currentState, segment);
-        regex += segment.regex();
-      }
-
-      handlers.push({ handler: route.handler, names: names });
-    }
-
-    if (isEmpty) {
-      currentState = currentState.put({ validChars: "/" });
-      regex += "/";
-    }
-
-    currentState.handlers = handlers;
-    currentState.regex = new RegExp(regex + "$");
-    currentState.types = types;
-
-    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 EpsilonSegment) { continue; }
-
-      output += "/";
-      output += segment.generate(params);
-    }
-
-    if (output.charAt(0) !== '/') { output = '/' + output; }
-
-    return output;
-  },
-
-  recognize: function(path) {
-    var states = [ this.rootState ],
-        pathLen, i, l;
-
-    // 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);
-    }
-
-    for (i=0, l=path.length; i<l; i++) {
-      states = 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 = sortSolutions(solutions);
-
-    var state = solutions[0];
-
-    if (state && state.handlers) {
-      return findHandler(state, path);
-    }
-  }
-};
-
-function Target(path, matcher, delegate) {
-  this.path = path;
-  this.matcher = matcher;
-  this.delegate = delegate;
-}
-
-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);
-    }
-  }
-};
-
-function Matcher(target) {
-  this.routes = {};
-  this.children = {};
-  this.target = target;
-}
-
-Matcher.prototype = {
-  add: function(path, handler) {
-    this.routes[path] = handler;
-  },
-
-  addChild: function(path, target, callback, delegate) {
-    var matcher = new Matcher(target);
-    this.children[path] = matcher;
-
-    var match = generateMatch(path, matcher, delegate);
-
-    if (delegate && delegate.contextEntered) {
-      delegate.contextEntered(target, match);
-    }
-
-    callback(match);
-  }
-};
-
-function generateMatch(startingPath, matcher, delegate) {
-  return function(path, nestedCallback) {
-    var fullPath = startingPath + path;
-
-    if (nestedCallback) {
-      nestedCallback(generateMatch(fullPath, matcher, delegate));
-    } else {
-      return new Target(startingPath + path, matcher, delegate);
-    }
-  };
-}
-
-function 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);
-  routeArray.push({ path: path, handler: handler });
-}
-
-function eachRoute(baseRoute, matcher, callback, binding) {
-  var routes = matcher.routes;
-
-  for (var path in routes) {
-    if (routes.hasOwnProperty(path)) {
-      var routeArray = baseRoute.slice();
-      addRoute(routeArray, path, routes[path]);
-
-      if (matcher.children[path]) {
-        eachRoute(routeArray, matcher.children[path], callback, binding);
-      } else {
-        callback.call(binding, routeArray);
-      }
-    }
-  }
-}
-
-RouteRecognizer.prototype.map = function(callback, addRouteCallback) {
-  var matcher = new Matcher();
-
-  callback(generateMatch("", matcher, this.delegate));
-
-  eachRoute([], matcher, function(route) {
-    if (addRouteCallback) { addRouteCallback(this, route); }
-    else { this.add(route); }
-  }, this);
-};
-
-ww.RouteRecognizer = RouteRecognizer;