emergent-core 0.1.0

data/rails_generators/emergent_config/templates/app/flex/application/models/factory/DocumentViewFactory.as

@@ -0,0 +1,59 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.models.factory
+{
+	import flash.utils.Dictionary;
+	
+	import mx.core.Container;
+	
+	import <%= base_package %>.models.domain.Document;
+	import <%= base_package %>.models.constant.DocumentType;
+	
+	import <%= base_package %>.views.document.*;
+
+	/**
+	 * A factory for document views that can create the appropriate view instance for a particular
+	 * document type.
+	 */
+	public class DocumentViewFactory {
+		
+		private static var _factoryMap:Dictionary;
+		
+		
+		private function get factoryMap( ):Dictionary {
+			if ( _factoryMap == null ) {
+				_factoryMap = new Dictionary();
+				_factoryMap[DocumentType.PLAIN] = PlainDocumentView;
+				_factoryMap[DocumentType.RICH]  = RichDocumentView;
+			}
+			
+			return _factoryMap;
+		}
+		
+		
+		/**
+		 * Creates a view that can display the specified document. 
+		 * 
+		 * Throws an exception if the document is null or if the document type is not supported.
+		 */
+		public function createDocumentView(document:Document):Container {
+			if ( document == null ) {
+				throw new ArgumentError("Cannot create document view, document was null");
+			}
+			
+			if ( factoryMap[document.documentType] == null ) {
+				throw new ArgumentError("Cannot create new document view, unknown type: \"" + document.documentType + "\"");
+			}
+			
+			var viewClass:Class = factoryMap[document.documentType];
+			
+			var view:Container = new viewClass();
+			
+			view.data = document;
+			
+			return view;
+		}
+
+	}
+
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/factory/ResourceFactory.as

@@ -0,0 +1,28 @@
+package <%= base_package %>.models.factory {
+	
+	import flash.utils.*;
+	
+	import org.restfulx.models.RxModel;
+
+	/**
+	 * A factory for creating Resource instances. The specific implementation created
+	 * depends on the ResourceType that is passed to the createResource method.
+	 * This class was created to abstract away the ResourceManager, so you don't have to
+	 * have a ResourceManager for each friggin Resource, which would be too repetitive.
+	 */
+	public class ResourceFactory {
+		
+		public function createResource(r:RxModel):RxModel {
+			var className:String = getQualifiedClassName(r).replace( "::", "." );
+			var resource:RxModel;
+
+			var ModelClass:Object = getDefinitionByName(className) as Class;
+			
+			if(ModelClass != null) {
+				resource = RxModel(new ModelClass());
+			}
+
+			return resource;
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/presentation/AboutUsModel.as

@@ -0,0 +1,22 @@
+package <%= base_package %>.models.presentation {
+	
+	import flash.events.Event;
+	import flash.events.IOErrorEvent;
+	
+	import <%= base_package %>.models.constant.Resource;
+	import <%= base_package %>.models.domain.Content;
+	import <%= base_package %>.models.domain.ContentAssignment;
+	import <%= base_package %>.models.domain.AssetAssignment;
+	
+	import org.restfulx.utils.RxFileReference;
+	
+	// Pages and components should extend this
+	public class AboutUsModel extends ContentModel {
+		
+		public function AboutUsModel() {
+			target = new Content();
+			contentAssignment = new ContentAssignment();
+			assetAssignment = new AssetAssignment();
+		}
+	}	
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/presentation/AccountModel.as

@@ -0,0 +1,68 @@
+package <%= base_package %>.models.presentation {
+	
+	import flash.events.Event;
+	import flash.events.KeyboardEvent;
+	import flash.events.IOErrorEvent;
+	
+	import org.restfulx.utils.RxFileReference;
+	
+	import <%= base_package %>.models.presentation.ResourceModel;
+	import <%= base_package %>.models.constant.Resource;
+	import <%= base_package %>.models.domain.Account;
+	import <%= base_package %>.controllers.event.ResourceEvent;
+
+	public class AccountModel extends ResourceModel {
+		
+		[Bindable] public var photoFileName:String = "None selected";
+		[Bindable] public var signUpFormDirty:Boolean = true;
+		[Bindable] public var photoErrorString:String;
+		
+		[Bindable] public var accountEvent:ResourceEvent;
+		
+		private var photo:RxFileReference;
+		
+		private var _account:Account; [Bindable]
+		public function get account():Account { return _account; }
+		public function set account(value:Account):void {
+			_account = value;
+		}
+		
+		public function AccountModel() {
+			account = new Account();
+		}
+
+		public function signUp():void {
+			create(account, accountEvent);
+		}
+
+		public function signUpOnEnter(event:KeyboardEvent):void {
+			if (event.keyCode == 13) {
+				signUp();
+			}
+		}
+		
+		public function chooseFile():void {
+	        photo = new RxFileReference("avatar");
+	        photo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler, false, 0, true);
+	        photo.addEventListener(Event.SELECT, selectFile, false, 0, true);
+	        photo.addEventListener(Event.CANCEL, cancelBrowse, false, 0, true);
+	        photo.browse();
+		}
+
+		private function fileSelected(event:Event):void {
+			photoFileName = RxFileReference(event.target).name;
+		}
+
+		private function ioErrorHandler(event:Event):void {
+			photoErrorString = "Failed to selected a file. Please try again.";
+		}
+		
+		private function selectFile(event:Event):void { 
+			fileSelected(event)
+		}
+
+		private function cancelBrowse(event:Event):void {
+			photo = null;
+		}
+	}	
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/presentation/AuthenticationModel.as

@@ -0,0 +1,44 @@
+package <%= base_package %>.models.presentation {
+	
+	import flash.events.KeyboardEvent;
+	
+	import <%= base_package %>.models.presentation.ResourceModel;
+	import <%= base_package %>.models.domain.Session;
+	import <%= base_package %>.models.constant.Resource;
+	import <%= base_package %>.models.constant.ResourceAction;
+	import <%= base_package %>.controllers.event.ResourceEvent;
+
+	public class AuthenticationModel extends ResourceModel {
+		
+		/** Injector targets */
+		[Bindable] public var sessionEvent:ResourceEvent;
+
+		[Bindable] public var loginErrorString:String;
+		
+		private var _session:Session; [Bindable]
+		public function get session():Session { return _session; }
+		public function set session(value:Session):void {
+			_session = value;
+		}
+		
+		private var _loginDirty:Boolean; [Bindable]
+		public function get loginDirty():Boolean { return _loginDirty; }
+		public function set loginDirty(value:Boolean):void {
+			_loginDirty = value;
+		}
+		
+		public function AuthenticationModel() {
+			session = new Session();
+		}
+
+ 		public function login():void {
+			create(session, sessionEvent);
+		}
+
+		public function loginOnEnter(event:KeyboardEvent):void {
+			if (event.keyCode == 13) {
+				login();
+			}
+		}
+	}	
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/presentation/ContactUsModel.as

@@ -0,0 +1,45 @@
+package <%= base_package %>.models.presentation {
+	
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IEventDispatcher;
+	
+	import mx.binding.utils.BindingUtils;
+	import mx.collections.ICollectionView;
+	import mx.events.CollectionEvent;
+
+	import org.restfulx.models.RxModel;
+	import org.restfulx.collections.ModelsCollection;
+	import org.restfulx.utils.RxUtils;
+	
+	import <%= base_package %>.models.presentation.ResourceModel;
+
+	public class ContactUsModel extends ResourceModel {
+	
+		public var emailSent:Boolean;
+		
+		[Bindable]
+		public function get submitButtonEnabled():Boolean {
+			return emailSent;
+		}
+		
+		public function ContactUsModel() {
+		}
+		
+		public function sendEmail():void
+		{
+/*			var senderName:String = senderName.text;
+			var senderEmail:String = senderEmail.text;
+			var sendToName:String = sendToName.text;
+			var sendToEmail:String = sendToEmail.text;
+			var emailMessage:String = emailMessage.text;
+		
+			this.emailService.send({senderName: senderName, senderEmail:senderEmail, sendToName: sendToName, sendToEmail: sendToEmail, emailMessage: emailMessage});
+		
+			if (cb.selected == true)
+			{
+				this.emailService.send({senderName: senderName, senderEmail:senderEmail, sendToName: sendToName, sendToEmail: senderEmail, emailMessage: emailMessage});
+			}	*/
+		}
+	}	
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/presentation/ContentModel.as

@@ -0,0 +1,70 @@
+package <%= base_package %>.models.presentation {
+	
+	import flash.events.Event;
+	import flash.events.IOErrorEvent;
+
+	import <%= base_package %>.controllers.event.ResourceEvent;
+	import <%= base_package %>.models.presentation.ResourceModel;
+	import <%= base_package %>.models.constant.Resource;
+	import <%= base_package %>.models.domain.Content;
+	import <%= base_package %>.models.domain.ContentAssignment;
+	import <%= base_package %>.models.domain.AssetAssignment;
+	
+	import org.restfulx.utils.RxFileReference;
+	
+	// Pages and components should extend this
+	public class ContentModel extends ResourceModel {
+		
+		/** Injector targets */
+		[Bindable] public var contentEvent:ResourceEvent;
+		[Bindable] public var contentAssignmentEvent:ResourceEvent;
+		
+		protected var contentAssignment:ContentAssignment;
+		protected var assetAssignment:AssetAssignment;
+		
+		[Bindable] public var assignContentDesired:Boolean;
+		[Bindable] public var assetsDesired:Boolean;
+		
+		private var _target:Content; [Bindable]
+		public function get target():Content { return _target; }
+		public function set target(value:Content):void {
+			_target = value;
+		}
+		
+		private var _parent:Content; [Bindable]
+		public function get parent():Content { return _parent; }
+		public function set parent(value:Content):void {
+			_parent = value;
+		}
+		
+		public function ContentModel() {
+			target = new Content();
+			contentAssignment = new ContentAssignment();
+			assetAssignment = new AssetAssignment();
+		}
+		
+		public function assignContent():void {
+			contentAssignment.target = target;
+			contentAssignment.ancestor = parent;//target.getParentAssignment(parentContentNode);
+			create(contentAssignment, contentAssignmentEvent);
+		}
+		
+		public function assignAssets():void {
+			// assetAssigment.assignableAsset = photo;
+			// assetAssignment.content = target;
+			// resourceName = Resource.ASSET_ASSIGNMENT;
+			// create(assetAssignment);
+		}
+		
+		public function saveContent():void {
+			if (assetsDesired) {
+				assignAssets();
+			}
+			if (assignContentDesired) {
+				assignContent();
+			} else {
+				create(target, contentEvent);
+			}
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/presentation/DocumentModel.as

@@ -0,0 +1,235 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.models.presentation {
+	
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IEventDispatcher;
+	
+	import mx.binding.utils.BindingUtils;
+	
+	import <%= base_package %>.controllers.command.Undoable;
+	
+	import <%= base_package %>.controllers.event.DocumentEvent;
+	import <%= base_package %>.controllers.event.UndoEvent;
+	
+	import <%= base_package %>.models.domain.Document;
+
+	/**
+	 * The presentation model of DocumentView.
+	 * 
+	 * The dispatcher, document, documentDirty, undoHistory, undoPossible and redoPossible
+	 * properties are injected by the local controller.
+	 * 
+	 * The methods save, undo, redo, restore and update (which is private but called by
+	 * the setters for title and text) insulates the view from the details of communicating
+	 * with the application. In the current implementation they dispatch events on the 
+	 * dispatcher provided by the local controller, but this could very well change and the
+	 * important thing here is that the view doesn't need to know if it does.
+	 * 
+	 * The presentation model acts as a mediator between the view and the application. It
+	 * presents a view-centric interface of the application model for the view, and takes
+	 * care of all state logic like which buttons should be enabled, etc. This makes the
+	 * view very simple, and it makes the state logic testable.
+	 * 
+	 * This particular presentation model is also unware of how the rest of the application
+	 * works, it communicates with the local and application controllers with implicit
+	 * invokation, i.e. it dispatches events. 
+	 * 
+	 * Many of the properties of this class only have a getter, but are still bindable.
+	 * The way this works is that the getters are defined to use custom binding events, and
+	 * these events are dispatched at the appropriate time. Consider for example the getter
+	 * for the enabled state of the undo button, undoButtonEnabled. It's binding tag says 
+	 * [Bindable(event="undoStateChanged")], which means that whenever that event is
+	 * dispatched the binding system should trigger that binding and update everyone that
+	 * are bound to it. The event is dispatched in the setter for undoPossible, which is
+	 * where the _undoPossible variable that the getter for undoButtonEnabled uses changes
+	 * (the event is dispatched in the setter for redoPossible too, just because I wanted
+	 * to keep things simple and not have too many events). It may seem like a complicated
+	 * way of doing something that could easily be done with plain bindable variables; the
+	 * setter for undoPossible could just set the value for a undoButtonEnabled variable,
+	 * and be done with it. That, however, has two downsides: firstly the undoButtonEnabled
+	 * variable would become changeable from the outside of this class, which is something
+	 * that you generally want to avoid. Secondly the algorithm for determining the enabled
+	 * state could be more complex than being just a reflection of another value, it could
+	 * depend on the value of several variables that all changed independently. Take a look
+	 * at the getter for displayTitle, for example. It depends on two things: the document
+	 * title and whether or not the document is unsaved ("dirty"). The getter declares this
+	 * by having two bindable statements with different events. Whenever either of these
+	 * events is dispatched the binding system knows that it should update everyone that
+	 * are bound to the property. The code that dispatches these events doesn't need to know
+	 * how to create the right value for the displayTitle, actually it doesn't even need
+	 * to know about the displayTitle property at all! This is the power of loose coupling.
+	 */
+	public class DocumentModel extends EventDispatcher {
+	
+		public var dispatcher:IEventDispatcher;
+
+		private var _document:Document;
+
+		private var _undoHistory:Array;
+		
+		private var _undoPossible :Boolean;
+		private var _redoPossible :Boolean;
+		private var _documentDirty:Boolean;
+		
+		/** This property is injected by the application. */
+		public function set undoPossible(value:Boolean):void {
+			_undoPossible = value;
+			
+			dispatchEvent(new Event("undoStateChanged"));
+		}
+		
+		/** This property is injected by the application. */
+		public function set redoPossible(value:Boolean):void {
+			_redoPossible = value;
+			
+			dispatchEvent(new Event("undoStateChanged"));
+		}
+		
+		/** This property is injected by the application. */
+		public function set documentDirty(value:Boolean):void {
+			_documentDirty = value;
+			
+			dispatchEvent(new Event("documentDirtyChanged"));
+		}
+		
+		/**
+		 * Returns the undo history sorted from the most recent command to the oldest.
+		 */
+		[Bindable]
+		public function get undoHistory():Array {
+			// this may look weird, but does a few necessary things that
+			// aren't easy to express in ActionScript:
+			// - it avoids the possibility that the undoHistory is null
+			// - it creates a copy of the array to avoid the possibility that
+			//   the caller changes the list outside of this object's control
+			return (_undoHistory || []).slice().reverse();
+		}
+		
+		/** The undo history is injected by the application. */
+		public function set undoHistory(value:Array):void {
+			_undoHistory = value;
+		}
+		
+		/**
+		 * This property is injected by the application. The getter is only here because
+		 * BindingUtils.bindSetter throws an error for read-only properties (see the constructor).
+		 */
+		[Bindable]
+		public function get document():Document {
+			return _document;
+		}
+		
+		public function set document(value:Document):void {
+			_document = value;
+			
+			// as a side effect of this property being set the titleChanged
+			// and textChanged methods will be called, because of the bindings
+			// set up in the constructor
+		}
+		
+		[Bindable(event="documentDirtyChanged")]
+		public function get displayTitle( ):String {
+			return document.content.title + (_documentDirty ? " *":"");
+		}
+		
+		/*
+		 * The following three getters encapsulate the logic that determines
+		 * if the undo, redo and save buttons should be enabled. The view
+		 * only needs to bind to these three, which keeps it simple.
+		 */
+		
+		[Bindable(event="undoStateChanged")]
+		public function get undoButtonEnabled( ):Boolean {
+			return _undoPossible;
+		}
+		
+		[Bindable(event="undoStateChanged")]
+		public function get redoButtonEnabled( ):Boolean {
+			return _redoPossible;
+		}
+		
+		[Bindable(event="documentDirtyChanged")]
+		public function get saveButtonEnabled( ):Boolean {
+			return _documentDirty;
+		}
+		
+		
+		
+		public function DocumentModel() {
+			// whenever the document property or the title and text properties of the
+			// document changes, call the titleChanged and/or textChanged methods
+			BindingUtils.bindSetter(update, this, ["document", "content", "title"]);
+			BindingUtils.bindSetter(update, this, ["document", "content", "body"]);
+		}
+		
+		/**
+		 * Returns a prettified label for an undoable command, the label contains the
+		 * index of the command in the history (1 is most recent), the description and
+		 * the timestamp in HH:MM:SS format.
+		 */
+		public function labelForUndoable( undoable:Undoable ):String {
+			var hours  :String = (undoable.timestamp.hours   < 10 ? "0":"") + undoable.timestamp.hours;
+			var minutes:String = (undoable.timestamp.minutes < 10 ? "0":"") + undoable.timestamp.minutes;
+			var seconds:String = (undoable.timestamp.seconds < 10 ? "0":"") + undoable.timestamp.seconds;
+			var index  :int    = undoHistory.indexOf(undoable) + 1;
+			
+			return index + ". " + undoable.description + " (" + hours + ":" + minutes + ":" + seconds + ")";
+		}
+		
+		/**
+		 * Notifies the application that the document needs updating.
+		 */
+		private function update(property:*=null):void {
+			dispatchEvent(new Event("documentDirtyChanged"));
+
+			var event:DocumentEvent = new DocumentEvent(DocumentEvent.UPDATE);
+			
+			event.reference = document;
+			
+			// somethings wrong with the dispatcher injection, shouldn't have to do this
+			if (dispatcher == null) { return; }
+
+			dispatcher.dispatchEvent(event);
+		}
+		
+		/**
+		 * Notifies the application that the document needs saving (after first calling update).
+		 */
+		public function save():void {
+			update();
+			
+			var event:DocumentEvent = new DocumentEvent(DocumentEvent.SAVE);
+			
+			event.reference = document;
+			
+			dispatcher.dispatchEvent(event);
+		}
+
+		/**
+		 * Notifies the application that the user has requested an undo. When the
+		 * application handles the undo request the document may change, and this
+		 * will be handled as any other change in the document's state.
+		 */
+		public function undo( ):void {
+			dispatcher.dispatchEvent(new UndoEvent(UndoEvent.UNDO));
+		}
+		
+		/**
+		 * Notifies the application that the user has requested a redo.
+		 */
+		public function redo( ):void {
+			dispatcher.dispatchEvent(new UndoEvent(UndoEvent.REDO));
+		}
+		
+		/**
+		 * Notifies the application that the user has requested a restore.
+		 */
+		public function restore( undoable:Undoable ):void {
+			dispatcher.dispatchEvent(new UndoEvent(UndoEvent.RESTORE, undoable));
+		}
+		
+	}
+	
+}