puremvc-ruby 1.0.0

data/puremvc-ruby.rb

@@ -0,0 +1,13 @@
+$:.unshift File.join(File.dirname(__FILE__), 'src/org/puremvc/ruby')
+require 'singleton'
+require 'patterns/facade/facade'
+require 'patterns/proxy/proxy'
+require 'patterns/observer/observer'
+require 'patterns/observer/notification'
+require 'patterns/observer/notifier'
+require 'patterns/mediator/mediator'
+require 'patterns/command/macro_command'
+require 'patterns/command/simple_command'
+require 'core/controller'
+require 'core/model'
+require 'core/view'

data/src/org/puremvc/ruby/core/controller.rb

@@ -0,0 +1,76 @@
+# In PureMVC, the Controller class assumes these responsibilities:
+# * Remembering which Command is intended to handle which Notification.
+# * Registering itself as an Observer with the View for each Notification that it has an Command mapping for.
+# * Creating instances of the proper Command to handle a given Notification when notified by the View.
+# * Calling the Command's execute method, passing in the Notification. 
+#  
+# Your application must register any Commands with the Controller.
+#
+# The simplest way is to subclass Facade, and use its initializeController method to add your registrations. 
+# 
+# * Command refers to SimpleCommand or MacroCommand
+
+
+class Controller
+  attr_accessor :command_map, :view
+  
+  include Singleton
+  
+  # This Controller implementation is a Singleton, 
+  # so you can not call the constructor 
+  # directly, but instead call the static Singleton 
+  # Factory method Controller.instance
+  def initialize
+    @command_map = {}
+    initialize_controller
+  end
+
+  # Initialize the Singleton Controller instance.
+  #
+  # Called Automatically by the construcor.
+  #
+  # Note that if you are using a subclass of View in your application, you should also
+  # subclass Controller and override the initialize_controller method in the following way:
+  #
+  # <tt>
+  #   def initialize_controller
+  #      @view = MyView.instance
+  #   end
+  # </tt>
+  def initialize_controller
+    @view = View.instance
+  end
+  
+   # If a Command has previously been registered to handle a given Notification, then it is executed
+  def execute_command(notification)
+    return unless @command_map[notification.name]
+    @command_map[notification.name].new().execute(notification)
+  end
+  
+  
+  # Register a particular Command class as the handler for a particular Notification.
+  #
+  # If a Command has already been registered to handle Notification's with this name, it is 
+  # no longer user, the new Command is used instead.
+  # 
+  # The Observer for the new Command is only created if this is the first time a Command
+  # has been registered for this Notification name.
+  def register_command(notification_name, command_class)
+    @view.register_observer( notification_name, Observer.new(:execute_command, self) );
+    @command_map[notification_name] = command_class
+  end
+  
+  # Check if a command is registered for a given Notification
+  def has_command?(notification_name)
+    !@command_map[notification_name].nil?
+  end
+  
+  # Remove a previously registered Command for a given Notification
+  def remove_command(notification_name)
+    @view.remove_observer(notification_name, self)
+    @command_map.delete(notification_name)
+  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/core/model.rb

@@ -0,0 +1,57 @@
+# In PureMVC, the Model class provides access to model objects (Proxies) by named lookup. 
+# 
+# The Model assumes these responsibilities:
+#  * Maintain a cache of Proxy instances.
+#  * Provide methods for registering, retrieving, and removing Proxy instances.
+# 
+# Your application must register Proxy instances with the Model. 
+# Typically, you use an Command to create and register Proxy
+# instances once the Facade has initialized the Core actors.
+
+class Model
+  
+  include Singleton
+  attr_accessor :proxy_map
+
+  
+  # This Model implementation is a Singleton, so you can not call the constructor 
+  # directly, but instead call the static Singleton Factory method Model.instance
+  def initialize
+    @proxy_map = {}
+    initialize_model
+  end
+  
+  
+  # Initialize the Singleton Model instance.
+  # 
+  # Called automatically by the constructor, this is your opportunity to initialize the Singleton
+  # instance in your subclass without overriding the constructor.
+  def initialize_model
+  end
+  
+  # Register a Proxy with the Model.
+  def register_proxy(proxy)
+    @proxy_map[proxy.name] = proxy
+    proxy.on_register
+  end
+  
+  # Retrieve a Proxy from the Model
+  def retrieve_proxy(proxy_name)
+    @proxy_map[proxy_name]
+  end
+  
+  # Check if a Proxy is registered.
+  def has_proxy?(proxy_name)
+    !@proxy_map[proxy_name].nil?
+  end
+  
+  # Remove a Proxy from teh Model.
+  def remove_proxy(proxy_name)
+    proxy = @proxy_map.delete(proxy_name)
+    proxy.on_remove
+    proxy
+  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/core/view.rb

@@ -0,0 +1,112 @@
+# In PureMVC, the View class assumes these responsibilities:
+# 
+# * Maintain a cache of IMediator instances.
+# * Provide methods for registering, retrieving, and removing Mediators.
+# * Notifiying Mediators when they are registered or removed.
+# * Managing the observer lists for each Notification in the application.
+# * Providing a method for attaching Observers to an Notification's observer list.
+# * Providing a method for broadcasting an Notification.
+# * Notifying the Observers of a given Notification when it broadcast.
+class View
+  include Singleton
+  
+  attr_accessor :mediator_map, :observer_map
+  
+  
+  # This View implementation is a Singleton, so you should not call the constructor 
+  # directly, but instead call the static Singleton Factory method View.instance.
+  def initialize
+    @mediator_map = {}
+    @observer_map = {}
+    initialize_view
+  end
+  
+  # Initialize the Singleton View instance.
+  # 
+  # Called automatically by the constructor, this is your opportunity to initialize 
+  # the Singleton instance in your subclass without overriding the constructor
+  def initialize_view
+  end
+  
+  # Register an Observer to be notified of Notifications with a given name.
+  def register_observer(notification_name, observer)
+    observers = @observer_map[notification_name]
+    if observers.nil?
+      @observer_map[notification_name] = observer
+    else
+      observers = Array(@observer_map[notification_name])
+      observers << observer
+      @observer_map[notification_name] = observers
+    end
+  end
+  
+  # Notify the Observers for a particular Notification.
+  #
+  # All previously attached Observers for this Notification's list are notified
+  # and are passed a reference to the Notification in the order in which they were registered.
+  def notify_observers(notification)
+    observers = Array(@observer_map[notification.name])
+    observers.each{|observer| observer.notify_observer(notification)}
+  end
+  
+  # Remove the observer for a given notify context from an observer list for a given 
+  # Notification name.
+  def remove_observer(notification_name, observer)
+    observers = @observer_map[notification_name]
+    observers = [observers] unless observers.is_a?(Array)
+    @observer_map[notification_name] = observers.reject { |o| o.compare_notify_context(observer) }
+    @observer_map.delete(notification_name) if observers.size.zero?
+  end
+  
+  # Register a Mediator instance with the View.
+  # 
+  # Registers the Mediator so that it can be retrieved by name and further interrogates
+  # the mediator for its Notification interests.
+  #
+  # If the mediator returns any Notifiation name to be notified about, an Observer is created
+  # encapsulating the Mediator instance's handle_notification method and registering it as an
+  # Observer for all Notifications the Mediator is interested in.
+  def register_mediator(mediator)
+    unless @mediator_map[mediator.name]
+      @mediator_map[mediator.name] = mediator
+      observer = Observer.new(:handle_notification, mediator)
+      mediator.list_notification_interests.each do |interest|
+        register_observer(interest, observer)
+      end
+      mediator.on_register
+    end
+  end
+  
+  # Retrieve a mediator from the View.
+  #
+  # returns the previously registered Mediator with the given name.
+  def retrieve_mediator(mediator_name)
+    @mediator_map[mediator_name]
+  end
+  
+  # Remove a Mediator from the View.
+  #
+  # returns the Mediator that was removed.
+  def remove_mediator(mediator_name)
+    mediator = @mediator_map[mediator_name]
+    if mediator
+      mediator.list_notification_interests.each do |interest|
+        remove_observer(interest, mediator)
+      end
+      @mediator_map.delete(mediator_name)
+      mediator.on_remove
+    end
+    mediator
+  end
+  
+  # Check if a Mediator is registered or not.
+  #
+  # returns whether a Mediator is registered with the given name.
+  def has_mediator?(mediator_name)
+    !@mediator_map[mediator_name].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/command/macro_command.rb

@@ -0,0 +1,59 @@
+# 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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,161 @@
+# 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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,32 @@
+# 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

@@ -0,0 +1,12 @@
+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.

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: puremvc-ruby
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jake Dempsey
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-23 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: 
+email: jake.dempsey@puremvc.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- version.txt
+files: 
+- src/org
+- src/org/puremvc
+- src/org/puremvc/ruby
+- src/org/puremvc/ruby/core
+- src/org/puremvc/ruby/core/controller.rb
+- src/org/puremvc/ruby/core/model.rb
+- src/org/puremvc/ruby/core/view.rb
+- src/org/puremvc/ruby/patterns
+- src/org/puremvc/ruby/patterns/command
+- src/org/puremvc/ruby/patterns/command/macro_command.rb
+- src/org/puremvc/ruby/patterns/command/simple_command.rb
+- src/org/puremvc/ruby/patterns/facade
+- src/org/puremvc/ruby/patterns/facade/facade.rb
+- src/org/puremvc/ruby/patterns/mediator
+- src/org/puremvc/ruby/patterns/mediator/mediator.rb
+- src/org/puremvc/ruby/patterns/observer
+- src/org/puremvc/ruby/patterns/observer/notification.rb
+- src/org/puremvc/ruby/patterns/observer/notifier.rb
+- src/org/puremvc/ruby/patterns/observer/observer.rb
+- src/org/puremvc/ruby/patterns/proxy
+- src/org/puremvc/ruby/patterns/proxy/proxy.rb
+- puremvc-ruby.rb
+- version.txt
+has_rdoc: true
+homepage: http://trac.puremvc.org/PureMVC_Ruby/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: PureMVC is a lightweight framework for creating applications based upon the classic Model-View-Controller design meta-pattern. This is the specific implementation for the Ruby language based on the Standard Version AS3 reference.
+test_files: []
+