emergent-core 0.1.0

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/PheronReceptor.as

@@ -0,0 +1,125 @@
+/*
+Copyright 2008 Nahuel Foronda/AsFusion
+
+Licensed under the Apache License, Version 2.0 (the "License"); 
+you may not use this file except in compliance with the License. Y
+ou may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0 
+
+Unless required by applicable law or agreed to in writing, s
+oftware distributed under the License is distributed on an "AS IS" BASIS, 
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+See the License for the specific language governing permissions and limitations under the License
+
+Author: Nahuel Foronda, Principal Architect
+        nahuel at asfusion dot com
+                
+@ignore
+*/
+package com.fourD.core
+{	
+	import com.asfusion.mate.core.mate;
+	import com.asfusion.mate.events.UnhandledMessageFaultEvent;
+	import com.asfusion.mate.utils.debug.DebuggerUtil;
+	
+	import mx.messaging.*;
+	import mx.messaging.events.MessageEvent;
+	import mx.messaging.events.MessageFaultEvent;
+	
+	use namespace mate;
+	/**
+	 * The <code>MessageHandlers</code> tag allows you to register a set of handlers as a consumer of a Flex Messaging Service. 
+	 * All the tags inside the <code>MessageHandlers</code> tag will be executed in order when a <code>Message</code> matching the 
+	 * criteria is received. This tag accepts the same attributes as the <code>Consumer</code> tag.
+	 */
+	public class PheronReceptors
+	
+		public var pheron:Pheron2;
+		
+		protected var initializeHandlersChanged:Boolean;
+		protected var startHandlersChanged:Boolean;
+		protected var completeHandlersChanged:Boolean;
+		
+		private var _initializeHandlers:Array;
+		public function get initializeHandlers():Array { return _initializeHandlers; }
+		[ArrayElementType("com.asfusion.mate.actions.IAction")]
+		public function set initializeHandlers(value:Array):void {
+			_initializeHandlers = value;
+			initializeHandlersChanged = true;
+			validateNow();
+		}
+		
+		private var _startHandlers:Array;
+		public function get startHandlers():Array { return _startHandlers; }
+		[ArrayElementType("com.asfusion.mate.actions.IAction")]
+		public function set startHandlers(value:Array):void {
+			_startHandlers = value;
+			startHandlersChanged = true;
+			validateNow();
+		}
+		
+		private var _completeHandlers:Array;
+		public function get completeHandlers():Array { return _completeHandlers; }
+		[ArrayElementType("com.asfusion.mate.actions.IAction")]
+		public function set completeHandlers(value:Array):void {
+			_completeHandlers = value;
+			completeHandlersChanged = true;
+			validateNow();
+		}
+		
+		public function PheronReceptor()
+		{
+			super();
+		}
+		
+		override public function errorString():String
+		{
+			var str:String = "Destination:"+ destination + ". Error was found in a MessageHandlers list in file " 
+							+ DebuggerUtil.getClassName(document);
+			return str;
+		}
+		
+		protected function tectonStart(pheron:Pheron2):void
+		{
+			var currentScope:TectonScope = new TectonScope(event,debug, map, inheritedScope);
+			currentScope.owner = this;
+			currentScope.tecton = pheron.tecton;
+			currentScope.tropon = pheron.tropon;
+			currentScope.kanon = pheron.kanon;
+			currentScope.action = pheron.action;
+			runSequence(currentScope, startHandlers);
+		}
+		
+		protected function tectonComplete(pheron:Pheron2):void
+		{
+			var currentScope:TectonScope = new TectonScope(event,debug, map, inheritedScope);
+			currentScope.owner = this;
+			currentScope.tecton = pheron.tecton;
+			currentScope.tropon = pheron.tropon;
+			currentScope.kanon = pheron.kanon;
+			currentScope.action = pheron.action;
+			runSequence(currentScope, completeHandlers);
+		}
+		/*-----------------------------------------------------------------------------------------------------------
+		*                                          Override Protected methods
+		-------------------------------------------------------------------------------------------------------------*/
+		
+		/*-.........................................commitProperties..........................................*/
+		/**
+		 * Processes the properties set on the component.
+		*/
+		override protected function commitProperties():void
+		{
+			if (initializeHandlersChanged) {
+				initializeHandlersChanged = false;
+			}
+			if (startHandlersChanged) {
+				startHandlersChanged = false;
+			}
+			if (completeHandlersChanged) {
+				completeHandlersChanged = false;
+			}
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/Properties.as

@@ -0,0 +1,57 @@
+package com.fourD.core {
+
+	public dynamic class Properties {
+		/*-----------------------------------------------------------------------------------------------------------
+		*                                          Public Fields
+		-------------------------------------------------------------------------------------------------------------*/
+		/**
+		*  If you need to specify a property that is called "id", you need
+		* to use <code>_id</code> instead because Flex will normally use the <code>id</code>
+		* property as the identifier for this tag.
+		*/
+		public var _id:*;
+		
+		/*-----------------------------------------------------------------------------------------------------------
+		*                                          Public static methods
+		-------------------------------------------------------------------------------------------------------------*/
+		/**
+		 * This method will parse all the SmartObjects and set the real values in the
+		 * <code>target</code> Object
+		 */
+		public static function copyValuesToTarget(source:Object, target:Object):Object
+		{
+			
+			for (var propertyName:String in source)
+			{
+				var realValue:* = source[propertyName];
+				try
+				{
+					target[propertyName] = realValue;
+				}
+				catch(error:ReferenceError)
+				{
+				}
+				catch(error:TypeError)
+				{
+				}
+				
+			}
+			if(source._id) target['id'] = source._id;
+			return target;
+		}
+		
+		/*-----------------------------------------------------------------------------------------------------------
+		*                                          Public Methods
+		-------------------------------------------------------------------------------------------------------------*/
+		/**
+		 * Similar to <code>smartCopy</code> this method will copy the properties
+		 * to the target object. 
+		 * The difference is that it will copy its own properties to the target.
+		 */
+		public function injectProperties(target:Object):Object
+		{
+			return copyValuesToTarget(this, target);
+		}
+
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/Router.as

@@ -0,0 +1,50 @@
+package com.fourD.core
+{
+	import flash.utils.Dictionary;
+	import flash.utils.getQualifiedClassName;
+	
+	public class Router
+	{
+		private var views:Dictionary;
+		// injected from the application...
+		public var viewInstances:Dictionary;
+		
+		public function Router()
+		{
+			views = new Dictionary();
+			viewInstances = new Dictionary();
+		}
+		
+		public static function mapClasses(classes:Array, cache:Boolean = true):void {
+			for each (var view:Class in views) {
+        		var fqn:String = getQualifiedClassName(view);
+        
+        		var viewName:String = fqn.split("::")[1] as String;
+				views[view] = fqn;
+				views[fqn] = view;
+			}
+			// once we have set up the core data structures we need another pass to compute 
+      		// the hierarchy of the components/views
+			classes.forEach(function(elm:Class, index:int, array:Array):void {
+        		Router.extractMetadata(elm);
+      		});
+		}
+		
+		public static function extractMetadata(viewClass:Class):void {
+			var fqn:String = views[viewClass];
+			var view:UIComponent = viewInstances[viewClass];
+			var meta:XML = describeType(view);
+      
+			for each (var node:XML in meta..accessor) {
+				var declaredBy:String = node.@declaredBy;
+				var name:String = node.@name;
+				var child:UIComponent;
+				// if the accessor was declared in one of your classes and it's a UIComponent...
+				if (viewClasses[declaredBy] && view[name] is UIComponent) {
+					child = view[name] as UIComponent;
+					mapChildToParent(troponMap, view, child);
+				}
+			}
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/RouterUtil.as

@@ -0,0 +1,70 @@
+package com.fourD.core
+{
+	import flash.utils.getQualifiedClassName;
+	
+	public class RouterUtil
+	{
+		public function RouterUtil()
+		{
+		}
+		
+		public static function getTectonName(path:String, action:String):String {
+			return path + "." + action;
+		}
+		
+		public static function getGenericTectonName(app:*, kanon:String, tropon:String, action:String):String {
+			return getQualifiedClassName(app) + "::" + kanon + "::" + tropon + "::" + RouterUtil.upperCaseFirst(action);
+		}
+		
+		public static function getClassTroponName(path:String):String {
+			// path = Project.mainView.tropon63
+			var pattern:RegExp = /\d+$/i; // numbers at the end
+			var index:int = path.indexOf(pattern);
+			var genericTropon:String = path.slice(0, index); // Project.mainView.tropon
+			pattern = /\w+$/i; // last word
+			index = path.indexOf(pattern);
+			genericTropon = path.slice(index, path.length);
+			return RouterUtil.upperCaseFirst(genericTropon);
+		}
+		
+		public static function getInstanceTroponName(path:String):String {
+			// path = Project.mainView.tropon63
+			var pattern:RegExp = /\w+$/i; // numbers and word at the end
+			var index:int = path.indexOf(pattern);
+			return = path.slice(index, path.length); // Project.mainView.tropon
+		}
+		
+		public static function getClassKanonName(path:String):String {
+			// path = Project.kanon12.tropon63
+			var pattern:RegExp = /\d+\.\w+$/i; // last word, period, and numbers before period
+			var index:int = path.indexOf(pattern);
+			var genericKanon:String = path.slice(0, index); // Project.kanon
+			pattern = /\w+$/i; // last word
+			index = path.indexOf(pattern);
+			genericKanon = path.slice(index, path.length);
+			return RouterUtil.upperCaseFirst(genericKanon);
+		}
+
+		
+		public static function getInstanceKanonName(path:String):String {
+			// path = Project.kanon12.tropon63
+			var pattern:RegExp = /\.\w+$/i; // numbers at the end and period
+			var index:int = path.indexOf(pattern);\w+\.\w+$
+			var kanon:String = path.slice(0, index); // Project.kanon12
+			pattern = /\w+$/i; // last word
+			index = path.indexOf(pattern);
+			return path.slice(index, path.length);
+		}
+		
+		public static function lowerCaseFirst(string:String):String {
+			return string.charAt(0).toLowerCase() + string.slice(1);
+		}
+    
+		/**
+		 * Upper cases first letter in a string leaving the rest of it alone
+		 */
+	    public static function upperCaseFirst(string:String):String {
+			return string.charAt(0).toUpperCase() + string.slice(1);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/SimpleCondition.as

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2008-2009 (c) Lance Pollard
+ * www.systemsofseven.com/blog
+ * www.4ddesignlab.com
+ * LanceJPollard@gmail.com
+ *
+ * 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 com.fourD.core {
+	
+	[Bindable]
+	public class SimpleCondition {
+		
+		public var property:*;
+		
+		public var value:*;
+		
+		// object with the property you're using in your condition
+		public var source:*;
+		
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/SimpleZSortVO.as

@@ -0,0 +1 @@
+package com.fourD.core {

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/SimpleZSorter.as

@@ -0,0 +1 @@
+package com.fourD.core {

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/Tecton.as

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2008-2009 (c) Lance Pollard
+ * www.systemsofseven.com/blog
+ * www.4ddesignlab.com
+ * LanceJPollard@gmail.com
+ *
+ * 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 com.fourD.core {
+	
+	import flash.events.EventDispatcher;
+	
+	[Bindable]
+	public class Tecton extends EventDispatcher {
+		
+		public var actions:Array;
+		
+		public var actionParams:*;
+		
+		public var tropon:*;
+		
+		// "parent", but more appropriately the rules defining it's behavior in a system.
+		public var kanon:*;
+		
+		public var tropons:Array;
+		
+		public var name:String;
+		
+		public var actionName:String;
+		
+		public var conditions:Array;
+		
+		public var receptors:Array
+		
+		public var initialize:Array;
+		
+		public var start:Array;
+		
+		public var complete:Array;
+		
+		public var isInitialized:Boolean;
+
+		public var isRunning:Boolean;
+
+		public var isComplete:Boolean;
+		
+		public var isActive:Boolean;
+		
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/Tecton2.as

@@ -0,0 +1,234 @@
+/*
+Copyright 2008 Nahuel Foronda/AsFusion
+
+Licensed under the Apache License, Version 2.0 (the "License"); 
+you may not use this file except in compliance with the License. Y
+ou may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0 
+
+Unless required by applicable law or agreed to in writing, s
+oftware distributed under the License is distributed on an "AS IS" BASIS, 
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+See the License for the specific language governing permissions and limitations under the License
+
+Author: Nahuel Foronda, Principal Architect
+        nahuel at asfusion dot com
+                
+@ignore
+*/
+package com.fourD.core
+{	
+	import com.asfusion.mate.core.mate;
+	import com.asfusion.mate.utils.debug.DebuggerUtil;
+	
+	import flash.utils.Dictionary;
+	
+	import mx.messaging.*;
+	
+	use namespace mate;
+	/**
+	 * The <code>MessageHandlers</code> tag allows you to register a set of handlers as a consumer of a Flex Messaging Service. 
+	 * All the tags inside the <code>MessageHandlers</code> tag will be executed in order when a <code>Message</code> matching the 
+	 * criteria is received. This tag accepts the same attributes as the <code>Consumer</code> tag.
+	 */
+	[Event(name="initialize", type="com.fourD.core.Pheron2")]
+	
+	[Event(name="start", type="com.fourD.core.Pheron2")]
+
+	[Event(name="complete", type="com.fourD.core.Pheron2")]
+	
+	public class Tecton2
+	
+		private var isActiveChanged:Boolean;
+		private var isInitializedChanged:Boolean;
+		private var isRunningChanged:Boolean;
+		private var isCompleteChanged:Boolean;
+		
+		private var activateBeforeChanged:Boolean;
+		private var activateDuringChanged:Boolean;
+		private var activateAfterChanged:Boolean;
+		private var inactivateBeforeChanged:Boolean;
+		
+		private var requiredPherons:Dictionary;
+		private var inactivatePherons:Dictionary;
+		private var numRequiredPherons:int;
+
+		// "parent", but more appropriately the rules defining it's behavior in a system.
+		public var kanon:*;
+		
+		public var tropons:Array;
+		
+		public var name:String;
+		
+		public var actionName:String;
+		
+		public var conditions:Array;
+		
+		private var _isActive:Boolean; [Bindable]
+		public function get isActive():Boolean { return _isActive; }
+		public function set isActive(value:Boolean):void {
+			_isActive = value;
+			isActiveChanged = true;
+			invalidateProperties();
+		}
+		
+		private var _isInitialized:Boolean; [Bindable]
+		public function get isInitialized():Boolean { return _isInitialized; }
+		public function set isInitialized(value:Boolean):void {
+			_isInitialized = value;
+			isInitializedChanged = true;
+			invalidateProperties();
+		}
+		
+		private var _isRunning:Boolean; [Bindable]
+		public function get isRunning():Boolean { return _isRunning; }
+		public function set isRunning(value:Boolean):void {
+			_isRunning = value;
+			isRunningChanged = true;
+			invalidateProperties();
+		}
+		
+		private var _isComplete:Boolean; [Bindable]
+		public function get isComplete():Boolean { return _isComplete; }
+		public function set isComplete(value:Boolean):void {
+			_isComplete = value;
+			isCompletehanged = true;
+			invalidateProperties();
+		}
+		
+		protected var initializeHandlersChanged:Boolean;
+		protected var startHandlersChanged:Boolean;
+		protected var completeHandlersChanged:Boolean;
+		
+		private var _activateBefore:Array; [Bindable] // therefore it listens for INITIALIZE events
+		public function get activateBefore():Array { return _activateBefore; }
+		[ArrayElementType("com.fourD.core.Pheron2")]
+		public function set activateBefore(value:Array):void {
+			_activateBefore = value;
+			activateBeforeChanged = true;
+			invalidateProperties();
+		}
+		
+		private var _inactivateBefore:Array; [Bindable] // therefore it listens for INITIALIZE events
+		public function get inactivateBefore():Array { return _inactivateBefore; }
+		[ArrayElementType("com.fourD.core.Pheron2")]
+		public function set inactivateBefore(value:Array):void {
+			_inactivateBefore = value;
+			inactivateBeforeChanged = true;
+			invalidateProperties();
+		}
+		
+		private var _activateDuring:Array; [Bindable] // therefore it's listening for READY events
+		[ArrayElementType("com.fourD.core.Pheron2")]		
+		public function get activateDuring():Array { return _activateDuring; }
+		public function set activateDuring(value:Array):void {
+			_activateDuring = value;
+			activateDuringChanged = true;
+			invalidateProperties();
+		}
+		
+		private var _activateAfter:Array; [Bindable] // don't need to do, but it would dispatch COMPLETE to these
+		public function get activateAfter():Array { return _activateAfter; }
+		[ArrayElementType("com.fourD.core.Tecton2")]
+		public function set activateAfter(value:Array):void {
+			_activateAfter = value;
+			activateAfterChanged = true;
+			invalidateProperties();
+		}
+		
+		public function Tecton2()
+		{
+			super();
+		}
+		
+		override public function errorString():String
+		{
+			var str:String = "Destination:"+ destination + ". Error was found in a MessageHandlers list in file " 
+							+ DebuggerUtil.getClassName(document);
+			return str;
+		}
+		
+		protected function prepare(pheron:Pheron2):void {
+			var pheronType:String = pheron.name;
+			if (isComplete) {
+				if (requiredPherons[pheronType] && pheron.phase == Pheron2.INITIALIZE) {
+					isComplete = false;
+					isActive = false;
+					return;
+				}
+			}
+			if (isActive && isComplete) { return; }
+			
+			delete requiredPherons[pheronType]; // do I even need to do this?
+			numRequirePherons --;
+			if (numRequiredPherons == 0) {
+				run(pheron.tecton);
+				dispatchPheron(Pheron2.COMPLETE);
+				isComplete = true;
+			}
+		}
+		
+		public function run(tecton:Tecton):void
+		{
+			var currentScope:TectonScope = new TectonScope(event,debug, map, inheritedScope);
+			currentScope.owner = this;
+			currentScope.tecton = pheron.tecton;
+			currentScope.tropon = pheron.tecton.tropon;
+			currentScope.kanon = pheron.tecton.kanon;
+			currentScope.action = pheron.tecton.action;
+			
+			var presenter:* = pheron.tecton.kanon.presenter;
+			currentScope.presenter = (presenter) ? presenter : null;
+			
+			isRunning = true;
+			
+			runSequence(currentScope, actions);
+		}
+
+		override protected function commitProperties():void
+		{
+			var i:int=0; var
+			if (isActive && !isInitialized) {
+				isInitialized = true;
+				numRequiredPherons = 0;
+				dispatchPheron(Pheron2.INITIALIZE);
+			}
+			if (isActive && isInitialized && !isRunning) {
+				attachHandlers(before, Pheron2.COMPLETE);
+				attachHandlers(during, Pheron2.READY);
+			}
+			if (isComplete) {
+				attachInactivateHandlers(inactivateBefore, Pheron2.INITIALIZE);
+			}
+		}
+		
+		private function dispatchPheron(phase:String):void {
+			var pheron:Pheron2 = new Pheron2(phase);
+			pheron.tecton = this;
+			dispatcher.dispatchEvent(pheron);
+		}
+		
+		private function attachHandlers(tectons:Array, phase:String):void {
+			var i:int=0, n:int=tectons.length;
+			for (i; i < n; i++) {
+				var tecton:Tecton = tectons[i].tecton;
+				var pheronType:String = tecton.toString() + phase;
+				dispatcher.addEventListener(pheronType, prepare);
+				numRequiredPherons ++;
+				requiredPherons[pheronType] = numRequiredPherons;
+			}
+		}
+		
+		private function attachInactivateHandlers(tectons:Array, phase:String):void {
+			var i:int=0, n:int=tectons.length;
+			for (i; i < n; i++) {
+				var tecton:Tecton = tectons[i].tecton;
+				var pheronType:String = tecton.toString() + phase;
+				dispatcher.addEventListener(pheronType, prepare);
+				numRequiredPherons ++;
+				inactivatePherons[pheronType] = numRequiredPherons;
+			}
+		}
+	}
+}