emergent-core 0.1.0

data/rails_generators/emergent_config/templates/app/flex/application/controllers/map/PresenterViewMap.mxml

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8"?>
+<EventMap xmlns="http://mate.asfusion.com/" xmlns:mx="http://www.adobe.com/2006/mxml">
+
+	<!--
+	This is the main event map for the application, think of it as the application controller.
+	-->
+
+	<mx:Script>
+	<![CDATA[
+			
+	import mx.events.FlexEvent;
+
+	import <%= base_package %>.views.navigation.NavigationBarLeftPresenter;
+	import <%= base_package %>.views.navigation.NavigationBarLeftView;
+	
+	import <%= base_package %>.views.navigation.NavigationBarRightPresenter;
+	import <%= base_package %>.views.navigation.NavigationBarRightView;
+	
+	import <%= base_package %>.views.navigation.NavigationBarTopPresenter;
+	import <%= base_package %>.views.navigation.NavigationBarTopView;
+	
+	import <%= base_package %>.views.navigation.NavigationBarBottomPresenter;
+	import <%= base_package %>.views.navigation.NavigationBarBottomView;
+	
+	import <%= base_package %>.views.main.MainView;
+	import <%= base_package %>.views.main.MainPresenter;
+			
+	]]>
+	</mx:Script>
+	
+	<!--	<Debugger level="{Debugger.ALL}"/>	-->
+
+	<EventHandlers type="{FlexEvent.PREINITIALIZE}">
+		<!--
+		The FlexEvent.PREINITIALIZE event is a good place for creating and initializing managers.
+		-->
+	</EventHandlers>
+	
+	<EventHandlers type="{FlexEvent.APPLICATION_COMPLETE}">
+	
+	</EventHandlers>
+	
+	<Injectors target="{MainView}">
+		<PropertyInjector targetKey="presenter" source="{MainPresenter}" />
+	</Injectors>
+	
+	<Injectors target="{NavigationBarRightView}">
+		<PropertyInjector targetKey="presenter" source="{NavigationBarRightPresenter}" />
+	</Injectors>
+	
+	<Injectors target="{NavigationBarLeftView}">
+		<PropertyInjector targetKey="presenter" source="{NavigationBarLeftPresenter}" />
+	</Injectors>
+	
+	<Injectors target="{NavigationBarTopView}">
+		<PropertyInjector targetKey="presenter" source="{NavigationBarTopPresenter}" />
+	</Injectors>
+	
+	<Injectors target="{NavigationBarBottomView}">
+		<PropertyInjector targetKey="presenter" source="{NavigationBarBottomPresenter}" />
+	</Injectors>
+	
+	<Injectors targets="{[NavigationBarLeftPresenter, NavigationBarRightPresenter, NavigationBarTopPresenter, NavigationBarBottomPresenter]}">		
+		<PropertyInjector targetKey="globalDispatcher" source="{scope.dispatcher}" />
+	</Injectors>
+	
+</EventMap>

data/rails_generators/emergent_config/templates/app/flex/application/models/constant/DocumentType.as

@@ -0,0 +1,52 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.models.constant
+{
+	/**
+	 * This class is a glorified enumeration. It should not be instantiated, only
+	 * used through its two constants PLAIN and RICH or through the static method
+	 * fromString (and that should only be used when really needed).
+	 * 
+	 * It could very well be said that it's overkill with this much code just to implement
+	 * an enum, and much simpler 
+	 */
+	public final class DocumentType {
+		
+		public static var PLAIN : DocumentType = new DocumentType("plain");
+		public static var  RICH : DocumentType = new DocumentType("rich");
+		
+		
+		private var _type : String;
+		
+		
+		public function get type( ) : String {
+			return _type;
+		}
+		
+		
+		public static function fromString( typeString : String ) : DocumentType {
+			var instance : DocumentType = DocumentType[typeString.toUpperCase()];
+			
+			if ( instance == null ) {
+				throw new ArgumentError("String does not match an existing document type: " + typeString);
+			}
+			
+			return instance;
+		}
+		
+		/**
+		 * DO NOT INSTANTIATE.
+		 * 
+		 * Use constants or fromString, this constructor is private.
+		 */
+		public function DocumentType( type : String ) {
+			_type = type;
+		}
+		
+		public function toString( ) : String {
+			return "[object DocumentType(\"" + type + "\")]";
+		}
+
+	}
+
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/constant/Resource.as

@@ -0,0 +1,25 @@
+package <%= base_package %>.models.constant
+{
+	public class Resource
+	{
+		/**
+     	 *	This is a list of all the Resource types you have in you application
+		 *	I have created this so we don't have to have 50 different events with the same
+		 *	6 types.  Now we have one event, a ResourceEvent, and you pass it a Resource.TYPE
+		 *	This allows us to abstract a lot of the data management from the subclasses.
+     	 */
+		
+		public static const MESSAGE:String = "messageResource";
+
+		public static const CONTENT:String = "contentResource";
+		public static const CONTENT_ASSIGNMENT:String = "contentAssignmentResource";
+		public static const ASSET:String = "assetResource";
+		public static const ASSET_ASSIGNMENT:String = "assetAssignmentResource";
+		
+		public static const SESSION:String = "sessionResource";
+		public static const USER:String = "userResource";
+		public static const ACCOUNT:String = "accountResource";
+		public static const ADDRESS:String = "addressResource";
+
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/constant/ResourceAction.as

@@ -0,0 +1,28 @@
+package <%= base_package %>.models.constant
+{
+		
+	public class ResourceAction {
+
+		/**
+     	 *	This is a list of all RESTful Resource Action you have in you application
+     	 */
+		
+		// CRUD events for the ResourceModel...
+		public static const LIST:String = "listResourceAction";
+		public static const OPEN:String = "openResourceAction";
+		public static const NEW:String = "newResourceAction";
+		public static const CREATE:String = "createResourceAction";
+		public static const UPDATE:String = "updateResourceAction";
+		public static const DESTROY:String = "destroyResourceAction";
+		public static const STORE:String = "storeResourceAction"; // use to save in favorites or add to cart
+		public static const UPLOAD:String = "uploadResourceAction";
+		public static const DOWNLOAD:String = "downloadResourceAction";
+		
+		public static const SUCCESS:String = "successResourceAction";
+		public static const FAILURE:String = "failureResourceAction";
+
+	}
+}
+		
+
+		

data/rails_generators/emergent_config/templates/app/flex/application/models/constant/ResourceResult.as

@@ -0,0 +1,8 @@
+package <%= base_package %>.models.constant
+{	
+	public class ResourceResult {
+
+		public static const SUCCESS:String = "success";
+		public static const FAILURE:String = "failure";
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/Account.as

@@ -0,0 +1,32 @@
+package <%= base_package %>.models.domain {
+
+	import org.restfulx.models.RxModel;
+  
+	[Resource(name="accounts")]
+	[Bindable]
+	public class Account extends RxModel {
+		public static const LABEL:String = "login";
+
+		public var login:String;
+    
+		public var firstName:String;
+
+		public var lastName:String;
+    
+		public var email:String;
+    
+		public var password:String;
+    
+		public var passwordConfirmation:String;
+    
+		[Ignored]
+		public var photoUrl:String;
+    
+		[Ignored]
+		public var sessionToken:String;
+    
+		public function Account() {
+			super(LABEL);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/Address.as

@@ -0,0 +1,26 @@
+package <%= base_package %>.models.domain {
+
+	import org.restfulx.models.RxModel;
+  
+	[Resource(name="addresses")]
+	[Bindable]
+	public class Address extends RxModel {
+		public static const LABEL:String = "lineOne";
+
+		public var lineOne:String;
+
+		public var lineTwo:String;
+
+		public var city:String;
+
+		public var province:String;
+
+		public var country:String;
+
+		public var postcode:String;
+
+		public function Address() {
+			super(LABEL);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/Asset.as

@@ -0,0 +1,25 @@
+package <%= base_package %>.models.domain {
+	
+	import org.restfulx.collections.ModelsCollection;
+	import org.restfulx.models.RxModel;
+  	import <%= base_package %>.models.domain.Content;
+
+	[Resource(name="assets")]
+	[Bindable]
+	public class Asset extends RxModel {
+		
+		public static const LABEL:String = "name";
+
+		public var name:String;
+    
+		[HasMany]
+		public var assetAssignments:ModelsCollection;
+		
+		[HasMany(through="assetAssignments")]
+		public var contents:ModelsCollection;
+
+		public function AssetAssignment() {
+			super(LABEL);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/AssetAssignment.as

@@ -0,0 +1,25 @@
+package <%= base_package %>.models.domain {
+	
+	import org.restfulx.collections.ModelsCollection;
+	import org.restfulx.models.RxModel;
+  	import <%= base_package %>.models.domain.Content;
+
+	[Resource(name="asset_assigments")]
+	[Bindable]
+	public class AssetAssignment extends RxModel {
+		
+		public static const LABEL:String = "name";
+
+		public var name:String;
+		
+		[BelongsTo(polymorphic="true", dependsOn="Asset, Content")]
+		public var assignableAsset:Object; // can we rename it asset?
+    
+		[BelongsTo]
+		public var content:Content;
+
+		public function AssetAssignment() {
+			super(LABEL);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/Content.as

@@ -0,0 +1,46 @@
+package <%= base_package %>.models.domain {
+	
+	import org.restfulx.collections.ModelsCollection;
+	import org.restfulx.models.RxModel;
+  
+	[Resource(name="contents")]
+	[Bindable]
+	public class Content extends RxModel {
+		
+		public static const LABEL:String = "title";
+
+		public var title:String;
+    
+		public var abstract:String;
+		
+		public var menuTitle:String;
+	
+		public var subTitle:String;
+		
+		public var body:String;
+		
+		[HasMany]
+		public var contentAssignments:ModelsCollection;
+		
+		[HasMany(through="contentAssignments")]
+		public var contents:ModelsCollection;
+		
+		[HasMany]
+		public var assetAssignments:ModelsCollection;
+    
+		[HasMany(through="assetAssignments")]
+		public var assets:ModelsCollection;
+		
+		[Ignored] //used to say to what component the content goes from the Manager
+		// CommentsView.name = "commen"
+		public var presentationModelName:String;
+
+		public function Content() {
+			super(LABEL);
+		}
+		
+		public function getParentAssignment(parent:Content):void {
+			
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/ContentAssignment.as

@@ -0,0 +1,33 @@
+package <%= base_package %>.models.domain {
+	
+	import org.restfulx.collections.ModelsCollection;
+	import org.restfulx.models.RxTreeModel;
+  
+	[Resource(name="content_assignments")]
+	[Bindable]
+	public class ContentAssignment extends RxTreeModel {
+		
+		public static const LABEL:String = "name";
+
+		public var name:String;
+		
+		public var author:String;
+		
+		public var ancestorAs:String;
+		
+		public var targetAs:String;
+		
+		public var ancestor:Content;
+		
+		public var target:Content;
+		
+		public var descendents:ModelsCollection;
+    
+		[BelongsTo]
+		public var parent:ContentAssignment;
+
+		public function ContentAssignment() {
+			super(LABEL);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/Document.as

@@ -0,0 +1,131 @@
+package <%= base_package %>.models.domain {
+	
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+
+	import mx.binding.utils.BindingUtils;
+
+	import <%= base_package %>.models.constant.DocumentType;
+	import <%= base_package %>.models.domain.Content;
+	
+	[Bindable]
+	public class Document extends EventDispatcher {
+		
+		/** Document isn't a RestfulX Model, but it acts like one, using Content as it's data */
+		public var content:Content;
+		
+		public var desiredProperties:Array;
+		
+		public var documentType:DocumentType;
+		
+		public function Document() {
+			BindingUtils.bindSetter(dispatchChange,  this, ["content", "title"]);
+			BindingUtils.bindSetter(dispatchChange,  this, ["content", "body"]);
+			BindingUtils.bindSetter(dispatchChange,  this, ["content", "abstract"]);
+			BindingUtils.bindSetter(dispatchChange,  this, ["content", "menuTitle"]);
+			BindingUtils.bindSetter(dispatchChange,  this, ["content", "subTitle"]);
+			
+			desiredProperties = ["title", "body", "abstract", "menuTitle", "subTitle"];
+			
+			content = new Content();
+		}
+		
+		public function mapProperties(source:Object, target:Object, properties:*):void {
+			for each (var property:* in properties) {
+				target[property] = source[property];
+			}
+		}
+		
+		protected function dispatchChange(property:*=null):void {
+			dispatchEvent(new Event(Event.CHANGE));
+		}
+		
+		/**
+		 * Create a snapshot of the current state of the document. This snapshot can
+		 * be used to restore the document at a later time, for example when undoing
+		 * a series of actions. To restore the document pass the snapshot to loadSnapshot.
+		 */
+		public function createSnapshot():Snapshot {
+			var snapshot:DocumentSnapshot = new DocumentSnapshot();
+			mapProperties(snapshot, content, desiredProperties);
+			/*snapshot.title = content.title;
+			snapshot.body = content.body;
+			snapshot.abstract = content.abstract;
+			snapshot.menuTitle = content.menuTitle;
+			snapshot.subTitle = content.subTitle;*/
+			snapshot.type = documentType;
+			
+			return snapshot;
+		}
+		
+		/**
+		 * Restore the document as it was at an earlier time. See createSnapshot.
+		 */
+		public function loadSnapshot(snapshot:Snapshot):void {
+			loadSnapshotImpl(snapshot);
+		}
+		
+		/**
+		 * This is the actual implementation of loadSnapshot. Because there are problems
+		 * with overriding methods in custom namespaces this method is needed to
+		 * let subclasses override the loading of snapshots.
+		 */
+		protected function loadSnapshotImpl(snapshot:Snapshot) : void {
+			if (snapshot is DocumentSnapshot) {
+				var s:DocumentSnapshot = DocumentSnapshot(snapshot);
+				mapProperties(content, s, desiredProperties);
+			} else {
+				throw new ArgumentError("Unsupported snapshot type");
+			}
+		}
+	}
+}
+
+import flash.utils.ByteArray;
+
+import <%= base_package %>.models.constant.DocumentType;
+import <%= base_package %>.models.domain.Snapshot;
+
+
+/**
+ * The document snapshot implementation. It is based on the DocumentData VO and adds the
+ * type and the getters defined by the Snapshot interface.
+ */
+class DocumentSnapshot implements Snapshot {
+	
+	public var type:DocumentType;
+	
+	public var title:String;
+    
+	public var abstract:String;
+		
+	public var menuTitle:String;
+	
+	public var subTitle:String;
+		
+	public var body:String;
+	
+	public function get bytes():ByteArray {
+		var data:ByteArray = new ByteArray();
+		
+		data.writeObject(this);
+		
+		return data;
+	}
+	
+	public function get xml():XML {
+		return <document type={type.type}>
+					<title>{title}</title>
+					<body>{body}</body>
+					<abstract>{abstract}</abstract>
+					<menuTitle>{menuTitle}</menuTitle>
+					<subTitle>{subTitle}</subTitle>
+				</document>;
+	}
+	
+	
+	public function DocumentSnapshot()
+	{
+	}
+	
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/PlainDocument.as

@@ -0,0 +1,19 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.models.domain {
+	
+	import <%= base_package %>.models.constant.DocumentType;
+	
+	/**
+	 * This class currently does nothing different from PlainDocument, but the idea
+	 * is that in the future it will support rich text documents.
+	 */
+	public class PlainDocument extends Document {
+		
+		public function PlainDocument() {
+			documentType = DocumentType.PLAIN;
+		}
+		
+	}
+
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/RichDocument.as

@@ -0,0 +1,19 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.models.domain {
+	
+	import <%= base_package %>.models.constant.DocumentType;
+	
+	/**
+	 * This class currently does nothing different from PlainDocument, but the idea
+	 * is that in the future it will support rich text documents.
+	 */
+	public class RichDocument extends Document {
+		
+		public function RichDocument( ) {
+			documentType = DocumentType.RICH;
+		}
+		
+	}
+
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/Session.as

@@ -0,0 +1,13 @@
+package <%= base_package %>.models.domain {
+	
+	[Bindable]
+	public class Session {
+		
+		public var login:String;
+		
+		public var password:String;
+
+    	public function Session() {
+    	}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/Snapshot.as

@@ -0,0 +1,21 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.models.domain
+{	
+	import flash.utils.ByteArray;
+
+	/**
+	 * Classes implementing this interface represent snapshots of other object's state
+	 * at a given time. The snapshot can be serialized either as ByteArray or XML.
+	 * 
+	 * Currently there is no way to restore a snapshot from a serialized representation.
+	 */
+	public interface Snapshot {
+		
+		function get bytes():ByteArray ;
+		
+		function get xml():XML ;
+		
+	}
+
+}

data/rails_generators/emergent_config/templates/app/flex/application/models/domain/User.as

@@ -0,0 +1,28 @@
+package <%= base_package %>.models.domain {
+
+  import org.restfulx.collections.ModelsCollection;
+  import org.restfulx.models.RxModel;
+  
+  [Resource(name="users")]
+  [Bindable]
+  public class User extends RxModel {
+    public static const LABEL:String = "title";
+
+    public var title:String;
+
+    [Ignored]
+    public var login:String;
+    
+    [Lazy]
+    [BelongsTo]
+    public var address:Address;
+    
+    [Lazy]
+    [BelongsTo]
+    public var account:Account;
+
+    public function User() {
+      super(LABEL);
+    }
+  }
+}

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

@@ -0,0 +1,61 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.models.factory
+{
+	import flash.utils.Dictionary;
+	
+	import <%= base_package %>.models.constant.DocumentType;
+	import <%= base_package %>.models.domain.Document;
+	import <%= base_package %>.models.domain.PlainDocument;
+	import <%= base_package %>.models.domain.RichDocument;
+
+	/**
+	 * A factory for creating Document instances. The specific implementation created
+	 * depends on the DocumentType that is passed to the createDocument method.
+	 */
+	public class DocumentFactory {
+		
+		private static var _factoryMap : Dictionary;
+		
+		
+		private function get factoryMap( ):Dictionary {
+			if ( _factoryMap == null ) {
+				_factoryMap = new Dictionary();
+				_factoryMap[DocumentType.PLAIN] = PlainDocument;
+				_factoryMap[DocumentType.RICH]  = RichDocument;
+			}
+			
+			return _factoryMap;
+		}
+		
+		
+		/**
+		 * Create a new document of the specified type using some default data.
+		 * 
+		 * Throws an exception if this factory cannot create documents of the specified type.
+		 */
+		public function createDocument(type:DocumentType, data:*=null):Document {
+			if ( factoryMap[type] == null ) {
+				throw new ArgumentError("Cannot create document, unknown type: \"" + type + "\"");
+			}
+			
+			var documentClass : Class = factoryMap[type];
+		
+			var document : Document = new documentClass();
+
+			if (data != null ) {
+				
+			} else {
+				document.content.title = "Untitled ";
+				document.content.body = "";
+				document.content.abstract = "";
+				document.content.menuTitle = "";
+				document.content.subTitle = "";
+			}
+		
+			return document;
+		}
+
+	}
+
+}