semillagen 0.0.1

data/default_templates/project/default/src/transforms/ReverseTransform.as

@@ -0,0 +1,22 @@
+package transforms 
+{
+	/**
+	 * ...
+	 * @author @@AUTHOR@@
+	 */
+	public class ReverseTransform 
+	{
+		
+		public function ReverseTransform() 
+		{
+			
+		}
+		
+		public function run(data:String):String
+		{
+			return data.split("").reverse().join("");
+		}
+		
+	}
+
+}

data/default_templates/project/default/src/transforms/SplitTransform.as

@@ -0,0 +1,22 @@
+package transforms 
+{
+	/**
+	 * ...
+	 * @author @@AUTHOR@@
+	 */
+	public class SplitTransform 
+	{
+		
+		public function SplitTransform() 
+		{
+			
+		}
+		
+		public function run(data:String, separator:String = "."):String
+		{
+			return data.split("").join(separator);
+		}
+		
+	}
+
+}

data/default_templates/project/default/src/transforms/UpperCaseTransform.as

@@ -0,0 +1,22 @@
+package transforms 
+{
+	/**
+	 * ...
+	 * @author @@AUTHOR@@
+	 */
+	public class UpperCaseTransform 
+	{
+		
+		public function UpperCaseTransform() 
+		{
+			
+		}
+		
+		public function run(data:String):String
+		{
+			return data.toUpperCase();
+		}
+		
+	}
+
+}

data/default_templates/project/default/test-src/TestRunner.template

@@ -0,0 +1,66 @@
+package  
+{
+	import flash.display.Sprite;
+	import flash.events.Event;
+	import flash.text.TextField;
+	import flash.text.TextFieldAutoSize;
+	import listeners.SemillaCIListener;
+	import org.flexunit.runner.FlexUnitCore;
+	import org.flexunit.runner.Request;
+	import org.flexunit.runner.notification.async.AsyncListenerWatcher;
+	
+
+@@IMPORTS@@
+
+	
+	/**
+	 * IMPORTANT: This file was generated, any edits to this file will be 
+	 *            overwritten the next time the rake test is executed.
+	 */
+	public class TestRunner extends Sprite 
+	{
+		private var txtoutput:TextField;
+		
+		public var classes:Array;
+		
+		public function TestRunner() 
+		{
+			addEventListener(Event.ADDED_TO_STAGE, addedToStageHandler);
+		}
+		
+		private function setupClasses():void 
+		{
+			classes = [
+				@@CLASSES@@
+			];
+		}
+		
+		private function addedToStageHandler(e:Event):void 
+		{
+			removeEventListener(Event.ADDED_TO_STAGE, addedToStageHandler);
+			
+			/*---- Run the unit tests ----*/
+			setupClasses();
+			runTests();
+			/*---- Finished ----*/
+		}
+		
+		public function runTests() : void {
+			
+			txtoutput = new TextField();
+			txtoutput.autoSize = TextFieldAutoSize.LEFT;
+			addChild(txtoutput);
+			
+            var core : FlexUnitCore = new FlexUnitCore();
+			var semillaListener:SemillaCIListener = new SemillaCIListener(@@PORT@@);
+			semillaListener.debugTxt = txtoutput;
+            core.addListener(semillaListener);
+			
+			var request:Request = Request.qualifyClasses.apply(null, classes);
+            core.run(request);
+         }
+		 
+		 
+	}
+
+}

data/default_templates/project/default/test-src/TextFieldListener.as

@@ -0,0 +1,66 @@
+package  
+{
+	import flash.text.TextField;
+	import org.flexunit.internals.TraceListener;
+	import org.flexunit.runner.notification.Failure;
+	import org.flexunit.runner.Result;
+	
+	/**
+	 * ...
+	 * @author Victor Rosales
+	 */
+	public class TextFieldListener extends TraceListener 
+	{
+		private var textField:TextField;
+		
+		public function TextFieldListener(textField:TextField) 
+		{
+			this.textField = textField;
+			log("TextfieldListener");
+		}
+		
+		override protected function printHeader(runTime:Number):void 
+		{
+			log( "Time: " + elapsedTimeAsString(runTime) );
+		}
+		
+		override protected function printFooter(result:Result):void 
+		{
+			//Determine if the result was a success
+			if (result.successful ) {
+			log( "OK (" + result.runCount + " test " + (result.runCount == 1 ? "" : "s") + ")" );
+			} else {
+			log( "FAILURES!!! Tests run: " + result.runCount + ", " + result.failureCount + " Failures:" );
+			}
+		}
+		
+		override protected function printFailures(result:Result):void 
+		{
+			var failures:Array = result.failures;
+			//Determine if there are any failures to print
+			if (failures.length == 0)
+			return;
+			if (failures.length == 1)
+			log( "There was " + failures.length + " failure:" );
+			else
+			log("There were " + failures.length + " failures:" );
+
+			//Print each failure
+			for ( var i:int=0; i<failures.length; i++ ) {
+			printFailure( failures[ i ], String( i+1 ) );
+}
+		}
+		
+		override protected function printFailure(failure:Failure, prefix:String):void 
+		{
+			log( prefix + " " + failure.testHeader + " " + failure.stackTrace );
+		}
+		
+		protected function log(...args):void 
+		{
+			textField.appendText(args.join(",") + "\n");
+		}
+		
+	}
+
+}

data/default_templates/project/default/test-src/listeners/SemillaCIListener.as

@@ -0,0 +1,389 @@
+/**
+ * Copyright (c) 2009 Digital Primates IT Consulting Group
+ *
+ * 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.
+ *
+ * @author Jeff Tapper
+ * @version
+ **/
+
+package listeners
+{
+	import flash.events.DataEvent;
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IOErrorEvent;
+	import flash.events.SecurityErrorEvent;
+	import flash.events.TimerEvent;
+	import flash.net.XMLSocket;
+	import flash.text.TextField;
+	import flash.utils.Timer;
+	
+	import org.flexunit.listeners.closer.ApplicationCloser;
+	import org.flexunit.listeners.closer.StandAloneFlashPlayerCloser;
+	import org.flexunit.reporting.FailureFormatter;
+	import org.flexunit.runner.Descriptor;
+	import org.flexunit.runner.IDescription;
+	import org.flexunit.runner.Result;
+	import org.flexunit.runner.notification.Failure;
+	import org.flexunit.runner.notification.IAsyncStartupRunListener;
+	import org.flexunit.runner.notification.ITemporalRunListener;
+	import org.flexunit.runner.notification.async.AsyncListenerWatcher;
+	
+	
+	
+	public class SemillaCIListener extends EventDispatcher implements IAsyncStartupRunListener, ITemporalRunListener
+	{
+		protected static const DEFAULT_PORT:uint = 1024;
+		
+		protected static const DEFAULT_SERVER:String = "127.0.0.1";
+		
+		private static const SUCCESS:String = "success";
+		
+		private static const ERROR:String = "error";
+		
+		private static const FAILURE:String = "failure";
+		
+		private static const IGNORE:String = "ignore";
+		
+		private var successes:Array = new Array();
+		
+		private var ignores:Array = new Array();
+		
+		private var _ready:Boolean = false;
+		
+		private static const END_OF_TEST_ACK:String = "<endOfTestRunAck/>";
+		
+		private static const END_OF_TEST_RUN:String = "<endOfTestRun/>";
+		
+		private static const START_OF_TEST_RUN_ACK:String = "<startOfTestRunAck/>";
+		
+		private var socket:XMLSocket;
+		
+		public var debugTxt:TextField;
+		
+		[Inspectable]
+		public var port:uint;
+		
+		[Inspectable]
+		public var server:String; //this is local host. same machine
+		
+		public var closer:ApplicationCloser;
+		
+		private var lastFailedTest:IDescription;
+		
+		private var timeOut:Timer;
+		
+		private var lastTestTime:Number = 0;
+		
+		
+		
+		public function SemillaCIListener(port:uint = DEFAULT_PORT, server:String = DEFAULT_SERVER)
+		{
+			this.port = port;
+			this.server = server;
+			this.closer = new StandAloneFlashPlayerCloser(); //default application closer
+			
+			socket = new XMLSocket();
+			socket.addEventListener(DataEvent.DATA, dataHandler);
+			socket.addEventListener(Event.CONNECT, handleConnect);
+			socket.addEventListener(IOErrorEvent.IO_ERROR, ioerrorHandler);
+			socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
+			socket.addEventListener(Event.CLOSE, errorHandler);
+			
+			timeOut = new Timer(2000, 1);
+			timeOut.addEventListener(TimerEvent.TIMER_COMPLETE, declareBroken, false, 0, true);
+			timeOut.start();
+			
+			try
+			{
+				socket.connect(server, port);
+				timeOut.stop();
+			}
+			catch (e:Error)
+			{
+//This needs to be more than a trace
+				trace(e.message);
+			}
+		}
+		
+		private function securityErrorHandler(e:SecurityErrorEvent):void 
+		{
+			log(e.text);
+			errorHandler(e);
+		}
+		
+		private function ioerrorHandler(e:IOErrorEvent):void 
+		{
+			log("IOError port:" + port + " server:" + server);
+			log(e.text);
+			errorHandler(e);
+		}
+		
+		
+		
+		private function declareBroken(event:TimerEvent):void
+		{
+			
+			errorHandler(new Event("broken"));
+		}
+		
+		
+		
+		[Bindable(event="listenerReady")]
+		public function get ready():Boolean
+		{
+			return _ready;
+		}
+		
+		
+		
+		private function setStatusReady():void
+		{
+			_ready = true;
+			dispatchEvent(new Event(AsyncListenerWatcher.LISTENER_READY));
+		}
+		
+		
+		
+		private function getTestCount(description:IDescription):int
+		{
+			return description.testCount;
+		}
+		
+		
+		
+		public function testTimed(description:IDescription, runTime:Number):void
+		{
+			if (!runTime || isNaN(runTime))
+			{
+				lastTestTime = 0;
+			}
+			else
+			{
+				lastTestTime = runTime;
+			}
+		
+//trace( description.displayName + " took " + runTime + " ms " );
+		}
+		
+		
+		
+		public function testRunStarted(description:IDescription):void
+		{
+//Since description tells us nothing about failure, error, and skip counts, this is
+//computed by the Ant task as the process executes and no work is needed to signify
+//the start of a test run.
+		}
+		
+		
+		
+		public function testRunFinished(result:Result):void
+		{
+			sendResults(END_OF_TEST_RUN);
+		}
+		
+		
+		
+		public function testStarted(description:IDescription):void
+		{
+// called before each test
+		}
+		
+		
+		
+		public function testFinished(description:IDescription):void
+		{
+// called after each test
+			if (!lastFailedTest || description.displayName != lastFailedTest.displayName)
+			{
+				var desc:Descriptor = getDescriptorFromDescription(description);
+				sendResults("<testcase classname=\"" + desc.suite + "\" name=\"" + desc.method + "\" time=\"" + lastTestTime + "\" status=\"" + SUCCESS + "\" />");
+			}
+		}
+		
+		
+		
+		public function testAssumptionFailure(failure:Failure):void
+		{
+// called on assumptionFail
+		}
+		
+		
+		
+		public function testIgnored(description:IDescription):void
+		{
+// called on ignored test if we want to send ignore to ant.
+			var descriptor:Descriptor = getDescriptorFromDescription(description);
+			
+			var xml:String = "<testcase classname=\"" + descriptor.suite + "\" name=\"" + descriptor.method + "\" time=\"" + lastTestTime + "\" status=\"" + IGNORE + "\">" + "<skipped />" + "</testcase>";
+			
+			sendResults(xml);
+		}
+		
+		
+		
+		public function testFailure(failure:Failure):void
+		{
+// called on a test failure
+			lastFailedTest = failure.description;
+			var descriptor:Descriptor = getDescriptorFromDescription(failure.description);
+			var type:String = failure.description.displayName
+			var message:String = failure.message;
+			var stackTrace:String = failure.stackTrace;
+			var methodName:String = descriptor.method;
+			
+			if (stackTrace != null)
+				stackTrace = stackTrace.toString();
+			
+			stackTrace = FailureFormatter.xmlEscapeMessage(stackTrace);
+			message = FailureFormatter.xmlEscapeMessage(message);
+			
+			var xml:String = null;
+			
+			if (FailureFormatter.isError(failure.exception))
+			{
+				xml = "<testcase classname=\"" + descriptor.suite + "\" name=\"" + descriptor.method + "\" time=\"" + lastTestTime + "\" status=\"" + ERROR + "\">" + "<error message=\"" + message + "\" type=\"" + type + "\" >" + "<![CDATA[" + stackTrace + "]]>" + "</error>" + "</testcase>";
+			}
+			else
+			{
+				xml = "<testcase classname=\"" + descriptor.suite + "\" name=\"" + descriptor.method + "\" time=\"" + lastTestTime + "\" status=\"" + FAILURE + "\">" + "<failure message=\"" + message + "\" type=\"" + type + "\" >" + "<![CDATA[" + stackTrace + "]]>" + "</failure>" + "</testcase>";
+			}
+			
+			sendResults(xml);
+		}
+		
+		
+		
+		/*
+		 * Internal methods
+		 */
+		private function getDescriptorFromDescription(description:IDescription):Descriptor
+		{
+// reads relavent data from descriptor
+			/**
+			 * JAdkins - 7/27/07 - FXU-53 - Listener was returning a null value for the test class
+			 * causing no data to be returned. If length of array is greater than 1, then class is
+			 * not in the default package. If array length is 1, then test class is default package
+			 * and formats accordingly.
+			 **/
+			var descriptor:Descriptor = new Descriptor();
+			var descriptionArray:Array = description.displayName.split("::");
+			var classMethod:String;
+			
+			if (descriptionArray.length > 1)
+			{
+				descriptor.path = descriptionArray[0];
+				classMethod = descriptionArray[1];
+			}
+			else
+			{
+				classMethod = descriptionArray[0];
+			}
+			var classMethodArray:Array = classMethod.split(".");
+			descriptor.suite = (descriptor.path == "") ? classMethodArray[0] : descriptor.path + "::" + classMethodArray[0];
+			descriptor.method = classMethodArray[1];
+			return descriptor;
+		}
+		
+		
+		
+		protected function sendResults(msg:String):void
+		{
+			if (socket.connected)
+			{
+				socket.send(msg);
+			}
+			
+			trace(msg);
+		}
+		
+		
+		
+		private function handleConnect(event:Event):void
+		{
+//This is a good start, but we are no longer considering this a valid
+//time to begin sending results
+//We are going to wait until we get some data first
+//_ready = true;
+//dispatchEvent( new Event( AsyncListenerWatcher.LISTENER_READY ) );
+		}
+		
+		
+		
+		private function errorHandler(event:Event):void
+		{
+			log(event.type);
+			
+			if (!ready)
+			{
+//If we are not yet ready and received this, just inform the core so it can move on
+				dispatchEvent(new Event(AsyncListenerWatcher.LISTENER_FAILED));
+			}
+			else
+			{
+//If on the other hand we were ready once, then the core is counting on us... so, if something goes
+//wrong now, we are likely hung up. For now we are simply going to bail out of this process
+				exit();
+			}
+		}
+		
+		private function log(msg:String):void 
+		{
+			trace(msg);
+			if (debugTxt != null)
+			{
+				debugTxt.appendText(msg + "\n");
+			}
+		}
+		
+		
+		
+		private function dataHandler(event:DataEvent):void
+		{
+			var data:String = event.data;
+			
+// If we received an acknowledgement on startup, the java server is read and we can start sending.
+			if (data == START_OF_TEST_RUN_ACK)
+			{
+				setStatusReady();
+			}
+			else if (data == END_OF_TEST_ACK)
+			{
+// If we received an acknowledgement finish-up.
+// Close the socket.
+				socket.close();
+				exit();
+			}
+		}
+		
+		
+		
+		/**
+		 * Exit the test runner by calling the ApplicationCloser.
+		 */
+		protected function exit():void
+		{
+			this.closer.close();
+		}
+	}
+}

data/default_templates/project/default/test-src/listeners/TraceListener.as

@@ -0,0 +1,79 @@
+package listeners 
+{
+	import org.flexunit.runner.notification.Failure;
+	import org.flexunit.runner.Result;
+	import flash.events.EventDispatcher;
+	import org.flexunit.runner.IDescription;
+	import org.flexunit.runner.notification.IAsyncStartupRunListener;
+	import org.flexunit.runner.notification.ITemporalRunListener;
+	
+	/**
+	 * ...
+	 * @author Victor Rosales
+	 */
+	public class TraceListener extends EventDispatcher implements IAsyncStartupRunListener, ITemporalRunListener 
+	{
+		
+		public function TraceListener() 
+		{
+			
+		}
+		
+		private function log(... args):void 
+		{
+			trace("[FlexUnit] " + args.join(","));
+		}
+		
+		
+		/* INTERFACE org.flexunit.runner.notification.ITemporalRunListener */
+		
+		public function testTimed(description:IDescription, runTime:Number):void 
+		{
+			log("Test timed", description.displayName, runTime);
+		}
+		
+		public function testRunStarted(description:IDescription):void 
+		{
+			log("Test run started", description.displayName);
+		}
+		
+		public function testRunFinished(result:Result):void 
+		{
+			log("Test run finished", result);
+		}
+		
+		public function testStarted(description:IDescription):void 
+		{
+			log("Test started", description.displayName);
+		}
+		
+		public function testFinished(description:IDescription):void 
+		{
+			log("Test finished", description.displayName);
+		}
+		
+		public function testFailure(failure:Failure):void 
+		{
+			log("Test failed", failure.toString());
+		}
+		
+		public function testAssumptionFailure(failure:Failure):void 
+		{
+			log("Test assumption failure", failure.toString());
+		}
+		
+		public function testIgnored(description:IDescription):void 
+		{
+			log("Test ignored", description.displayName);
+		}
+		
+		/* INTERFACE org.flexunit.runner.notification.IAsyncStartupRunListener */
+		
+		public function get ready():Boolean 
+		{
+			return true;
+		}
+		
+	}
+
+}

data/default_templates/project/default/test-src/transforms/LeetTransformTest.as

@@ -0,0 +1,45 @@
+package transforms 
+{
+	import org.flexunit.Assert;
+	import transforms.LeetTransform;
+	
+	/**
+	 * ...
+	 * @author @@AUTHOR@@
+	 */
+	public class LeetTransformTest
+	{
+		
+		[Test]
+		public function leetTest1():void
+		{
+			var t:LeetTransform = new LeetTransform();
+			Assert.assertEquals("1337", t.run("leet"));
+		}
+		
+		[Test]
+        public function leetTest2():void
+        {
+            var t:LeetTransform = new LeetTransform();
+            Assert.assertEquals("h3110", t.run("hello"));
+        }
+        
+        [Test]
+        public function leetTest3():void
+        {
+            var t:LeetTransform = new LeetTransform();
+            Assert.assertEquals("n00b", t.run("noob"));
+        }
+        
+        [Test]
+        public function leetTest4():void
+        {
+            var t:LeetTransform = new LeetTransform();
+            Assert.assertEquals("haxor", t.run("hacker"));
+        }
+		
+		
+		
+	}
+
+}