Initial commit

Jagged.js

@@ -0,0 +1,27 @@
+Class.define(
+
+'Jagged',
+{
+
+	Require: [
+		'Jagged.Initialiser',
+		'Jagged.Injector',
+		'Jagged.ScopeHandler',
+		'Jagged.Parser',
+		'Jagged.Templater'
+	],
+
+	'public construct : [string]': function(customNamespaces)
+	{
+
+		var injector = new Jagged.Injector();
+
+		injector.registerSingleton(injector.resolve('Jagged.ScopeHandler'));
+		injector.registerSingleton(injector.resolve('Jagged.Parser'));
+		injector.registerSingleton(injector.resolve('Jagged.Templater'));
+
+		new Jagged.Initialiser(customNamespaces, injector);
+
+	}
+
+});

Jagged/Directive/Click.js

@@ -0,0 +1,30 @@
+Class.define(
+
+'Jagged.Directive.Click',
+{
+
+	Require: [
+		'Jagged.IDirective',
+		'/scripts/Jagged/vendor/jquery-1.11.1.min.js'
+	],
+
+	Implements: 'Jagged.IDirective',
+
+	'private parser': undefined,
+	'private scopeHandler': undefined,
+
+	'public construct : Jagged.Parser Jagged.ScopeHandler Jagged.Templater': function(parser, scopeHandler, templater)
+	{
+		this.set('parser', parser);
+		this.set('scopeHandler', scopeHandler);
+	},
+
+	'public undefined initialise : object string': function(element, value)
+	{
+		var parser = this.get('parser');
+		$(element).on('click', function(){
+			parser.parse(value, element);
+		});
+	}
+
+});

Jagged/Directive/Controller.js

@@ -0,0 +1,65 @@
+Class.define(
+
+'Jagged.Directive.Controller',
+{
+
+	Require: [
+		'Jagged.IDirective',
+		'Jagged.Parser',
+		'Jagged.Parser.Member.Property',
+		'Jagged.Parser.Member.Method'
+	],
+
+	Implements: 'Jagged.IDirective',
+
+	'private controller': null,
+	'private element': null,
+	'private parser': null,
+	'private scopeHandler': null,
+
+	'public construct : Jagged.Parser Jagged.ScopeHandler': function(parser, scopeHandler)
+	{
+		this.set('parser', parser);
+		this.set('scopeHandler', scopeHandler);
+	},
+
+	'public undefined initialise : object string': function(element, value)
+	{
+		this.set('element', element);
+		Class.require(value, 'controllerClassLoaded');
+	},
+
+	'private undefined controllerClassLoaded : string': function(controllerClass)
+	{
+		var controller = this.createController(controllerClass)
+		this.set('controller', controller);
+		var propertiesAndMethods = {};
+		for (var i in controller.properties) {
+			if (!controller.properties.hasOwnProperty(i)) continue;
+			propertiesAndMethods[i] = new Jagged.Parser.Member.Property(controller, i);
+		}
+		for (var i in controller.type.methods) {
+			if (!controller.type.methods.hasOwnProperty(i)) continue;
+			propertiesAndMethods[i] = new Jagged.Parser.Member.Method(controller, i);
+		}
+		this.get('scopeHandler').registerProperties(this.get('element'), propertiesAndMethods);
+	},
+
+	'private object createController : string': function(controllerClass)
+	{
+		var classParts = controllerClass.split('.');
+		var controllerClass = window;
+		for (var i = 0; i < classParts.length; i++) {
+			controllerClass = controllerClass[classParts[i]];
+		}
+		var controller = new controllerClass();
+		if (!controller.instanceOf('Jagged.Directive.Controller.IController')) {
+			throw new Error(
+				'Controller is not an instance of Jagged.Directive.Controller.IController ' +
+				'(Controller class: ' + classParts.join('.') + ')'
+			);
+		}
+		return controller;
+	}
+
+});

Jagged/Directive/Controller/IController.js

@@ -0,0 +1,8 @@
+Interface.define(
+
+'Jagged.Directive.Controller.IController',
+[
+
+
+
+]);

Jagged/Directive/Model.js

@@ -0,0 +1,57 @@
+Class.define(
+
+'Jagged.Directive.Model',
+{
+
+	Require: [
+		'Jagged.IDirective',
+		'/scripts/Jagged/vendor/jquery-1.11.1.min.js'
+	],
+
+	Implements: 'Jagged.IDirective',
+
+	'private parser': undefined,
+	'private scopeHandler': undefined,
+	'private templater': undefined,
+	'private element': undefined,
+
+	'public construct : Jagged.Parser Jagged.ScopeHandler Jagged.Templater': function(parser, scopeHandler, templater)
+	{
+		this.set('parser', parser);
+		this.set('scopeHandler', scopeHandler);
+		this.set('templater', templater);
+	},
+
+	'public undefined initialise : object string': function(element, value)
+	{
+		this.set('element', element);
+		var scopeHandler = this.get('scopeHandler');
+		var scopeElement = this.getScopeElement(element);
+		var properties = {};
+		properties[value] = element.value;
+		scopeHandler.registerProperties(scopeElement, properties);
+		scopeHandler.bind('objectChanged', 'objectChanged');
+		var templater = this.get('templater');
+		$(element).on('input', function(){
+			properties[value] = $(this).val();
+			templater.render(scopeElement);
+		});
+	},
+
+	'private object getScopeElement : object': function(element)
+	{
+		var $currentElement = $(element);
+		do {
+			if (typeof $parentElement != 'undefined') $currentElement = $parentElement;
+			if ($currentElement.attr('jagged.directive.controller')) break;
+			$parentElement = $currentElement.parent();
+		} while ($parentElement[0] !== document);
+		return $currentElement[0];
+	},
+
+	'public undefined objectChanged : string object': function(propertyName, object)
+	{
+		this.get('templater').render(this.get('element'));
+	}
+
+});

Jagged/Directive/Repeat.js

@@ -0,0 +1,81 @@
+Class.define(
+
+'Jagged.Directive.Repeat',
+{
+
+	Require: [
+		'Jagged.IDirective',
+		'Jagged.Templater'
+	],
+
+	Implements: 'Jagged.IDirective',
+
+	'private parser': null,
+	'private scopeHandler': null,
+	'private templater': null,
+	'private array': null,
+	'private itemName': null,
+	'private originalElement': null,
+	'private parentElement': null,
+	'private currentClonedElements': [],
+
+	'public construct : Jagged.Parser Jagged.ScopeHandler Jagged.Templater': function(parser, scopeHandler, templater)
+	{
+		this.set('parser', parser);
+		this.set('scopeHandler', scopeHandler);
+		this.set('templater', templater);
+	},
+
+	'public undefined initialise : object string': function(element, value)
+	{
+		this.set('originalElement', element);
+		this.set('parentElement', element.parentNode);
+		var match = value.match(/^([^\s]+) in ([^\s]+)$/);
+		if (!match) {
+			throw new Error(
+				'Attribute value passed to repeat directive ' +
+				'must be of the format \'item in array\''
+			);
+		}
+		this.set('itemName', match[1]);
+		var parser = this.get('parser');
+		var array = parser.parse(match[2], element);
+		// @todo Check is array
+		// @todo Handle object as well
+		this.set('array', array);
+		element.parentNode.removeChild(element);
+		this.updateListElements();
+		this.get('scopeHandler').bind('objectChanged', 'objectChanged');
+	},
+
+	'private undefined updateListElements : undefined': function()
+	{
+		var array = this.get('array');
+		var itemName = this.get('itemName');
+		var originalElement = this.get('originalElement');
+		var parentElement = this.get('parentElement');
+		var currentClonedElements = this.get('currentClonedElements');
+		for (var i in currentClonedElements) {
+			if (!currentClonedElements.hasOwnProperty(i)) continue;
+			parentElement.removeChild(currentClonedElements[i]);
+		}
+		currentClonedElements = [];
+		for (var i = 0; i < array.length; i++) {
+			var clone = originalElement.cloneNode(true);
+			currentClonedElements.push(clone);
+			var properties = {};
+			properties[itemName] = array[i];
+			this.get('scopeHandler').registerProperties(clone, properties);
+			this.get('parentElement').appendChild(clone);
+		}
+		this.set('currentClonedElements', currentClonedElements);
+		this.get('templater').render(parentElement);
+	},
+
+	'public undefined objectChanged : string object': function(propertyName, object)
+	{
+		if (this.get('array') !== object.get(propertyName)) return;
+		this.updateListElements();
+	}
+
+});

Jagged/Helper/Array.js

@@ -0,0 +1,19 @@
+Class.define(
+
+'Jagged.Helper.Array',
+{
+
+	'static public boolean isArray': function(array)
+	{
+		return Object.prototype.toString.call(array) == '[object Array]';
+	},
+
+	'static public array removeDuplicates : array': function(array)
+	{
+		// http://stackoverflow.com/questions/9229645/remove-duplicates-from-javascript-array
+		return array.filter(function(element, position, self) {
+			return self.indexOf(element) == position;
+		});
+	}
+
+});

Jagged/Helper/String.js

@@ -0,0 +1,46 @@
+Class.define(
+
+'Jagged.Helper.String',
+{
+
+	'static public string uppercaseFirst : string': function(string)
+	{
+		return string.charAt(0).toUpperCase() + string.slice(1);
+	},
+
+	'static public string underscoreToPascalCasing : string': function(string)
+	{
+		var parts = string.split('_');
+		for (var i = 0; i < parts.length; i++) {
+			parts[i] = Jagged.Helper.String.uppercaseFirst(parts[i]);
+		}
+		return parts.join('');
+	},
+
+	'static public string hyphenToPascalCasing : string': function(string)
+	{
+		var parts = string.split('-');
+		for (var i = 0; i < parts.length; i++) {
+			parts[i] = Jagged.Helper.String.uppercaseFirst(parts[i]);
+		}
+		return parts.join('');
+	},
+
+	'static public string pascalToHyphenCasing : string': function(string)
+	{
+		var parts = [];
+		var currentString = '';
+		for (var i = 0; i < string.length; i++) {
+			if (string[i].match(/[A-Z]/)) {
+				if (currentString != '') {
+					parts.push(currentString);
+					currentString = '';
+				}
+			}
+			currentString += string[i].toLowerCase();
+		}
+		parts.push(currentString);
+		return parts.join('-');
+	}
+
+});

Jagged/IDirective.js

@@ -0,0 +1,9 @@
+Interface.define(
+
+'Jagged.IDirective',
+[
+
+	// Accepts element and attribute value
+	'undefined initialise : object string'
+
+]);