neon 1.0.0 → 2.0.1

package/.jshintrc

@@ -0,0 +1,3 @@
+{
+	"laxbreak": false 
+}

package/CHANGELOG.markdown

@@ -1,3 +1,22 @@
+2.0.0 (2014-02-15)
+
+    - Requiring now adds Class, Module, Interface to global scope (neon)
+    - You can now require the stdlib with require('neon/stdlib')
+    - Requiring now adds CustomEvent, CustomEventSupport, NodeSupport
+      and BubblingSupport to the global scope (stdlib)
+    - Major version bump because it's not compatible with 1.x (The other
+      was loaded in a namespace)
+
+1.1.0 (2014-01-29)
+
+    - Added stdlib, consisting on:
+        - NodeSupport
+        - CustomEvent and CustomEventSupport
+        - BubblingSupport
+    - Added tests for stdlib
+    - Moved files to /lib
+
 1.0.0 (2012-06-23)
 
-    Cleaned up and packed Neon library, used already in production. Added usage files, improved documentation.
+    - Cleaned up and packed Neon library, used already in production.
+      Added usage files, improved documentation.

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Freshout.
+
+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.

package/README.markdown

@@ -1,6 +1,6 @@
-= Neon
+# Neon
 
-== JavaScript DSL for Classical Inheritance
+## JavaScript DSL for Classical Inheritance
 
 This files provides a DSL for the following design patterns: 
 
@@ -13,7 +13,11 @@ Neon packs a DSL for Class creation, that helps in making programs following an
 The philosophy is that it should not try to emulate other languages, so it preserves the JavaScript good parts,
 but with a nicer syntax to create classes that ensure interfaces and include reusable functionality as modules.
 
-=== Usage
+## Why another Class System?
+
+As the web applications are getting more complex these times, backend and frontend engineers work has fusioned, and they need to be able to establish a common language. It was created for people coming from OOP languages like Ruby to Javascript.
+
+### Usage
 
     Interface('Editable')({
         constructor : ['x'],
@@ -48,7 +52,7 @@ but with a nicer syntax to create classes that ensure interfaces and include reu
         }
     });
 
-== License
+## License
 
 Copyright (c) 2009 Fernando Trasviña
 

package/bower.json

@@ -0,0 +1,23 @@
+{
+  "name": "neon",
+  "main": "neon.js",
+  "version": "2.0.0",
+  "homepage": "https://github.com/azendal/neon",
+  "authors": [
+    "Fernando Trasviña <fernando@freshout.us>"
+  ],
+  "description": "JavaScript DSL for Classical Inheritance",
+  "keywords": [
+    "DSL",
+    "class",
+    "inheritance"
+  ],
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ]
+}

package/license.txt

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright 2009-2017 Fernando Trasvina
+
+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.

package/neon.js

@@ -1,219 +1,234 @@
-/**
- * neon.js v1.0.0 http://github.com/azendal/neon
- *
- * Class DSL
- * This files provides a dsl for the following design patterns:
- * inheritance, interface, module.
- *
- * It also provides a dsl for class creation.
- *
- * The philosophy is that it should not try to emulate other languages,
- * and it preserves the javascript good parts, but with a nicer syntax to
- * create classes that ensure interfaces and include reusable functionality as modules.
- *
- * Author: Fernando Trasviña
- *
- * Usage:
- * Interface('Editable')({
- *     constructor : ['x'],
- *     prototype   : ['x']
- * });
- *
- * Module('Composition')({
- *     y : 5,
- *     prototype : {
- *         z : 3
- *     }
- * });
- *
- * Module('Other')({
- *     a : 5,
- *     prototype : {
- *         b : 3
- *     }
- * });
- *
- * Class('Overlay').inherits(Widget).ensures(Editable).includes(Composition, Other)({
- *     html : '<div></div>',
- *     prototype : {
- *         init : function (element){
- *             if(!element){
- *                 element = document.createElement('div');
- *                 element.innerHTML = 'hello';
- *                 document.body.appendChild(element);
- *             }
- *         },
- *         b : 5
- *     }
- * });
- */
-(function(global) {
-
-    var Neon = {};
-
-    Neon.Interface = function Interface(nameOrNameSpace, name) {
-        var nameSpace, interfaceName, factory;
-        nameSpace = (nameOrNameSpace && name) ? nameOrNameSpace : this;
-        interfaceName = (nameOrNameSpace && name) ? name :
-            (nameOrNameSpace) ? nameOrNameSpace : 'interface' + Math.random().toString();
-        factory = function(definition) {
-            definition.isInterface = true;
-            definition.name = interfaceName;
-            nameSpace[interfaceName] = definition;
-            return nameSpace[interfaceName];
-        };
-        return factory;
-    };
 
-    Neon.Module = function Module(nameOrNameSpace, name) {
-        var nameSpace, moduleName, factory;
-        nameSpace = (nameOrNameSpace && name) ? nameOrNameSpace : this;
-        moduleName = (nameOrNameSpace && name) ? name :
-            (nameOrNameSpace) ? nameOrNameSpace : 'module' + Math.random().toString();
-        factory = function(definition) {
-            definition.isModule = true;
-            nameSpace[moduleName] = definition;
-            return nameSpace[moduleName];
-        };
-        return factory;
+if (typeof global === "undefined") {
+  global = window;
+}
+
+global.Interface = function Interface(nameOrNameSpace, name) {
+    var nameSpace, interfaceName, factory;
+    nameSpace = (nameOrNameSpace && name) ? nameOrNameSpace : this;
+    interfaceName = (nameOrNameSpace && name) ? name :
+        (nameOrNameSpace) ? nameOrNameSpace : 'interface' + Math.random().toString();
+    factory = function(definition) {
+        definition.isInterface = true;
+        definition.name = interfaceName;
+        nameSpace[interfaceName] = definition;
+        return nameSpace[interfaceName];
     };
+    return factory;
+};
+
+global.Module = function Module(nameOrNameSpace, name) {
+    var nameSpace, moduleName, factory, newModule;
+
+    nameSpace = (nameOrNameSpace && name) ? nameOrNameSpace : this;
+    moduleName = (nameOrNameSpace && name) ? name :
+        (nameOrNameSpace) ? nameOrNameSpace : 'module' + Math.random().toString();
+
+    newModule = {
+        moduleName : moduleName,
+         prototype : {},
+         __includedModules : [],
+         include : function(module) {
+             var property;
+             for (property in module) {
+                 if (module.hasOwnProperty(property)
+                         && property !== 'prototype'
+                         && property !== 'isModule'
+                         && property !== '__includedModules'
+                         && property !== 'include'
+                         && property !== 'moduleName') {
+                     newModule[property] = module[property];
+                 }
+             }
+
+             if (module.hasOwnProperty('prototype') && module.prototype) {
+                 for (property in module.prototype) {
+                     if (module.prototype.hasOwnProperty(property)) {
+                         newModule.prototype[property] = module.prototype[property];
+                     }
+                 }
+             }
+             else {
+                module.prototype = {};
+             }
 
-    Neon.Class = function Class(classNameOrNameSpace, className) {
-        var nameSpace, newClass, classFactory;
-        nameSpace = (classNameOrNameSpace && className) ? classNameOrNameSpace : this;
-        className = (classNameOrNameSpace && className) ? className :
-            (classNameOrNameSpace) ? classNameOrNameSpace : 'class' + Math.random().toString();
+             this.__includedModules.push(module);
 
-        newClass = function() {
-            if (this.init) {
-                this.init.apply(this, arguments);
+             return this;
+         }
+    };
+    
+    factory = function(definition){
+        var property;
+        
+        newModule.isModule = true;
+        
+        for (property in definition) {
+            if (definition.hasOwnProperty(property)
+                && property !== 'prototype'
+                && property !== 'isModule'
+                && property !== '__includedModules'
+                && property !== 'include'
+                && property !== 'moduleName') {
+                newModule[property] = definition[property];
             }
-        };
-
-        newClass.__descendants = [];
-        newClass.__implementedInterfaces = [];
-        newClass.__includedModules = [];
-        newClass.className = className;
-        newClass.include = function(module) {
-            var property;
-            for (property in module) {
-                if (module.hasOwnProperty(property)
-                    && property != 'prototype'
-                    && property != 'constructor'
-                    && property != 'isModule'
-                    && property != 'superClass') {
-                    newClass[property] = module[property];
+        }
+        
+        if (definition.hasOwnProperty('prototype') && definition.prototype) {
+            for (property in definition.prototype) {
+                if (definition.prototype.hasOwnProperty(property)) {
+                    newModule.prototype[property] = definition.prototype[property];
                 }
             }
+        }
+        
+        nameSpace[moduleName] = newModule;
+        
+        return nameSpace[moduleName];
+    };
+    
+    factory.includes = function () {
+        for(var i = 0; i < arguments.length; i++){
+            newModule.include(arguments[i]);
+        }
+        return factory;
+    };
+    
+    return factory;
+};
+
+global.Class = function Class(classNameOrNameSpace, className) {
+    var nameSpace, newClass, classFactory;
+    nameSpace = (classNameOrNameSpace && className) ? classNameOrNameSpace : global;
+    className = (classNameOrNameSpace && className) ? className :
+        (classNameOrNameSpace) ? classNameOrNameSpace : 'class' + Math.random().toString();
+
+    newClass = function() {
+        if (this.init) {
+            this.init.apply(this, arguments);
+        }
+    };
+
+    newClass.__descendants = [];
+    newClass.__implementedInterfaces = [];
+    newClass.__includedModules = [];
+    newClass.className = className;
+    newClass.include = function(module) {
+        var property;
+        for (property in module) {
+            if (module.hasOwnProperty(property)
+                && property != 'prototype'
+                && property != 'constructor'
+                && property != 'isModule'
+                && property != 'superClass'
+                && property != 'include') {
+                newClass[property] = module[property];
+            }
+        }
 
-            if (module.hasOwnProperty('prototype') && module.prototype) {
-                for (property in module.prototype) {
-                    if (module.prototype.hasOwnProperty(property)) {
-                        newClass.prototype[property] = module.prototype[property];
-                    }
+        if (module.hasOwnProperty('prototype') && module.prototype) {
+            for (property in module.prototype) {
+                if (module.prototype.hasOwnProperty(property)) {
+                    newClass.prototype[property] = module.prototype[property];
                 }
-            } else {
-                module.prototype = {};
             }
+        } else {
+            module.prototype = {};
+        }
 
-            newClass.__includedModules.push(module);
-            return this;
-        };
+        newClass.__includedModules.push(module);
+        return this;
+    };
 
-        classFactory = function(classDefinition) {
-            var i, il, j, jl, property, classPrototype = classDefinition.prototype;
-            if (classPrototype) {
-                for (property in classPrototype) {
-                    if (classPrototype.hasOwnProperty(property)) {
-                        newClass.prototype[property] = classPrototype[property];
-                    }
+    classFactory = function(classDefinition) {
+        var i, il, j, jl, property, classPrototype = classDefinition.prototype;
+        if (classPrototype) {
+            for (property in classPrototype) {
+                if (classPrototype.hasOwnProperty(property)) {
+                    newClass.prototype[property] = classPrototype[property];
                 }
-                delete classDefinition.prototype;
             }
-            for (property in classDefinition) {
-                if (classDefinition.hasOwnProperty(property)) {
-                    newClass[property] = classDefinition[property];
-                }
+            delete classDefinition.prototype;
+        }
+        for (property in classDefinition) {
+            if (classDefinition.hasOwnProperty(property)) {
+                newClass[property] = classDefinition[property];
             }
+        }
 
-            for (i = 0, il = newClass.__implementedInterfaces.length; i < il; i++) {
-                for (j = 0, jl = newClass.__implementedInterfaces[i].constructor.length; j < jl; j++) {
-                    if (!newClass[ newClass.__implementedInterfaces[i].constructor[j] ]) {
-                        console.log('must implement static ' + newClass.__implementedInterfaces[i].name);
-                        break;
-                    }
+        for (i = 0, il = newClass.__implementedInterfaces.length; i < il; i++) {
+            for (j = 0, jl = newClass.__implementedInterfaces[i].constructor.length; j < jl; j++) {
+                if (!newClass[ newClass.__implementedInterfaces[i].constructor[j] ]) {
+                    console.log('must implement static ' + newClass.__implementedInterfaces[i].name);
+                    break;
                 }
+            }
 
-                if (newClass.__implementedInterfaces[i].hasOwnProperty('prototype')
-                    && newClass.__implementedInterfaces[i].prototype) {
-                    for (j = 0, jl = newClass.__implementedInterfaces[i].prototype.length; j < jl; j++) {
-                        if (!newClass.prototype[newClass.__implementedInterfaces[i].prototype[j]]) {
-                            console.log('must implement prototype ' + newClass.__implementedInterfaces[i].name);
-                            break;
-                        }
+            if (newClass.__implementedInterfaces[i].hasOwnProperty('prototype')
+                && newClass.__implementedInterfaces[i].prototype) {
+                for (j = 0, jl = newClass.__implementedInterfaces[i].prototype.length; j < jl; j++) {
+                    if (!newClass.prototype[newClass.__implementedInterfaces[i].prototype[j]]) {
+                        console.log('must implement prototype ' + newClass.__implementedInterfaces[i].name);
+                        break;
                     }
                 }
             }
+        }
 
-            nameSpace[className] = newClass;
-            return newClass;
-        };
-
-        classFactory.inherits = function(superClass) {
-            var i, inheritedClass;
-            newClass.superClass = superClass;
-            if (superClass.hasOwnProperty('__descendants')) {
-                superClass.__descendants.push(newClass);
-            }
-            inheritedClass = function() {
-            };
-            inheritedClass.prototype = superClass.prototype;
-            newClass.prototype = new inheritedClass();
-            newClass.prototype.constructor = newClass;
-
-            for (i in superClass) {
-                if (superClass.hasOwnProperty(i)
-                    && i != 'prototype'
-                    && i !== 'className'
-                    && i !== 'superClass'
-                    && i !== 'include'
-                    && i != '__descendants') {
-                    newClass[i] = superClass[i];
-                }
+        try {
+            if (Li && Li.ObjectSpy && Li.Spy) {
+                newClass.__objectSpy = new Li.ObjectSpy();
+                newClass.__objectSpy.spy(newClass);
+                newClass.__objectSpy.spy(newClass.prototype);
             }
+        } catch (error) {}
 
-            delete this.inherits;
-            return this;
-        };
+        nameSpace[className] = newClass;
+        return newClass;
+    };
 
-        classFactory.ensures = function(interfaces) {
-            for (var i = 0; i < arguments.length; i++) {
-                newClass.__implementedInterfaces.push(arguments[i]);
-            }
-            delete this.ensures;
-            return classFactory;
+    classFactory.inherits = function(superClass) {
+        var i, inheritedClass;
+        newClass.superClass = superClass;
+        if (superClass.hasOwnProperty('__descendants')) {
+            superClass.__descendants.push(newClass);
+        }
+        inheritedClass = function() {
         };
-
-        classFactory.includes = function() {
-            for (var i = 0; i < arguments.length; i++) {
-                newClass.include(arguments[i]);
+        inheritedClass.prototype = superClass.prototype;
+        newClass.prototype = new inheritedClass();
+        newClass.prototype.constructor = newClass;
+
+        for (i in superClass) {
+            if (superClass.hasOwnProperty(i)
+                && i != 'prototype'
+                && i !== 'className'
+                && i !== 'superClass'
+                && i !== 'include'
+                && i != '__descendants') {
+                newClass[i] = superClass[i];
             }
-            return classFactory;
-        };
+        }
 
-        return classFactory;
+        delete this.inherits;
+        return this;
+    };
 
+    classFactory.ensures = function(interfaces) {
+        for (var i = 0; i < arguments.length; i++) {
+            newClass.__implementedInterfaces.push(arguments[i]);
+        }
+        delete this.ensures;
+        return classFactory;
     };
 
-    if (typeof define === 'function') {
-        define(function() {
-            return Neon;
-        });
-    } else {
-        global.Class = Neon.Class;
-        global.Module = Neon.Module;
-        global.Interface = Neon.Interface;
-    }
+    classFactory.includes = function() {
+        for (var i = 0; i < arguments.length; i++) {
+            newClass.include(arguments[i]);
+        }
+        return classFactory;
+    };
 
-}(typeof window !== 'undefined' ? window : (typeof exports !== 'undefined' ? exports : null)));
+    return classFactory;
 
+};

package/package.json

@@ -1,10 +1,19 @@
 {
-	"name"    : "neon",
-	"version" : "1.0.0",
-	"main"    : "./neon",
-	"repository": {
-		"type" : "git",
-		"url"  : "https://github.com/Siedrix/neon.git"
-	},
-	"keywords": ["class", "prototype", "inheritance", "oop"]
-}
+    "name": "neon",
+    "version": "2.0.1",
+    "description": "Javascript DSL for Classical Inheritance",
+    "main": "./neon",
+    "directories": {
+        "lib": "./lib"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/azendal/neon.git"
+    },
+    "keywords": [
+        "class",
+        "prototype",
+        "inheritance",
+        "oop"
+    ]
+}

package/stdlib/bubbling_support.js

@@ -0,0 +1,32 @@
+Module('BubblingSupport')({
+        dispatch : function (type, data) {
+            data = data || {};
+            var event = NeCustomEventSupport.prototype.dispatch.call(this, type, data);
+            if (event.isPropagationStopped === false) {
+                if (this.parent && this.parent.dispatch) {
+                    data.target = event.target;
+                    data.currentTarget = this.parent;
+                    this.parent.dispatch(event.type, data);
+                }
+            }
+            return event;
+        },
+
+        prototype : {
+            dispatch : function (type, data) {
+                data = data || {};
+
+                var event = NeCustomEventSupport.prototype.dispatch.call(this, type, data);
+
+                if (event.isPropagationStopped === false && event.bubbles === true) {
+                    if (this.parent && this.parent.dispatch) {
+                        data.target = event.target;
+                        data.currentTarget = this.parent;
+                        this.parent.dispatch(event.type, data);
+                    }
+                }
+
+                return event;
+            }
+        }
+    });

package/stdlib/custom_event.js

@@ -0,0 +1,54 @@
+/**
+ * @deprecated CustomEvent is deprecated and will be removed on February 1st, 2026. Use NeCustomEvent instead.
+ */
+Class('NeCustomEvent')({
+    prototype : {
+        bubbles                       : true,
+        cancelable                    : true,
+        currentTarget                 : null,
+        timeStamp                     : 0,
+        target                        : null,
+        type                          : '',
+        isPropagationStopped          : false,
+        isDefaultPrevented            : false,
+        isImmediatePropagationStopped : false,
+        areImmediateHandlersPrevented : false,
+        init : function init(type, data) {
+            this.type = type;
+            if (typeof data !== 'undefined') {
+                for(var property in data) {
+                    if (data.hasOwnProperty(property)) {
+                        this[property] = data[property];
+                    }
+                }
+            }
+        },
+        stopPropagation : function stopPropagation() {
+            this.isPropagationStopped = true;
+        },
+        preventDefault : function preventDefault() {
+            this.isDefaultPrevented = true;
+        },
+        stopImmediatePropagation : function stopImmediatePropagation() {
+            this.preventImmediateHandlers();
+            this.stopPropagation();
+        },
+        preventImmediateHandlers : function preventImmediateHandlers() {
+            this.areImmediateHandlersPrevented = true;
+        }
+    }
+
+});
+
+if (typeof window !== 'undefined') {
+    window.CustomEvent = new Proxy(NeCustomEvent, {
+        construct(target, args) {
+            console.warn('DEPRECATION NOTICE: CustomEvent is deprecated and will be removed on February 1st, 2026. Use NeCustomEvent instead.');
+            return new target(...args);
+        },
+        get(target, prop, receiver) {
+            console.warn('DEPRECATION NOTICE: CustomEvent is deprecated and will be removed on February 1st, 2026. Use NeCustomEvent instead.');
+            return Reflect.get(target, prop, receiver);
+        }
+    });
+}