revelry_data 0.0.7

data/app/assets/javascripts/vendor/backbone-jsonapi.js

@@ -0,0 +1,117 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+var backboneJSONAPI = require('./src/backbone-jsonapi.js');
+
+backboneJSONAPI(Backbone, _);
+
+},{"./src/backbone-jsonapi.js":2}],2:[function(require,module,exports){
+var toolbox = require('./toolbox');
+
+module.exports = function (Backbone, _) {
+  if (!Backbone || !_) {
+    throw new Error('Backbone and/or Lodash (or Underscore) are not loaded...');
+  }
+  toolbox = toolbox(_); // Bootstrap toolbox;
+  Backbone.Collection.prototype.parse = function (response) {
+    if (response === undefined) {
+      return;
+    }
+    var output = toolbox.parse(response);
+    var mainCollection = toolbox.getMainCollection(response);
+    return _.each(output[mainCollection], function (obj) {
+      obj._alreadyBBJSONAPIParsed = true;
+    });
+  };
+  Backbone.Model.prototype.parse = function (response) {
+    if (response === undefined) {
+      return;
+    }
+    if (response._alreadyBBJSONAPIParsed) {
+      delete response._alreadyBBJSONAPIParsed;
+      return response;
+    }
+    var output = toolbox.parse(response);
+    var mainCollection = toolbox.getMainCollection(response);
+    var parsed =
+      _(output[mainCollection])
+        .chain()
+        .omit('attributes')
+        .extend(output[mainCollection].attributes)
+        .value();
+    return parsed;
+  };
+  return module.exports;
+};
+
+module.exports.VERSION = '0.1.6';
+
+},{"./toolbox":3}],3:[function(require,module,exports){
+var _;
+
+module.exports = function bootStrapToolBox(lodash) {
+  _ = lodash;
+  // Underscore shim
+  _.forOwn = _.forOwn || function (obj, iterator) {
+    var keys;
+    try {
+      keys = _.keys(obj);
+    } catch (e) {
+      return;
+    }
+    _.each(keys, function (key) {
+      iterator(obj[key], key);
+    });
+  };
+  return module.exports;
+};
+
+var findById = module.exports.findById = function (array, id) {
+  return _.find(array, function (item) {
+    return item.id === id;
+  });
+};
+
+var applyTemplateUrl = module.exports.applyTemplateUrl = function (collectionName, template, data) {
+  var regex = new RegExp('{' + collectionName + '\\.(.+?)}', 'g'),
+    execResult = regex.exec(template);
+  if (execResult !== null) {
+    if (data[execResult[1]] === undefined && data.links[execResult[1]] === undefined) {
+      throw new Error('Template required a property not present in data object');
+    }
+    template = template.substr(0, execResult.index) + (data.links[execResult[1]] || data[execResult[1]]) + template.substr(regex.lastIndex);
+  }
+  return template;
+};
+
+var processLink = module.exports.processLink = function (response, linkObj, linkName) {
+  var linkNameSplit = linkName.split('.'),
+    collection = linkNameSplit[0],
+    attribute = linkNameSplit[1];
+
+  _.each(response[collection], function (item) {
+    item.links = item.links || {};
+    if (item.links[attribute] !== undefined) {
+      var preloadedItem = findById(response[linkObj.type], item.links[attribute]);
+      if (preloadedItem !== undefined) {
+        item[attribute] = preloadedItem;
+      }
+    }
+    try {
+      item.links[attribute] = applyTemplateUrl(collection, linkObj.href, item);
+    } catch (e) {}
+  });
+  return response;
+};
+
+module.exports.parse = function (response) {
+  _.forOwn(response.links, function (value, key) {
+    processLink(response, value, key);
+  });
+  return response;
+};
+
+module.exports.getMainCollection = function (response) {
+  var collections = _.without(_.keys(response), 'links', 'meta');
+  var types = _.pluck(_.values(response.links), 'type');
+  return _.difference(collections, types)[0];
+};
+},{}]},{},[1]);

data/app/assets/javascripts/vendor/jsonpath.js

@@ -0,0 +1,246 @@
+/*global module, exports, require*/
+/*jslint vars:true, evil:true*/
+/* JSONPath 0.8.0 - XPath for JSON
+ *
+ * Copyright (c) 2007 Stefan Goessner (goessner.net)
+ * Licensed under the MIT (MIT-LICENSE.txt) licence.
+ */
+
+(function (require) {'use strict';
+
+// Keep compatibility with old browsers
+if (!Array.isArray) {
+    Array.isArray = function (vArg) {
+        return Object.prototype.toString.call(vArg) === '[object Array]';
+    };
+}
+
+// Make sure to know if we are in real node or not (the `require` variable
+// could actually be require.js, for example.
+var isNode = typeof module !== 'undefined' && !!module.exports;
+
+var vm = isNode ?
+    require('vm') : {
+        runInNewContext: function (expr, context) {
+            return eval(Object.keys(context).reduce(function (s, vr) {
+                return 'var ' + vr + '=' + JSON.stringify(context[vr]) + ';' + s;
+            }, expr));
+        }
+    };
+
+var cache = {};
+
+function push (arr, elem) {arr = arr.slice(); arr.push(elem); return arr;}
+function unshift (elem, arr) {arr = arr.slice(); arr.unshift(elem); return arr;}
+
+function JSONPath (opts, obj, expr) {
+    if (!(this instanceof JSONPath)) {
+        try {
+            return new JSONPath(opts, obj, expr);
+        }
+        catch (e) {
+            if (!e.avoidNew) {
+                throw e;
+            }
+            return e.value;
+        }
+    }
+
+    opts = opts || {};
+    var objArgs = opts.hasOwnProperty('json') && opts.hasOwnProperty('path');
+    this.resultType = (opts.resultType && opts.resultType.toLowerCase()) || 'value';
+    this.flatten = opts.flatten || false;
+    this.wrap = opts.hasOwnProperty('wrap') ? opts.wrap : true;
+    this.sandbox = opts.sandbox || {};
+
+    if (opts.autostart !== false) {
+        var ret = this.evaluate((objArgs ? opts.json : obj), (objArgs ? opts.path : expr));
+        if (!ret || typeof reg !== 'object') {
+            throw {avoidNew: true, value: ret, message: "JSONPath should not be called with 'new'"};
+        }
+    }
+}
+
+// PUBLIC METHODS
+
+JSONPath.prototype.evaluate = function (obj, expr) {
+    var self = this;
+    this._obj = obj;
+    if (expr && obj && (this.resultType === 'value' || this.resultType === 'path')) {
+        var exprList = this._normalize(expr);
+        if (exprList[0] === '$' && exprList.length > 1) {exprList.shift();}
+        var result = this._trace(exprList, obj, ['$']);
+        result = result.filter(function (ea) { return ea && !ea.isParentSelector; });
+        if (!result.length) {return this.wrap ? [] : false;}
+        if (result.length === 1 && !this.wrap && !Array.isArray(result[0].value)) {return result[0][this.resultType] || false;}
+        return result.reduce(function (result, ea) {
+            var valOrPath = ea[self.resultType];
+            if (self.resultType === 'path') {valOrPath = self._asPath(valOrPath);}
+            if (self.flatten && Array.isArray(valOrPath)) {
+                result = result.concat(valOrPath);
+            } else {
+                result.push(valOrPath);
+            }
+            return result;
+        }, []);
+    }
+};
+
+// PRIVATE METHODS
+
+JSONPath.prototype._normalize = function (expr) {
+    if (cache[expr]) {return cache[expr];}
+    var subx = [];
+    var normalized = expr.replace(/[\['](\??\(.*?\))[\]']/g, function ($0, $1) {return '[#' + (subx.push($1) - 1) + ']';})
+                    .replace(/'?\.'?|\['?/g, ';')
+                    .replace(/(?:;)?(\^+)(?:;)?/g, function ($0, ups) {return ';' + ups.split('').join(';') + ';';})
+                    .replace(/;;;|;;/g, ';..;')
+                    .replace(/;$|'?\]|'$/g, '');
+    var exprList = normalized.split(';').map(function (expr) {
+        var match = expr.match(/#([0-9]+)/);
+        return !match || !match[1] ? expr : subx[match[1]];
+    });
+    cache[expr] = exprList;
+    return cache[expr];
+};
+
+JSONPath.prototype._asPath = function (path) {
+    var i, n, x = path, p = '$';
+    for (i = 1, n = x.length; i < n; i++) {
+        p += /^[0-9*]+$/.test(x[i]) ? ('[' + x[i] + ']') : ("['" + x[i] + "']");
+    }
+    return p;
+};
+
+JSONPath.prototype._trace = function (expr, val, path) {
+    // No expr to follow? return path and value as the result of this trace branch
+    var self = this;
+    if (!expr.length) {return [{path: path, value: val}];}
+
+    var loc = expr[0], x = expr.slice(1);
+    // The parent sel computation is handled in the frame above using the
+    // ancestor object of val
+    if (loc === '^') {return path.length ? [{path: path.slice(0, -1), expr: x, isParentSelector: true}] : [];}
+
+    // We need to gather the return value of recursive trace calls in order to
+    // do the parent sel computation.
+    var ret = [];
+    function addRet (elems) {ret = ret.concat(elems);}
+
+    if (val && val.hasOwnProperty(loc)) { // simple case, directly follow property
+        addRet(this._trace(x, val[loc], push(path, loc)));
+    }
+    else if (loc === '*') { // any property
+        this._walk(loc, x, val, path, function (m, l, x, v, p) {
+            addRet(self._trace(unshift(m, x), v, p));
+        });
+    }
+    else if (loc === '..') { // all child properties
+        addRet(this._trace(x, val, path));
+        this._walk(loc, x, val, path, function (m, l, x, v, p) {
+            if (typeof v[m] === 'object') {
+                addRet(self._trace(unshift('..', x), v[m], push(p, m)));
+            }
+        });
+    }
+    else if (loc[0] === '(') { // [(expr)]
+        addRet(this._trace(unshift(this._eval(loc, val, path[path.length], path), x), val, path));
+    }
+    else if (loc.indexOf('?(') === 0) { // [?(expr)]
+        this._walk(loc, x, val, path, function (m, l, x, v, p) {
+            if (self._eval(l.replace(/^\?\((.*?)\)$/, '$1'), v[m], m, path)) {
+                addRet(self._trace(unshift(m, x), v, p));
+            }
+        });
+    }
+    else if (loc.indexOf(',') > -1) { // [name1,name2,...]
+        var parts, i;
+        for (parts = loc.split(','), i = 0; i < parts.length; i++) {
+            addRet(this._trace(unshift(parts[i], x), val, path));
+        }
+    }
+    else if (/^(-?[0-9]*):(-?[0-9]*):?([0-9]*)$/.test(loc)) { // [start:end:step]  Python slice syntax
+        addRet(this._slice(loc, x, val, path));
+    }
+
+    // We check the resulting values for parent selections. For parent
+    // selections we discard the value object and continue the trace with the
+    // current val object
+    return ret.reduce(function (all, ea) {
+        return all.concat(ea.isParentSelector ? self._trace(ea.expr, val, ea.path) : [ea]);
+    }, []);
+};
+
+JSONPath.prototype._walk = function (loc, expr, val, path, f) {
+    var i, n, m;
+    if (Array.isArray(val)) {
+        for (i = 0, n = val.length; i < n; i++) {
+            f(i, loc, expr, val, path);
+        }
+    }
+    else if (typeof val === 'object') {
+        for (m in val) {
+            if (val.hasOwnProperty(m)) {
+                f(m, loc, expr, val, path);
+            }
+        }
+    }
+};
+
+JSONPath.prototype._slice = function (loc, expr, val, path) {
+    if (!Array.isArray(val)) {return;}
+    var i,
+        len = val.length, parts = loc.split(':'),
+        start = (parts[0] && parseInt(parts[0], 10)) || 0,
+        end = (parts[1] && parseInt(parts[1], 10)) || len,
+        step = (parts[2] && parseInt(parts[2], 10)) || 1;
+    start = (start < 0) ? Math.max(0, start + len) : Math.min(len, start);
+    end    = (end < 0)    ? Math.max(0, end + len) : Math.min(len, end);
+    var ret = [];
+    for (i = start; i < end; i += step) {
+        ret = ret.concat(this._trace(unshift(i, expr), val, path));
+    }
+    return ret;
+};
+
+JSONPath.prototype._eval = function (code, _v, _vname, path) {
+    if (!this._obj || !_v) {return false;}
+    if (code.indexOf('@path') > -1) {
+        this.sandbox._$_path = this._asPath(path.concat([_vname]));
+        code = code.replace(/@path/g, '_$_path');
+    }
+    if (code.indexOf('@') > -1) {
+        this.sandbox._$_v = _v;
+        code = code.replace(/@/g, '_$_v');
+    }
+    try {
+        return vm.runInNewContext(code, this.sandbox);
+    }
+    catch(e) {
+        console.log(e);
+        throw new Error('jsonPath: ' + e.message + ': ' + code);
+    }
+};
+
+// For backward compatibility (deprecated)
+JSONPath.eval = function (obj, expr, opts) {
+    return JSONPath(opts, obj, expr);
+};
+
+if (typeof module === 'undefined') {
+  var topScope;
+  if(typeof window === 'undefined') {
+    topScope = global;
+  } else {
+    topScope = window;
+  }
+    topScope.jsonPath = { // Deprecated
+        eval: JSONPath.eval
+    };
+    topScope.JSONPath = JSONPath;
+}
+else {
+    module.exports = JSONPath;
+}
+
+}(typeof require === 'undefined' ? null : require));

data/app/assets/javascripts/vendor/underscore.inflections.js

@@ -0,0 +1,279 @@
+// Generated by CoffeeScript 1.6.3
+(function() {
+  var Inflections, root, _,
+    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+    __slice = [].slice;
+
+  Inflections = (function() {
+    Inflections.prototype.defaultUncountables = ['equipment', 'information', 'rice', 'money', 'species', 'series', 'fish', 'sheep', 'jeans', 'moose', 'deer', 'news', 'music'];
+
+    Inflections.prototype.defaultPluralRules = [[/$/, 's'], [/s$/i, 's'], [/^(ax|test)is$/i, '$1es'], [/(octop|vir)us$/i, '$1i'], [/(octop|vir)i$/i, '$1i'], [/(alias|status)$/i, '$1es'], [/(bu)s$/i, '$1ses'], [/(buffal|tomat)o$/i, '$1oes'], [/([ti])um$/i, '$1a'], [/([ti])a$/i, '$1a'], [/sis$/i, 'ses'], [/(?:([^f])fe|([lr])f)$/i, '$1$2ves'], [/(hive)$/i, '$1s'], [/([^aeiouy]|qu)y$/i, '$1ies'], [/(x|ch|ss|sh)$/i, '$1es'], [/(matr|vert|ind)(?:ix|ex)$/i, '$1ices'], [/(m|l)ouse$/i, '$1ice'], [/(m|l)ice$/i, '$1ice'], [/^(ox)$/i, '$1en'], [/^(oxen)$/i, '$1'], [/(quiz)$/i, '$1zes']];
+
+    Inflections.prototype.defaultSingularRules = [[/s$/i, ''], [/(ss)$/i, '$1'], [/(n)ews$/i, '$1ews'], [/([ti])a$/i, '$1um'], [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '$1$2sis'], [/(^analy)(sis|ses)$/i, '$1sis'], [/([^f])ves$/i, '$1fe'], [/(hive)s$/i, '$1'], [/(tive)s$/i, '$1'], [/([lr])ves$/i, '$1f'], [/([^aeiouy]|qu)ies$/i, '$1y'], [/(s)eries$/i, '$1eries'], [/(m)ovies$/i, '$1ovie'], [/(x|ch|ss|sh)es$/i, '$1'], [/(m|l)ice$/i, '$1ouse'], [/(bus)(es)?$/i, '$1'], [/(o)es$/i, '$1'], [/(shoe)s$/i, '$1'], [/(cris|test)(is|es)$/i, '$1is'], [/^(a)x[ie]s$/i, '$1xis'], [/(octop|vir)(us|i)$/i, '$1us'], [/(alias|status)(es)?$/i, '$1'], [/^(ox)en/i, '$1'], [/(vert|ind)ices$/i, '$1ex'], [/(matr)ices$/i, '$1ix'], [/(quiz)zes$/i, '$1'], [/(database)s$/i, '$1']];
+
+    Inflections.prototype.defaultIrregularRules = [['person', 'people'], ['man', 'men'], ['child', 'children'], ['sex', 'sexes'], ['move', 'moves'], ['cow', 'kine'], ['zombie', 'zombies']];
+
+    Inflections.prototype.defaultHumanRules = [];
+
+    function Inflections() {
+      this.apply_inflections = __bind(this.apply_inflections, this);
+
+      this.titleize = __bind(this.titleize, this);
+      this.humanize = __bind(this.humanize, this);
+      this.underscore = __bind(this.underscore, this);
+      this.camelize = __bind(this.camelize, this);
+      this.singularize = __bind(this.singularize, this);
+
+      this.pluralize = __bind(this.pluralize, this);
+
+      this.clearInflections = __bind(this.clearInflections, this);
+
+      this.human = __bind(this.human, this);
+      this.uncountable = __bind(this.uncountable, this);
+
+      this.irregular = __bind(this.irregular, this);
+
+      this.singular = __bind(this.singular, this);
+
+      this.plural = __bind(this.plural, this);
+
+      this.acronym = __bind(this.acronym, this);
+      this.applyDefaultPlurals = __bind(this.applyDefaultPlurals, this);
+
+      this.applyDefaultUncountables = __bind(this.applyDefaultUncountables, this);
+
+      this.applyDefaultRules = __bind(this.applyDefaultRules, this);
+      this.plurals = [];
+      this.singulars = [];
+      this.uncountables = [];
+      this.humans = [];
+      this.acronyms = {};
+      this.applyDefaultRules();
+    }
+
+    Inflections.prototype.applyDefaultRules = function() {
+      this.applyDefaultUncountables();
+      this.applyDefaultPlurals();
+      this.applyDefaultSingulars();
+      return this.applyDefaultIrregulars();
+    };
+
+    Inflections.prototype.applyDefaultUncountables = function() {
+      return this.uncountable(this.defaultUncountables);
+    };
+
+    Inflections.prototype.applyDefaultPlurals = function() {
+      var _this = this;
+      return _.each(this.defaultPluralRules, function(rule) {
+        var capture, regex;
+        regex = rule[0], capture = rule[1];
+        return _this.plural(regex, capture);
+      });
+    };
+
+    Inflections.prototype.applyDefaultSingulars = function() {
+      var _this = this;
+      return _.each(this.defaultSingularRules, function(rule) {
+        var capture, regex;
+        regex = rule[0], capture = rule[1];
+        return _this.singular(regex, capture);
+      });
+    };
+
+    Inflections.prototype.applyDefaultIrregulars = function() {
+      var _this = this;
+      return _.each(this.defaultIrregularRules, function(rule) {
+        var plural, singular;
+        singular = rule[0], plural = rule[1];
+        return _this.irregular(singular, plural);
+      });
+    };
+
+    Inflections.prototype.acronym = function(word) {
+      this.acronyms[word.toLowerCase()] = word;
+      return this.acronym_matchers = _.values(this.acronyms).join("|");
+    };
+
+    Inflections.prototype.plural = function(rule, replacement) {
+      if (typeof rule === 'string') {
+        delete this.uncountables[_.indexOf(this.uncountables, rule)];
+      }
+      delete this.uncountables[_.indexOf(this.uncountables, replacement)];
+      return this.plurals.unshift([rule, replacement]);
+    };
+
+    Inflections.prototype.singular = function(rule, replacement) {
+      if (typeof rule === 'string') {
+        delete this.uncountables[_.indexOf(this.uncountables, rule)];
+      }
+      delete this.uncountables[_.indexOf(this.uncountables, replacement)];
+      return this.singulars.unshift([rule, replacement]);
+    };
+
+    Inflections.prototype.irregular = function(singular, plural) {
+      delete this.uncountables[_.indexOf(this.uncountables, singular)];
+      delete this.uncountables[_.indexOf(this.uncountables, plural)];
+      if (singular.substring(0, 1).toUpperCase() === plural.substring(0, 1).toUpperCase()) {
+        this.plural(new RegExp("(" + (singular.substring(0, 1)) + ")" + (singular.substring(1, plural.length)) + "$", "i"), '$1' + plural.substring(1, plural.length));
+        this.plural(new RegExp("(" + (plural.substring(0, 1)) + ")" + (plural.substring(1, plural.length)) + "$", "i"), '$1' + plural.substring(1, plural.length));
+        return this.singular(new RegExp("(" + (plural.substring(0, 1)) + ")" + (plural.substring(1, plural.length)) + "$", "i"), '$1' + singular.substring(1, plural.length));
+      } else {
+        this.plural(new RegExp("" + (singular.substring(0, 1)) + (singular.substring(1, plural.length)) + "$", "i"), plural.substring(0, 1) + plural.substring(1, plural.length));
+        this.plural(new RegExp("" + (singular.substring(0, 1)) + (singular.substring(1, plural.length)) + "$", "i"), plural.substring(0, 1) + plural.substring(1, plural.length));
+        this.plural(new RegExp("" + (plural.substring(0, 1)) + (plural.substring(1, plural.length)) + "$", "i"), plural.substring(0, 1) + plural.substring(1, plural.length));
+        this.plural(new RegExp("" + (plural.substring(0, 1)) + (plural.substring(1, plural.length)) + "$", "i"), plural.substring(0, 1) + plural.substring(1, plural.length));
+        this.singular(new RegExp("" + (plural.substring(0, 1)) + (plural.substring(1, plural.length)) + "$", "i"), singular.substring(0, 1) + singular.substring(1, plural.length));
+        return this.singular(new RegExp("" + (plural.substring(0, 1)) + (plural.substring(1, plural.length)) + "$", "i"), singular.substring(0, 1) + singular.substring(1, plural.length));
+      }
+    };
+
+    Inflections.prototype.uncountable = function() {
+      var words;
+      words = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      this.uncountables.push(words);
+      return this.uncountables = _.flatten(this.uncountables);
+    };
+
+    Inflections.prototype.human = function(rule, replacement) {
+      return this.humans.unshift([rule, replacement]);
+    };
+
+    Inflections.prototype.clearInflections = function(scope) {
+      if (scope == null) {
+        scope = 'all';
+      }
+      return this[scope] = [];
+    };
+
+    Inflections.prototype.pluralize = function(word, count, options) {
+      var result, _ref;
+      if (options == null) {
+        options = {};
+      }
+      options = _.extend({
+        plural: void 0,
+        showNumber: true
+      }, options);
+      if (count !== void 0) {
+        result = "";
+        if (options.showNumber === true) {
+          result += "" + (count != null ? count : 0) + " ";
+        }
+        return result += count === 1 || (count != null ? typeof count.toString === "function" ? count.toString().match(/^1(\.0+)?$/) : void 0 : void 0) ? word : (_ref = options.plural) != null ? _ref : this.pluralize(word);
+      } else {
+        return this.apply_inflections(word, this.plurals);
+      }
+    };
+
+    Inflections.prototype.singularize = function(word) {
+      return this.apply_inflections(word, this.singulars);
+    };
+
+    Inflections.prototype.camelize = function(term, uppercase_first_letter) {
+      var _this = this;
+      if (uppercase_first_letter == null) {
+        uppercase_first_letter = true;
+      }
+      if (uppercase_first_letter) {
+        term = term.replace(/^[a-z\d]*/, function(a) {
+          return _this.acronyms[a] || _.capitalize(a);
+        });
+      } else {
+        term = term.replace(RegExp("^(?:" + this.acronym_matchers + "(?=\\b|[A-Z_])|\\w)"), function(a) {
+          return a.toLowerCase();
+        });
+      }
+      return term = term.replace(/(?:_|(\/))([a-z\d]*)/gi, function(match, $1, $2, idx, string) {
+        $1 || ($1 = '');
+        return "" + $1 + (_this.acronyms[$2] || _.capitalize($2));
+      });
+    };
+
+    Inflections.prototype.underscore = function(camel_cased_word) {
+      var word;
+      word = camel_cased_word;
+      word = word.replace(RegExp("(?:([A-Za-z\\d])|^)(" + this.acronym_matchers + ")(?=\\b|[^a-z])", "g"), function(match, $1, $2) {
+        return "" + ($1 || '') + ($1 ? '_' : '') + ($2.toLowerCase());
+      });
+      word = word.replace(/([A-Z\d]+)([A-Z][a-z])/g, "$1_$2");
+      word = word.replace(/([a-z\d])([A-Z])/g, "$1_$2");
+      word = word.replace('-', '_');
+      return word = word.toLowerCase();
+    };
+
+    Inflections.prototype.humanize = function(lower_case_and_underscored_word) {
+      var human, replacement, rule, word, _i, _len, _ref,
+        _this = this;
+      word = lower_case_and_underscored_word;
+      _ref = this.humans;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        human = _ref[_i];
+        rule = human[0];
+        replacement = human[1];
+        if (((rule.test != null) && rule.test(word)) || ((rule.indexOf != null) && word.indexOf(rule) >= 0)) {
+          word = word.replace(rule, replacement);
+          break;
+        }
+      }
+      word = word.replace(/_id$/g, '');
+      word = word.replace(/_/g, ' ');
+      word = word.replace(/([a-z\d]*)/gi, function(match) {
+        return _this.acronyms[match] || match.toLowerCase();
+      });
+      return word = _.trim(word).replace(/^\w/g, function(match) {
+        return match.toUpperCase();
+      });
+    };
+
+    Inflections.prototype.titleize = function(word) {
+      return this.humanize(this.underscore(word)).replace(/([\s¿]+)([a-z])/g, function(match, boundary, letter, idx, string) {
+        return match.replace(letter, letter.toUpperCase());
+      });
+    };
+
+    Inflections.prototype.apply_inflections = function(word, rules) {
+      var capture, match, regex, result, rule, _i, _len;
+      if (!word) {
+        return word;
+      } else {
+        result = word;
+        match = result.toLowerCase().match(/\b\w+$/);
+        if (match && _.indexOf(this.uncountables, match[0]) !== -1) {
+          return result;
+        } else {
+          for (_i = 0, _len = rules.length; _i < _len; _i++) {
+            rule = rules[_i];
+            regex = rule[0], capture = rule[1];
+            if (result.match(regex)) {
+              result = result.replace(regex, capture);
+              break;
+            }
+          }
+          return result;
+        }
+      }
+    };
+
+    return Inflections;
+
+  })();
+
+  root = typeof exports !== "undefined" && exports !== null ? exports : this;
+
+  _ = root._ || require('underscore');
+
+  if (typeof require !== "undefined" && require !== null) {
+    _.str = require('underscore.string');
+    _.mixin(_.str.exports());
+    _.str.include('Underscore.string', 'string');
+  } else {
+    _.mixin(_.str.exports());
+  }
+
+  if (typeof exports === 'undefined') {
+    _.mixin(new Inflections);
+  } else {
+    module.exports = new Inflections;
+  }
+
+}).call(this);

data/app/assets/stylesheets/revelry_data/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/revelry_data/application_controller.rb

@@ -0,0 +1,4 @@
+module RevelryData
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/revelry_data/application_helper.rb

@@ -0,0 +1,4 @@
+module RevelryData
+  module ApplicationHelper
+  end
+end

data/app/views/layouts/revelry_data/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>RevelryData</title>
+  <%= stylesheet_link_tag    "revelry_data/application", media: "all" %>
+  <%= javascript_include_tag "revelry_data/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+RevelryData::Engine.routes.draw do
+end