asunit4 4.2.1.pre

data/vendor/as3reflection/p2/reflect/Reflection.as

@@ -0,0 +1,417 @@
+package p2.reflect {
+    import flash.net.getClassByAlias;
+    import flash.utils.Dictionary;
+    import flash.utils.describeType;
+    import flash.utils.getDefinitionByName;
+    import flash.utils.getQualifiedClassName;
+    
+    public class Reflection extends ReflectionBase {
+
+        private static var READ_WRITE:String = "readwrite";
+        private static var READ_ONLY:String = "readonly";
+        private static var WRITE_ONLY:String = "writeonly";
+        private static var reflections:Object;
+        private var _accessors:Array;
+        private var _allMembers:Array;
+        private var _base:String;
+        private var _classReference:Class;
+        private var _constructor:ReflectionMethod;
+        private var _extendedClasses:Array;
+        private var _interfaceNames:Array;
+        private var _isClass:Boolean;
+        private var _isDynamic:Boolean;
+        private var _isFinal:Boolean;
+        private var _isInterface:Boolean;
+        private var _isStatic:Boolean;
+        private var _methodNames:Array;
+        private var _methods:Array;
+        private var _readMembers:Array;
+        private var _readWriteMembers:Array;
+        private var _types:Array;
+        private var _variables:Array;
+        private var _writeMembers:Array;
+
+        public function Reflection(classOrInstance:*) {
+            _isClass = (classOrInstance is Class);
+            super(describeType(classOrInstance));
+        }
+        
+        public static function create(classOrInstance:*):Reflection {
+            var name:String = getCacheNameFromClassOrInstance(classOrInstance);
+            var cache:Object = getCache();
+            if(cache[name] != null) {
+                return cache[name];
+            }
+            return cache[name] = new Reflection(classOrInstance);
+        }
+
+        override protected function getRawMetaData():XMLList {
+            return description.factory.metadata;
+        }
+
+        private static function getCacheNameFromClassOrInstance(classOrInstance:*):String {
+            return getQualifiedClassName(classOrInstance) + ((classOrInstance is Class) ? "Class" : "");
+        }
+        
+        private static function getCache():Object {
+            if(reflections == null) {
+                clearCache();
+            }
+            return reflections;
+        }
+        
+        public static function clearCache():void {
+            reflections = new Object();
+        }
+
+        private function buildMethods():Array {
+            var methods:Array = new Array();
+            var list:XMLList = description..method;
+            var item:XML;
+            var method:ReflectionMethod
+            for each(item in list) {
+                method = new ReflectionMethod(item);
+                methods.push(method);
+            }
+            return methods;
+        }
+        
+        private function buildAccessors():Array {
+            var accessors:Array = new Array();
+            var list:XMLList = description..accessor;
+            var item:XML;
+            var accessor:ReflectionAccessor;
+            for each(item in list) {
+                accessor = new ReflectionAccessor(item);
+                accessors.push(accessor);
+            }
+            return accessors;
+        }
+        
+        public function get hasConstructor():Boolean {
+            return (constructor != null);
+        }
+        
+        public function get classReference():Class {
+            return _classReference ||= getDefinitionByName(name.split("::").join(".")) as Class;
+        }
+
+        public function get constructor():ReflectionMethod {
+            return _constructor ||= buildConstructor();
+        }
+
+        private function buildConstructor():ReflectionMethod {
+            var constr:XML = description..constructor[0];
+            if(constr != null) {
+                return new ReflectionMethod(constr);
+            }
+            return null;
+        }
+
+        /**
+         * Returns whether or not this Class implements or extends the 
+         * provided Class or Interface name.
+         *
+         * The name provided must be fully qualified and can use only
+         * dots to delimit between the package and class name (pkg.ClassName), 
+         * or it can use the double-colon that Adobe seems to prefer.
+         *
+         **/
+        public function isA(fullyQualifiedClassOrInterfaceName:String):Boolean {
+            var cleanedName:String = normalizeEntityName(fullyQualifiedClassOrInterfaceName);
+            return referencesInterfaceOrClassName(function(name:String):Boolean {
+                return (name == cleanedName);
+            });
+        }
+
+        /**
+         * Works just like +isA+, but doesn't require a fully-qualified name,
+         * and will instead work with any portion of the full Class or Interface name.
+         **/
+        public function mightBeA(classOrInterfaceName:String):Boolean {
+            return referencesInterfaceOrClassName(function(name:String):Boolean {
+                return (name.indexOf(classOrInterfaceName) > -1);
+            });
+        }
+
+        private function referencesInterfaceOrClassName(matcher:Function):Boolean {
+            return findFirst(types, function(name:String, index:int, names:Array):Boolean {
+                return matcher.call(null, name);
+            });
+        }
+
+        /**
+         * Convert human-normal class names and return Adobe-generated Strings 
+         * for matching purposes.
+         **/
+        private function normalizeEntityName(name:String):String {
+            if(name.indexOf('::') > -1 || name.indexOf('.') == -1) {
+                return name;
+            }
+            var parts:Array = name.split('.');
+            var className:String = parts.pop();
+            return [parts.join('.'), className].join('::');
+        }
+        
+        public function hasAccessor(name:String, type:String, declaredBy:String=null):Boolean {
+            return findFirst(accessors, function(item:*, index:int, items:Array):Boolean {
+                return (item.name == name && item.type == type);
+            }) != null;
+        }
+        
+        public function hasVariable(name:String, type:String):Boolean {
+            return findFirst(variables, function(item:*, index:int, items:Array):Boolean {
+                return (item.name == name && item.type == type);
+            }) != null;
+        }
+        
+        public function hasReadWriteMember(name:String, type:String):Boolean {
+            return findFirst(readWriteMembers, function(item:*, index:int, items:Array):Boolean {
+                return (item.name == name && item.type == type);
+            }) != null;
+        }
+        
+        public function hasWriteMember(name:String, type:String):Boolean {
+            return findFirst(writeMembers, function(item:*, index:int, items:Array):Boolean {
+                return (item.name == name && item.type == type);
+            }) != null;
+        }
+        
+        public function get variables():Array {
+            return _variables ||= buildVariables();
+        }
+
+        private function buildVariables():Array {
+            var result:Array = [];
+            var list:XMLList = description..variable;
+            var item:XML;
+            for each(item in list) {
+                result.push(new ReflectionVariable(item));
+            }
+            return result;
+        }
+        
+        public function get readWriteMembers():Array {
+            return _readWriteMembers ||= buildReadWriteMembers();
+        }
+
+        private function buildReadWriteMembers():Array {
+            var result:Array = [];
+
+            variables.forEach(function(item:*, index:int, items:Array):void {
+                result.push(item);
+            });
+
+            accessors.forEach(function(accessor:ReflectionAccessor, index:int, items:Array):void {
+                if(accessor.access == READ_WRITE) {
+                    result.push(accessor);
+                }
+            });
+            
+            return result;
+        }
+
+        public function get readMembers():Array {
+            if(_readMembers == null) {
+                _readMembers = [];
+                variables.forEach(function(item:*, index:int, items:Array):void {
+                    _readMembers.push(item);
+                });
+                var accessors:Array = this.accessors;
+                var accessor:ReflectionAccessor
+                for each(accessor in accessors) {
+                    if(accessor.access == READ_WRITE || accessor.access == READ_ONLY) {
+                        _readMembers.push(accessor);
+                    }
+                }
+            }
+            
+            return _readMembers;
+        }
+        
+        public function get writeMembers():Array {
+            if(_writeMembers == null) {
+                _writeMembers = [];
+                variables.forEach(function(item:*, index:int, items:Array):void {
+                    _writeMembers.push(item);
+                });
+                var accessors:Array = this.accessors;
+                var accessor:ReflectionAccessor
+                for each(accessor in accessors) {
+                    if(accessor.access == READ_WRITE || accessor.access == WRITE_ONLY) {
+                        _writeMembers.push(accessor);
+                    }
+                }
+            }
+
+            return _writeMembers;
+        }
+        
+        public function get interfaceNames():Array {
+            return _interfaceNames ||= buildInterfaceNames();
+        }
+
+        private function buildInterfaceNames():Array {
+            var result:Array = new Array();
+            var list:XMLList = description..implementsInterface.@type;
+            var item:XML;
+            for each(item in list) {
+                result.push(item);
+            }
+            return result;
+        }
+        
+        public function get extendedClasses():Array {
+            return _extendedClasses ||= buildExtendedClasses();
+        }
+
+        private function buildExtendedClasses():Array {
+            var result:Array = [];
+            var list:XMLList = description..extendsClass.@type;
+            var item:XML;
+            for each(item in list) {
+                result.push(item);
+            }
+            return result;
+        }
+        
+        public function get types():Array {
+            return _types ||= extendedClasses.concat(interfaceNames);
+        }
+        
+        public function get base():String {
+            return _base ||= description.@base;
+        }
+
+        public function get isInterface():Boolean {
+            return _isInterface ||= inferIsInterface();
+        }
+
+        private function inferIsInterface():Boolean {
+            return (base == "Class" && (description..factory..extendsClass.length() == 0));
+        }
+        
+        public function get isClass():Boolean {
+            return _isClass;
+        }
+        
+        public function get isDynamic():Boolean {
+            return _isDynamic ||= (description.@isDynamic == "true");
+        }
+        
+        public function get isFinal():Boolean {
+            return _isFinal ||= (description.@isFinal == "true");
+        }
+        
+        public function get isStatic():Boolean {
+            return _isStatic ||= (description.@isStatic == "true");
+        }
+        
+        public function get methods():Array {
+            return _methods ||= buildMethods();
+        }
+        
+        public function get accessors():Array {
+            return _accessors ||= buildAccessors();
+        }
+
+        /**
+         * An alphabetized list of all variables, accessors and methods.
+         **/
+        public function get allMembers():Array {
+            return _allMembers ||= buildAllMembers();
+        }
+
+        private function buildAllMembers():Array {
+            return variables.concat(accessors).concat(methods).sortOn('name');
+        }
+        
+        public function get methodNames():Array {
+            return _methodNames ||= buildMethodNames();
+        }
+
+        private function buildMethodNames():Array {
+            var result:Array = [];
+            var list:XMLList = description..method.@name;
+            var item:XML;
+            for each(item in list) {
+                result.push(item.toString());
+            }
+            return result;
+        }
+        
+        public function hasMethod(methodName:String):Boolean {
+            return (methodNames.indexOf(methodName) > -1);
+        }
+
+        /**
+         * Return an alphabetized list of all variables, accessors and
+         * methods that are annotated with the provided +metaDataName+.
+         **/
+        public function getMembersByMetaData(metaDataName:String):Array {
+            var result:Array = allMembers.filter(function(item:ReflectionMember, index:int, items:Array):Boolean {
+                return (item.getMetaDataByName(metaDataName) != null);
+            });
+            // We should have some way to remind folks to add a new metadata tag to
+            // their compiler options, shouldn't we? 
+            // it's just that the following is really annoying...
+            //if(Reflection.WARN && result.length == 0) {
+                //var warning:String = "[WARNING] p2.reflect.Reflection.getMembersByMetaData was unable to find any members with meta data: " + metaDataName + "\n";
+                //warning += "Did you forget to add --keep-as3-metadata=" + metaDataName + " to your compiler options?\n";
+                //warning += "(set p2.reflect.Reflection.WARN = false to hide this message in the future)";
+                //trace(warning);
+            //}
+
+            return result;
+        }
+
+        /**
+         * Return an alphabetized list of all methods that are 
+         * annotated with the provided +metaDataName+.
+         **/
+        public function getMethodsByMetaData(metaDataName:String):Array {
+            return methods.filter(function(item:ReflectionMember, index:int, items:Array):Boolean {
+                return (item.getMetaDataByName(metaDataName) != null);
+            });
+        }
+        
+        public function getAccessorByName(name:String):ReflectionAccessor {
+            var ln:Number = accessors.length
+            for(var i:Number = 0; i < ln; i++) {
+                if(accessors[i].name == name) {
+                    return accessors[i];
+                }
+            }
+            return null;
+        }
+        
+        public function getMethodByName(name:String):ReflectionMethod {
+            var ln:Number = methods.length;
+            for(var i:Number = 0; i < ln; i++) {
+                if(methods[i].name == name) {
+                    return methods[i];
+                }
+            }
+            return null;
+        }
+        
+        // This implementation of Clone has some serious caveats...
+        // a) Only member variables and accessors that are read/write will be cloned
+        // b) The clone is shallow, meaning property references will not also be cloned
+        // c) Only argument-free constructors are supported
+        public static function clone(instance:Object):Object {
+            var reflection:Reflection = new Reflection(instance);
+            var clazz:Class = reflection.classReference;
+            var clone:Object = new clazz();
+            var members:Array = reflection.readWriteMembers;
+            var name:String;
+            var member:ReflectionMember;
+            for each(member in members) {
+                name = member.name;
+                clone[name] = instance[name];
+            }
+            return clone;
+        }
+    }
+}
+

data/vendor/as3reflection/p2/reflect/ReflectionAccessor.as

@@ -0,0 +1,14 @@
+package p2.reflect {
+
+	public class ReflectionAccessor extends ReflectionVariable {
+		protected var _access:String;
+		
+		public function ReflectionAccessor(description:XML) {
+			super(description);
+		}
+		
+		public function get access():String {
+			return _access ||= description.@access;
+		}
+	}
+}

data/vendor/as3reflection/p2/reflect/ReflectionBase.as

@@ -0,0 +1,52 @@
+package p2.reflect {
+
+    public class ReflectionBase {
+
+		private var _description:XML;
+        private var _metaDataItems:Array;
+		private var _name:String;
+
+        public function ReflectionBase(description:*) {
+			_description = description;
+        }
+
+		public function get name():String {
+			return _name ||= description.@name;
+		}
+
+        public function get description():XML {
+            return _description;
+        }
+
+        public function get metaDataItems():Array {
+            return _metaDataItems ||= parseMetaDataItems();
+        }
+		
+		public function toString():String {
+			return description.toXMLString();
+		}
+
+        public function getMetaDataByName(name:String):ReflectionMetaData {
+            return findFirst(metaDataItems, function(item:*, index:int, items:Array):Boolean {
+                return (item.name == name);
+            });
+        }
+
+        // Class metadata is stored in a different
+        // location from member metadata... Boo.
+        protected function getRawMetaData():XMLList {
+            return description.metadata;
+        }
+
+        private function parseMetaDataItems():Array {
+            var items:Array = [];
+            var list:XMLList = getRawMetaData();
+            var item:XML;
+            for each(item in list) {
+                items.push(new ReflectionMetaData(item));
+            }
+            return items;
+        }
+    }
+}
+

data/vendor/as3reflection/p2/reflect/ReflectionMember.as

@@ -0,0 +1,16 @@
+package p2.reflect {
+
+	public class ReflectionMember extends ReflectionBase {
+
+		protected var _declaredBy:String;
+
+		public function ReflectionMember(description:XML) {
+            super(description);
+		}
+		
+		public function get declaredBy():String {
+			return _declaredBy ||= description.@declaredBy;
+		}
+
+	}
+}

data/vendor/as3reflection/p2/reflect/ReflectionMetaData.as

@@ -0,0 +1,69 @@
+package p2.reflect {
+
+    /**
+     * Parses:
+     * <metadata name="BeforeFilter">
+     *   <arg key="order" value="1"/>
+     * </metadata>
+     */
+    dynamic public class ReflectionMetaData {
+
+        private var _args:Array;
+		private var _xmlDescription:XML;
+		private var _name:String;
+
+		public function ReflectionMetaData(xmlDescription:XML) {
+			_xmlDescription = xmlDescription;
+            // Have to parse args here, because the 
+            // args are appended to this instance - there's
+            // no getter to trigger the parse:
+            _args = parseArgs();
+        }
+
+		public function get name():String {
+			return _name ||= _xmlDescription.@name;
+		}
+
+        public function get xmlDescription():XML {
+            return _xmlDescription;
+        }
+
+        public function get args():Array {
+            return _args;
+        }
+
+        public function getValueFor(argumentKey:String):* {
+            var found:Object =  findFirst(args, function(item:Object, index:int, items:Array):Boolean {
+                return (item.key == argumentKey);
+            });
+            if(found) {
+                return found.value;
+            }
+            return null;
+        }
+
+        public function toString():String {
+            return xmlDescription;
+        }
+
+        private function parseArgs():Array {
+            var items:Array = [];
+            var list:XMLList = xmlDescription..arg;
+            var item:XML;
+            var key:String;
+            var value:*;
+            for each(item in list) {
+                key = item.@key;
+                value = item.@value;
+                if(key == "") {
+                    items.push(value);
+                }
+                else {
+                    items.push({ key: key, value: value });
+                }
+                this[key] = value;
+            }
+            return items;
+        }
+    }
+}

data/vendor/as3reflection/p2/reflect/ReflectionMethod.as

@@ -0,0 +1,36 @@
+package p2.reflect {
+
+	public class ReflectionMethod extends ReflectionMember {
+
+		protected var _parameters:Array;
+		protected var _returnType:String;
+		
+		public function ReflectionMethod(description:XML) {
+			super(description);
+		}
+		
+		private function buildParameters():Array {
+			var parameters:Array = new Array();
+			var list:XMLList = description..parameter;
+			var param:ReflectionMethodParameter;
+			var item:XML;
+			for each(item in list) {
+				param = new ReflectionMethodParameter(item);
+				parameters.push(param);
+			}
+			return parameters;
+		}
+		
+		public function get returnType():String {
+			return _returnType ||= description.@returnType;			
+		}
+		
+		public function get parameters():Array {
+			if(_parameters == null) {
+				_parameters = buildParameters();
+			}
+			return _parameters;
+		}
+	}
+}
+

data/vendor/as3reflection/p2/reflect/ReflectionMethodParameter.as

@@ -0,0 +1,19 @@
+package p2.reflect {
+
+	public class ReflectionMethodParameter extends ReflectionVariable {
+		protected var _index:int;
+		protected var _optional:Boolean;
+		
+		public function ReflectionMethodParameter(description:XML) {
+		    super(description);
+		}
+		
+		public function get index():int {
+			return _index ||= description.@index;
+		}
+		
+		public function get optional():Boolean {
+			return _optional ||= (description.@optional == "true");
+		}
+	}
+}

data/vendor/as3reflection/p2/reflect/ReflectionVariable.as

@@ -0,0 +1,15 @@
+package p2.reflect {
+
+	public class ReflectionVariable extends ReflectionMember {
+
+		protected var _type:String;
+
+		public function ReflectionVariable(description:XML) {
+			super(description);
+		}
+		
+		public function get type():String {
+			return _type ||= description.@type;
+		}
+	}
+}

data/vendor/as3reflection/p2/reflect/findFirst.as

@@ -0,0 +1,14 @@
+package p2.reflect {
+
+    public function findFirst(collection:Array, handler:Function):* {
+        var result:*;
+        var len:Number = collection.length;
+        for(var i:int; i < len; i++) {
+            result = collection[i];
+            if(handler(result, i, collection)) {
+                return result;
+            }
+        }
+    }
+}
+

data/vendor/generators/suite/suite_generator.rb

@@ -0,0 +1,17 @@
+
+# Generate a new ActionScript 3.0 test suite
+# This generator can be executed as follows:
+# 
+#   sprout -n as3 SomeProject
+#   cd SomeProject
+#   script/generator suite
+#
+class SuiteGenerator < Sprout::Generator::NamedBase # :nodoc:
+
+  def manifest
+    record do |m|
+      m.template 'TestSuite.as', File.join(test_dir, 'AllTests.as'), :collision => :force
+    end
+  end
+  
+end

data/vendor/generators/suite/templates/TestSuite.as

@@ -0,0 +1,17 @@
+package {
+	/**
+	 * This file has been automatically created using
+	 * #!/usr/bin/ruby script/generate suite
+	 * If you modify it and run this script, your
+	 * modifications will be lost!
+	 */
+    <% test_case_classes.each do |test_case| %>
+    import <%= test_case %>;<% end %>
+
+    [Suite]
+	public class AllTests {
+        <% test_case_classes.each do |test_case| %>
+        public var <%= test_case.gsub('.', '_') %>:<%= test_case %>;<% end %>
+	}
+}
+