stormfront-rails 0.1.0

data/vendor/assets/javascripts/stormfront/Overlay.js

@@ -0,0 +1,178 @@
+Stormfront.Overlay = Stormfront.Class.extend({
+    initialize: function(options){
+        var selector = options.selector;
+
+        if (!selector)
+            this.overlay = new Stormfront.FullScreenOverlay({model: options});
+        else if (options.saveRequest)
+            this.overlay = new Stormfront.InlineOverlay();
+        else
+            this.overlay = new Stormfront.AnonymousOverlay();
+
+        selector = selector ? selector : document.body;
+        this.location = selector.size ? selector : $(selector);
+        this.render();
+    },
+    render: function(){
+        this.location.append(this.overlay.render().$el);
+        this.overlay.transition('attached');
+        return this;
+    },
+    close: function(){
+        this.overlay.close();
+        this.location = null;
+    },
+    error: function(){
+        this.overlay.error.apply(this.overlay, arguments);
+    }
+});
+
+Stormfront.OverlayBase = Stormfront.View.extend({
+    className: 'overlay',
+    activated: false,
+    PAUSE_DURATION: 0,
+    MINIMUM_DURATION: 0,
+    base_css: {
+        overlay_background: {
+            top: '0px', left: '0px',
+            width: '100%', height: '100%'
+        },
+        overlay_panel: {
+            position: 'absolute',
+            top: '50%', left: '50%'
+        }
+    },
+    base: {
+        rendering: function(){
+            function applyCss(value, key){
+                var selector = '.' + key;
+                this.$(selector).css(value);
+            }
+            this.startTime = stormfront.time().now();
+            _.each(this.base_css, applyCss, this);
+            _.each(this.css, applyCss, this);
+            this.$el.css({opacity: '0', 'pointer-events': 'none'});
+        },
+        attached: function(){
+            var self = this;
+            function activate(){
+                self.$el.css({opacity: '1', 'pointer-events': 'auto'});
+                self.activated = true;
+            }
+            function setDimensions(panel){
+                var content = self.$('.content');
+                var position = {
+                    'margin-left': - content.outerWidth() / 2,
+                    'margin-top': - content.outerHeight() / 2
+                };
+                panel.css(position);
+            }
+            setDimensions(this.$('.overlay_panel'));
+            if (this.PAUSE_DURATION)
+                setTimeout(activate, this.PAUSE_DURATION);
+            else
+                activate();
+        },
+        closing: function(){
+            var self = this;
+            function remove(){
+                self.remove();
+            }
+            if (!this.activated)
+                this.remove();
+
+            var currentDuration = stormfront.time().now() - this.startTime;
+            var remainingDuration = this.MINIMUM_DURATION - currentDuration;
+            if (remainingDuration > 0)
+                setTimeout(remove, remainingDuration);
+            else
+                this.remove();
+        }
+    },
+    initialize: function(){
+        this.addSubscriber(this.base);
+        Stormfront.View.prototype.initialize.apply(this, arguments);
+    },
+    error: function(){
+        this.remove();
+    },
+    close: function(){
+        this.transition.apply(this, stormfront.arguments(arguments).prepend('closing').get());
+    }
+});
+
+Stormfront.FullScreenOverlay = Stormfront.OverlayBase.extend({
+    MINIMUM_DURATION: 900,
+    css: {
+        overlay_background: {
+            position: 'fixed',
+            'z-index': '100000'
+        },
+        overlay_panel: {
+            'z-index': '100001'
+        }
+    },
+    when: {
+        rendering: function(){
+            this.$el.addClass('blocking');
+        }
+    }
+});
+
+Stormfront.AnonymousOverlay = Stormfront.OverlayBase.extend({
+    PAUSE_DURATION: 200,
+    MINIMUM_DURATION: 450,
+    css: {
+        overlay_background: {
+            position: 'absolute',
+            'z-index': 'auto'
+        },
+        overlay_panel: {
+            'z-index': 'auto'
+        }
+    },
+    when: {
+        rendering: function(){
+            this.$el.addClass('anonymous');
+        }
+    }
+});
+
+Stormfront.InlineOverlay = Stormfront.OverlayBase.extend({
+    className: 'input_overlay',
+    MINIMUM_DURATION: 1500,
+    MAXIMUM_WIDTH: 1200,
+    base_css: {
+        input: {
+            position: 'absolute',
+            top: '2px',
+            right: '10px',
+            width:'16px',
+            'z-index':'10000'
+        }
+    },
+    when: {
+        rendering: function () {
+            this.$el.find('.error').hide();
+            this.$el.find('.confirm').hide();
+        },
+        closing: function(){
+            this.$el.find('.spinner').hide();
+            this.$el.find('.confirm').show();
+        }
+    },
+    error: function (xhr) {
+        //TODO: Elevate this code up a level to the Request
+        try {
+            var response = JSON.parse(xhr.responseText);
+            var error = response.error || response.message;
+            this.$el.find('.spinner').hide();
+            this.$el.find('.error').show().attr('title', error);
+            xhr.handled = true;
+        }
+        catch (e) {
+            console.warn('Could not parse error', arguments);
+            this.remove();
+        }
+    }
+});

data/vendor/assets/javascripts/stormfront/Reducer.js

@@ -0,0 +1,9 @@
+Stormfront.Reducer = Stormfront.Class.extend({
+    type: Stormfront.Errors.NOT_IMPLEMENTED,
+    initialize: function(){
+        _.extend(this, Stormfront.Mixin.Dispatch);
+    },
+    execute: function(model, event){
+        throw Stormfront.Errors.UseCases.NOT_IMPLEMENTED;
+    }
+});

data/vendor/assets/javascripts/stormfront/Request.js

@@ -0,0 +1,39 @@
+Stormfront.Request = function(model, request, options){
+    var startTime = stormfront.time.now();
+    var overlay = new Stormfront.Overlay(options);
+    function tryRequest(){
+        return shouldWait() ? delayRequest() : sendRequest();
+    }
+    function shouldWait(){
+        //TODO: This is a dependency upon the Indigo behavior
+        return options.wait && $.xhrPool.length > 0;
+    }
+    function delayRequest(){
+        if (stormfront.time.now() - startTime < 5000)
+            setTimeout(tryRequest, 1000);
+        else
+            overlay.error('Request timed out. Please try again soon.');
+        return null;
+    }
+    function sendRequest(){
+        function onComplete(){
+            removeListeners();
+            overlay.close();
+        }
+        function onError(model, xhr){
+            removeListeners();
+            overlay.error(xhr);
+        }
+        function removeListeners(){
+            model.off('error', onError);
+            model.off('sync', onComplete);
+            model.off('invalid', onComplete);
+        }
+        model.once('invalid', onError);
+        model.once('error', onError);
+        model.once('sync', onComplete);
+
+        return request.call(model, options.args, options.options);
+    }
+    return tryRequest();
+};

data/vendor/assets/javascripts/stormfront/View.js

@@ -0,0 +1,55 @@
+Stormfront.View = Stormfront.ViewBase.extend({
+    initialize: function(options){
+        Stormfront.ViewBase.prototype.initialize.call(this, options);
+        this.when = this.when || { };
+        this.addPublisher(this);
+        this.addSubscriber(this.when);
+        this.transition.apply(this, stormfront.arguments(arguments).prepend('initializing').get());
+    },
+    render: function(){
+        Stormfront.ViewBase.prototype.render.call(this);
+        this.transition.apply(this, stormfront.arguments(arguments).prepend('rendering').get());
+        return this;
+    },
+    addPublisher: function(publisher, identity){
+        function notify(event){
+            var args = stormfront.arguments(arguments).skip(1).get();
+            function executeHandler(subscriber){
+                var handler = stormfront.hash(subscriber).findNestedValue(event.split(':'));
+                if (_.isFunction(handler))
+                    handler.apply(this, args);
+            }
+            _.each(this._subscribers, executeHandler, this);
+        }
+        function prepend(identity){
+            return function(event){
+                var newEvent = identity + ':' + event;
+                var args = stormfront.arguments(arguments).skip(1).prepend(newEvent).get();
+                notify.apply(this, args);
+            }
+        }
+        if (publisher === this)
+            this.listenTo(publisher, 'transition', notify);
+        else if (this.model && publisher === this.model)
+            this.listenTo(publisher, 'all', prepend('model'));
+        else if (this.collection && publisher === this.collection)
+            this.listenTo(publisher, 'all', prepend('collection'));
+        else if (publisher.className)
+            this.listenTo(publisher, 'transition', prepend(publisher.getIdentity()));
+        else
+            this.listenTo(publisher, 'all', prepend(identity));
+    },
+    addSubscriber: function(whenBlock){
+        this._subscribers = this._subscribers || [];
+        if (whenBlock)
+            this._subscribers.push(whenBlock);
+    },
+    transition: function(){
+        var args = stormfront.arguments(arguments).prepend('transition').get();
+        this.trigger.apply(this, args);
+    },
+    close: function(){
+        this.transition.apply(this, stormfront.arguments(arguments).prepend('closing').get());
+        Stormfront.ViewBase.prototype.close.call(this);
+    }
+});

data/vendor/assets/javascripts/stormfront/ViewBase.js

@@ -0,0 +1,57 @@
+Stormfront.ViewBase = Backbone.View.extend({
+    initialize: function(){
+        this.errors = [];
+    },
+    render: function(){
+        try {
+            this.$el.html(new Stormfront.Template(this).render());
+        }
+        catch(e) {
+            this.handleException(e);
+        }
+        return this;
+    },
+    getViewModel: function(){
+        return this.model ? this.model.toJSON ? this.model.toJSON() : this.model : {};
+    },
+    handleException: function(exception){
+        if (exception.innerException)
+            console.warn(exception.message, exception.innerException);
+        else
+            console.warn(exception.message);
+
+        this.handleError(exception.message);
+    },
+    handleError: function(message){
+        if (_.contains(this.errors, message))
+            return;
+        this.notifyUser(message);
+    },
+    notifyUser: function(message){
+        this.alert && this.alert.close();
+
+        this.errors.push(message);
+        this.alert = new Stormfront.Alert({
+            model: {
+                summary: Stormfront.Errors.FEEDBACK,
+                details: this.errors.join(', ')
+            }
+        });
+
+        this.listenTo(this.alert, 'closing', this.removeNotification);
+        this.$el.append(this.alert.render().$el);
+    },
+    removeNotification: function(){
+        this.errors = [];
+        this.stopListening(this.alert);
+    },
+    getIdentity: function(){
+        return stormfront.string(this.className).firstWord();
+    },
+    toString: function(){
+        return this.getIdentity();
+    },
+    close: function(){
+        this.remove();
+    }
+});

data/vendor/assets/javascripts/stormfront/mixin/Dispatch.js

@@ -0,0 +1,19 @@
+Stormfront.Mixin.Dispatch = {
+    hasEvents: function(){
+        return this.trigger;
+    },
+    addEvents: function(){
+        $.extend(this, Backbone.Events);
+    },
+    streamlineDispatch: function(event){
+        this.dispatch = function(){
+            this.trigger('dispatch', event)
+        };
+        this.dispatch(event);
+    },
+    dispatch: function(event){
+        if (!this.hasEvents())
+            this.addEvents();
+        this.streamlineDispatch(event);
+    }
+};

data/vendor/assets/javascripts/stormfront/mixin/Other.js

@@ -0,0 +1,25 @@
+Stormfront.Mixin.Other = {
+    unauthorized: function(entity){
+        function propagateUnauthorized(source, response, options){
+            if (response.status === 403)
+                this.trigger('unauthorized', source, response, options);
+        }
+        entity.on('error', propagateUnauthorized);
+    },
+    invalid: function(entity){
+        function propagateInvalid(source, response, options){
+            if (response.status === 400)
+                this.trigger('invalid', source, response, options);
+        }
+        entity.on('error', propagateInvalid);
+    },
+    empty: function(collection){
+        function determineEmpty(collection, response, options){
+            if (collection.isEmpty())
+                this.trigger('empty', collection, response, options);
+            else
+                this.trigger('populated', collection, response, options);
+        }
+        collection.on('sync', determineEmpty);
+    }
+};

data/vendor/assets/javascripts/stormfront/support/Chaperone.js

@@ -0,0 +1,69 @@
+Stormfront.Chaperone = Stormfront.Class.extend({
+    initialize: function(){
+        this.children = {};
+        _.extend(this, Backbone.Events);
+        this.throttle('create',  'created',  Stormfront.Errors.INITIALIZING);
+        this.throttle('render',  'rendered', Stormfront.Errors.RENDERING);
+        this.throttle('attach', 'attached', Stormfront.Errors.ATTACHING);
+        this.wrap('add',     'added',    Stormfront.Errors.ADDING);
+        this.wrap('remove',  'removed',  Stormfront.Errors.CLOSING);
+    },
+
+    create: function(childClass, options, context){
+        return new window[childClass](options.call(context));
+    },
+    find: function(identity){
+        return this.children[identity];
+    },
+    add: function(child){
+        var identity = child.getIdentity();
+        this.remove(this.find(identity));
+        this.children[identity] = child;
+        return child;
+    },
+    remove: function(child){
+        if (child)
+            this.children = _.omit(this.children, child.getIdentity());
+        return child;
+    },
+    render: function(child){
+        return child.render();
+    },
+    attach: function(child, location, method){
+        if (location.size() === 0)
+            throw Stormfront.Errors.NO_LOCATION(child);
+        else if (location.size() > 1)
+            throw Stormfront.Errors.MULTIPLE_LOCATIONS(child);
+
+        location[method](child.$el);
+        return child;
+    },
+
+    wrap: function(field, event, error){
+        var implementation = this[field];
+        this[field] = function(){
+            try {
+                var result = implementation.apply(this, arguments);
+                result && this.trigger(event, result);
+            } catch (e) {
+                this.trigger('error', error(arguments[0].toString()), e);
+            }
+        }
+    },
+    throttle: function(field, event, error){
+        this.wrap(field, event, error);
+        var implementation = this[field];
+        this[field] = function(){
+            var self = this;
+            var capturedArguments = arguments;
+            function func(){
+                implementation.apply(self, capturedArguments);
+            }
+            setTimeout(func, 5);
+        }
+    },
+
+    close: function(){
+        _.each(this.children, this.remove, this);
+    }
+});

data/vendor/assets/javascripts/stormfront/support/Template.js

@@ -0,0 +1,75 @@
+Stormfront.Template = Stormfront.Class.extend({
+    initialize: function(view){
+        this.view = view;
+    },
+    render: function(){
+        function renderTemplate(view){
+            function getTemplate(view){
+                var selector = view.getIdentity();
+                return $('#' + selector + '_template');
+            }
+            function compileTemplate(selection){
+                return Handlebars.compile(selection.html());
+            }
+            function expandTemplate(template){
+                return template(view.getViewModel());
+            }
+            return expandTemplate(compileTemplate(getTemplate(view)))
+        }
+        function findError(view){
+            function getTemplate(view){
+                if (!view.className)
+                    throw Stormfront.Errors.NO_SELECTOR();
+                var selector = view.getIdentity();
+                return $('#' + selector + '_template');
+            }
+            function compileTemplate(template){
+                if (template.size() === 1)
+                    return template;
+                if (template.size() === 0)
+                    throw Stormfront.Errors.NO_TEMPLATE(view.getIdentity());
+
+                return Handlebars.compile(template.html());
+            }
+            function expandTemplate(template, vm){
+                try {
+                    return template(vm);
+                }
+                catch(e) {
+                    throw Stormfront.Errors.INCOMPATIBLE_TEMPLATE(view.getIdentity());
+                }
+            }
+            function getViewModel(view){
+                try {
+                    return view.getViewModel();
+                }
+                catch (e){
+                    throw Stormfront.Errors.VIEW_MODEL(view.getIdentity());
+                }
+            }
+            try {
+                return expandTemplate(compileTemplate(getTemplate(view)), getViewModel(view));
+            }
+            catch(e) {
+                return e;
+            }
+        }
+        try {
+            return renderTemplate(this.view);
+        }
+        catch(e) {
+            throw new TemplateError(findError(this.view), e.message);
+        }
+    }
+});
+
+function TemplateError(message, innerException) {
+    var error = Error.call(this, message);
+    this.name = 'TemplateError';
+    this.message = error.message;
+    this.stack = error.stack;
+    this.innerException = innerException;
+}
+
+TemplateError.prototype = Object.create(Error.prototype);
+TemplateError.prototype.constructor = TemplateError;

data/vendor/assets/javascripts/stormfront/types/Arguments.js

@@ -0,0 +1,27 @@
+stormfront.arguments = function(args){
+    return new Stormfront.Arguments(args);
+};
+
+Stormfront.Arguments = Stormfront.Class.extend({
+    initialize: function(array){
+        if (array)
+            this.array = [].slice.call(array);
+        else
+            this.array = [];
+    },
+    skip: function(start) {
+        this.array = this.array.slice(start);
+        return this;
+    },
+    prepend: function(item){
+        this.array.unshift(item);
+        return this;
+    },
+    at: function(index, value){
+        this.array[index] = value;
+        return this;
+    },
+    get: function(){
+        return this.array;
+    }
+});

data/vendor/assets/javascripts/stormfront/types/Class.js

@@ -0,0 +1,25 @@
+Stormfront.Class = function(options) {
+    if (this.initialize)
+        this.initialize.apply(this, arguments);
+};
+
+Stormfront.Class.extend = function(protoProps, staticProps) {
+    var parent = this;
+    var child;
+
+    if (protoProps && _.has(protoProps, 'constructor'))
+        child = protoProps.constructor;
+    else
+        child = function(){ return parent.apply(this, arguments); };
+
+    _.extend(child, parent, staticProps);
+
+    var Surrogate = function(){ this.constructor = child; };
+    Surrogate.prototype = parent.prototype;
+    child.prototype = new Surrogate;
+
+    if (protoProps) _.extend(child.prototype, protoProps);
+    child.__super__ = parent.prototype;
+
+    return child;
+};

data/vendor/assets/javascripts/stormfront/types/Hash.js

@@ -0,0 +1,23 @@
+stormfront.hash = function(hash){
+    return new Stormfront.Hash(hash);
+};
+
+Stormfront.Hash = Stormfront.Class.extend({
+    initialize: function(hash){
+        this.hash = hash;
+    },
+    findNestedValue: function(keys){
+        function retrieve(keys, context){
+            if (!context)
+                return null;
+            if (keys.length === 0)
+                return context;
+            var current = keys.shift();
+            return retrieve(keys, context[current]);
+        }
+        return retrieve(keys, this.hash);
+    },
+    subtract: function(values){
+        return _.omit(this.hash, _.keys(values));
+    }
+});

data/vendor/assets/javascripts/stormfront/types/Number.js

@@ -0,0 +1,15 @@
+stormfront.number = function(number){
+    return new Stormfront.Number(number);
+};
+
+Stormfront.Number = Stormfront.Class.extend({
+    initialize: function(number){
+        this.number = number;
+    },
+    isWithin: function(range){
+        return range[0] < this.number && range[1] > this.number;
+    },
+    compare: function(value){
+        return this.number < value ? -1 : this.number > value ? 1 : 0;
+    }
+});

data/vendor/assets/javascripts/stormfront/types/Response.js

@@ -0,0 +1,31 @@
+Stormfront.Response = Stormfront.Class.extend({
+    initialize: function(xhr){
+        this.xhr = xhr;
+    },
+    isActionable: function(){
+        return !(this.hasBeenHandled() || this.isUserUnauthorized() || this.hasBeenAborted());
+    },
+    hasBeenHandled: function(){
+        return this.xhr.handled === true;
+    },
+    markAsHandled: function(){
+        this.xhr.handled = true;
+    },
+    isUserUnauthorized: function(){
+        return this.xhr.status === 401;
+    },
+    hasBeenAborted: function(){
+        //TODO: consider xhr.status === 'abort'?
+        return this.xhr.readyState != 4;
+    },
+    getError: function(){
+        try {
+            var message = JSON.parse(this.xhr.responseText);
+            return message.error || message.message;
+        }
+        catch (e){
+            console.warn('Unhandled error', this.xhr, e);
+            return Stormfront.Errors.FEEDBACK;
+        }
+    }
+});