modjs-architecture 0.0.0 → 0.1.0

data/spec/fixtures/test.js

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

data/spec/fixtures/test.module.js

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

data/spec/fixtures/update.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/fixtures/update.js

@@ -0,0 +1,329 @@
+/*---------- ModJS dependency ../modules/test.module ----------*/
+var test = 'test';
+
+/*---------- ModJS ../lib/mod.js ----------*/
+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;
+})();
+
+var myapp = new Mod.Application('myapp');
+
+/*---------- ModJS autoload ../modules/test.module ----------*/
+

data/spec/javascripts/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/javascripts/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();
+        });
+    });
+});

data/spec/javascripts/existence_spec.js

@@ -0,0 +1,143 @@
+describe("Mod.js", function() {
+  function CustomClass() {};
+  var undef,
+      empty_string = "",
+      whitespace = "        ",
+      tabs = "\t\t",
+      string = "Hello World",
+      alpha = "xabcdefx",
+      alpha_num = "abcdefghijklm1234567890",
+      empty_array = [],
+      array = ['one', 'two', 'three'],
+      custom_object = new CustomClass,
+      number_string = "42",
+      mix_string_num = "bcfed5.2",
+      oct_int_string = "040",
+      oct_int = 0144,
+      hex_int_string = "0xFF",
+      hex_int = 0xFFF,
+      number = 42,
+      neg_int = -16,
+      neg_int_string = "-10",
+      neg_float_string = "-1.6",
+      pos_float_string = "4.536",
+      neg_float = -2.6,
+      pos_float = 3.1415,
+      exp = 8e5,
+      exp_string = "123e-2",
+      zero_string = "0",
+      obj = {},
+      func = function() {},
+      date = new Date,
+      bool_true = true,
+      bool_false = false,
+      one = 1,
+      zero = 0,
+      pattern = /regex/;
+
+  it("should test for existence with is_defined", function() {
+    expect(is_defined).toBeTruthy();
+    expect(is_defined(undef)).toBeFalsy();
+    expect(is_defined(empty_string)).toBeTruthy();
+  });
+
+  it("should test for existence with is_undefined", function() {
+    expect(is_undefined).toBeTruthy();
+    expect(is_undefined(undef)).toBeTruthy();
+    expect(is_undefined(empty_string)).toBeFalsy();
+  });
+
+  it("should check for strict types with is_typeof", function() {
+    expect(is_typeof).toBeTruthy();
+    expect(is_typeof(String, empty_string)).toBeTruthy();
+    expect(is_typeof(Array, empty_array)).toBeTruthy();
+    expect(is_typeof(CustomClass, custom_object)).toBeTruthy();
+  });
+
+  it("should test for numeric values with is_numeric", function() {
+    expect(is_numeric(neg_int_string)).toBeTruthy();
+    expect(is_numeric(zero_string)).toBeTruthy();
+    expect(is_numeric(number)).toBeTruthy();
+    expect(is_numeric(neg_int)).toBeTruthy();
+    expect(is_numeric(zero)).toBeTruthy();
+    expect(is_numeric(oct_int_string)).toBeTruthy();
+    expect(is_numeric(oct_int)).toBeTruthy();
+    expect(is_numeric(hex_int)).toBeTruthy();
+    expect(is_numeric(neg_float)).toBeTruthy();
+    expect(is_numeric(pos_float)).toBeTruthy();
+    expect(is_numeric(exp)).toBeTruthy();
+    expect(is_numeric(exp_string)).toBeTruthy();
+
+    expect(is_numeric(empty_string)).toBeFalsy();
+    expect(is_numeric(whitespace)).toBeFalsy();
+    expect(is_numeric(tabs)).toBeFalsy();
+    expect(is_numeric(alpha_num)).toBeFalsy();
+    expect(is_numeric(alpha)).toBeFalsy();
+    expect(is_numeric(bool_true)).toBeFalsy();
+    expect(is_numeric(bool_false)).toBeFalsy();
+    expect(is_numeric(mix_string_num)).toBeFalsy();
+    expect(is_numeric(NaN)).toBeFalsy();
+    expect(is_numeric(Infinity)).toBeFalsy();
+    expect(is_numeric(Number.POSITIVE_INFINITY)).toBeFalsy();
+    expect(is_numeric(Number.NEGATIVE_INFINITY)).toBeFalsy();
+    expect(is_numeric(date)).toBeFalsy();
+    expect(is_numeric(obj)).toBeFalsy();
+    expect(is_numeric(func)).toBeFalsy();
+  });
+
+  it("should test for strings with is_string", function() {
+    expect(is_string).toBeTruthy();
+    expect(is_string(empty_string)).toBeTruthy();
+    expect(is_string(empty_array)).toBeFalsy();
+    expect(is_string(custom_object)).toBeFalsy();
+  });
+
+  it("should test for arrays with is_array", function() {
+    expect(is_array).toBeTruthy();
+    expect(is_array(empty_array)).toBeTruthy();
+    expect(is_array(empty_string)).toBeFalsy();
+  });
+
+  it("should test for numbers with is_number", function() {
+    expect(is_number).toBeTruthy();
+    expect(is_number(number)).toBeTruthy();
+    expect(is_number(number_string)).toBeFalsy();
+    expect(is_number(empty_string)).toBeFalsy();
+  });
+
+  it("should test for date objects with is_date", function() {
+    expect(is_date).toBeTruthy();
+    expect(is_date(date)).toBeTruthy();
+    expect(is_date(empty_string)).toBeFalsy();
+  });
+
+  it("should test for boolean values with is_bool", function() {
+    expect(is_bool).toBeTruthy();
+    expect(is_bool(bool_true)).toBeTruthy();
+    expect(is_bool(bool_false)).toBeTruthy();
+    expect(is_bool(one)).toBeFalsy();
+    expect(is_bool(zero)).toBeFalsy();
+  });
+
+  it("should test for RegEx objects with is_regex", function() {
+    expect(is_regex).toBeTruthy();
+    expect(is_regex(pattern)).toBeTruthy();
+    expect(is_regex(empty_string)).toBeFalsy();
+  });
+
+  it("should test for emptiness with is_empty", function() {
+    expect(is_empty).toBeTruthy();
+    expect(is_empty(empty_string)).toBeTruthy();
+    expect(is_empty(empty_array)).toBeTruthy();
+    expect(is_empty(array)).toBeFalsy();
+    expect(is_empty(string)).toBeFalsy();
+  });
+
+  it("should test for emptiness with is_not_empty", function() {
+    expect(is_not_empty).toBeTruthy();
+    expect(is_not_empty(empty_string)).toBeFalsy();
+    expect(is_not_empty(empty_array)).toBeFalsy();
+    expect(is_not_empty(array)).toBeTruthy();
+    expect(is_not_empty(string)).toBeTruthy();
+  });
+});