emergent-core 0.1.0

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/ContentManager.as

@@ -0,0 +1,92 @@
+package <%= base_package %>.controllers.manager {
+
+	import <%= base_package %>.models.constant.ResourceResult;
+	import <%= base_package %>.models.constant.ResourceAction;
+	import <%= base_package %>.models.domain.Content;
+	import <%= base_package %>.models.domain.ContentAssignment;
+	import <%= base_package %>.controllers.event.ResourceEvent;
+
+	import org.restfulx.Rx;
+	import org.restfulx.collections.ModelsCollection;
+	
+	public class ContentManager extends ResourceManager {
+		
+		protected var contentAssignment:ContentAssignment;
+		
+		private var _contentTree:ModelsCollection; [Bindable]
+		public function get contentTree():ModelsCollection { return _contentTree; }
+		public function set contentTree(value:ModelsCollection):void {
+			_contentTree = value;
+		}
+		
+		// e.g. Site
+		private var _parent:Content; [Bindable]
+		public function get parent():Content { return _parent; }
+		public function set parent(value:Content):void {
+			_parent = value;
+		}
+		
+		// e.g. HomePage
+		private var _target:Content; [Bindable]
+		public function get target():Content { return _target; }
+		public function set target(value:Content):void {
+			_target = value;
+		}
+		
+		// e.g. [BlurbA, BlurbB, BlurbC, ImageA, ImageB]
+		private var _children:ModelsCollection; [Bindable]
+		public function get children():ModelsCollection { return _children; }
+		public function set children(value:ModelsCollection):void {
+			_children = value;
+		}
+		
+		public function ContentManager() {
+			setModel(target);
+		}
+		
+		protected function dispatchContentToManager(resource:Object, action:String, nameOfContent:String):void {
+			
+			var event:ResourceEvent = new ResourceEvent(nameOfContent);
+			event.data = resource;
+			event.action = action;
+			
+			dispatcher.dispatchEvent(event);
+		}
+		
+		override protected function setModel(resource:Object, binder:*=null, action:String=null):void {
+			super.setModel(resource, binder, action);
+			
+			if (resource is Content) {
+				target = model as Content;
+		//		parent = target.parent;
+		//		children = target.children;
+			} else if (resource is ContentAssignment) {
+				contentAssignment = model as ContentAssignment;
+			}
+		}
+		
+		override protected function beforeCreate(resource:Object):void {
+
+		}
+		
+		override protected function beforeUpdate(resource:Object):void {
+			// children = Rx.models.index(Content);
+		}
+		
+		override protected function beforeDestroy(resource:Object):void {
+			// children = Rx.models.index(Content);
+		}
+		
+		override protected function afterCreate(resource:Object):void {
+			setModel(resource, ResourceAction.CREATE);
+		}
+		
+		override protected function afterUpdate(resource:Object):void {
+			setModel(resource, ResourceAction.UPDATE);
+		}
+		
+		override protected function afterDestroy(resource:Object):void {
+			setModel(resource, ResourceAction.DESTROY);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/DocumentManager.as

@@ -0,0 +1,131 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.controllers.manager {
+
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IEventDispatcher;
+	
+	import <%= base_package %>.models.domain.Document;
+
+	import <%= base_package %>.controllers.event.UndoEvent;
+	import <%= base_package %>.controllers.command.ICommand;
+	import <%= base_package %>.controllers.command.Undoable;
+	import <%= base_package %>.controllers.command.UpdateDocumentCommand;
+	
+	/**
+	 * The DocumentManager manages a single document. It provides a transactional interface
+	 * for manipulating that document, making sure that actions are undoable, and keeping
+	 * track of whether or not the document needs saving or not (i.e. if it's "dirty").
+	 * 
+	 * All modifications of the managed document are done in commands, and a change is
+	 * undoable the particular command implements the Undoable interface. After an undoable
+	 * command has been executed it is reported to the undo system.
+	 * 
+	 * Currently there is only one action that modifies the document: update, which has the
+	 * corresponding command UpdateDocumentCommand.
+	 */
+	public class DocumentManager extends EventDispatcher {
+
+		/*
+		 * All methods on the Document class that are destructive (i.e. changes the object's state)
+		 * are marked with the app_internal namespace. This means that any code that wants to modify
+		 * a document needs to open that namespace somehow. This makes it easier to keep track on
+		 * where destructive changes are made.
+		 */
+		private var _document:Document;
+		
+		private var _documentDirty:Boolean;
+		
+		private var _dispatcher:IEventDispatcher;
+		public function set dispatcher( value : IEventDispatcher ) : void {
+			_dispatcher = value;
+		}
+	
+		[Bindable(event="documentChanged")]	
+		public function get document():Document {
+			return _document;
+		}
+		
+		/**
+		 * Returns whether or not the managed document has unsaved changes.
+		 */
+		[Bindable(event="documentDirtyChanged")]
+		public function get documentDirty():Boolean {
+			return _documentDirty;
+		}
+
+
+		/** Internal method for dispatching the "documentChanged" event. */
+		private function dispatchDocumentChanged():void {
+			dispatchEvent(new Event("documentChanged"));
+		}
+		
+		/** Internal method for dispatching the "documentDirtyChanged" event. */
+		private function dispatchDocumentDirtyChanged():void {
+			dispatchEvent(new Event("documentDirtyChanged"));
+		}
+		
+		/** Listener for the Event.CHANGE event on the managed Document instance. */
+		private function onDocumentChange( event:Event ):void {
+			_documentDirty = true;
+			
+			dispatchDocumentDirtyChanged();
+		}
+		
+		/**
+		 * Sets the document instance that this manager manages, this triggers the
+		 * dispatch of both the "documentChanged" and "documentDirtyChanged" events.
+		 */
+		public function setDocument(d:Document):void {
+			if (_document != null) {
+				_document.removeEventListener(Event.CHANGE, onDocumentChange);
+			}
+			
+			_document      = d;
+			_documentDirty = false;
+			
+			if ( _document != null ) {
+				_document.addEventListener(Event.CHANGE, onDocumentChange);
+			}
+			
+			dispatchDocumentChanged();
+			dispatchDocumentDirtyChanged();
+		}
+		
+		/**
+		 * After a document has been saved (an action that this manager is unaware of),
+		 * this method needs to be called to unset the dirty flag.
+		 */
+		public function documentSaved():void {
+			_documentDirty = false;
+			
+			dispatchDocumentDirtyChanged();
+		}
+		
+		/**
+		 * Modifes the managed document by setting a new title and text. This action
+		 * is undoable.
+		 */
+		public function update(doc:Document):void {
+			var command:UpdateDocumentCommand = new UpdateDocumentCommand();
+			command.prepare(_document, doc.content);
+			exec(command);
+		}
+		
+		/**
+		 * Executes the specified command by calling its execute method. Also, and more
+		 * importantly, it checks if that command is undoable. Undoable commands are
+		 * reported to the undo system by dispatching the UndoEvent.ADD_UNDOABLE event.
+		 */
+		private function exec(command:ICommand):void {
+			command.execute();
+			
+			if (command is Undoable) {
+				_dispatcher.dispatchEvent(new UndoEvent(UndoEvent.ADD_UNDOABLE, Undoable(command)));
+			}
+		}
+
+	}
+	
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/DocumentsManager.as

@@ -0,0 +1,156 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.controllers.manager {
+	
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	
+	import mx.collections.ArrayCollection;
+	import mx.collections.ICollectionView;
+	
+	import <%= base_package %>.models.domain.Document;
+	import <%= base_package %>.models.constant.DocumentType;
+	import <%= base_package %>.models.factory.DocumentFactory;
+	import <%= base_package %>.controllers.manager.ResourceManager;
+	
+	/**
+	 * The DocumentsManager manages the overall state of the application, things like
+	 * all documents, open documents and the current document, it also creates and deletes
+	 * documents.
+	 */
+	public class DocumentsManager extends ResourceManager {
+		
+		private var _documents:ArrayCollection;
+		private var _openDocuments:ArrayCollection;
+		private var _currentDocument:Document;
+		private var _documentFactory:DocumentFactory;
+		
+		/**
+		 * Returns a collection of all douments that exist within the application, 
+		 * whether or not they are open or closed.
+		 */
+		[Bindable(event="documentsChanged")]
+		public function get documents():ICollectionView {
+			return _documents;
+		}
+		
+		/**
+		 * Returns a collection of all open documents.
+		 */
+		[Bindable(event="openDocumentsChanged")]
+		public function get openDocuments():ICollectionView {
+			return _openDocuments;
+		}
+		
+		/**
+		 * Returns the current document, i.e. the document that is the front-most
+		 * opened document and the one that the user is editing.
+		 */
+		[Bindable(event="currentDocumentChanged")]
+		public function get currentDocument():Document {
+			return _currentDocument;
+		}
+		
+		/**
+		 * The DocumentsManager needs a DocumentFactory instance for creating
+		 * new documents, it should be injected through this setter.
+		 */
+		public function set documentFactory(value:DocumentFactory):void {
+			_documentFactory = value;
+		}
+		
+	
+		public function DocumentsManager() {
+			_documents = new ArrayCollection();
+			_openDocuments = new ArrayCollection();
+		}
+		
+		override public function save(resource:*):void {
+			if (r.content.id) {
+				update(r);
+			} else {
+				create(r);
+			}
+		}
+		
+		/**
+		 * Creates a new document of the specified type and opens it with openDocument.
+		 */
+		public function newDocument(type:DocumentType):void {			
+			var doc:Document = _documentFactory.createDocument(type);
+			doc.content.title = "Untitled " + (documents.length + 1);
+			_documents.addItem(doc);
+			
+			openDocument(doc);
+		}
+		
+		/**
+		 * Puts the specified document in the list of open documents, if it's not already
+		 * there. Also sets it as the current document with setCurrentDocument.
+		 */
+		public function openDocument(d:Document):void {
+			if (!_openDocuments.contains(d)) {
+				_openDocuments.addItem(d);
+			}
+			
+			setCurrentDocument(d);
+		}
+		
+		/**
+		 * Remoes a document from the list of open documents. If the document
+		 * was also the current document, the last document in the list of open
+		 * documents is set as the new current document (or none if the closed 
+		 * document was the only open document).
+		 * 
+		 * Throws an exception if the document wasn't open.
+		 */
+		public function closeDocument(d:Document):void {
+			var index:int = _openDocuments.getItemIndex(d);
+			
+			if (index != -1) {
+				_openDocuments.removeItemAt(index);
+				
+				if (currentDocument == d && _openDocuments.length > 0) {
+					var doc:Document = Document(_openDocuments.getItemAt(_openDocuments.length - 1));
+					setCurrentDocument(doc);
+				} else {
+					setCurrentDocument(null);
+				}
+			} else {
+				throw new ArgumentError("Cannot close document that isn't open");
+			}
+		}
+		
+		/**
+		 * Sets the specified document as the current document, see get currentDocument.
+		 */
+		protected function setCurrentDocument(d:Document):void {
+			_currentDocument = d;
+			
+			dispatchEvent(new Event("currentDocumentChanged"));
+		}
+		
+		/**
+		 * Deletes the specified document. If the document was open it is
+		 * closed using closeDocument.
+		 * 
+		 * Throws an exception if the document isn't among the documents
+		 * managed by this manager.
+		 */
+		public function deleteDocument(d:Document):void {
+			if (_openDocuments.contains(d)) {
+				closeDocument(d);
+			}
+			
+			var index:int = _documents.getItemIndex(d);
+			
+			if (index != -1) {
+				_documents.removeItemAt(index);
+			} else {
+				throw new ArgumentError("Cannot remove document that doesn't exist");
+			}
+		}
+
+	}
+	
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/HomeManager.as

@@ -0,0 +1,18 @@
+package <%= base_package %>.controllers.manager {
+
+	import <%= base_package %>.models.constant.ResourceResult;
+	import <%= base_package %>.models.constant.ResourceAction;
+	import <%= base_package %>.controllers.event.ResourceEvent;
+	import <%= base_package %>.models.domain.Content;
+	import <%= base_package %>.models.domain.ContentAssignment;
+	
+	import org.restfulx.Rx;
+	import org.restfulx.collections.ModelsCollection;
+	
+	public class HomeManager extends ContentManager {
+		
+		public function HomeManager() {
+			setModel(target);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/MainManager.as

@@ -0,0 +1,23 @@
+package <%= base_package %>.controllers.manager {
+	
+	import flash.events.EventDispatcher;
+	
+	import <%= base_package %>.models.constant.ResourceResult;
+	import <%= base_package %>.models.constant.ResourceAction;
+	import <%= base_package %>.controllers.event.ResourceEvent;
+	import <%= base_package %>.models.domain.Content;
+	import <%= base_package %>.models.domain.ContentAssignment;
+
+	import org.restfulx.Rx;
+	import org.restfulx.collections.ModelsCollection;
+	
+	public class MainManager extends EventDispatcher {
+		
+		[Bindable] public var cmsMode:Boolean;
+		
+		public function MainManager() {
+			setModel(target);
+		}
+		
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/PagesManager.as

@@ -0,0 +1,71 @@
+package <%= base_package %>.controllers.manager
+{
+	import <%= base_package %>.models.constant.ResourceResult;
+	import <%= base_package %>.models.constant.ResourceAction;
+	import <%= base_package %>.controllers.event.ResourceEvent;
+	import <%= base_package %>.models.domain.Content;
+	import <%= base_package %>.models.domain.ContentAssignment;
+
+	import org.restfulx.Rx;
+	import org.restfulx.collections.ModelsCollection;
+
+	import mx.collections.ICollectionView;
+	
+	public class PagesManager extends ResourceManager {
+		
+		/**
+		 * Returns a collection of all pages that exist within the application, 
+		 */
+		private var _pages:ICollectionView;
+		[Bindable(event="documentsChanged")]
+		public function get pages():ICollectionView {
+			return _pages;
+		}
+		
+		/**
+		 * Returns a collection of all open pages.
+		 */
+		private var _openPages:ICollectionView;
+		[Bindable(event="openDocumentsChanged")]
+		public function get openPages():ICollectionView {
+			return _openPages;
+		}
+		
+		/**
+		 * Returns the current pages, i.e. the page that is the front-most
+		 */
+		private var _currentPage:Content;
+		[Bindable(event="currentDocumentChanged")]
+		public function get currentPage():Content {
+			return _currentPage;
+		}
+		
+		public function PagesManager() {
+			setModel(currentPage);
+		}
+		
+		override protected function beforeCreate(resource:Object):void {
+
+		}
+		
+		override protected function beforeUpdate(resource:Object):void {
+			// children = Rx.models.index(Content);
+		}
+		
+		override protected function beforeDestroy(resource:Object):void {
+			// children = Rx.models.index(Content);
+		}
+		
+		override protected function afterCreate(resource:Object):void {
+			setModel(resource, ResourceAction.CREATE);
+		}
+		
+		override protected function afterUpdate(resource:Object):void {
+			setModel(resource, ResourceAction.UPDATE);
+		}
+		
+		override protected function afterDestroy(resource:Object):void {
+			setModel(resource, ResourceAction.DESTROY);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/ResourceManager.as

@@ -0,0 +1,195 @@
+package <%= base_package %>.controllers.manager {
+
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.utils.getDefinitionByName;
+	import flash.utils.getQualifiedClassName;
+	
+	import org.restfulx.Rx;
+	import org.restfulx.collections.ModelsCollection;
+	import org.restfulx.models.RxModel;
+	import org.restfulx.utils.RxUtils;
+	
+	import <%= base_package %>.controllers.event.ResourceEvent;
+	import <%= base_package %>.models.constant.ResourceAction;
+	import <%= base_package %>.models.domain.Document;
+	import <%= base_package %>.models.constant.ResourceResult;
+	import <%= base_package %>.models.factory.ResourceFactory;
+	
+	public class ResourceManager extends EventDispatcher {
+		
+		/** This property is injected by the application. */
+		public var dispatcher:IEventDispatcher;
+		
+		/** Can be used as the main resource, or as a temp/place-holder resource :) */
+		private var _model:RxModel; [Bindable]
+		public function get model():RxModel { return _model; }
+		public function set model(value:RxModel):void {
+			_model = value;
+		}
+		
+		/**
+		 * The ResourcesManager needs a ResourceFactory instance for creating
+		 * new resources, it should be injected through this setter.
+		 */
+		private var _resourceFactory:ResourceFactory; [Bindable]
+		public function get resourceFactory():ResourceFactory { return _resourceFactory; }
+		public function set resourceFactory(value:ResourceFactory):void {
+			_resourceFactory = value;
+		}
+		
+		/**
+		 *	Just as the ResourcesModel has a resourceName property, the ResourcesModel has
+		 *	a resourceResultName property.  The ModelName is listened to by the Manager, and the
+		 *	ResultName is listened to by the view, or the presModel, so the view can update
+		 */
+		private var _resourceResultName:String; [Bindable]
+		public function get resourceResultName():String { return _resourceResultName; }
+		public function set resourceResultName(value:String):void {
+			_resourceResultName = value;
+		}
+		
+		public function ResourceManager() {
+		}
+		
+		// used to allow the subclass the privilege of using the _resource variable
+		protected function setModel(resource:Object, binder:*=null, action:String=null):void {
+			if (binder) { model = binder; }
+			if (!action) {
+				model = resource as RxModel;
+			} else if (action == ResourceAction.CREATE || action == ResourceAction.DESTROY) {
+				model = resourceFactory.createResource(resource as RxModel);
+			} else if (action == ResourceAction.UPDATE) {
+				model = RxUtils.clone(resource) as RxModel;
+			}
+		}
+		
+		protected function dispatchResourceResult(resource:Object, nameOfResource:String,
+			result:String=null, action:String=null):void {
+
+			var event:ResourceEvent = new ResourceEvent(nameOfResource);
+			event.data = resource;
+			event.result = (result) ? result : ResourceResult.SUCCESS;
+			event.action = action;
+			
+			dispatcher.dispatchEvent(event);
+		}
+		
+		public function route(action:String, resource:Object, contentNode:String=null):void {
+			if (action == ResourceAction.CREATE) {
+				beforeCreate(resource);
+				create(resource);
+			} else if (action == ResourceAction.UPDATE) {
+				beforeUpdate(resource);
+				update(resource);
+			} else if (action == ResourceAction.DESTROY) {
+				beforeDestroy(resource);
+				destroy(resource);
+			}
+		}
+		
+		protected function beforeCreate(resource:Object):void {
+			
+		}
+		
+		protected function beforeUpdate(resource:Object):void {
+			
+		}
+		
+		protected function beforeDestroy(resource:Object):void {
+			
+		}
+		
+		public function save(resource:*):void {
+			if (resource.content.id) {
+				update(resource.content);
+			} else {
+				create(resource.content);
+			}
+		}
+		
+    	/**
+     	 * POST /resource
+	 	 * POST /resource.xml
+	 	 * POST /resource.fxml
+     	 */
+		protected function create(resource:*):void {
+			var r:* = discover(resource);
+			
+			var rModel:RxModel = RxUtils.clone(r) as RxModel;
+			
+			rModel.create({afterCallback: afterCreate});
+		}
+	
+    	/**
+     	 * PUT /resource/1
+	 	 * PUT /resource/1.xml
+	 	 * PUT /resource/1.fxml
+     	 */
+		protected function update(resource:*):void {
+			var r:* = discover(resource);
+			r.update({afterCallback: afterUpdate});
+		}
+	
+    	/**
+     	 * DELETE /resource/1
+	 	 * DELETE /resource/1.xml
+	 	 * DELETE /resource/1.fxml
+     	 */
+		protected function destroy(resource:*):void {
+			var r:* = discover(resource);
+			r.destroy({afterCallback: afterDestroy});
+		}
+		
+		/** After the resource returns from the Database */
+		
+		protected function afterCreate(resource:Object):void {
+			model = resourceFactory.createResource(resource as RxModel);
+		}
+
+		protected function afterUpdate(resource:Object):void {
+			model = RxUtils.clone(resource) as RxModel;//clazz(r);
+		}
+
+		protected function afterDestroy(resource:Object):void {
+			model = resourceFactory.createResource(resource as RxModel);
+		}
+		
+		protected function success(resource:*, binder:*=null):void {
+			var event:ResourceEvent = new ResourceEvent(ResourceAction.SUCCESS);
+			event.data = resource;
+			inject(event, binder);
+		}
+		
+		protected function failure(resource:*, binder:*=null):void {
+			var event:ResourceEvent = new ResourceEvent(ResourceAction.FAILURE);
+			event.data = resource;
+			inject(event, binder);
+		}
+		
+		public function clazz(resource:RxModel):Class {
+			var className:String = getQualifiedClassName(resource).replace( "::", "." )
+			var ModelClass:Class = getDefinitionByName(className) as Class;
+			return ModelClass;
+		}
+		
+		protected function discover(resource:*):* {
+			var r:RxModel;
+			
+			if (resource is RxModel) { r = resource as RxModel; }
+			else if (resource is ResourceEvent) { r = resource.data as RxModel; }
+			else if (resource is Document) { r = resource.content as RxModel; }
+			else { r = resource; }
+			
+			return r;
+		}
+		
+		protected function inject(event:*, binder:*=null):void {
+			if (binder !== null) {
+				binder = event;
+			} else {
+				dispatcher.dispatchEvent(event);
+			}
+		}
+	}
+}