package  
{
        import org.flexunit.asserts.assertTrue;

        /**
         * An example Test Case to get FlexUnit 4.1 Beta up and running.
         * @author Jonny Reeves
         */
        public class TestExample
        {
                [Test]
                public function exampleTest() : void
                {
                        // Not much of a test! :)
                        assertTrue("FlexUnit 4.1 Beta is running under FDT", true);
                }
        }
}
 

<project name="FlexUnit4.1-Example">
</project>
 

<project name="FlexUnit4.1-Example">
        <!– Update this property to point to your FLEX SDK; note there is
                        a bug in FlexUnit 4.1 Beta 1 where the FLEX SDK path must
                        NOT include any spaces, otherwise you will get an error during
                        the MXMLC compilation stage; this has already been fixed in the
                        latest Builds of FlexUnit 4.1, see: http://bit.ly/dpHcHT –>
        <property name="FLEX_HOME" location="${eclipse.fdt.flexsdk}" />

        <property name="bin.dir" value="${basedir}/bin" />
        <property name="report.dir" value="${basedir}/reports" />
        <property name="lib.dir" value="${basedir}/libs" />
        <property name="test-src.dir" value="${basedir}/test-src" />

        <taskdef resource="flexTasks.tasks" classpath="${FLEX_HOME}/ant/lib/flexTasks.jar" />
        <taskdef resource="flexUnitTasks.tasks" classpath="${lib.dir}/flexUnitTasks-4.1.0-beta1.14.jar" />

        <!– Run FlexUnit 4.1 and generate JUnit Output –>
        <target name="test" depends="init" description="Run Unit Tests">
                <flexunit
                        workingDir="${bin.dir}"
                        toDir="${report.dir}"
                        verbose="true"
                        haltonfailure="true">
                        <testSource dir="${test-src.dir}">
                                <include name="**/*Test*.as" />
                        </testSource>
                        <library dir="${lib.dir}" />
                </flexunit>

                <junitreport todir="${report.dir}">
                        <fileset dir="${report.dir}">
                                <include name="TEST-*.xml" />
                        </fileset>
                        <report format="frames" todir="${report.dir}/html" />
                </junitreport>

        </target>

        <!– Create the required directories and clean out the reports folder –>
        <target name="init">
                <delete dir="${report.dir}" />
                <mkdir dir="${bin.dir}" />
                <mkdir dir="${report.dir}" />
        </target>
</project>
 

package uk.co.jonnyreeves.logging
{
        import mx.logging.ILogger;
        import mx.logging.ILoggingTarget;
        import mx.logging.Log; 
        import flash.utils.getQualifiedClassName;       

        /**
         * Flex Logger Helper, automatically returns the Category Name when used inside
         * a Class.
         *
         * @author jonny reeves
         */
        public class Logger
        {
                /**
                 * Returns an instance of Flex Logger with the correct category name for the calling Class
                 *
                 * @return ILogger instance with the correct category set for the calling Class.
                 */
                public static function getLogger() : ILogger
                {
                        var category : String = "";
                        category = getCallerFromStackTrace();
                        return Log.getLogger(category);
                }
               
               
                /**
                 * Triggers a StackTrace and extracts the calling method from it, neat.
                 */
                private static function getCallerFromStackTrace() : String
                {
                        var callerMethod : String = "";
                        var nullArray : Array;
                       
                        // Pop a StackTrace by creating a RunTime error.
                        try
                        {
                                nullArray.push("whoops");
                        }
                        catch (e : Error)
                        {
                                var stackTrace : String = new Error().getStackTrace();
                        }
                       
                        // Extract the ClassName from the StackTrack
                        if (stackTrace != null)
                        {
                                var parts : Array = new Array();
                                stackTrace.split("\n").join("");
                                parts = stackTrace.split("      at ");
                                if (parts[3] != null)
                                {
                                        // Handle Both Class Init and internal method cases
                                        if (parts[3].indexOf("$cinit") != -1)
                                        {
                                                callerMethod = parts[3].split("$cinit")[0];
                                        }
                                        else
                                        {
                                                callerMethod = parts[3].split("/")[0];
                                        }
                                }
                        }
                       
                        return getCategoryNameFor(callerMethod);
                }

               
                /**
                 * Helper method which takes an ActionScript 3 Formatted Class Name
                 * and replaces the semi-colons seperating the package and Class name
                 * with a Single Period for use as teh Flex Logging Category name
                 *
                 * @param qualifiedClassName
                 * @return String Legal Flex Logging Category String
                 */
                private static function getCategoryNameFor(qualifiedClassName : String) : String
                {
                        return qualifiedClassName.indexOf("::") > -1 ? qualifiedClassName.split("::").join(".") : qualifiedClassName;
                }
        }
}
 

package uk.co.jonnyreeves.logging
{
        public class LoggingExample
        {
                /**
                 * Instance of the Flex Logging Framework via the Logger Helper Class which will
                 * automatically set the Category name to uk.co.jonnyreeves.logging.LoggingExample
                 */
                private static var Logger : ILogger = Logger.getLogger();

                /**
                 * You can now log away, don’t forget to initialise your Flex Logger Instance (Log) first
                 * by setting the Target Publisher (not shown).
                 */
                public function LoggingExample()
                {
                        Logger.info("Hello World!");
                }
        }
}
 

/**
 * This example method will send an event back to a Registered Listener, in this
 * case we’re going to inform the listener that we have loaded our data and
 * are ready for use.
 *
 *      @param Void
 *      @return Void
*/
private function __onLoadComplete():Void
{
        // This forms the basis of the event we are going to send.
        var eventObject:Object = new Object();
       
        // Populate our eventObject with its type & the event message to send
        eventObject.type = ‘ModelEvent’;
        eventObject.event = ‘data_loaded’
       
        // And send the object via mx.events.EventDispatcher
        this.dispatchEvent(eventObject);
}
 

/**
 * Example function, showing us registering the event listener to the Model with
 * a delegated callback to the __onModelEvent() function.
 *
 *      @param Void
 *      @return Void
*/
private function registerModel()
{
        model.addEventListener("modelEvent", Delegate.create(this, __onModelEvent));
}

/**
 * Callback method which was registered at the same time as adding the eventListener
 * this method handles incoming events from registered models
 *
 *      @param Object event object dispatched from registered model.
 *      @return Void
*/
private function __onModelEvent(event:Object):Void
{
        switch (event.event)
        {
                case ‘data_loaded’:
                        trace (‘Controller::__onModelEvent — Data Loaded!’);
                        break;

                default:
                        trace (‘Controller::__onModelEvent — Unkown Model State recieved: ‘ + event.event);
                        break;
        }
}
 

/**
 * ModelEvent.as
 * John Reeves, http://www.jonnyreeves.co.uk/
 * May 2008
 *
 * Typesafe Event dispatched from Models.
*/
class ModelEvent
{
        private var _name:String;
        private var _level:Number;
       
        /**
         * Private Constructor for creating ModelEvent instances.  This stops developers
         * creating their own ModelEvent’s in the code, instead we encourage people
         * to create Static Model Events below:
        */
        private function ModelEvent(name:String, level:Number)
        {
                this._name = name;
                this._level = level;
        }
       
        // Static Events Models can Send.
        static public var DATA_LOADED:ModelEvent = new ModelEvent(‘DATA_LOADED’, 1);   
        static public var DATA_ERROR:ModelEvent = new ModelEvent(‘DATA_ERROR’, 2);
       

        /**
         * Returns the ModelEvent object for the given ModelEvent String
         *
         *      @param mediaType the MediaType’s name
         *      @return the MediaType object
        */     
        public static function forName(ModelEvent:String):ModelEvent
        {
                if ((ModelEvent[ModelEvent.toUpperCase()] instanceof ModelEvent)) {
                        return ModelEvent[ModelEvent.toUpperCase()];
                }
        }
       

        /**
         * Returns the current ModelEvent’s name as a String
        */
        public function getName():String
        {
                return this._name;
        }
       

        /**
         * Returns the current ModelEvent’s Level as a Number
        */
        public function getLevel():Number
        {
                return this._level;
        }
       
       
        /**
         * Compares an incoming ModelEvent (x) to the current Object.
         *
         *      @param ModelEvent x Incoming ModelEvent Object to perform comparison on.
         *      @return Boolean true if it matches
        */
        public function equals(x:ModelEvent):Boolean
        {
                if (x.getName() == this.getName() && x.getLevel() == this.getLevel()) {
                        return true;
                }
                return false;
        }       
}
 

/**
 * Now we will update this method to use the ModelEvent Enum class.
 *
 *      @param Void
 *      @return Void
*/
private function __onLoadComplete():Void
{
        // This forms the basis of the event we are going to send.
        var eventObject:Object = new Object();
       
        // Populate our eventObject with its type & the state message to send,
        // this time instead of setting state as a String, we set it to be on the
        // ModelEvent’s static properties.
        eventObject.type = ‘ModelEvent’;
        eventObject.event = ModelEvent.DATA_LOADED;
       
        // And send the object via mx.events.EventDispatcher
        this.dispatchEvent(eventObject);
}
 

/**
 * Callback method, this time update to handle the incoming ModelEvent
 *
 *      @param Object event object dispatched from registered model.
 *      @return Void
*/
private function __onModelEvent(event:Object):Void
{
        // extract the ModelEvent Enum from the event Object
        var event:ModelEvent = event.event;
       
        // Use the ModelEvent::equals method to perform comparison
        if (event.equals(ModelEvent.DATA_LOADED)) {
                trace (‘Controller::__onModelEvent — Data Loaded!’);
        }
}
 

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
 <textValue>armén</textValue>
 </configuration>
 

import mx.events.EventDispatcher;
import mx.utils.Delegate;

/**
 * ActionScript 2.0 Configuration Class
 * John Reves, http://www.jonnyreeves.co.uk/
 * June 2008
 *
 * Singleton configuration class with class notation value access and XML
 * import.
*/
class co.uk.jonnyreeves.Configure
{
        // Event Listener
        private var dispatchEvent:Function;
        public var addEventListener:Function;
        public var removeEventListener:Function;

        /**
         * Singleton Instance of this Object.
        */
        private static var _INSTANCE:Configure;

        /**
         * Dynamic Object containing all configuration values
         *      @see Configure::read()
        */
        private var _values:Object;

        /**
         * Interval used to handle Timeouts when retrieving XML Documents.
        */
        private var _xmlTimeoutInterval:Number

        /**
         * Indicates if the XML document timed out whilst loading.
        */
        private var _hasTimedOut:Boolean

        /**
         * Constructor
         * Private, Access via getInstance() only.
        */
        private function Configure(Void)
        {
                this._values = new Object();
                EventDispatcher.initialize(this);
        }

        /**
         * Return a singleton instance of Configure.
         *
         *      @return Configure instance
        */
        static public function getInstance(Void):Configure
        {
                if (_INSTANCE == undefined) {
                        _INSTANCE = new Configure();
                }
                return _INSTANCE;
        }

        /**
         * Attempts to load in Configuration from an XML File, will dispatch
         * an Event depending on the result of this method.
         *
         *      @param xmlFile Location of XML File containing Configuration Values
         *      @return Void
        */
        static public function loadXML(xmlFile:String):Void
        {
                var _this:Configure = getInstance();
                var parser:XML = new XML();
                parser.ignoreWhite = true;

                // Handles XML Document Retreval.
                parser.onLoad = function(success:Boolean):Void
                {
                        if (success &amp;&amp; _this.__validates(this)) {
                                _this.__clearXMLTimeout();
                                _this.__parseXML(this.childNodes[0], _this._values);
                                _this.__onXMLLoadSuccess();
                        }
                        else {
                                _this.__onXMLLoadError();
                        }
                }

                // Create an Interval to handle timeouts.
                _this.__createXMLTimeout();
                parser.load(xmlFile);
        }

        /**
         * Attemps to load all flashVars from _root which exist in the ‘config’
         * namespace.  flashVars should be written using dot notation, but with
         * underscores replacing the dots.
         *
         * For example:
         *      _root.config_testMessage = ‘hello world!’
         *      _root.config_shapes_rectangle_width’ = ‘250′
         *
         * Or using SWFObject notation in the HTML
         *      fo.AddVariable(’config_testMessage’, ‘hello world!’);
         *      fo.AddVariable(’config_shapes_rectangle_width’, ‘250′);
        */
        static public function loadFlashVars():Void
        {
                for (var flashVar:String in _root) {
                        if (flashVar.substr(0, 7) == ‘config_’) {
                                Configure.write(flashVar.substr(7).split(‘_’).join(‘.’), unescape(_root[flashVar]));
                        }
                }
        }

        /**
         * Read a Variable from the Loaded Configuration.  Access to Conifg Groups
         * is handled in {dot} notation.  So to access _config[Omniture][tracking][dc]
         * you would pass in the String ‘omniture.tracking.dc’
         *
         *      @param key Variable to obtain in . notation
         *      @return String value of Configure::_values[key]
        */
        static public function read(key:String):String
        {
                // Turn the . syntax notation into AS2.0 Array access notation.
                var keys:Array = key.split(‘.’);
                var thisGroup:Object = getInstance()._values
                while (keys.length) {
                        thisGroup = thisGroup[keys.shift()];
                }

                // Debugging.
                if (thisGroup.toString() == undefined) {
                        trace(‘Configure::read – Returning Undefined Value for: ‘ + arguments[0]);
                }

                return thisGroup.toString();
        }

        /**
         * Write a Key, Value pair to the Config Object at Run Time.  The key
         * should be supplied in {dot} notation.  The return value could slow
         * down performance on writes.
         *
         *      @param key Varible to write in . notation
         *      @param value Value to write to @param key as a String
         *      @return indicates write was succesfull.
        */
        static public function write(key:String, value:String):Boolean
        {
                // Helper method used for recursion
                getInstance().__recurseWrite(key.split(‘.’), value, getInstance()._values);
                return (read(key) == value);
        }

        /**
         * Helper method used by Configure::write() when dealing with "deep"
         * values inside the _values object.  Method will recurse through the
         * input String (x), and write value to the current configObj node.
         *
         *      @param keys Array contianing the "path" of _values object to write to
         *      @param value String value to write to ConfigObject.
         *      @param configObj Current Node of the Configuration Values _values object
         *      @return Void
        */
        private function __recurseWrite(keys:Array, value:String, configObj:Object):Void
        {
                // Write if that was the last key index.
                if (keys.length == 1) {
                        configObj[keys.shift()] = value;
                }
                // Otherwise Recurse again, create new object if needed.
                else {
                        var thisKey = keys.shift();
                        if (configObj[thisKey] == undefined) {
                                configObj[thisKey] = new Object();
                        }
                        this.__recurseWrite(keys, value, configObj[thisKey]);
                }
        }

        /**
         * Callback to handle failed attempts to Load the configuration XML.
         *
         *      @param Void
         *      @return Void
        */
        private function __onXMLLoadError(Void):Void
        {
                this.__clearXMLTimeout();
                var eventObject:Object = new Object();
                eventObject.target = this;
                eventObject.type = ‘configureEvent’;
                eventObject.name = ‘Configure.onXMLLoadError’
                this.dispatchEvent(eventObject);
        }

        /**
         * XML has been successfully loaded and is ready to be interacted with.
         *
         *      @param Void
         *      @return Void
        */
        private function __onXMLLoadSuccess(Void):Void
        {
                var eventObject:Object = new Object();
                eventObject.target = this;
                eventObject.type = ‘configureEvent’;
                eventObject.name = ‘Configure.onXMLLoaded’
                this.dispatchEvent(eventObject);
        }

        /**
         * Validates the loaded XML Document
         *
         *      @param xml XMLObject loaded by Configure::loadXML()
         *      @return Boolean false on validation errors
        */
        private function __validates(xml:XML):Boolean
        {
                // Abort if we have already timed out.
                if (this._hasTimedOut) {
                        trace (‘Configure::__validateXML – Refusing to Parse XML, timed out’);
                        return false;
                }

                // Check the first node is
                if (String(xml.childNodes[0].nodeName) !== "configuration") {
                        this.__onInvalidXML();
                        return false;
                }

                return true;
        }

        /**
         * Parses the Loaded XML Documents, populating this object’s _values prop.
         *
         *      @param xml XMLObject loaded by Configure::loadXML()
         *      @param config Internal Configuration Object to write values to
         *      @return Void
        */
        private function __parseXML(xml:XMLNode, config:Object):Void
        {
                // loop through all Children of this Node.
                var nodeCount:Number = xml.childNodes.length;
                for (var i:Number = 0; i < nodeCount; i++)
                {
                        var thisNode:XMLNode = xml.childNodes[i];

                        // Recurse into Config Groups (tricky because values are considered to have Length.
                        if (thisNode.childNodes.length > 0 &amp;&amp; thisNode.childNodes[0].nodeValue == null)
                        {
                                // Create new Object off of this._values
                                config[thisNode.nodeName] = new Object();
                                this.__parseXML(thisNode, config[thisNode.nodeName]);
                        }

                        // Write Value
                        else {
                                config[thisNode.nodeName] = thisNode.childNodes[0].nodeValue.toString();
                        }
                }
        }

        /**
         * Creates an Interval used by Configure::loadXML to handle XML documents
         * which timeout.
         *
         *      @param Void
         *      @return Void
        */
        private function __createXMLTimeout(Void):Void
        {
                this._xmlTimeoutInterval = _global.setTimeout(this, ‘__onXMLTimeout’, 1000);
                this._hasTimedOut = false;
        }

        /**
         * Triggered when the timeout in createXMLTimeout() has expired, indicates
         * that the XML document failed to load.
         *
         *      @param Void
         *      @return Void
        */
        private function __onXMLTimeout(Void):Void
        {
                trace (‘Configure::__onXMLTimeout’);
                this._hasTimedOut = true;
                this.__clearXMLTimeout();
                this.__onXMLLoadError();
        }

        /**
         * Gets called when the Parser fails to parse the incoming configuration
         * XML.
         *      @param Void
         *      @return Void
        */
        private function __onInvalidXML(Void):Void
        {
                trace(‘Configure::__onInvalidXML’);
        }

        /**
         * Clears the Interval, tidies up.
        */
        private function __clearXMLTimeout()
        {
                clearInterval(this._xmlTimeoutInterval);
        }
}

/**
 * TimerHelper
 * John Reeves, john.reeves@mailc.net, http://www.jonnyreeves.co.uk/
 * March 2008
 *
 * Timer Class based on user’s system clock for accurate timing in ActionScript
 * When creating an instance of this class, use the `onTick` prototype to get
 * readings, a simple example would be:
 *
 *      class TimerExample
 *      {
 *              private var _timer:TimerHelper;
 *
 *              // Constructor, create instance of Timer.
 *              public function TimerExample() {
 *                      this._timer = new TimerHelper();
 *                      this._timer.onTick = mx.utils.Delegate.create(this, onTimerTick);
 *              }
 *
 *              // Timer callback, handled by the Delegate above.
 *              public function onTimerTick():Void {
 *                      trace(’Timer Callback: ‘ + this._timer.getElapsed() + ‘ seconds’);
 *              }
 *
*/
class co.uk.jonnyreeves.helpers.TimerHelper
{
        /**
         * Indicaqtes if the TimerHelper is Running.
        */
        private var _isRunning:Boolean;
       
        /**
         * Interval for Tracking the clock’s ticks
        */
        private var _tickInterval:Number;
       
        /**
         * Time in seconds elapsed whilist the timer has been running
        */
        private var _secondsElpased:Number;
       
        /**
         * Previous Reading from the Date Object.
        */
        private var _previousTime:Number;
       
        /**
         * Is the TimerHelper using the system clock, or falling back to using an
         * Interval.
        */
        private var _useSystemClock:Boolean;
       
       
        /**
         * Constructor.
         *
         *      @param Void
         *      @return Void
        */
        public function TimerHelper()
        {
                this._isRunning = false;
                this._tickInterval = 0;
                this._secondsElpased = 0;
               
                // Check that we can use the local system clock
                if (isNaN(new Date().getTime())) {
                        this._useSystemClock = false;
                        trace (‘Timer::construct() -> Could not initialise Local System Clock’);
                }
                else {
                        this._useSystemClock = true;
                }
        }

       
        /**
         * Starts the timer.
         *
         *      @param Void
         *      @return Void
        */
        public function start():Void
        {
                // Remove an existing interval
                if (this._isRunning) {
                        this.pause();
                }
               
                // Update last time
                if (this._useSystemClock) {
                        this._previousTime = new Date().getTime();
                }
               
                // Create the new interval.
                this._tickInterval = setInterval(this, ‘__advanceOneTick’, 1000);
                this._isRunning = true;
        }
       
        /**
         * Pauses the timer on its current value.
         *
         *      @param Void
         *      @return Void
        */
        public function pause():Void
        {
                clearInterval(this._tickInterval);
        }
       
       
        /**
         * Resets the Timer back to 0.
         *
         *      @param Void
         *      @return Void
        */
        public function reset():Void
        {
                this.pause();
                this._secondsElpased = 0;
                this._isRunning = false;
        }
       
       
        /**
         * Advance the timer one "tick" either by polling the System Clock, or
         * incrementing.
         *
         *      @param Void
         *      @return Void
        */
        private function __advanceOneTick():Void
        {
                if (this._useSystemClock)
                {
                        var date:Date = new Date();
                        this._secondsElpased += (date.getTime() – this._previousTime) / 1000
                        this._previousTime = date.getTime();
                }
                else {
                        // Fall back to incremening, this method is less acurate.
                        this._secondsElpased += 1;
                }
                               
                // Call the callback Method (depricated)
                this.onTick();
        }
       
       
        /**
         * Accessor method for getting the number of seconds elapsed
         *
         *      @param Void
         *      @return Void
        */
        public function getElapsed():Number
        {
                return this._secondsElpased
        }
       
       
        /**
         * Call back method letting you hook into the timer.
         *
         *      @param Void
         *      @return Void
         *      @depricated
        */
        public function onTick():Void
        {
        }
}