asproject 0.1.21

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/ui/RemoteVersion.as

@@ -0,0 +1,24 @@
+
+import com.asunit.ui.*;
+
+class RemoteVersion extends XML {
+	private var callback:Main;
+	
+	public function RemoteVersion(cb:Main) {
+		callback = cb;
+		init();
+	}
+	
+	public function init():Void {
+		ignoreWhite = true;
+		load("http://www.asunit.com/version.xml?userVersion=" + callback.getVersionNumber());
+	}
+	
+	public function onLoad(success:Boolean):Void {
+		parseVersion(this.firstChild.firstChild);
+	}
+	
+	public function parseVersion(node:XMLNode):Void {
+		callback.checkRemoteVersion(node.firstChild.nodeValue);
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/ui/SuccessMeter.as

@@ -0,0 +1,32 @@
+
+import com.asunit.ui.*;
+
+class SuccessMeter extends MovieClip {
+	private var bg_mc:MovieClip;
+	private var border_mc:MovieClip;
+	private var _hasFailed:Boolean = false;
+
+	private var successColor:Number = 0xA8E085;
+	private var failureColor:Number = 0xDF412B;
+
+	public function hasFailed():Boolean
+	{
+		return _hasFailed;
+	}
+
+	public function setSuccess(success:Boolean):Void
+	{
+		var col:Number = (success) ? successColor : failureColor;
+		var bgColor:Color = new Color(bg_mc);
+		bgColor.setRGB(col);
+		if(!success) {
+			_hasFailed = true;
+		}
+	}
+
+	public function setSize(w:Number, h:Number):Void
+	{
+		_width = Math.floor(w);
+		_height = Math.floor(h);
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/util/Comparable.as

@@ -0,0 +1,7 @@
+
+import com.asunit.util.*;
+
+interface com.asunit.util.Comparable {
+	public function equals(obj:Object):Boolean;
+	public function toString():String;
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/util/EventListener.as

@@ -0,0 +1,29 @@
+
+// immutable, protected class...
+class com.asunit.util.EventListener extends Object {
+	private var source:Object;
+	private var event:String;
+	private var scope:Object;
+	public static var defaultEvent:String = "all"
+	
+	public function EventListener(evnt:String, src:Object, scp:Object) {
+		if(src instanceof Function && !(scp instanceof Object)) {
+			Sys.println(">> EventListener constructor may cause problems because Function reference passed without appropriate scope argument.");
+		}
+		source = src;
+		scope = scp;
+		event = (evnt == undefined || evnt == null) ? EventListener.defaultEvent : evnt;
+	}
+	
+	public function getScope():Object {
+		return scope;
+	}
+	
+	public function getSource():Object {
+		return source;
+	}
+	
+	public function getEvent():String {
+		return event;
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/util/EventSource.as

@@ -0,0 +1,89 @@
+
+import com.asunit.util.*;
+
+class com.asunit.util.EventSource implements Observable {
+	private var listeners:Array;
+
+	public function EventSource() {
+		listeners = new Array();
+	}
+	
+	public function addEventListener(event:String, observer:Object, scope:Object):Void {
+		if(typeof(observer) == "string") {
+			Sys.println(">> failed to addEventListener because observer argument is type:String.");
+			return;
+		} else if(event.indexOf(",") > -1) {
+			parseMultipleEvents(event, observer, scope);
+			return;
+		} else if(getListenerIndex(event, observer) > -1) {
+			return;
+		}
+		listeners.push(new EventListener(event, observer, scope));
+	}
+	
+	public function removeEventListener(event:String, observer:Object):Boolean {
+		var index:Number = getListenerIndex(event, observer);
+		var found:Boolean = false;
+
+		do {
+			listeners.splice(index, 1);
+			index = getListenerIndex(event, observer);
+			found = true;
+		} while (index > -1);
+		return found;
+	}
+	
+	public function addListener(observer:Object, scope:Object):Void {
+		if(typeof(observer) == "string") {
+			Sys.println(">> attempting to addListener with invalid argument - try addEventListener");
+			return;
+		}
+		addEventListener(EventListener.defaultEvent, observer, scope);
+	}
+	
+	public function removeListener(observer:Object):Boolean {
+		// Needs updated to remove all instances that have this observer?
+		// If no event name identified...
+		return removeEventListener(EventListener.defaultEvent, observer);
+	}
+	
+	public function getListenerCount():Number {
+		return listeners.length;
+	}
+	
+	public function getListenerIndex(event:Object, observer:Object):Number {
+		for(var i:Number=0; i<listeners.length; i++) {
+			if(event == null || event == undefined || event == EventListener.defaultEvent) {
+				if(listeners[i].getSource() == observer) {
+					return i;
+				}
+			} else if(listeners[i].getEvent() == event && listeners[i].getSource() == observer) {
+				return i;
+			}
+		}
+		return -1;
+	}
+	
+	public function parseMultipleEvents(events:Object, observer:Object):Void {
+		var evnts:Array = events.split(",");
+		var ln:Number = evnts.length;
+		for(var i:Number = 0; i < ln; i++) {
+			addEventListener(evnts[i], observer);
+		}
+	}
+	
+	public function broadcastMessage():Void {
+		var eventName:Object = arguments.shift();
+		var list:Array = listeners;
+		var ln:Number = list.length;
+		for(var i:Number = 0; i < ln; i++) {
+			if(list[i].getEvent() == eventName || list[i].getEvent() == EventListener.defaultEvent) {
+				if(list[i].getSource() instanceof Function) {
+ 					list[i].getSource().apply(list[i].getScope(), arguments);
+				} else {
+					list[i].getSource()[eventName].apply(list[i].getSource(), arguments);
+				}
+			}
+		}	
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/util/LocalConnClient.as

@@ -0,0 +1,42 @@
+
+import com.asunit.util.*;
+
+dynamic class com.asunit.util.LocalConnClient extends LocalConnection {
+
+	public var serverId:String;
+
+	public function LocalConnClient(srvrId:String) {
+		init(srvrId);
+	}
+
+	private function init(srvrId:String):Void {
+		serverId = srvrId;
+	}
+
+	public function __resolve(fname:String):Function {
+		// Execute Any Method Call thru gateway on Server and return results...
+		var ref:LocalConnClient = this;
+		return Function( function() {
+			arguments.unshift(fname);
+			arguments.unshift("execResolve");
+			arguments.unshift( ref.serverId);
+			return ref.execMethod.apply(this, arguments);
+		});
+	}
+
+	public function execMethod():Object {
+		//send.apply(this, arguments);
+		return send.apply(this, arguments);
+	}
+
+	public function onStatus(infoObject:Object):Void {
+// 		trace("!! Client Local Connection Object.onStatus Called with : ");
+// 		for(var i in arguments) {
+// 			trace(i + " : " + arguments[i]);
+// 			for(var k in arguments[i]) {
+// 				trace(i + "." + k + " : "+ arguments[i][k]);
+// 			}
+// 		}
+	}
+
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/util/LocalConnGateway.as

@@ -0,0 +1,47 @@
+
+import com.asunit.util.*;
+
+/************************************************
+::: LocalConnGateway
+
+SERVER EXAMPLE:
+var dp = new RemoteApiClass(); // Like DataProviderClass();
+var srvrId = "SomeUniqueIdentifier";
+this.local = com.framework.util.LocalConnGateway.createServer(dp, srvrId);
+
+CLIENT EXAMPLE:
+var srvrId = "SomeUniqueIdentifier"; // matches an existing serverId
+this.remote = com.framework.util.LocalConnGateway.createClient(srvrId);
+
+this.res = this.remote.getItemAt(3);
+echo("res : " + this.res.label);
+
+************************************************/
+
+class com.asunit.util.LocalConnGateway {
+	//private static var existingServers:Array;
+	//private static var clientQueue:Array;
+
+	//------------------------------------------------
+	// Factory method for LC Server Instances
+	// cb : An Object Instance that whose methods/props will be called
+	// 		by any client classes
+	// srvrId : Unique string to identify the LC Server instance
+	// NOTE: Any "." found in the serverId will be ripped out...
+	// this is done to prevent any potential namespace conflicts...
+	public static function createServer(cb:Object, srvrId:String):LocalConnServer
+	{
+		return new LocalConnServer(cb, srvrId);
+	}
+
+	//------------------------------------------------
+	// Factory method for LC Client Instances
+	// srvrId : Unique String Matching an existing .createServer instance
+	public static function createClient(srvrId:String):LocalConnClient
+	{
+		return new LocalConnClient(srvrId);
+		// was attempting to build a queue so that clients could be created
+		// before servers - but *I think* that they already can!!!
+		//return getClient(validateId(srvrId));
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/util/LocalConnServer.as

@@ -0,0 +1,61 @@
+
+dynamic class com.asunit.util.LocalConnServer extends LocalConnection {
+
+	private var controller:Object;
+	private var id:String;
+	public var status:Boolean;
+
+	public function LocalConnServer(ctrl:Object, srvrId:String) {
+		init(ctrl, srvrId);
+	}
+
+	private function init(ctrl:Object, srvrId:String):Void {
+		controller = ctrl;
+		id = srvrId;
+		status = connect(srvrId);
+	}
+
+	public function getId():String {
+		return id;
+	}
+
+	public function close():Void {
+		//trace(">> LocalConnServer Closing now from : " + id);
+		super.close();
+	}
+
+	public function connect(str:String):Boolean {
+		if(super.connect(str)) {
+			return true;
+		} else {
+			trace("!! CONNECT CALL FAILED IN createServer with : " + getId());
+			return false;
+		}
+	}
+
+	public function allowDomain(domain:String):Boolean {
+		// EXTREMELY INSECURE...
+		return true;
+	}
+
+	public function allowInsecureDomain(domain:String):Boolean {
+		return true;
+	}
+
+	// Used for synchronous communication...
+	public function execResolve_sync(method:String):Object {
+		arguments.shift();
+		return controller[method].apply(controller, arguments);
+	}
+
+	// Used for asynchronous communication...
+	public function execResolve( method:String):Void {
+// 		trace(">> exec resolve called from the window swf with : " + arguments);
+		arguments.shift();
+		controller[method].apply(controller, arguments);
+	}
+
+	public function onStatus(infoObject:Object):Void {
+		trace("!! Server LocalConnonStatus Called with : " + arguments + " id : " + getId());
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/util/LocalMessageBroker.as

@@ -0,0 +1,58 @@
+
+import com.asunit.util.*;
+
+class com.asunit.util.LocalMessageBroker extends Object implements Observable {
+	private static var instance:LocalMessageBroker;
+	private var msgs:Array;
+	private var eventSrc:EventSource;
+	
+	private function LocalMessageBroker() {
+		init();
+	}
+	
+	private function init():Void {
+		msgs = new Array();
+		eventSrc = new EventSource();
+	}
+	
+	public static function getInstance():LocalMessageBroker {
+		if(instance == undefined) {
+			instance = new LocalMessageBroker();
+		}
+		return instance;
+	}
+	
+	public function send(msg:String, category:String):String {
+		msgs.push({message:msg, category:category});
+		eventSrc.broadcastMessage("onMessageSent", {event:"onMessageSent", message:msg, category:category});
+		return msg;
+	}
+	
+	public function toString():String {
+		var str:String = "";
+		for(var i:Number = 0; i < msgs.length; i++) {
+			str += msgs[i] + "\n";
+		}
+		return str;
+	}
+	
+	// Can accept either an event:String or an event:String[]
+	// if the observer wants to subscribe to multiple events.
+	public function addEventListener(event:String, observer:Object, scope:Object):Void {
+		eventSrc.addEventListener(event, observer, scope);
+	}
+	
+	public function addListener(observer:Object, scope:Object):Void {
+		eventSrc.addListener(observer, scope);
+	}
+
+	// Should return bool false if handler ref was not found.
+	// Should return bool true if handler ref was found
+	public function removeEventListener(event:String, observer:Object):Boolean {
+		return eventSrc.removeEventListener(event, observer);
+	}
+	
+	public function removeListener(observer:Object):Boolean {
+		return eventSrc.removeListener(observer);
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/util/Observable.as

@@ -0,0 +1,11 @@
+
+interface com.asunit.util.Observable {
+	// Can accept either an event:String or an event:String[]
+	// if the observer wants to subscribe to multiple events.
+	public function addEventListener(event:String, observer:Object, scope:Object):Void;
+	public function addListener(observer:Object, scope:Object):Void;
+	// Should return bool false if handler ref was not found.
+	// Should return bool true if handler ref was found
+	public function removeEventListener(event:String, observer:Object):Boolean;
+	public function removeListener(observer:Object):Boolean;
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/util/TextFile.as

@@ -0,0 +1,30 @@
+
+class com.asunit.util.TextFile extends XML {
+	public static var linkageId:String = "com.asunit.util.TextFile";
+	public static var classRef:Function = TextFile;
+
+	private var source:String;
+	private var callback:Object;
+	private var fileString:String;
+	
+	public function TextFile(src:String, cb:Object) {
+		source = src;
+		callback = cb;
+		ignoreWhite = true;
+		onData = doData;
+		if(src != undefined) {
+			load(source);
+		}
+	}
+	
+	public function doData(str:String):Void {
+		fileString = str;
+		callback.onTextFileLoaded(this);
+	}
+	
+	public function toString():String {
+		return fileString;
+	}
+		
+	public static var serializable:Boolean = Object.registerClass(linkageId, classRef);
+}

data/templates/asproject/asunit25/project/lib/asunit/AsUnitTestRunner.as

@@ -0,0 +1,13 @@
+import asunit.textui.TestRunner;
+
+class AsUnitTestRunner extends TestRunner {
+
+	public function AsUnitTestRunner() {
+		fscommand("fullscreen", "true");
+		start(AllTests);
+	}
+
+	public static function main():Void {
+		var runner = new AsUnitTestRunner();
+	}
+}