puremvc 1.0.0 → 1.0.1

data/src/org/puremvc/ruby/patterns/command/macro_command.rb

@@ -1,59 +0,0 @@
-# A MacroCommand maintains an list of Command Class references called SubCommands
-# 
-# When execute is called, the MacroCommand instantiates and calls execute on each 
-# of its SubCommands.Each SubCommand will be passed a reference to the original 
-# Notification that was passed to the MacroCommand's execute method.
-# 
-# Unlike SimpleCommand, your subclass should not override execute, but instead, 
-# should override the initialize_macro_command method, calling add_sub_command 
-# once for each SubCommand to be executed.
-class MacroCommand
-  attr_accessor :sub_commands
-  
-  
-  # You should not need to define a constructor, 
-  # instead, override the initialize_macro_command method.
-  # 
-  # If your subclass does define a constructor, be sure to call super.
-  def initialize
-    @sub_commands = []
-    initialize_macro_command
-  end
-  
-  # Initialize the MacroCommand.
-  # 
-  # In your subclass, override this method to initialize the MacroCommand's
-  # SubCommand list with Command class references like this:
-  # 
-  # <tt>
-  #	def initialize_macro_command
-  #       add_sub_command( FirstCommand.new )
-  #       add_sub_command( SecondCommand.new )
-  #       add_sub_command( ThirdCommand.new )
-  #     end
-  # </tt>
-  # 
-  # Note that SubCommands may be MacroCommands or SimpleCommands.
-  def initialize_macro_command
-    raise NotImplementedError
-  end
-  
-  # Add a SubCommand
-  #
-  #The Subcommands will be called in First In/First Out (FIFO) order.
-  def add_sub_command(command)
-    @sub_commands << command
-  end
-  
-  # Execute this MacroCommand's Subcommands. The SubCommands will be called in First
-  # In/First Out (FIFO) order.
-  def execute(notification)
-    @sub_commands.each do |command|
-      command.new().execute(notification)
-    end
-  end
-  
-end
-# PureMVC Port to Ruby by Jake Dempsey <jake.dempsey@puremvc.org>
-# PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
-# Your reuse is governed by the Creative Commons Attribution 3.0 License

data/src/org/puremvc/ruby/patterns/command/simple_command.rb

@@ -1,17 +0,0 @@
-# Your subclass should override the execute method where your business logic 
-# will handle the Notification.
-class SimpleCommand < Notifier
-  
-  # Fulfill the use-case initiated by the given Notification.
-  # 
-  # In the Command Pattern, an application use-case typically
-  # begins with some user action, which results in an Notification being broadcast, which 
-  # is handled by business logic in the execute method of an Command.
-  def execute(notification)
-    #override if you want to do something on this event
-  end
-  
-end
-# PureMVC Port to Ruby by Jake Dempsey <jake.dempsey@puremvc.org>
-# PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
-# Your reuse is governed by the Creative Commons Attribution 3.0 License

data/src/org/puremvc/ruby/patterns/facade/facade.rb

@@ -1,161 +0,0 @@
-# In PureMVC, the Facade class assumes these responsibilities:
-# 
-# * Initializing the Model, View and Controller Singletons. 
-# * Providing all the methods defined by the Model, View, & Controller.
-# * Providing the ability to override the specific Model, View and Controller Singletons created. 
-# * Providing a single point of contact to the application for registering Commands and notifying Observers
-class Facade
-  include Singleton
-  
-  attr_accessor :model, :view, :controller
-  
-  # This Facade implementation is a Singleton, so you can not call the constructor 
-  # directly, but instead call the static Singleton Factory method Facade.instance
-  def initialize
-    initialize_facade
-  end
-  
-  # Initialize the Singleton Facade instance.
-  # 
-  # Called automatically by the constructor. Override in your
-  # subclass to do any subclass specific initializations. Be sure to call super.
-  def initialize_facade
-    initialize_model
-    initialize_view
-    initialize_controller
-  end
-  
-  # Initialize the Controller.
-  # 
-  # Called by the initialize_facade method.
-  # Override this method in your subclass of Facade if one or both of the following are true:
-  # * You wish to initialize a different Controller.
-  # * You have Commands to register with the Controller at startup.		  
-  # 
-  # If you don't want to initialize a different Controller, 
-  # call super at the beginning of your method, then register Commands.
-  def initialize_controller
-    return unless @controller.nil?
-    @controller = Controller.instance
-  end
-  
-  # Initialize the Model.
-  # 
-  # Called by the initialize_facade method.
-  # Override this method in your subclass of Facade if one or both of the following are true:
-  # * You wish to initialize a different Model.
-  # * You have Proxys to register with the Model that do not retrieve a reference to 
-  # the Facade at construction time.
-  # 
-  # If you don't want to initialize a different Model, 
-  # call super at the beginning of your method, then register Proxys.
-  # 
-  # Note: This method is rarely overridden; in practice you are morelikely to use a
-  # Command to create and register Proxys with the Model, since Proxys with mutable
-  # data will likely need to send Notifications and thus will likely want to fetch a 
-  # reference to the Facade during their construction. 
-  def initialize_model
-    return unless @model.nil?
-    @model = Model.instance
-  end
-  
-  
-  # Initialize the View.
-  # 
-  # Called by the initialize_facade method.
-  # Override this method in your subclass of Facade if one or both of the following are true:
-  # * You wish to initialize a different View.
-  # * You have Observers to register with the View.
-  # 
-  # If you don't want to initialize a different View, call super at the beginning of your
-  # method, then register Mediator instances.
-  # 
-  # Note: This method is rarely overridden; in practice you are more likely to use a 
-  # Command to create and register Mediators with the View, since Mediator instances 
-  # will need to send Notifications and thus will likely want to fetch a reference 
-  # to the Facade during their construction. 
-  def initialize_view
-    return unless @view.nil?
-    @view = View.instance
-  end
-  
-  # Register an Command with the Controller by Notification name.
-  def register_command(name, command_class_ref)
-    @controller.register_command(name, command_class_ref)
-  end
-  
-  # Remove a previously registered Command to Notification mapping from the Controller.
-  def remove_command(notification_name)
-    @controller.remove_command(notification_name)
-  end
-  
-  # Check if a Command is registered for a given Notification 
-  def has_command?(notification_name)
-    @controller.has_command?(notification_name)
-  end
-  
-  # Register a Proxy with the Model by name.
-  def register_proxy(proxy)
-    @model.register_proxy(proxy)
-  end
-  
-  # Retrieve a Proxy with the Model by name.
-  def retrieve_proxy(proxy_name)
-    @model.retrieve_proxy(proxy_name)
-  end
-  
-  # Remove an Proxy from the Model by name.
-  def remove_proxy(proxy_name)
-    proxy = @model.remove_proxy(proxy_name) unless @model.nil?
-    proxy
-  end
-  
-  # Check if a Proxy is registered
-  def has_proxy?(proxy_name)
-    @model.has_proxy?(proxy_name)
-  end
-  
-  # Register a Mediator with the View.
-  def register_mediator(mediator)
-    @view.register_mediator(mediator) unless @view.nil?
-  end
-  
-  # Retrieve a Mediator from the View.
-  def retrieve_mediator(mediator_name)
-    @view.retrieve_mediator(mediator_name)
-  end
-  
-  # Remove a Mediator from the View.
-  def remove_mediator(mediator_name)
-    mediator = @view.remove_mediator(mediator_name) unless @view.nil?
-    mediator
-  end
-  
-  # Check if a Mediator is registered or not
-  def has_mediator?(mediator_name)
-    @view.has_mediator?(mediator_name)
-  end
-  
-  # Create and send a Notification.
-  # 
-  # Keeps us from having to construct new notification 
-  # instances in our implementation code.
-  def send_notification(notification_name, body=nil, type=nil)
-    notify_observers(Notification.new(notification_name, body, type))
-  end
-  
-  # Notify Observers.
-  # 
-  # This method is left public mostly for backward compatibility, and to allow 
-  # you to send custom notification classes using the facade.
-  # 
-  # Usually you should just call send_notification and pass the parameters, 
-  # never having to construct the notification yourself.
-  def notify_observers(notification)
-    @view.notify_observers(notification) unless @view.nil?
-  end
-  
-end
-# PureMVC Port to Ruby by Jake Dempsey <jake.dempsey@puremvc.org>
-# PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
-# Your reuse is governed by the Creative Commons Attribution 3.0 License

data/src/org/puremvc/ruby/patterns/mediator/mediator.rb

@@ -1,37 +0,0 @@
-class Mediator < Notifier
-  
-  # The name of the Mediator
-  # Typically, a Mediator will be written to serve one specific control or group
-  # controls and so,will not have a need to be dynamically named.
-  attr_accessor :name
-  attr_accessor :view
-  
-  def initialize(name="Mediator", view=nil )
-    @name = name
-    @view = view
-  end
-  
-  # List the Notification names this Mediator is interested in being notified of.
-  def list_notification_interests
-    []
-  end
-  
-  # Handle Notifications.
-  # 
-  # Typically this will be handled in a switch statement, with one 'case' entry 
-  # per Notification the Mediator is interested in.
-  def handle_notification(note)
-    #override if you want to do something on this event
-  end
-
-  # Called by the View when the Mediator is registered
-  def on_register
-    #override if you want to do something on this event
-  end
-
-  # Called by the View when the Mediator is removed
-  def on_remove
-    #override if you want to do something on this event
-  end
-  
-end

data/src/org/puremvc/ruby/patterns/observer/notification.rb

@@ -1,38 +0,0 @@
-# PureMVC does not rely upon underlying event models such as the one provided with Flash.
-# 
-# The Observer Pattern as implemented within PureMVC exists to support event-driven 
-# communication between the application and the actors of the MVC triad.
-# 
-# Notifications are not meant to be a replacement for Events. Generally, Mediator 
-# implementors place event listeners on their view components, which they
-# then handle in the usual way. This may lead to the broadcast of Notifications to 
-# trigger Commands or to communicate with other Mediators. Proxy and Command
-# instances communicate with each other and Mediators by broadcasting Notifications.
-# 
-# A key difference between UI Events and PureMVC Notifications is that Events
-# follow the 'Chain of Responsibility' pattern, 'bubbling' up the display hierarchy 
-# until some parent component handles the Event, while PureMVC Notifications 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 Notifications.
-class Notification
-  
-  attr_accessor :name, :body, :type
-  
-  def initialize(name=nil, body=nil, type=nil)
-    @name = name
-    @body = body
-    @type = type
-  end
-  
-  # Get the string representation of the Notification instance.
-  def to_s
-    msg = "Notifcation Name: #{@name}"
-    msg += "\nBody: #{@body.inspect}"
-    msg += "\nType: #{@type.inspect}"
-    msg
-  end
-  
-end
-# PureMVC Port to Ruby by Jake Dempsey <jake.dempsey@puremvc.org>
-# PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
-# Your reuse is governed by the Creative Commons Attribution 3.0 License

data/src/org/puremvc/ruby/patterns/observer/notifier.rb

@@ -1,27 +0,0 @@
-# MacroCommand, Command, Mediator and Proxy all have a need to send Notifications.
-# 
-# The Notifier provides a common method called send_notification that relieves 
-# implementation code of the necessity to actually construct Notifications.
-# 
-# The Notifier class, which all of the above mentioned classes extend, provides 
-# an initialized reference to the Facade Singleton, which is required for the 
-# convienience method for sending Notifications, but also eases implementation 
-# as these classes have frequent Facade interactions and usually require access
-# to the facade anyway.
-class Notifier
-
-  # Create and send an Notification.
-  #
-  # Keeps us from having to construct new Notification instances in our implementation code.
-  def send_notification(notification_name, body=nil, type=nil)
-    facade.send_notification(notification_name, body, type)
-  end
-  
-  # Local reference to the Facade Singleton
-  def facade
-    Facade.instance
-  end
-end
-# PureMVC Port to Ruby by Jake Dempsey <jake.dempsey@puremvc.org>
-# PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
-# Your reuse is governed by the Creative Commons Attribution 3.0 License

data/src/org/puremvc/ruby/patterns/observer/observer.rb

@@ -1,31 +0,0 @@
-# An Observer is an object that encapsulates information about an interested object 
-# with a method that should be called when a particular Notification is broadcast.
-# 
-# In PureMVC, the Observer class assumes these responsibilities:
-# * Encapsulate the notification (callback) method of the interested object.
-# * Encapsulate the notification context (this) of the interested object.
-# * Provide methods for setting the notification method and context.
-# * Provide a method for notifying the interested object.
-class Observer
-  attr_accessor :notify, :context
-  
-  # The notification method on the interested object should take 
-  # one parameter of type Notification
-  def initialize(notify=nil, context=nil)
-    @notify = notify
-    @context = context
-  end
-  
-  # Notify the interested object.
-  def notify_observer(notification)
-    @context.send(@notify, notification)
-  end
-  
-  # Compare an object to the notification context.
-  def compare_notify_context(object)
-    @context.equal?(object)
-  end
-end
-# PureMVC Port to Ruby by Jake Dempsey <jake.dempsey@puremvc.org>
-# PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
-# Your reuse is governed by the Creative Commons Attribution 3.0 License

data/src/org/puremvc/ruby/patterns/proxy/proxy.rb

@@ -1,32 +0,0 @@
-# In PureMVC, Proxy classes are used to manage parts of the application's data model.
-# 
-# A Proxy 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.
-# 
-# Proxy 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 Proxy and listening for a 
-# Notification to be sent when the Proxy has retrieved the data from the service.
-class Proxy
-  
-  attr_accessor :name, :data
-  def initialize(proxy_name, data=nil)
-    @name = proxy_name
-    @data = data
-  end
-  
-  # Called by the Model when the Proxy is registered
-  def on_register
-    #override if you want to do something on this event
-  end
-
-  # Called by the Model when the Proxy is removed
-  def on_remove
-    #override if you want to do something on this event
-  end
-
-end
-# PureMVC Port to Ruby by Jake Dempsey <jake.dempsey@puremvc.org>
-# PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
-# Your reuse is governed by the Creative Commons Attribution 3.0 License

data/version.txt

@@ -1,12 +0,0 @@
-PureMVC Port to Ruby by Jake Dempsey <jake.dempsey@puremvc.org>
-PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
---------------------------------------------------------------------------
-Release Date: 1/14/09
-    Platform: Ruby 
-     Version: 1 
-    Revision: 0
-     Authors: Jake Dempsey <jake.dempsey@puremvc.org>
-     License: Creative Commons Attribution 3.0 Unported License
---------------------------------------------------------------------------
-
-1.0 - Initial upload of ported code, equivalent to AS3 Standard Version 2.0.4.