crossroadsjs-rails 1.0.0

data/.gitignore

@@ -0,0 +1 @@
+/Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--tty

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (C) 2012 Phil Ostler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# Crossroads.js for Rails ![Build Status][travis_ci_build_status]
+
+Provides Crossroads.js (0.7.1) for use with Rails 3
+
+[RubyGems][ruby_gems] | [Ruby Toolbox][ruby_toolbox] | [GitHub][github] | [Travis CI][travis_ci] | [RubyDoc][ruby_doc]
+
+## Installation
+### JavaScript Dependencies
+Crossroads.js depends upon [js-signals][jssignals_project_page] which must also be added to your application. Either...
+
+* Use [jssignals-rails][jssignals_rails_github] gem to add js-signals to the asset pipeline
+* Place a copy of signals.js (or signals.min.js) in one of the asset pipeline or public directories
+
+### Rails 3.1+
+To use Crossroads.js with your Rails 3.1+ application, add the following to your Gemfile
+
+```
+gem "crossroadsjs-rails"
+``` 
+Run ```bundle install``` and Crossroads.js will be available for you to use via the asset pipeline. Add the following line into your ```app/assets/javascripts/application.js``` file...
+
+```
+//= require crossroads
+```
+...or for the minified version in development
+
+```
+//= require crossroads.min
+```
+Crossroads.js is now installed. Woop!
+
+### Rails 3.0
+To use Crossroads.js with your Rails 3.0 application, add the following to your Gemfile
+
+```
+gem "crossroadsjs-rails"
+``` 
+Run ```bundle install``` followed by the install generator
+
+```
+rails generate crossroadsjs:install
+``` 
+Crossroads.js is now installed. Woop!
+
+##Crossroads.js Resources
+[Project Page][crossroadsjs_project_page] | [GitHub][crossroadsjs_github]
+
+[github]: http://github.com/philostler/crossroadsjs-rails
+[ruby_doc]: http://rubydoc.info/github/philostler/crossroadsjs-rails/master/frames
+[ruby_gems]: http://rubygems.org/gems/crossroadsjs-rails
+[travis_ci]: http://travis-ci.org/philostler/crossroadsjs-rails
+[travis_ci_build_status]: https://secure.travis-ci.org/philostler/crossroadsjs-rails.png
+[ruby_toolbox]: http://www.ruby-toolbox.com/projects/crossroadsjs-rails
+[jssignals_project_page]: http://millermedeiros.github.com/js-signals
+[jssignals_rails_github]: http://github.com/philostler/jssignals-rails
+[crossroadsjs_project_page]: http://millermedeiros.github.com/crossroads.js
+[crossroadsjs_github]: http://github.com/millermedeiros/crossroads.js

data/Rakefile

@@ -0,0 +1,5 @@
+require "rspec/core/rake_task"
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new :spec

data/crossroadsjs-rails.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/crossroadsjs/rails/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "crossroadsjs-rails"
+  s.version     = Crossroadsjs::Rails::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.author      = "Phil Ostler"
+  s.email       = "philostler@gmail.com"
+  s.homepage    = "http://github.com/philostler/crossroadsjs-rails"
+  s.summary     = %q{Crossroads.js for Rails}
+  s.description = %q{Provides Crossroads.js for use with Rails 3}
+
+  s.add_dependency "railties", "~> 3.0"
+
+  s.add_development_dependency "rspec", "~> 2.0"
+
+  s.files = Dir[".gitignore"] +
+            Dir[".rspec"] +
+            Dir["Gemfile"] +
+            Dir["crossroadsjs-rails.gemspec"] +
+            Dir["LICENSE"] +
+            Dir["Rakefile"] +
+            Dir["README.md"] +
+            Dir["**/*.js"] +
+            Dir["**/*.rb"]
+  s.require_paths = ["lib"]
+end

data/lib/crossroadsjs-rails.rb

@@ -0,0 +1 @@
+require "crossroadsjs/rails"

data/lib/crossroadsjs/rails.rb

@@ -0,0 +1,10 @@
+module Crossroadsjs
+  module Rails
+    if ::Rails.version < "3.1"
+      require "crossroadsjs/rails/railtie"
+    else
+      require "crossroadsjs/rails/engine"
+    end
+    require "crossroadsjs/rails/version"
+  end
+end

data/lib/crossroadsjs/rails/engine.rb

@@ -0,0 +1,6 @@
+module Crossroadsjs
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/crossroadsjs/rails/railtie.rb

@@ -0,0 +1,6 @@
+module Crossroadsjs
+  module Rails
+    class Railtie < ::Rails::Railtie
+    end
+  end
+end

data/lib/crossroadsjs/rails/version.rb

@@ -0,0 +1,6 @@
+module Crossroadsjs
+  module Rails
+    VERSION = "1.0.0"
+    CROSSROADSJS_VERSION = "0.7.1";
+  end
+end

data/lib/generators/crossroadsjs/install/install_generator.rb

@@ -0,0 +1,17 @@
+require "rails"
+
+module Crossroadsjs
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "This generator installs Crossroads.js (#{Crossroadsjs::Rails::CROSSROADSJS_VERSION})"
+      source_root File.expand_path "../../../../../vendor/assets/javascripts", __FILE__
+
+      def copy_crossroadsjs
+        say_status "copying", "Crossroads.js (#{Crossroadsjs::Rails::CROSSROADSJS_VERSION})", :green
+
+        copy_file "crossroads.js",     "public/javascripts/crossroads.js"
+        copy_file "crossroads.min.js", "public/javascripts/crossroads.min.js"
+      end
+    end
+  end
+end if ::Rails.version < 3.1

data/spec/crossroadsjs/rails/version_spec.rb

@@ -0,0 +1,6 @@
+require "spec_helper"
+
+describe Crossroadsjs::Rails do
+  it { Crossroadsjs::Rails::VERSION.should == "1.0.0" }
+  it { Crossroadsjs::Rails::CROSSROADSJS_VERSION.should == "0.7.1" }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require "rails/all"
+
+require "crossroadsjs-rails"

data/vendor/assets/javascripts/crossroads.js

@@ -0,0 +1,395 @@
+/** @license
+ * Crossroads.js <http://millermedeiros.github.com/crossroads.js>
+ * Released under the MIT license
+ * Author: Miller Medeiros
+ * Version: 0.7.1 - Build: 93 (2012/02/02 09:29 AM)
+ */
+
+(function (define) {
+define(['signals'], function (signals) {
+
+    var crossroads,
+        patternLexer,
+        UNDEF;
+
+    // Helpers -----------
+    //====================
+
+    function arrayIndexOf(arr, val) {
+        if (arr.indexOf) {
+            return arr.indexOf(val);
+        } else {
+            //Array.indexOf doesn't work on IE 6-7
+            var n = arr.length;
+            while (n--) {
+                if (arr[n] === val) {
+                    return n;
+                }
+            }
+            return -1;
+        }
+    }
+
+    function isKind(val, kind) {
+        return '[object '+ kind +']' === Object.prototype.toString.call(val);
+    }
+
+    function isRegExp(val) {
+        return isKind(val, 'RegExp');
+    }
+
+    function isArray(val) {
+        return isKind(val, 'Array');
+    }
+
+    function isFunction(val) {
+        return isKind(val, 'Function');
+    }
+
+    //borrowed from AMD-utils
+    function typecastValue(val) {
+        var r;
+        if (val === null || val === 'null') {
+            r = null;
+        } else if (val === 'true') {
+            r = true;
+        } else if (val === 'false') {
+            r = false;
+        } else if (val === UNDEF || val === 'undefined') {
+            r = UNDEF;
+        } else if (val === '' || isNaN(val)) {
+            //isNaN('') returns false
+            r = val;
+        } else {
+            //parseFloat(null || '') returns NaN
+            r = parseFloat(val);
+        }
+        return r;
+    }
+
+    function typecastArrayValues(values) {
+        var n = values.length,
+            result = [];
+        while (n--) {
+            result[n] = typecastValue(values[n]);
+        }
+        return result;
+    }
+
+
+    // Crossroads --------
+    //====================
+
+    /**
+     * @constructor
+     */
+    function Crossroads() {
+        this._routes = [];
+        this.bypassed = new signals.Signal();
+        this.routed = new signals.Signal();
+    }
+
+    Crossroads.prototype = {
+
+        normalizeFn : null,
+
+        create : function () {
+            return new Crossroads();
+        },
+
+        shouldTypecast : false,
+
+        addRoute : function (pattern, callback, priority) {
+            var route = new Route(pattern, callback, priority, this);
+            this._sortedInsert(route);
+            return route;
+        },
+
+        removeRoute : function (route) {
+            var i = arrayIndexOf(this._routes, route);
+            if (i !== -1) {
+                this._routes.splice(i, 1);
+            }
+            route._destroy();
+        },
+
+        removeAllRoutes : function () {
+            var n = this.getNumRoutes();
+            while (n--) {
+                this._routes[n]._destroy();
+            }
+            this._routes.length = 0;
+        },
+
+        parse : function (request) {
+            request = request || '';
+
+            var routes = this._getMatchedRoutes(request),
+                i = 0,
+                n = routes.length,
+                cur;
+
+            if (n) {
+                //shold be incremental loop, execute routes in order
+                while (i < n) {
+                    cur = routes[i];
+                    cur.route.matched.dispatch.apply(cur.route.matched, cur.params);
+                    cur.isFirst = !i;
+                    this.routed.dispatch(request, cur);
+                    i += 1;
+                }
+            } else {
+                this.bypassed.dispatch(request);
+            }
+        },
+
+        getNumRoutes : function () {
+            return this._routes.length;
+        },
+
+        _sortedInsert : function (route) {
+            //simplified insertion sort
+            var routes = this._routes,
+                n = routes.length;
+            do { --n; } while (routes[n] && route._priority <= routes[n]._priority);
+            routes.splice(n+1, 0, route);
+        },
+
+        _getMatchedRoutes : function (request) {
+            var res = [],
+                routes = this._routes,
+                n = routes.length,
+                route;
+            //should be decrement loop since higher priorities are added at the end of array
+            while (route = routes[--n]) {
+                if ((!res.length || route.greedy) && route.match(request)) {
+                    res.push({
+                        route : route,
+                        params : route._getParamsArray(request)
+                    });
+                }
+            }
+            return res;
+        },
+
+        toString : function () {
+            return '[crossroads numRoutes:'+ this.getNumRoutes() +']';
+        }
+    };
+
+    //"static" instance
+    crossroads = new Crossroads();
+    crossroads.VERSION = '0.7.1';
+
+
+
+    // Route --------------
+    //=====================
+
+    /**
+     * @constructor
+     */
+    function Route(pattern, callback, priority, router) {
+        var isRegexPattern = isRegExp(pattern);
+        this._router = router;
+        this._pattern = pattern;
+        this._paramsIds = isRegexPattern? null : patternLexer.getParamIds(this._pattern);
+        this._optionalParamsIds = isRegexPattern? null : patternLexer.getOptionalParamsIds(this._pattern);
+        this._matchRegexp = isRegexPattern? pattern : patternLexer.compilePattern(pattern);
+        this.matched = new signals.Signal();
+        if (callback) {
+            this.matched.add(callback);
+        }
+        this._priority = priority || 0;
+    }
+
+    Route.prototype = {
+
+        greedy : false,
+
+        rules : void(0),
+
+        match : function (request) {
+            return this._matchRegexp.test(request) && this._validateParams(request); //validate params even if regexp because of `request_` rule.
+        },
+
+        _validateParams : function (request) {
+            var rules = this.rules,
+                values = this._getParamsObject(request),
+                key;
+            for (key in rules) {
+                // normalize_ isn't a validation rule... (#39)
+                if(key !== 'normalize_' && rules.hasOwnProperty(key) && ! this._isValidParam(request, key, values)){
+                    return false;
+                }
+            }
+            return true;
+        },
+
+        _isValidParam : function (request, prop, values) {
+            var validationRule = this.rules[prop],
+                val = values[prop],
+                isValid = false;
+
+            if (val == null && this._optionalParamsIds && arrayIndexOf(this._optionalParamsIds, prop) !== -1) {
+                isValid = true;
+            }
+            else if (isRegExp(validationRule)) {
+                isValid = validationRule.test(val);
+            }
+            else if (isArray(validationRule)) {
+                isValid = arrayIndexOf(validationRule, val) !== -1;
+            }
+            else if (isFunction(validationRule)) {
+                isValid = validationRule(val, request, values);
+            }
+
+            return isValid; //fail silently if validationRule is from an unsupported type
+        },
+
+        _getParamsObject : function (request) {
+            var shouldTypecast = this._router.shouldTypecast,
+                values = patternLexer.getParamValues(request, this._matchRegexp, shouldTypecast),
+                o = {},
+                n = values.length;
+            while (n--) {
+                o[n] = values[n]; //for RegExp pattern and also alias to normal paths
+                if (this._paramsIds) {
+                    o[this._paramsIds[n]] = values[n];
+                }
+            }
+            o.request_ = shouldTypecast? typecastValue(request) : request;
+            o.vals_ = values;
+            return o;
+        },
+
+        _getParamsArray : function (request) {
+            var norm = this.rules? this.rules.normalize_ : null,
+                params;
+            norm = norm || this._router.normalizeFn; // default normalize
+            if (norm && isFunction(norm)) {
+                params = norm(request, this._getParamsObject(request));
+            } else {
+                params = patternLexer.getParamValues(request, this._matchRegexp, this._router.shouldTypecast);
+            }
+            return params;
+        },
+
+        dispose : function () {
+            this._router.removeRoute(this);
+        },
+
+        _destroy : function () {
+            this.matched.dispose();
+            this.matched = this._pattern = this._matchRegexp = null;
+        },
+
+        toString : function () {
+            return '[Route pattern:"'+ this._pattern +'", numListeners:'+ this.matched.getNumListeners() +']';
+        }
+
+    };
+
+
+
+    // Pattern Lexer ------
+    //=====================
+
+    patternLexer = crossroads.patternLexer = (function () {
+
+
+        var ESCAPE_CHARS_REGEXP = /[\\.+*?\^$\[\](){}\/'#]/g, //match chars that should be escaped on string regexp
+            UNNECESSARY_SLASHES_REGEXP = /\/$/g, //trailing slash
+            OPTIONAL_SLASHES_REGEXP = /([:}]|\w(?=\/))\/?(:)/g, //slash between `::` or `}:` or `\w:`. $1 = before, $2 = after
+            REQUIRED_SLASHES_REGEXP = /([:}])\/?(\{)/g, //used to insert slash between `:{` and `}{`
+
+            REQUIRED_PARAMS_REGEXP = /\{([^}]+)\}/g, //match everything between `{ }`
+            OPTIONAL_PARAMS_REGEXP = /:([^:]+):/g, //match everything between `: :`
+            PARAMS_REGEXP = /(?:\{|:)([^}:]+)(?:\}|:)/g, //capture everything between `{ }` or `: :`
+
+            //used to save params during compile (avoid escaping things that
+            //shouldn't be escaped).
+            SAVE_REQUIRED_PARAMS = '__CR_RP__',
+            SAVE_OPTIONAL_PARAMS = '__CR_OP__',
+            SAVE_REQUIRED_SLASHES = '__CR_RS__',
+            SAVE_OPTIONAL_SLASHES = '__CR_OS__',
+            SAVED_REQUIRED_REGEXP = new RegExp(SAVE_REQUIRED_PARAMS, 'g'),
+            SAVED_OPTIONAL_REGEXP = new RegExp(SAVE_OPTIONAL_PARAMS, 'g'),
+            SAVED_OPTIONAL_SLASHES_REGEXP = new RegExp(SAVE_OPTIONAL_SLASHES, 'g'),
+            SAVED_REQUIRED_SLASHES_REGEXP = new RegExp(SAVE_REQUIRED_SLASHES, 'g');
+
+
+        function captureVals(regex, pattern) {
+            var vals = [], match;
+            while (match = regex.exec(pattern)) {
+                vals.push(match[1]);
+            }
+            return vals;
+        }
+
+        function getParamIds(pattern) {
+            return captureVals(PARAMS_REGEXP, pattern);
+        }
+
+        function getOptionalParamsIds(pattern) {
+            return captureVals(OPTIONAL_PARAMS_REGEXP, pattern);
+        }
+
+        function compilePattern(pattern) {
+            pattern = pattern || '';
+            if(pattern){
+                pattern = pattern.replace(UNNECESSARY_SLASHES_REGEXP, '');
+                pattern = tokenize(pattern);
+                pattern = pattern.replace(ESCAPE_CHARS_REGEXP, '\\$&');
+                pattern = untokenize(pattern);
+            }
+            return new RegExp('^'+ pattern + '/?$'); //trailing slash is optional
+        }
+
+        function tokenize(pattern) {
+            //save chars that shouldn't be escaped
+            pattern = pattern.replace(OPTIONAL_SLASHES_REGEXP, '$1'+ SAVE_OPTIONAL_SLASHES +'$2');
+            pattern = pattern.replace(REQUIRED_SLASHES_REGEXP, '$1'+ SAVE_REQUIRED_SLASHES +'$2');
+            pattern = pattern.replace(OPTIONAL_PARAMS_REGEXP, SAVE_OPTIONAL_PARAMS);
+            return pattern.replace(REQUIRED_PARAMS_REGEXP, SAVE_REQUIRED_PARAMS);
+        }
+
+        function untokenize(pattern) {
+            pattern = pattern.replace(SAVED_OPTIONAL_SLASHES_REGEXP, '\\/?');
+            pattern = pattern.replace(SAVED_REQUIRED_SLASHES_REGEXP, '\\/');
+            pattern = pattern.replace(SAVED_OPTIONAL_REGEXP, '([^\\/]+)?\/?');
+            return pattern.replace(SAVED_REQUIRED_REGEXP, '([^\\/]+)');
+        }
+
+        function getParamValues(request, regexp, shouldTypecast) {
+            var vals = regexp.exec(request);
+            if (vals) {
+                vals.shift();
+                if (shouldTypecast) {
+                    vals = typecastArrayValues(vals);
+                }
+            }
+            return vals;
+        }
+
+        //API
+        return {
+            getParamIds : getParamIds,
+            getOptionalParamsIds : getOptionalParamsIds,
+            getParamValues : getParamValues,
+            compilePattern : compilePattern
+        };
+
+    }());
+
+
+    return crossroads;
+});
+}(typeof define === 'function' && define.amd ? define : function (deps, factory) {
+    if (typeof module !== 'undefined' && module.exports) { //Node
+        module.exports = factory(require(deps[0]));
+    } else {
+        /*jshint sub:true */
+        window['crossroads'] = factory(window[deps[0]]);
+    }
+}));

data/vendor/assets/javascripts/crossroads.min.js

@@ -0,0 +1,15 @@
+/*
+
+ Crossroads.js <http://millermedeiros.github.com/crossroads.js>
+ Released under the MIT license
+ Author: Miller Medeiros
+ Version: 0.7.1 - Build: 93 (2012/02/02 09:29 AM)
+*/
+(function(f){f(["signals"],function(g){function f(a,b){if(a.indexOf)return a.indexOf(b);else{for(var c=a.length;c--;)if(a[c]===b)return c;return-1}}function i(a,b){return"[object "+b+"]"===Object.prototype.toString.call(a)}function n(a){return a===null||a==="null"?null:a==="true"?!0:a==="false"?!1:a===m||a==="undefined"?m:a===""||isNaN(a)?a:parseFloat(a)}function k(){this._routes=[];this.bypassed=new g.Signal;this.routed=new g.Signal}function o(a,b,c,e){var d=i(a,"RegExp");this._router=e;this._pattern=
+a;this._paramsIds=d?null:h.getParamIds(this._pattern);this._optionalParamsIds=d?null:h.getOptionalParamsIds(this._pattern);this._matchRegexp=d?a:h.compilePattern(a);this.matched=new g.Signal;b&&this.matched.add(b);this._priority=c||0}var j,h,m;k.prototype={normalizeFn:null,create:function(){return new k},shouldTypecast:!1,addRoute:function(a,b,c){a=new o(a,b,c,this);this._sortedInsert(a);return a},removeRoute:function(a){var b=f(this._routes,a);b!==-1&&this._routes.splice(b,1);a._destroy()},removeAllRoutes:function(){for(var a=
+this.getNumRoutes();a--;)this._routes[a]._destroy();this._routes.length=0},parse:function(a){var a=a||"",b=this._getMatchedRoutes(a),c=0,e=b.length,d;if(e)for(;c<e;)d=b[c],d.route.matched.dispatch.apply(d.route.matched,d.params),d.isFirst=!c,this.routed.dispatch(a,d),c+=1;else this.bypassed.dispatch(a)},getNumRoutes:function(){return this._routes.length},_sortedInsert:function(a){var b=this._routes,c=b.length;do--c;while(b[c]&&a._priority<=b[c]._priority);b.splice(c+1,0,a)},_getMatchedRoutes:function(a){for(var b=
+[],c=this._routes,e=c.length,d;d=c[--e];)(!b.length||d.greedy)&&d.match(a)&&b.push({route:d,params:d._getParamsArray(a)});return b},toString:function(){return"[crossroads numRoutes:"+this.getNumRoutes()+"]"}};j=new k;j.VERSION="0.7.1";o.prototype={greedy:!1,rules:void 0,match:function(a){return this._matchRegexp.test(a)&&this._validateParams(a)},_validateParams:function(a){var b=this.rules,c=this._getParamsObject(a),e;for(e in b)if(e!=="normalize_"&&b.hasOwnProperty(e)&&!this._isValidParam(a,e,c))return!1;
+return!0},_isValidParam:function(a,b,c){var e=this.rules[b],d=c[b],l=!1;d==null&&this._optionalParamsIds&&f(this._optionalParamsIds,b)!==-1?l=!0:i(e,"RegExp")?l=e.test(d):i(e,"Array")?l=f(e,d)!==-1:i(e,"Function")&&(l=e(d,a,c));return l},_getParamsObject:function(a){for(var b=this._router.shouldTypecast,c=h.getParamValues(a,this._matchRegexp,b),e={},d=c.length;d--;)e[d]=c[d],this._paramsIds&&(e[this._paramsIds[d]]=c[d]);e.request_=b?n(a):a;e.vals_=c;return e},_getParamsArray:function(a){var b=this.rules?
+this.rules.normalize_:null;return(b=b||this._router.normalizeFn)&&i(b,"Function")?b(a,this._getParamsObject(a)):h.getParamValues(a,this._matchRegexp,this._router.shouldTypecast)},dispose:function(){this._router.removeRoute(this)},_destroy:function(){this.matched.dispose();this.matched=this._pattern=this._matchRegexp=null},toString:function(){return'[Route pattern:"'+this._pattern+'", numListeners:'+this.matched.getNumListeners()+"]"}};h=j.patternLexer=function(){function a(a,b){for(var c=[],d;d=a.exec(b);)c.push(d[1]);
+return c}var b=/[\\.+*?\^$\[\](){}\/'#]/g,c=/\/$/g,e=/([:}]|\w(?=\/))\/?(:)/g,d=/([:}])\/?(\{)/g,f=/\{([^}]+)\}/g,g=/:([^:]+):/g,h=/(?:\{|:)([^}:]+)(?:\}|:)/g,i=RegExp("__CR_RP__","g"),j=RegExp("__CR_OP__","g"),k=RegExp("__CR_OS__","g"),m=RegExp("__CR_RS__","g");return{getParamIds:function(b){return a(h,b)},getOptionalParamsIds:function(b){return a(g,b)},getParamValues:function(a,b,c){if(a=b.exec(a))if(a.shift(),c){c=a;a=c.length;for(b=[];a--;)b[a]=n(c[a]);a=b}return a},compilePattern:function(a){if(a=
+a||"")a=a.replace(c,""),a=a.replace(e,"$1__CR_OS__$2"),a=a.replace(d,"$1__CR_RS__$2"),a=a.replace(g,"__CR_OP__"),a=a.replace(f,"__CR_RP__"),a=a.replace(b,"\\$&"),a=a.replace(k,"\\/?"),a=a.replace(m,"\\/"),a=a.replace(j,"([^\\/]+)?/?"),a=a.replace(i,"([^\\/]+)");return RegExp("^"+a+"/?$")}}}();return j})})(typeof define==="function"&&define.amd?define:function(f,g){typeof module!=="undefined"&&module.exports?module.exports=g(require(f[0])):window.crossroads=g(window[f[0]])});

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: crossroadsjs-rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Phil Ostler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: &22510320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *22510320
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &22509852 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *22509852
+description: Provides Crossroads.js for use with Rails 3
+email: philostler@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- crossroadsjs-rails.gemspec
+- LICENSE
+- Rakefile
+- README.md
+- vendor/assets/javascripts/crossroads.js
+- vendor/assets/javascripts/crossroads.min.js
+- lib/crossroadsjs/rails/engine.rb
+- lib/crossroadsjs/rails/railtie.rb
+- lib/crossroadsjs/rails/version.rb
+- lib/crossroadsjs/rails.rb
+- lib/crossroadsjs-rails.rb
+- lib/generators/crossroadsjs/install/install_generator.rb
+- spec/crossroadsjs/rails/version_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/philostler/crossroadsjs-rails
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Crossroads.js for Rails
+test_files: []