stormfront-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 607f574ffebeed664fd07f4405364de3db985bb8
+  data.tar.gz: aeb81e1a7a89a8b1004c20ce422684bf5efdb96d
+SHA512:
+  metadata.gz: 0ec6b5d716dfc4928e5680a64c0963bfcb498c3f6b0a8b15fdcde573b851d2afb560e86dc2c033a8a3ae5d0ccef92d78b6539ff581a851f5089138bcde448786
+  data.tar.gz: 0700879935004467d0538d2a483165d5ee2f6c8de0550c66fa4443c9afe9c64669691d6dcf3b4a9103632c515fef34d44212796c640756c20cc9acfcc19a2b57

data/.gitignore

@@ -0,0 +1,15 @@
+.idea/*
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in stormfront-rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Chris G
+
+MIT License
+
+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,31 @@
+# Stormfront::Rails
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'stormfront-rails'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stormfront-rails
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/stormfront-rails/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/stormfront/rails/version.rb

@@ -0,0 +1,5 @@
+module Stormfront
+  module Rails
+    VERSION = '0.1.0'
+  end
+end

data/lib/stormfront/rails.rb

@@ -0,0 +1,7 @@
+require 'stormfront/rails/version'
+
+module Stormfront
+  module Rails
+    class Engine < ::Rails::Engine; end
+  end
+end

data/stormfront-rails.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stormfront/rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'stormfront-rails'
+  spec.version       = Stormfront::Rails::VERSION
+  spec.authors       = ['Chris Gee']
+  spec.summary       = %q{A framework built upon Backbone}
+  spec.description   = %q{This is an initial extraction into a gem of the framework in use by my company}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files`.split("\n")
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'simple-jquery-rails'
+  spec.add_dependency 'simple-backbone-rails'
+  spec.add_dependency 'simple-momentjs-rails'
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

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

@@ -0,0 +1,17 @@
+//TODO: This whole class depends on Bootstrap
+Stormfront.Alert = Stormfront.View.extend({
+    className: 'alert',
+    when: {
+        rendering: function(){
+            this.$el.attr('role', 'alert').
+                addClass('alert-warning').
+                addClass('alert-dismissible');
+
+            var self = this;
+            this.$el.on('closed.bs.alert', function(){
+                self.trigger('closing');
+                self.close();
+            });
+        }
+    }
+});

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

@@ -0,0 +1,31 @@
+Stormfront.Container = Stormfront.View.extend({
+    reducers: [],
+    store: null,
+    root: null,
+    when: {
+        initializing: function(){
+            this._reducers = _.map(this.reducers, this.createReducer, this);
+        },
+        rendering: function(){
+            this.store = new this.store();
+            this.root = new this.root({model: this.store});
+            this.listenToDispatches(this.root);
+            this.$el.append(this.root.render().$el);
+        }
+    },
+    createReducer: function(interaction){
+        var useCase = new interaction();
+        this.listenToDispatches(useCase);
+        return this.addReducer(useCase);
+    },
+    addReducer: function(useCase){
+        this._reducers[useCase.type] = useCase;
+        return useCase;
+    },
+    executeUseCase: function(event){
+        this._reducers[event.type].execute(this.store, event);
+    },
+    listenToDispatches: function(publisher){
+        this.listenTo(publisher, 'dispatch', this.executeUseCase);
+    }
+});

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

@@ -0,0 +1,53 @@
+Stormfront.Entity = Stormfront.View.extend({
+    exceptions: {
+        model: {
+            error: function(collection, xhr){
+                var response = new Stormfront.Response(xhr);
+                if (response.isActionable()) {
+                    this.handleException({error: response.getError()});
+                    response.markAsHandled();
+                }
+            },
+            invalid: function(model, error){
+                this.handleException({error: error});
+            }
+        }
+    },
+    overlays: {
+        model: {
+            request: function(){
+                this.addOverlay();
+            },
+            sync: function(){
+                this.removeOverlay();
+            },
+            error: function(){
+                this.removeOverlay();
+            }
+        }
+    },
+    change: {
+        model: {
+            change: function(){
+                this.render();
+            }
+        }
+    },
+    initialize: function(){
+        this.addSubscriber(this.overlays);
+        this.addSubscriber(this.exceptions);
+        this.addSubscriber(this.change);
+        this.addPublisher(this.model);
+        Stormfront.View.prototype.initialize.apply(this, arguments);
+    },
+    addOverlay: function(){
+        this.removeOverlay();
+        this.overlay = new Stormfront.Overlay({selector: this.$el});
+    },
+    removeOverlay: function(){
+        if (this.overlay) {
+            this.overlay.close();
+            this.overlay = null;
+        }
+    }
+});

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

@@ -0,0 +1,25 @@
+Stormfront.Errors = {
+    FEEDBACK: 'An unexpected error was encountered',
+    /** @return {string} */
+    NO_SELECTOR: function() { return 'A template selector was not provided for your view' },
+    /** @return {string} */
+    NO_TEMPLATE: function(name) { return name +'\'s template was not found'; },
+    /** @return {string} */
+    INCOMPATIBLE_TEMPLATE: function(name) { return name +'\'s template and view model for your view are not compatible'; },
+    /** @return {string} */
+    VIEW_MODEL: function(name) { return name + '\'s view model for the child generated an error'; },
+    /** @return {string} */
+    NO_LOCATION: function(name) { return name + ' has no locations available to render'; },
+    /** @return {string} */
+    MULTIPLE_LOCATIONS: function(name) { return name + ' has multiple locations available to render'; },
+    /** @return {string} */
+    INITIALIZING: function(name) { return name + ' failed to initialize'; },
+    /** @return {string} */
+    RENDERING: function(name) { return name + ' failed to render'; },
+    /** @return {string} */
+    ATTACHING: function(name) { return name + ' failed to attach'; },
+    /** @return {string} */
+    CLOSING: function(name) { return name + ' failed to close'; },
+    /** @return {string} */
+    ADDING: function(name) { return name + ' failed to add'; }
+};

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

@@ -0,0 +1,52 @@
+Keys = {
+    Enter: 13,
+    LeftArrow: 37,
+    DownArrow: 40,
+    RightArrow: 39,
+    UpArrow: 38,
+    C: 67,
+    R: 82,
+    M: 77,
+    Tab: 9,
+    Override: 1000,
+    Shift: 2000
+};
+
+KeyboardEvents = Stormfront.Class.extend({
+    initialize: function(){
+        _.bindAll(this, 'onKeyDown');
+        _.extend(this, Backbone.Events);
+        $(window).on('keydown', this.onKeyDown);
+    },
+    onKeyDown: function(event){
+        function isInput(node){
+            switch(node){
+                case 'SELECT':
+                    return true;
+                case 'TEXTAREA':
+                    return true;
+                case 'INPUT':
+                    return true;
+                case 'BUTTON':
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        var shift = event.shiftKey ? Keys.Shift : 0;
+        var override = isInput(document.activeElement.nodeName) ? Keys.Override : 0;
+        this.trigger(shift + override + event.which, event);
+    },
+    enterState: function(bindings){
+        var self = this;
+        this.off();
+        function addBinding(value, key) {
+            self.on(key, value);
+        }
+        _.each(bindings, addBinding);
+    },
+    close: function(){
+        $(window).off('keydown', this.onKeyDown);
+        this.off('all');
+    }
+});

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

@@ -0,0 +1,60 @@
+Stormfront.Layout = Stormfront.View.extend({
+    base: {
+        initializing: function(){
+            this._children = new Stormfront.Chaperone();
+            this.addPublisher(this._children, 'child');
+        },
+        rendering: function(){
+            _.each(this.children, this.composeChild, this);
+        },
+        closing: function(){
+            this._children.close();
+        },
+        child: {
+            created: function(child){
+                this._children.add(child);
+            },
+            added: function(child){
+                this.addPublisher(child);
+                this._children.render(child);
+            },
+            rendered: function(child){
+                var location = this.$('.' + child.getIdentity());
+                this._children.attach(child, location, 'replaceWith');
+            },
+            attached: function(child){
+                child.transition('rendered', child);
+            },
+            removed: function(child){
+                child.close();
+                this.stopListening(child);
+            },
+            error: function(error, innerException){
+                this.handleException(
+                    new LayoutError(error, innerException)
+                );
+            }
+        }
+    },
+    initialize: function(){
+        this.addSubscriber(this.base);
+        Stormfront.View.prototype.initialize.apply(this, arguments);
+    },
+    composeChild: function(childOptions, childClass){
+        this._children.create(childClass, childOptions, this);
+    },
+    findChild: function(identity){
+        return this._children.find(identity);
+    }
+});
+
+function LayoutError(message, innerException) {
+    var error = Error(message);
+    this.name = 'LayoutError';
+    this.message = error.message;
+    this.stack = error.stack;
+    this.innerException = innerException;
+}
+
+LayoutError.prototype = Object.create(Error.prototype);
+LayoutError.prototype.constructor = LayoutError;

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

@@ -0,0 +1,123 @@
+Stormfront.List = Stormfront.View.compose({
+    base: {
+        initializing: function(){
+            this.itemViews = {};
+        },
+        rendering: function(){
+            this.darkness = $('<div></div>').addClass('hidden');
+            this.getContent().after(this.darkness);
+            this.base.collection.sync.call(this);
+        },
+        collection: {
+            error: function(collection, xhr){
+                if (xhr.handled || xhr.status == 401)
+                    return;
+                function requestAppearsAborted(xhr){
+                    return xhr.readyState != 4;
+                }
+                if (requestAppearsAborted(xhr)){
+                    xhr.handled = true;
+                    console.warn('Request appears aborted', xhr);
+                } else {
+                    try {
+                        var message = JSON.parse(xhr.responseText);
+                        var error = message.error || message.message;
+                        this.alertUser(error);
+                        xhr.handled = true;
+                    }
+                    catch(e) {
+                        console.warn('Unhandled error', xhr, e);
+                    }
+                }
+            },
+            invalid: function(model, error){
+                this.alertUser(error);
+            },
+            add: function(model){
+                var options = this.getModel(model);
+                var type = this.getItemType();
+                var view = new type(options);
+                this.setView(model, view);
+                this.observeView(view);
+                this.appendContent(view.render().$el).and('item:rendered', view);
+            },
+            remove: function(model){
+                var view = this.getView(model);
+                this.removeView(view);
+                //Remove has a bug that causes sync not to happen
+                this.collection.trigger('sync', this.collection);
+            },
+            reset: function(){
+                this.each(this.removeView);
+                this.collection.each(this.base.collection.add, this);
+                //This is a handy re-use of other code paths
+                this.collection.trigger('sync', this.collection);
+            }
+        }
+    },
+    initialize: function(options){
+        this.collection = options.collection;
+        this.register(this.collection, 'collection');
+        this.subscribe(this.base);
+    },
+    removeView: function(view){
+        this.stopListening(view);
+        view.close();
+        delete this.itemViews[view.model.cid];
+        this.trigger('item:removed', view);
+    },
+    observeView: function(view){
+        this.register(view, 'item');
+        this.forward(view);
+    },
+
+    getModel: function(model){
+        return { model: model };
+    },
+    getItemType: function(){
+        return this.itemView;
+    },
+    eject: function(){
+        this.getContent().children().appendTo(this.darkness);
+    },
+
+    alertUser: function(error){
+        this.alerts = this.alerts || [];
+
+        if (!_.contains(this.alerts, error)){
+            this.alerts.push(error);
+            alert(error);
+            this.alerts = _.without(this.alerts, error);
+        }
+    },
+
+    appendContent: function(el){
+        return new CollectionRenderContext(this).append(el);
+    },
+    getContent: function(other){
+        var selector = other ? '.collection > ' + other  : '.collection';
+        return this.$(selector).first();
+    },
+
+    getView: function(model){
+        return this.itemViews[model.cid];
+    },
+    setView: function(model, view){
+        this.itemViews[model.cid] = view;
+    },
+    each: function(predicate){
+        _.each(this.itemViews, predicate, this);
+    }
+});
+
+var CollectionRenderContext = function(root){
+    this.append = function (el) {
+            root.getContent().append(el);
+        return this;
+    };
+    this.and = function(state) {
+        root.transition.apply(root, arguments);
+        return this;
+    };
+    return this;
+};

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

@@ -0,0 +1,146 @@
+MouseEvents = Stormfront.Class.extend({
+    initialize: function(options){
+        options = _.extend({delay: 175}, options);
+        this.delay = options.delay ? options.delay : 175;
+        this.public = _.clone(Backbone.Events);
+        this.internal = _.clone(Backbone.Events);
+    },
+    listen: function(target){
+        this.$el = target;
+        this.$el.global = $(document);
+        this.el = this.$el[0];
+
+        var self = this;
+        function enterStandardEventMode() {
+            self.$el.on('wheel.me', handleMouseWheel);
+            self.$el.on('mousewheel.me', handleMouseWheel);
+            self.$el.one('mousedown.me', handleFirstMouseDown);
+
+            function handleFirstMouseDown(eventArgs) {
+                self.$el.one('mousemove.me', enterDraggingMode);
+
+                self.$el.one('mousedown.me', handleSubsequentMouseDown);
+                self.internal.once("special:single-click:down", function() { handleSpecialMouseDown(eventArgs)});
+                self.$el.global.one('mouseup.me', handleFirstMouseUp);
+                delay("special:single-click:down", eventArgs);
+            }
+
+            function handleFirstMouseUp(eventArgs) {
+                self.$el.off('mousemove.me');
+                self.internal.once("special:single-click:up", function() { handleSpecialMouseUp(eventArgs); });
+                delay("special:single-click:up", eventArgs);
+            }
+
+            function delay(event, eventArgs){
+                setTimeout(function() { publishInternalEvent(event, eventArgs);}, self.delay);
+            }
+
+            function handleSpecialMouseDown(eventArgs) {
+                self.$el.off('mousedown.me');
+                self.$el.one('mousedown.me', handleFirstMouseDown);
+                publishExternalEvent("single-click:down", eventArgs);
+            }
+
+            function handleSpecialMouseUp(eventArgs) {
+                publishExternalEvent("single-click:up", eventArgs);
+            }
+
+            function handleSubsequentMouseDown(eventArgs) {
+                self.internal.off("special:single-click:down");
+                self.$el.one('mousedown.me', handleFirstMouseDown);
+                self.$el.global.one('mouseup.me', handleSubsequentMouseUp);
+                publishExternalEvent("double-click:down", eventArgs);
+            }
+
+            function handleSubsequentMouseUp(eventArgs) {
+                self.internal.off("special:single-click:up");
+                publishExternalEvent("double-click:up", eventArgs);
+            }
+
+            function handleMouseWheel(eventArgs) {
+                publishExternalEvent("mousewheel", eventArgs);
+            }
+        }
+
+        function exitStandardEventMode() {
+            self.$el.off('mousedown.me');
+            self.$el.global.off('mouseup.me');
+            self.$el.off('mousemove.me');
+            self.$el.off('wheel.me');
+            self.$el.off('mousewheel.me');
+            self.internal.off("special:single-click:down");
+            self.internal.off("special:single-click:up");
+        }
+
+        function enterDraggingMode(eventArgs) {
+            function handleMouseMove(eventArgs) {
+                publishExternalEvent("dragging:move", eventArgs);
+            }
+
+            function handleMouseUp(eventArgs) {
+                publishExternalEvent("dragging:end", eventArgs);
+                exitDraggingMode();
+                enterStandardEventMode();
+            }
+
+            exitStandardEventMode();
+            publishExternalEvent("dragging:start", eventArgs);
+            self.$el.global.on('mousemove.me', handleMouseMove);
+            self.$el.global.one('mouseup.me', handleMouseUp);
+        }
+
+        function exitDraggingMode() {
+            self.$el.off('mouseup.me');
+            self.$el.global.off('mousemove.me');
+            self.$el.global.off('mousedown.me');
+        }
+
+        function disableUnsupportedEvents() {
+            self.$el.global.on('selectstart.me', function(eventArgs) {
+                eventArgs.preventDefault();
+                eventArgs.stopPropagation();
+                return false; });
+            self.$el.on("contextmenu.me", function(eventArgs) {
+                eventArgs.preventDefault();
+                eventArgs.stopPropagation();
+                return false; });
+        }
+
+        function publishInternalEvent(event, eventArgs){
+            publishEvent(self.internal, event, eventArgs);
+        }
+        function publishExternalEvent(event, eventArgs){
+            publishEvent(self.public, event, eventArgs);
+        }
+        function publishEvent(publisher, event, eventArgs){
+            function getMousePosition(eventArgs) {
+                var offset = self.$el.offset();
+                var relativeX = eventArgs.originalEvent.pageX - offset.left;
+                var relativeY = eventArgs.originalEvent.pageY - offset.top;
+                eventArgs.preventDefault();
+                eventArgs.stopPropagation();
+                return  {
+                    x: relativeX,
+                    y: relativeY
+                };
+            }
+            var position = getMousePosition(eventArgs);
+            publisher.trigger(event, position, eventArgs.originalEvent);
+        }
+
+        enterStandardEventMode();
+        disableUnsupportedEvents();
+    },
+    on: function(event, callback){
+        this.public.on(event, callback);
+        return this;
+    },
+    off: function(event ,callback){
+        this.public.off(event, callback);
+        return this;
+    },
+    stopListening: function(){
+        this.$el && this.$el.off('.me');
+        this.$el.global && this.$el.global.off('.me');
+    }
+});

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

@@ -0,0 +1,5 @@
+stormfront = { };
+
+Stormfront = {
+    Mixin: { }
+};