modjs-architecture 0.3.0 → 0.3.1

data/spec/tmp/application/test.js

@@ -0,0 +1 @@
+var test = 'test';

data/spec/tmp/application/test.module.js

@@ -0,0 +1 @@
+var test = 'test';

data/spec/tmp/foo-elements.js

@@ -0,0 +1,11 @@
+(function(app) {
+    var m = app.add_module("foo-elements");
+
+    //= require "../elements/foo-elements.elements"
+
+    m.actions = function() {
+        
+    }
+
+    m.run();
+})(myapp);

data/spec/tmp/foo.js

@@ -0,0 +1,9 @@
+(function(app) {
+    var m = app.add_module("foo");
+
+    m.actions = function() {
+        
+    }
+
+    m.run();
+})(myapp);

data/spec/tmp/foo_all.js

@@ -0,0 +1,13 @@
+(function(app) {
+    var m = app.add_module("foo_all");
+
+    //= require "../elements/foo_all.elements"
+
+    //= require "../models/foo_all.model"
+
+    m.actions = function() {
+        
+    }
+
+    m.run();
+})(myapp);

data/spec/tmp/foo_elements.js

@@ -0,0 +1,11 @@
+(function(app) {
+    var m = app.add_module("foo_elements");
+
+    //= require "../elements/foo_elements.elements"
+
+    m.actions = function() {
+        
+    }
+
+    m.run();
+})(myapp);

data/spec/tmp/foo_model.js

@@ -0,0 +1,11 @@
+(function(app) {
+    var m = app.add_module("foo_model");
+
+    //= require "../models/foo_model.model"
+
+    m.actions = function() {
+        
+    }
+
+    m.run();
+})(myapp);

data/spec/tmp/lib/mod.js

@@ -0,0 +1,320 @@
+is_defined = function(suspect) {
+  return typeof suspect == "undefined" ? false : true;
+};
+
+is_undefined = function(suspect) {
+  return typeof suspect == "undefined" ? true : false;
+};
+
+is_typeof = function(type, suspect) {
+  if (is_undefined(type)) {
+    throw new Error("is_typeof(Type, suspect): type is undefined");
+  }
+
+  if (is_undefined(suspect)) {
+    throw new Error("is_typeof(Type, suspect): suspect is undefined");
+  }
+
+  return suspect.constructor == type ? true : false;
+};
+
+is_numeric = function(suspect) {
+  if (isNaN(suspect)) {
+    return false;
+  }
+  return !isNaN(parseFloat(suspect)) && isFinite(suspect);
+};
+
+is_string = function(suspect) {
+  return is_typeof(String, suspect);
+};
+
+is_array = function(suspect) {
+  return is_typeof(Array, suspect);
+};
+
+is_number = function(suspect) {
+  return is_typeof(Number, suspect);
+};
+
+is_date = function(suspect) {
+  return is_typeof(Date, suspect);
+};
+
+is_bool = function(suspect) {
+  return is_typeof(Boolean, suspect);
+};
+
+is_regex = function(suspect) {
+  return is_typeof(RegExp, suspect);
+};
+
+is_empty = function(suspect) {
+  if (is_undefined(suspect)) {
+    return true;
+  }
+
+  return suspect.length === 0;
+};
+
+is_not_empty = function(suspect) {
+  return suspect.length >= 1;
+};
+if (!Element.prototype.addEventListener) {
+    var oListeners = {};
+
+    function runListeners(oEvent) {
+        if (!oEvent) {
+            oEvent = window.event;
+        }
+
+        for (var iLstId = 0, iElId = 0, oEvtListeners = oListeners[oEvent.type]; iElId < oEvtListeners.aEls.length; iElId++) {
+            if (oEvtListeners.aEls[iElId] === this) {
+                for (iLstId; iLstId < oEvtListeners.aEvts[iElId].length; iLstId++) {
+                    oEvtListeners.aEvts[iElId][iLstId].call(this, oEvent);
+                }
+
+                break;
+            }
+        }
+    }
+
+    Element.prototype.addEventListener = function (sEventType, fListener) {
+        if (oListeners.hasOwnProperty(sEventType)) {
+            var oEvtListeners = oListeners[sEventType];
+
+            for (var nElIdx = -1, iElId = 0; iElId < oEvtListeners.aEls.length; iElId++) {
+                if (oEvtListeners.aEls[iElId] === this) {
+                    nElIdx = iElId; break;
+                }
+            }
+
+            if (nElIdx === -1) {
+                oEvtListeners.aEls.push(this);
+                oEvtListeners.aEvts.push([fListener]);
+                this["on" + sEventType] = runListeners;
+            }
+            else {
+                var aElListeners = oEvtListeners.aEvts[nElIdx];
+
+                if (this["on" + sEventType] !== runListeners) {
+                    aElListeners.splice(0);
+                    this["on" + sEventType] = runListeners;
+                }
+
+                for (var iLstId = 0; iLstId < aElListeners.length; iLstId++) {
+                    if (aElListeners[iLstId] === fListener) {
+                        return;
+                    }
+                }
+
+                aElListeners.push(fListener);
+            }
+        }
+        else {
+            oListeners[sEventType] = {
+                aEls: [this],
+                aEvts: [[fListener]]
+            };
+
+            this["on" + sEventType] = runListeners;
+        }
+    };
+
+    Element.prototype.removeEventListener = function (sEventType) {
+        if (!oListeners.hasOwnProperty(sEventType)) {
+            return;
+        }
+
+        var oEvtListeners = oListeners[sEventType];
+
+        for (var nElIdx = -1, iElId = 0; iElId < oEvtListeners.aEls.length; iElId++) {
+            if (oEvtListeners.aEls[iElId] === this) {
+                nElIdx = iElId;
+                break;
+            }
+        }
+
+        if (nElIdx === -1) {
+            return;
+        }
+
+        for (var iLstId = 0, aElListeners = oEvtListeners.aEvts[nElIdx]; iLstId < aElListeners.length; iLstId++) {
+            aElListeners.splice(iLstId, 1);
+        }
+    };
+}
+
+var Mod = {};
+
+Mod.DOM = (function() {
+
+    var timer,
+        queue = [];
+
+    function DOM() {
+        this.cache = {};
+        this.is_ready = false;
+    }
+
+    DOM.prototype.add_event = function(element, type, fn, capture) {
+        if (is_undefined(capture)) {
+            capture = false;
+        }
+
+        if (is_string(element)) {
+            element = this.cache[element];
+        }
+
+        element.addEventListener(type, fn, capture);
+    };
+
+    DOM.prototype.remove_event = function(element, type, fn, capture) {
+        if (is_undefined(capture)) {
+            capture = false;
+        }
+
+        if (is_string(element)) {
+            element = this.cache[element];
+        }
+
+        element.removeEventListener(type, fn, capture);
+    };
+
+    DOM.prototype.call_when_ready = function(func) {
+        if (this.is_ready) {
+            return func();
+        }
+
+        if (timer) {
+            queue.push(func);
+        }
+        else {
+            this.add_event(window, 'load', this.execute_ready_queue);
+            queue.push(func);
+            timer = setInterval(this.execute_ready_queue, 13);
+        }
+    };
+
+    DOM.prototype.execute_ready_queue = function() {
+        if (this.is_ready) {
+            return false;
+        }
+
+        if (document && document.getElementsByTagName && document.getElementById && document.body) {
+            clearInterval(timer);
+            timer = null;
+            for(var i = 0, j = queue.length; i < j; i++) {
+                queue[i]();
+            }
+
+            queue = [];
+            this.is_ready = true;
+        }
+    };
+
+    DOM.prototype.add_elements = function(elements) {
+        for(var key in elements) {
+            if (elements.hasOwnProperty(key)) {
+                this.add_element(key, elements[key]);
+            }
+        }
+    };
+
+    DOM.prototype.add_element = function(key, element) {
+        this.cache[key] = element;
+    };
+
+    return DOM;
+})();
+Mod.Module = (function() {
+
+    function Module(name) {
+        if (is_undefined(name)) {
+            throw new Error("Mod.Module(name): name is undefined");
+        }
+
+        this.dom = new Mod.DOM;
+        this.data = {};
+        this.name = name;
+    }
+
+    Module.prototype.actions = function() {};
+
+    Module.prototype.run = function() {
+        var mod = this;
+        this.dom.call_when_ready(function() {
+            mod.execute();
+        });
+    };
+
+    Module.prototype.execute = function() {
+        this.actions();
+    };
+
+    Module.prototype.elements = function(elements) {
+        if (is_undefined(elements)) {
+            return this.dom.cache;
+        }
+
+        if (is_string(elements)) {
+            var name = elements;
+            return this.dom.cache[name];
+        }
+        else {
+            this.dom.add_elements(elements);
+        }
+    };
+
+    Module.prototype.set_data = function(key, value) {
+        if (is_undefined(key)) {
+            throw new Error(this.name + '.set_data(key, value): key is undefined');
+        }
+
+        if (is_typeof(String, key) && is_undefined(value)) {
+            throw new SyntaxError(this.name + 'Module.set_data(key, value): value is undefined');
+        }
+
+        if (is_typeof(String, key)) {
+            this.data[key] = value;
+        }
+        else if (is_typeof(Object, key)) {
+            var data = key;
+            for(var property in data) {
+                this.data[property] = data[property];
+            }
+        }
+
+        return this;
+    };
+
+    return Module;
+})();
+Mod.Application = (function() {
+
+    function Application(name) {
+        if (is_undefined(name)) {
+            throw new Error("new Mod.Application(name): name is undefined");
+        }
+
+        this.name = name
+    };
+
+    Application.prototype.add_module = function(name) {
+        if (is_undefined(name)) {
+            throw new Error("Mod.Application.add_module(name): name is undefined");
+        }
+
+        if (is_defined(this[name])) {
+            throw new Error("Mod.Application.add_module('" + name + "'): '" + name + "' already declared");
+        }
+
+        if (this.name === name) {
+            throw new Error("Mod.Application.add_module('" + name + "'): a module cannot have the same name as the application. It's bad idea. Do you really want to write " + name + "." + name + "? It's confusing.'");
+        }
+
+        return this[name] = new Mod.Module(name);
+    };
+
+    return Application;
+})();

data/spec/tmp/modules/test.module.js

@@ -0,0 +1 @@
+var test = 'test';

data/spec/tmp/myapp.architecture

@@ -0,0 +1,8 @@
+framework: modjs
+src_dir: modules
+build_dir: application
+asset_root: ../
+output: expanded
+dependencies: ["../modules/test.module"]
+autoload: ["../modules/test.module"]
+name: myapp

data/spec/tmp/myapp.blueprint

@@ -0,0 +1,8 @@
+blueprint: modjs
+src_dir: modules
+build_dir: application
+asset_root: ../
+output: compressed
+dependencies: []
+autoload: []
+name: myapp

data/spec/tmp/spec/application_spec.js

@@ -0,0 +1,23 @@
+describe("Mod.Application", function() {
+
+  it("should require a name attribute", function() {
+    expect(function() {
+      var app = new Mod.Application;
+    }).toThrow("new Mod.Application(name): name is undefined");
+    
+  });
+
+  it("should create a new application instance", function() {
+    var app = new Mod.Application('app');
+    expect(app).toBeTruthy();
+    expect(app.name).toEqual('app');
+  });
+
+  it("should have a module factory method", function() {
+    var app = new Mod.Application('app');
+    app.add_module('foo');
+    expect(app.foo).toBeTruthy();
+    expect(app.foo.name).toEqual('foo');
+  });
+
+});

data/spec/tmp/spec/dom_spec.js

@@ -0,0 +1,49 @@
+describe("Mod.DOM", function() {
+    var dom;
+
+    beforeEach(function() {
+        dom = new Mod.DOM;
+    });
+
+    it("should have a cache", function() {
+        expect(dom.cache).toEqual({});
+    });
+
+    it("should have an is_ready property", function() {
+        expect(is_bool(dom.is_ready)).toBeTruthy();
+    });
+
+    it("should add an element to the cache", function() {
+        dom.add_element('foo', document.getElementById('body'));
+        expect(dom.cache.foo).toEqual(document.getElementById('body'));
+    });
+
+    it("should add a hash of elements to the cache", function() {
+        dom.add_elements({
+            bar: document.getElementsByTagName('html')[0],
+            baz: document.getElementsByTagName('head')[0]
+        });
+
+        expect(dom.cache.bar).toEqual(document.getElementsByTagName('html')[0]);
+        expect(dom.cache.baz).toEqual(document.getElementsByTagName('head')[0]);
+    });
+
+    it("should have an add_event method", function() {
+        expect(dom.add_event).toBeTruthy();
+    });
+
+    it("should have a remove_event method", function() {
+        expect(dom.remove_event).toBeTruthy();
+    });
+
+    it("should have a call_when_ready method", function() {
+        dom.call_when_ready(function() {
+            var body = document.getElementsByTagName('body')[0],
+                h1 = document.createElement('h1');
+
+                h1.setAttribute('id', 'foo');
+                body.appendChild(h1);
+                expect(document.getElementById('foo')).toBeTruthy();
+        });
+    });
+});