puremvc-as3 2.0.4

data/2.0.4/src/org/puremvc/as3/patterns/observer/Notification.as

@@ -0,0 +1,128 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.patterns.observer
+{
+	import org.puremvc.as3.interfaces.*;
+	
+	/**
+	 * A base <code>INotification</code> implementation.
+	 * 
+	 * <P>
+	 * PureMVC does not rely upon underlying event models such 
+	 * as the one provided with Flash, and ActionScript 3 does 
+	 * not have an inherent event model.</P>
+	 * 
+	 * <P>
+	 * The Observer Pattern as implemented within PureMVC exists 
+	 * to support event-driven communication between the 
+	 * application and the actors of the MVC triad.</P>
+	 * 
+	 * <P>
+	 * Notifications are not meant to be a replacement for Events
+	 * in Flex/Flash/Apollo. Generally, <code>IMediator</code> implementors
+	 * place event listeners on their view components, which they
+	 * then handle in the usual way. This may lead to the broadcast of <code>Notification</code>s to 
+	 * trigger <code>ICommand</code>s or to communicate with other <code>IMediators</code>. <code>IProxy</code> and <code>ICommand</code>
+	 * instances communicate with each other and <code>IMediator</code>s 
+	 * by broadcasting <code>INotification</code>s.</P>
+	 * 
+	 * <P>
+	 * A key difference between Flash <code>Event</code>s and PureMVC 
+	 * <code>Notification</code>s is that <code>Event</code>s follow the 
+	 * 'Chain of Responsibility' pattern, 'bubbling' up the display hierarchy 
+	 * until some parent component handles the <code>Event</code>, while
+	 * PureMVC <code>Notification</code>s follow a 'Publish/Subscribe'
+	 * pattern. PureMVC classes need not be related to each other in a 
+	 * parent/child relationship in order to communicate with one another
+	 * using <code>Notification</code>s.
+	 * 
+	 * @see org.puremvc.as3.patterns.observer.Observer Observer
+	 * 
+	 */
+	public class Notification implements INotification
+	{
+		
+		/**
+		 * Constructor. 
+		 * 
+		 * @param name name of the <code>Notification</code> instance. (required)
+		 * @param body the <code>Notification</code> body. (optional)
+		 * @param type the type of the <code>Notification</code> (optional)
+		 */
+		public function Notification( name:String, body:Object=null, type:String=null )
+		{
+			this.name = name;
+			this.body = body;
+			this.type = type;
+		}
+		
+		/**
+		 * Get the name of the <code>Notification</code> instance.
+		 * 
+		 * @return the name of the <code>Notification</code> instance.
+		 */
+		public function getName():String
+		{
+			return name;
+		}
+		
+		/**
+		 * Set the body of the <code>Notification</code> instance.
+		 */
+		public function setBody( body:Object ):void
+		{
+			this.body = body;
+		}
+		
+		/**
+		 * Get the body of the <code>Notification</code> instance.
+		 * 
+		 * @return the body object. 
+		 */
+		public function getBody():Object
+		{
+			return body;
+		}
+		
+		/**
+		 * Set the type of the <code>Notification</code> instance.
+		 */
+		public function setType( type:String ):void
+		{
+			this.type = type;
+		}
+		
+		/**
+		 * Get the type of the <code>Notification</code> instance.
+		 * 
+		 * @return the type  
+		 */
+		public function getType():String
+		{
+			return type;
+		}
+
+		/**
+		 * Get the string representation of the <code>Notification</code> instance.
+		 * 
+		 * @return the string representation of the <code>Notification</code> instance.
+		 */
+		public function toString():String
+		{
+			var msg:String = "Notification Name: "+getName();
+			msg += "\nBody:"+(( body == null )?"null":body.toString());
+			msg += "\nType:"+(( type == null )?"null":type);
+			return msg;
+		}
+		
+		// the name of the notification instance
+		private var name			: String;
+		// the type of the notification instance
+		private var type			: String;
+		// the body of the notification instance
+		private var body			: Object;
+		
+	}
+}

data/2.0.4/src/org/puremvc/as3/patterns/observer/Notifier.as

@@ -0,0 +1,55 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.patterns.observer
+{
+	import org.puremvc.as3.interfaces.*;
+	import org.puremvc.as3.patterns.facade.Facade;
+	
+	/**
+	 * A Base <code>INotifier</code> implementation.
+	 * 
+	 * <P>
+	 * <code>MacroCommand, Command, Mediator</code> and <code>Proxy</code> 
+	 * all have a need to send <code>Notifications</code>. <P>
+	 * <P>
+	 * The <code>INotifier</code> interface provides a common method called
+	 * <code>sendNotification</code> that relieves implementation code of 
+	 * the necessity to actually construct <code>Notifications</code>.</P>
+	 * 
+	 * <P>
+	 * The <code>Notifier</code> class, which all of the above mentioned classes
+	 * extend, provides an initialized reference to the <code>Facade</code>
+	 * Singleton, which is required for the convienience method
+	 * for sending <code>Notifications</code>, but also eases implementation as these
+	 * classes have frequent <code>Facade</code> interactions and usually require
+	 * access to the facade anyway.</P>
+	 * 
+	 * @see org.puremvc.as3.patterns.facade.Facade Facade
+	 * @see org.puremvc.as3.patterns.mediator.Mediator Mediator
+	 * @see org.puremvc.as3.patterns.proxy.Proxy Proxy
+	 * @see org.puremvc.as3.patterns.command.SimpleCommand SimpleCommand
+	 * @see org.puremvc.as3.patterns.command.MacroCommand MacroCommand
+	 */
+	public class Notifier implements INotifier
+	{
+		/**
+		 * Create and send an <code>INotification</code>.
+		 * 
+		 * <P>
+		 * Keeps us from having to construct new INotification 
+		 * instances in our implementation code.
+		 * @param notificationName the name of the notiification to send
+		 * @param body the body of the notification (optional)
+		 * @param type the type of the notification (optional)
+		 */ 
+		public function sendNotification( notificationName:String, body:Object=null, type:String=null ):void 
+		{
+			facade.sendNotification( notificationName, body, type );
+		}
+		
+		// Local reference to the Facade Singleton
+		protected var facade:IFacade = Facade.getInstance();
+	}
+}

data/2.0.4/src/org/puremvc/as3/patterns/observer/Observer.as

@@ -0,0 +1,114 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.patterns.observer
+{
+	import org.puremvc.as3.interfaces.*;
+
+	/**
+	 * A base <code>IObserver</code> implementation.
+	 * 
+	 * <P> 
+	 * An <code>Observer</code> is an object that encapsulates information
+	 * about an interested object with a method that should 
+	 * be called when a particular <code>INotification</code> is broadcast. </P>
+	 * 
+	 * <P>
+	 * In PureMVC, the <code>Observer</code> class assumes these responsibilities:
+	 * <UL>
+	 * <LI>Encapsulate the notification (callback) method of the interested object.</LI>
+	 * <LI>Encapsulate the notification context (this) of the interested object.</LI>
+	 * <LI>Provide methods for setting the notification method and context.</LI>
+	 * <LI>Provide a method for notifying the interested object.</LI>
+	 * </UL>
+	 * 
+	 * @see org.puremvc.as3.core.view.View View
+	 * @see org.puremvc.as3.patterns.observer.Notification Notification
+	 */
+	public class Observer implements IObserver
+	{
+		private var notify:Function;
+		private var context:Object;
+	
+		/**
+		 * Constructor. 
+		 * 
+		 * <P>
+		 * The notification method on the interested object should take 
+		 * one parameter of type <code>INotification</code></P>
+		 * 
+		 * @param notifyMethod the notification method of the interested object
+		 * @param notifyContext the notification context of the interested object
+		 */
+		public function Observer( notifyMethod:Function, notifyContext:Object ) 
+		{
+			setNotifyMethod( notifyMethod );
+			setNotifyContext( notifyContext );
+		}
+		
+		/**
+		 * Set the notification method.
+		 * 
+		 * <P>
+		 * The notification method should take one parameter of type <code>INotification</code>.</P>
+		 * 
+		 * @param notifyMethod the notification (callback) method of the interested object.
+		 */
+		public function setNotifyMethod( notifyMethod:Function ):void
+		{
+			notify = notifyMethod;
+		}
+		
+		/**
+		 * Set the notification context.
+		 * 
+		 * @param notifyContext the notification context (this) of the interested object.
+		 */
+		public function setNotifyContext( notifyContext:Object ):void
+		{
+			context = notifyContext;
+		}
+		
+		/**
+		 * Get the notification method.
+		 * 
+		 * @return the notification (callback) method of the interested object.
+		 */
+		private function getNotifyMethod():Function
+		{
+			return notify;
+		}
+		
+		/**
+		 * Get the notification context.
+		 * 
+		 * @return the notification context (<code>this</code>) of the interested object.
+		 */
+		private function getNotifyContext():Object
+		{
+			return context;
+		}
+		
+		/**
+		 * Notify the interested object.
+		 * 
+		 * @param notification the <code>INotification</code> to pass to the interested object's notification method.
+		 */
+		public function notifyObserver( notification:INotification ):void
+		{
+			this.getNotifyMethod().apply(this.getNotifyContext(),[notification]);
+		}
+	
+		/**
+		 * Compare an object to the notification context. 
+		 * 
+		 * @param object the object to compare
+		 * @return boolean indicating if the object and the notification context are the same
+		 */
+		 public function compareNotifyContext( object:Object ):Boolean
+		 {
+		 	return object === this.context;
+		 }		
+	}
+}

data/2.0.4/src/org/puremvc/as3/patterns/proxy/Proxy.as

@@ -0,0 +1,88 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.patterns.proxy
+{
+	import org.puremvc.as3.interfaces.*;
+	import org.puremvc.as3.patterns.observer.*;
+	import org.puremvc.as3.patterns.facade.Facade;
+	
+	/**
+	 * A base <code>IProxy</code> implementation. 
+	 * 
+	 * <P>
+	 * In PureMVC, <code>Proxy</code> classes are used to manage parts of the 
+	 * application's data model. </P>
+	 * 
+	 * <P>
+	 * A <code>Proxy</code> might simply manage a reference to a local data object, 
+	 * in which case interacting with it might involve setting and 
+	 * getting of its data in synchronous fashion.</P>
+	 * 
+	 * <P>
+	 * <code>Proxy</code> classes are also used to encapsulate the application's 
+	 * interaction with remote services to save or retrieve data, in which case, 
+	 * we adopt an asyncronous idiom; setting data (or calling a method) on the 
+	 * <code>Proxy</code> and listening for a <code>Notification</code> to be sent 
+	 * when the <code>Proxy</code> has retrieved the data from the service. </P>
+	 * 
+	 * @see org.puremvc.as3.core.model.Model Model
+	 */
+	public class Proxy extends Notifier implements IProxy, INotifier
+	{
+
+		public static var NAME:String = 'Proxy';
+		
+		/**
+		 * Constructor
+		 */
+		public function Proxy( proxyName:String=null, data:Object=null ) 
+		{
+			
+			this.proxyName = (proxyName != null)?proxyName:NAME; 
+			if (data != null) setData(data);
+		}
+
+		/**
+		 * Get the proxy name
+		 */
+		public function getProxyName():String 
+		{
+			return proxyName;
+		}		
+		
+		/**
+		 * Set the data object
+		 */
+		public function setData( data:Object ):void 
+		{
+			this.data = data;
+		}
+		
+		/**
+		 * Get the data object
+		 */
+		public function getData():Object 
+		{
+			return data;
+		}		
+
+		/**
+		 * Called by the Model when the Proxy is registered
+		 */ 
+		public function onRegister( ):void {}
+
+		/**
+		 * Called by the Model when the Proxy is removed
+		 */ 
+		public function onRemove( ):void {}
+		
+		
+		// the proxy name
+		protected var proxyName:String;
+		
+		// the data object
+		protected var data:Object;
+	}
+}

data/2.0.4/src/puremvc-manifest.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<!-- 
+ PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+-->
+<componentPackage>
+	<!-- Core Components -->
+	<component id="Controller" class="org.puremvc.as3.core.Controller"/>
+	<component id="Model" class="org.puremvc.as3.core.Model"/>
+	<component id="View" class="org.puremvc.as3.core.View"/>
+	<!-- Pattern Components -->
+	<component id="Notifier" class="org.puremvc.as3.patterns.observer.Notifier"/>
+	<component id="Facade" class="org.puremvc.as3.patterns.facade.Facade"/>
+	<component id="Observer" class="org.puremvc.as3.patterns.observer.Observer"/>
+	<component id="Notification" class="org.puremvc.as3.patterns.observer.Notification"/>
+	<component id="Mediator" class="org.puremvc.as3.patterns.mediator.Mediator"/>
+	<component id="Proxy" class="org.puremvc.as3.patterns.proxy.Proxy"/>
+	<component id="SimpleCommand" class="org.puremvc.as3.patterns.command.SimpleCommand"/>
+	<component id="MacroCommand" class="org.puremvc.as3.patterns.command.MacroCommand"/>
+</componentPackage>

data/2.0.4/version.txt

@@ -0,0 +1,117 @@
+PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+--------------------------------------------------------------------------
+Release Date: 08/14/08
+    Platform: ActionScript 3 (Flash, Flex, AIR)
+     Version: 2 
+    Revision: 0
+       Minor: 4    
+      Author: Cliff Hall <cliff@puremvc.org>
+     License: Creative Commons Attribution 3.0 United States License
+--------------------------------------------------------------------------
+2.0.4 Dissallowed re-registration of Mediators in View.registerMediator. 
+      For more on this bug, see:
+      http://forums.puremvc.org/index.php?topic=372
+      Modified View.notifyObservers to notify from a copy of the 
+      observer list rather than the actual observer list, which may
+      change during the notification loop. For more on this bug, see:
+      http://forums.puremvc.org/index.php?topic=490
+
+2.0.3 Added notifyObservers back to IFacade, where it is required
+      if you are sending custom Notifications. No unit tests required.
+      
+2.0.2 Refactored View.removeMediator method, moving the logic for removing
+      an observer into a removeObserver method (also on IView), which is now 
+      called by the Controller.removeCommand method as well as the
+      View.removeMediator method. This fixes the issue described here:
+      http://forums.puremvc.org/index.php?topic=308.0 
+      Also, the Proxy.removeProxy method only attempts to remove the Proxy 
+      if it is registered.
+
+2.0.1 This is the public release, due to the limited release of 2.0 which 
+      did not contain onRegister and onRemove for Proxy and IProxy. Also
+      Model, View and Controller classes have been moved together in the 
+      core package. This has impact to you only if you are extending or 
+      importing Model, View or Controller directly. Since access to 
+      these actors is generally through the Facade, this should not be 
+      an issue. 
+      
+2.0   This release breaks backward compatibility with any previous release
+      because the package structure has changed to incorporate the language
+      for this release. Also, the Mediator naming scheme changed to match 
+      that of the Proxy. Now the constructor to the Mediator takes a 
+      mediatorName argument before the viewComponent argument. This means 
+      that you no longer need to override the getMediatorName method in 
+      your Mediators, you merely send the name to super to be set in the 
+      constructor.The Mediator also gets a setViewComponent method so that 
+      transient view components are supported. The Model, View and Facade 
+      removeProxy and removeMediator methods now return a reference to the 
+      Proxy or Mediator that was removed from the Model or the View. This 
+      supports dynamic unregistration and reregistration of Proxies and 
+      Mediators. And the Facade now implements INotifier, adding a 
+      sendNotification method. This method makes use of the facade's 
+      notifyObservers method, and so Notifier's sendNotification method now 
+      calls facade.sendNotification. This means that you never have
+      to create a notification inside the facade and call notifyObservers,
+      you may simply call sendNotification with the parameters in the same
+      way that Commands, Mediators and Proxies do. It is left public in the
+      facade only so that you may still create and send custom notification
+      classes. Model and Facade get hasProxy method; View and Facade get a 
+      hasMediator method to. Mediator and Proxy get onRegister and onRemove
+      methods. Notification.toString method was fixed.
+      
+1.7.1 A unneeded break statement was in the view's removeMediator method after the
+      refactor for 1.7. This bug was not flushed out because of a flaw in the test
+      which has been corrected. Here is the associated forum post:
+      http://forums.puremvc.org/index.php?topic=181.msg579#msg579
+
+1.7   The Controller's registerCommand method was modified to only create the corresponding
+      Observer for the ICommand being registered if no previous ICommand was registered
+      to the Notification name in question. The behavior of the method is the same in that
+      if an ICommand was previously registered for the Notification, it is no longer used
+      and the newly registered ICommand is. However, the previous implementation created
+      and registered an extra Observer, which could lead to the new ICommand being executed
+      twice. Added removeCommand method to the Facade, which is passed through to the 
+      Controller. Being such a little-used method its omission was intentional, but it is 
+      included now as a matter of form. Added to the removeCommand to the IFacade interface 
+      as well. An issue with the View's removeMediator method was fixed. The previous
+      implementation iterated through the observer list, removing associated Observers,
+      however this caused the length of the Observer list to change, leading to the 
+      possibility that some Observers would not be removed when they should have been. The
+      issue is discussed here: http://forums.puremvc.org/index.php?topic=145.msg478#msg478
+      
+1.6   The 1.5 removeMediator implementation created a new situation where after an 
+      observerMap array was nulled due to its length falling to zero. subsequent calls 
+      to removeMediator could throw an exception. This was because the method of removing
+      the only reference to the array was setting the observerMap value to null for the
+      observerMap key in question. This method was used since Adobe's 'Programming 
+      ActionScript 3.0  > Core ActionScript 3.0 Data Types and Classes > Working with 
+      Arrays' says: "You may come across code that uses the delete operator on an array 
+      element. The delete operator sets the value of an array element to undefined, but 
+      it does not remove the element from the array". However, this proves to no longer
+      be the case. So now, the delete operator is used to remove both observerMap and 
+      mediatorMap entries.
+      
+1.5   Amended removeMediator method to remove associated Observer references from
+      the observerMap. When a notificationName's observer list length falls to zero
+      the reference to the observer list is also removed. Added compareNotifyContext
+      method to the Observer class and IObserver interface, which compares a given 
+      object to the Observer's notification context and returns a Boolean indicating
+      their equality. This allows the View to  compare the Mediator being removed with 
+      the Observer's notification context without breaking the Observer's encapsulation.
+
+1.4   Added INotifier interface and Notifier class. MacroCommand, Command, Mediator
+      and Proxy all extend Notifier and implement INotifier. The sendNotification
+      method in Proxy and Mediator was moved to Notifier and is now available to
+      Commands. Also the protected facade property was moved from Proxy and Mediator
+      into Notifier, so Commands now get the facade reference at construction time.
+      
+1.3  Obviated the need for AbstractProxy and AbstractMediator in applications:
+     * Implemented sendNotification convenience method in Proxy and Mediator
+     * Added protected facade:Ifacade property initialized to Facade.getInstance()
+       on both Mediator and Proxy. The concrete Facade must be instantiated 
+       first, but this call will return the concrete instance, even though the
+       framework Facade.getInstance is called. 
+           
+1.2 - Removed old files that were inadvertently included.
+
+1.1 - Repackaged zip and updated inline docs