michaelforrest-tidy 0.1.1

data/lib/aslibs/as3/lbi/com/lbi/mvc/model/ConcurrentDependencyLoader.as

@@ -0,0 +1,27 @@
+package com.lbi.mvc.model {
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+
+	import com.lbi.animation.group.Stack;
+	/**
+	 * @author michaelforrest
+	 */
+	public class ConcurrentDependencyLoader extends EventDispatcher {
+		public static var READY : String = "ready";
+		public function dispatchReady():void {dispatchEvent(new Event(READY));
+		}
+		public function ConcurrentDependencyLoader(dependencies : Array) {
+			var stack : Stack = new Stack();
+			for (var i : Number = 0;i < dependencies.length; i++) {
+				var d : EventDispatcher = dependencies[i];
+				stack.addMethod(d, null, Event.COMPLETE);
+			}
+			stack.addEventListener(Event.COMPLETE, onReady,false,0,true);
+			stack.go();
+		}
+
+		private function onReady(event : Event) : void {
+			dispatchReady();
+		}
+	}
+}

data/lib/aslibs/as3/lbi/com/lbi/mvc/model/EventMapper.as

@@ -0,0 +1,85 @@
+package com.lbi.mvc.model {
+	import flash.events.Event;
+
+	import com.lbi.mvc.collection.Collection;
+
+	import flash.events.EventDispatcher;
+	import flash.utils.getQualifiedClassName;
+	/**
+	 * @author michaelforrest
+	 */
+	public class EventMapper extends EventDispatcher implements IEventMapper {
+		private var listeners : Collection;
+
+		/**
+		 * Use registerEvents to automatically wire up controller events to which this view must respond.
+		 * So, if you do registerEvents(["complete","ready","pressed"]); you would then need to implement methods
+		 * onComplete(e:Event), onReady(e:Event), onPressed(e:Event)
+		 * @param events = an array of event names dispatched by the controller
+		 */
+		public function registerEvents(view : Object,events : Array) : void {
+			for (var i : Number = 0; i < events.length; i++) {
+				var event:String = events[i];
+				var method_name:String = eventToMethodName(event);
+				var responding_method:Function = view[method_name];
+				if( responding_method === null ) {
+					var msg:String ="Error - view class "+ getQualifiedClassName(view) + " does not implement " + method_name;
+					throw new Error(msg);
+				}
+				addEventListener(event, responding_method,false,0,true);
+				trackListener(view);
+			}
+		}
+
+
+		public function getListeners() : Collection {
+			return listeners;
+		}
+
+		public function unregisterEvents(view : Object, events : Array) : void {
+			if(!events) return;
+			for (var i : Number = 0; i < events.length; i++) {
+				var event:String = events[i];
+				removeEventListener(event,  view[eventToMethodName(event)]);
+			}
+			untrackListener(view);
+		}
+
+		public static function eventToMethodName(event : String) : String {
+			return "on" +StringFormatting.pascalize(event);
+		}
+
+		private function trackListener(view : Object) : void {
+			if(!listeners) listeners = new Collection();
+			if(listeners.find(view)) return;
+			listeners.add(view);
+		}
+
+		private function untrackListener(view : Object) : void {
+			listeners.remove(view);
+			//TODO: think about this properly. This doesn't make sense does it. Necessarily.
+		}
+
+
+		/**
+		 * Override this method to return an array of strings that can be registered as events.
+		 * This is useful if you want to dynamically generate event names (e.g. with keyboard controllers)
+		 */
+		private function getPossibleEvents():Array{
+			return null;
+		}
+		private function eventIsPossible(event_name : String) : Boolean {
+			var possible_events:Array = getPossibleEvents();
+			for (var i : Number = 0; i < possible_events.length; i++) {
+				var e:String = possible_events[i];
+				if (e==event_name) return true;
+			}
+			return false;
+		}
+
+		protected function getAllListeners() : void {
+
+		}
+
+	}
+}

data/lib/aslibs/as3/lbi/com/lbi/mvc/model/Hyperlink.as

@@ -0,0 +1,36 @@
+package com.lbi.mvc.model {
+	import flash.events.Event;
+	import flash.net.URLRequest;
+	import flash.net.navigateToURL;
+	/**
+	 * @author michaelforrest
+	 */
+	public class Hyperlink {
+		public static var BLANK : String = "_blank";
+		public static var SELF : String = "_self";
+		public static var PARENT : String = "_parent";
+		public static var TOP : String = "_top";
+
+		public var text : String;
+		public var href : String;
+		public var target : String;
+		/**
+		 * optionally supply an object literal with
+		 * {text:'text',href:'http://href',target:'_blank'} (target is optional)
+		 */
+		public function Hyperlink(xml : XML) {
+			text = xml.toString();
+			href = xml.@href;
+			target = xml.@target;
+		}
+
+		public function follow(e :Event = null) : void{
+			var request : URLRequest = new URLRequest(href);
+			navigateToURL(request, target);
+		}
+		public function toString() : String{
+			return "[Hyperlink text=" + text + ", href=" + href+ ", target=" + target + "]";
+		}
+
+	}
+}

data/lib/aslibs/as3/lbi/com/lbi/mvc/model/IEventMapper.as

@@ -0,0 +1,10 @@
+package com.lbi.mvc.model {
+	import flash.events.IEventDispatcher;
+	/**
+	 * @author michaelforrest
+	 */
+	public interface IEventMapper extends IEventDispatcher {
+		function registerEvents(view : Object,events : Array):void;
+		function unregisterEvents(view : Object, events : Array) : void;
+	}
+}

data/lib/aslibs/as3/lbi/com/lbi/mvc/model/Merge.as

@@ -0,0 +1,14 @@
+package com.lbi.mvc.model {
+
+	/**
+	 * @author michaelforrest
+	 */
+	public class Merge {
+		public static function objects(extra : Object, original : Object) : Object {
+			for (var i : String in extra) {
+				original[i] = extra[i];
+			}
+			return original;
+		}
+	}
+}

data/lib/aslibs/as3/lbi/com/lbi/mvc/model/SequentialDependencyLoader.as

@@ -0,0 +1,43 @@
+package com.lbi.mvc.model {
+	import com.lbi.animation.group.Queue;
+
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	/**
+	 * @author michaelforrest
+	 */
+	public class SequentialDependencyLoader extends EventDispatcher {
+		public static var READY : String = "ready";
+		public var loaded : Number = 0;
+		private var queue : Queue;
+		private var bytesLoaded : uint;
+
+		public function dispatchReady():void {dispatchEvent(new Event(READY));
+		}
+
+		public function SequentialDependencyLoader(dependencies : Array) {
+			queue = new Queue();
+			for (var i : Number = 0;i < dependencies.length; i++) {
+				var klass : Class = dependencies[i];
+				var loaderDispatcher : XMLListLoaderDispatcher = new XMLListLoaderDispatcher(klass);
+				queue.addMethod(loaderDispatcher, loaderDispatcher.start, XMLListLoaderDispatcher.READY);
+				//queue.addMessage("loaded xml for " + getQualifiedClassName(klass));
+			}
+			queue.addEventListener(Event.COMPLETE, onReady,false,0,true);
+			queue.go();
+		}
+
+		private function onReady(event : Event) : void {
+			dispatchReady();
+		}
+
+		public function getBytesLoaded() : Number {
+			return bytesLoaded;
+		}
+
+//		public function getBytesTotal() : Number {
+//			trace("warning - SequentialDependencyLoader.getBytesTotal() is not defined")
+//			return null;
+//		}
+	}
+}

data/lib/aslibs/as3/lbi/com/lbi/mvc/model/StringFormatting.as

@@ -0,0 +1,142 @@
+package com.lbi.mvc.model {
+	/**
+	 * @author michaelforrest
+	 */
+	public class StringFormatting {
+		public static function formatTimeInCentiseconds(t : Number) : String {
+			var seconds:Number = Math.floor(t % 60);
+			var minutes:Number = Math.floor((t - seconds)/ 60 );
+			var centiseconds:Number = Math.floor(( t-Math.floor(t) ) * 100);
+			return pad(minutes) + ":" + pad(seconds) + ":" + pad(centiseconds);
+		}
+		public static function formatTimeInSeconds(t : Number) : String {
+			var seconds:Number = Math.floor(t % 60);
+			var minutes:Number = Math.floor((t - seconds)/ 60 );
+			return pad(minutes) + ":" + pad(seconds) ;
+		}
+
+		private static function pad(n : Number) : String {
+			var s:String = n.toString();
+			if(s.length==1) s = "0" + s;
+			return s;
+		}
+		/**
+		 * converts string from underscore_lower_case to camelCase
+		 * Utterly untested.
+		 */
+		public static function camelize($s:String):String{
+			var s_arr:Array = $s.split('_');
+		    if (s_arr.length == 1) return s_arr[0];
+
+		    var camelizedString:String = $s.indexOf('_') == 0
+		      ? s_arr[0].charAt(0).toUpperCase() + s_arr[0].substring(1)
+		      : s_arr[0];
+
+		    for (var i:Number = 1, len:Number = s_arr.length; i < len; i++) {
+		      var s:String = s_arr[i];
+		      camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
+		    }
+
+		    return camelizedString;
+		}
+		/**
+		 * converts any string into a valid variable name
+		 * See tests [aslibs_framafabTest ->StringFormattingTest] for behaviour expectations
+		 */
+		public static function variablify(string:String):String{
+			string = string.split(".").join("_");
+			string = string.split(" ").join("_");
+			string = string.split("-").join("_");
+			return string;
+		}
+		/**
+		 * ThisIsPascalCase
+		 */
+		public static function pascalize(underscore_separated : String) : String {
+			var s:String = camelize(underscore_separated.toLowerCase());
+			var pascalized:String = s.charAt(0).toUpperCase() + s.substr(1,s.length-1);
+			return pascalized;
+		}
+
+		public static function underscore(string : String) : String {
+			var alphabet : String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+			for (var i : Number = 0; i < alphabet.length; i++) {
+				var letter:String = alphabet.charAt(i);
+				string = string.split(letter).join("_" + letter.toLowerCase());
+				if(string.charAt(0)=="_") string = string.substr(1,string.length);
+			}
+			return string;
+		}
+		/**
+		 * Trim functions from as2lib
+		 */
+
+		 public static function trim(string:String):String {
+			return leftTrim(rightTrim(string));
+		}
+
+		public static function leftTrim(string:String):String {
+			return leftTrimForChars(string, "\n\t\n ");
+		}
+
+		public static function rightTrim(string:String):String {
+			return rightTrimForChars(string, "\n\t\n ");
+		}
+
+		public static function leftTrimForChars(string:String, chars:String):String {
+			var from:Number = 0;
+			var to:Number = string.length;
+			while (from < to && chars.indexOf(string.charAt(from)) >= 0){
+				from++;
+			}
+			return (from > 0 ? string.substr(from, to) : string);
+		}
+
+		public static function rightTrimForChars(string:String, chars:String):String {
+			var from:Number = 0;
+			var to:Number = string.length - 1;
+			while (from < to && chars.indexOf(string.charAt(to)) >= 0) {
+				to--;
+			}
+			return (to >= 0 ? string.substr(from, to+1) : string);
+		}
+
+		public static function leftTrimForChar(string:String, char:String):String {
+			return leftTrimForChars(string, char.charAt(0));
+		}
+
+		public static function rightTrimForChar(string:String, char:String):String {
+			return rightTrimForChars(string, char.charAt(0));
+		}
+
+		private static var LINES_DELIMETERS : Array = ["\r\n", "\n\r", "\r", "\n"];
+
+		public static function stripInLines ( s : String ) : Array
+		{
+			var res : Array = [];
+			var delimeter_index : Number = 0;
+			var delimeter : String;
+			while(res.length<2 && delimeter_index<LINES_DELIMETERS.length){
+				delimeter = LINES_DELIMETERS[delimeter_index];
+				res = s.split(delimeter);
+				delimeter_index++;
+			}
+			return res;
+		}
+
+
+		public static function collectionize(class_name : String) : String {
+			return underscore(class_name).toLowerCase() + "s";			;
+		}
+
+		public static function sentenceCase(underscored : String) : String {
+			var words : Array = underscored.split("_");
+			var first_word : String = words[0];
+			words[0] = words[0].charAt(0).toUpperCase() + words[0].substr(1,words[0].length-1);
+			for (var i : Number = 0; i < words.length; i++) {
+				if(words[i] == "and") words[i] = "&";
+			}
+			return words.join(' ');
+		}
+	}
+}

data/lib/aslibs/as3/lbi/com/lbi/mvc/model/XMLListLoader.as

@@ -0,0 +1,98 @@
+package com.lbi.mvc.model {
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IOErrorEvent;
+	import flash.events.ProgressEvent;
+	import flash.net.URLLoader;
+	import flash.net.URLRequest;
+
+	import com.lbi.debug.Log;
+	import com.lbi.mvc.collection.Collection;
+import flash.utils.getQualifiedClassName;	/**
+	 * @author michaelforrest
+	 */
+	public class XMLListLoader extends EventDispatcher {
+
+		private static var loaders : Object = {};
+
+		private var url : String;
+		private var item_class :  Class;
+		private var path_to_items : String;
+
+		private var collection : Collection;
+		private static const READY : String = "ready";
+		private var loader : URLLoader;
+		public function XMLListLoader($url : String,$item_class : Class, $path_to_items : String) {
+			super();
+			url = $url;
+			item_class = $item_class;
+			path_to_items = $path_to_items;
+			loadOrAttachToLoaderInProgress();
+			loadXML();
+		}
+
+		private function loadOrAttachToLoaderInProgress() : void {
+//			if(loaders[url]!=null) {
+//				trace("retrieving ")
+//				loader = loaders[url];
+//			}else{
+				loader = new URLLoader();
+				loaders[url] = loader;
+//			}
+		}
+
+		private function loadXML() : void {
+			var xml_request : URLRequest = new URLRequest(url);
+			loader.load(xml_request);
+			loader.addEventListener(Event.COMPLETE, onLoad,false,0,true);
+			loader.addEventListener(ProgressEvent.PROGRESS, onProgress,false,0,true);
+			loader.addEventListener(IOErrorEvent.IO_ERROR, onError,false,0,true);
+
+		}
+		private function onError(event : IOErrorEvent) : void {
+			trace("failed to load " + url);
+		}
+		private function onProgress(event : ProgressEvent) : void {
+			dispatchEvent(event);
+		}
+
+		private function onLoad(event : Event = null) : void {
+			var xml : XML = new XML(loader.data);
+			//trace("DATA FOUND FOR " + url + "? "  +(loader.data != null).toString().toUpperCase());
+			prepare(xml);
+			dispatchEvent(new Event(READY));
+		}
+		private function prepare(xml:XML) : void {
+			collection = new Collection();
+
+			var models:XMLList = xml.descendants(path_to_items);
+			if(models.length() == 0){
+				 Log.warn("No '" + path_to_items + "' nodes found in " + url);
+				 Log.debug("xml:" + xml);
+			}
+			for (var i : Number = 0;i < models.length(); i++) {
+				var model : XML = models[i];
+				var parsed_model : Object = new item_class(model);
+				collection.AS3::push(parsed_model);
+			}
+		}
+		public function getItems() : Array {
+			return collection;
+		}
+		public static function initialize($class : Class, $collection_name : String, $xml_url : String, $path_to_items : String) : XMLListLoaderDispatcher {
+			var events : XMLListLoaderDispatcher = new XMLListLoaderDispatcher($class);
+			var xmlListLoader : XMLListLoader = new XMLListLoader($xml_url, $class, $path_to_items);
+			var callback : Function = function() : void {
+				$class[$collection_name] = xmlListLoader.getItems();
+				trace("Loaded ",  $class[$collection_name].length, "instances into", getQualifiedClassName($class) + "."  +$collection_name, "from", $xml_url);
+				events.dispatchEvent(new Event(Event.COMPLETE));
+			};
+			xmlListLoader.addEventListener(READY, callback,false,0,true);
+			var progressCallback : Function = function(e:ProgressEvent) : void{
+				events.dispatchEvent(e);
+			}
+			xmlListLoader.addEventListener(ProgressEvent.PROGRESS, progressCallback,false,0,true);
+			return events;
+		}
+	}
+}

data/lib/aslibs/as3/lbi/com/lbi/mvc/model/XMLListLoaderDispatcher.as

@@ -0,0 +1,52 @@
+package com.lbi.mvc.model {
+	import flash.events.ProgressEvent;
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.utils.getQualifiedClassName;
+	/**
+	 * @author michaelforrest
+	 * Yep sorry, actually two of these classes are used in the course of the autopopulation process now... (the other place is XMLListloader.prepare() for some reason.)
+	 * Since it works, I am not looking at it any more....
+	 */
+	public class XMLListLoaderDispatcher extends EventDispatcher {
+		private var klass : *;
+		private var events : EventDispatcher;
+		public static const READY : String= "ready";
+
+		public function XMLListLoaderDispatcher($class : Class) {
+			super();
+			klass = $class;
+		}
+
+		public function getClass() : String {
+			return getQualifiedClassName(klass);
+		}
+
+		public function start() : void {
+			checkClassHasWhatIsNeeded();
+			events = klass.prepare();
+			if(!events) {
+				onOtherDispatcherReady();
+			}else{
+				events.addEventListener(ProgressEvent.PROGRESS, onProgress,false,0,true);
+				events.addEventListener(Event.COMPLETE, onOtherDispatcherReady,false,0,true);
+			}
+		}
+
+		private function checkClassHasWhatIsNeeded() : void {
+			if(!klass) throw new Error("No class provided!");
+			if(!klass.prepare) {
+				throw new Error("Please create a prepare() : EventDispatcher {} event on class " +  getQualifiedClassName(klass));
+			}
+		}
+
+		private function onProgress(event : ProgressEvent) : void {
+			dispatchEvent(event);
+		}
+
+		private function onOtherDispatcherReady(event : Event = null) : void {
+			checkClassHasWhatIsNeeded();
+			dispatchEvent(new Event(READY));
+		}
+	}
+}