puremvc 1.0.0 → 1.0.2

data/src/patterns/observer/notification.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# notification.rb
+# PureMVC Ruby Multicore
+#
+# Copyright(c) 2025 Saad Shams <saad.shams@puremvc.org>
+# Your reuse is governed by the BSD 3-Clause License
+
+module PureMVC
+  # A base <code>INotification</code>implementation.
+  #
+  # 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.
+  #
+  # 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
+  # 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>IMediator</code>s. <code>IProxy</code> and
+  # <code>ICommand</code> instances communicate with each other and <code>IMediator</code>s
+  # by broadcasting <code>INotification</code>s.
+  #
+  # 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 to communicate with one another
+  # using <code>Notification</code>s.
+  #
+  # @see Observer
+  class Notification
+    # @return [String] the name of the notification
+    attr_reader :name
+
+    # @return [Object, nil] the body of the notification
+    attr_accessor :body
+
+    # @return [String, nil] the type of the notification
+    attr_accessor :type
+
+    # The Notification class represents a message with a name, optional body, and optional type.
+    #
+    # @param name [String] the name of the notification
+    # @param body [Object, nil] optional data to pass with the notification
+    # @param type [String, nil] optional type identifier
+    def initialize(name, body = nil, type = nil)
+      @name = name
+      @body = body
+      @type = type
+    end
+
+    # Returns a string representation of the notification.
+    #
+    # @return [String]
+    def to_s
+      "Notification Name: #{@name}" \
+        "\nBody: #{@body.inspect}" \
+        "\nType: #{@type}"
+    end
+  end
+end

data/src/patterns/observer/notifier.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# notifier.rb
+# PureMVC Ruby Multicore
+#
+# Copyright(c) 2025 Saad Shams <saad.shams@puremvc.org>
+# Your reuse is governed by the BSD 3-Clause License
+
+module PureMVC
+  # A base <code>INotifier</code> implementation.
+  #
+  # <code>MacroCommand</code>, <code>SimpleCommand</code>, <code>Mediator</code>, and <code>Proxy</code>
+  # all need to send <code>Notification</code>s.
+  #
+  # The <code>INotifier</code> interface provides a common method called
+  # <code>send_notification</code> that relieves implementation code of
+  # the necessity to actually construct <code>Notification</code>s.
+  #
+  # The <code>Notifier</code> class, which all the above-mentioned classes
+  # extend, provides an initialized reference to the <code>Facade</code>
+  # Multiton, which is required for the convenience method
+  # for sending <code>Notification</code>s. It also eases implementation,
+  # as these classes have frequent <code>Facade</code> interactions and
+  # usually require access to it anyway.
+  #
+  # NOTE: In the MultiCore version of the framework, there is one caveat:
+  # notifiers cannot send notifications or reach the facade until they
+  # have a valid <code>multiton_key</code>.
+  #
+  # The <code>multiton_key</code> is set:
+  # * on a <code>SimpleCommand</code> when it is executed by the <code>Controller<c/ode>
+  # * on a <code>Mediator</code> when registered with the <code>View</code>
+  # * on a <code>Proxy</code> when registered with the <code>Model</code>
+  #
+  # @see Proxy
+  # @see Facade
+  # @see Mediator
+  # @see MacroCommand
+  # @see SimpleCommand
+  class Notifier
+    # Message Constants
+    MULTITON_MSG = 'multitonKey for this Notifier not yet initialized!'
+    private_constant :MULTITON_MSG
+
+    # @attr_reader [String] The Multiton Key for this app
+    attr_reader :multiton_key
+
+    # Initialize this INotifier instance.
+    #
+    # This is how a Notifier receives its <code>multiton_key</code>.
+    # Any calls to <code>send_notification</code> or attempts to access the <code>facade</code>
+    # will fail until this method has been called.
+    #
+    # Subclasses such as <code>Mediator</code>, <code>Command</code>, or <code>Proxy</code> may override this
+    # method if they need to send notifications or access the <code>Facade</code> instance
+    # as early as possible. However, note that the <code>Facade</code> cannot be accessed
+    # within the constructor of these classes, because <code>initialize_notifier</code>
+    # will not yet have been called at that point.
+    #
+    # @param key [String] the <code>multiton_key</code> this <code>INotifier</code> will use
+    def initialize_notifier(key)
+      @multiton_key = key
+    end
+
+    # Create and send an INotification.
+    #
+    # This method eliminates the need to manually construct
+    # INotification instances in your implementation code.
+    #
+    # @param name [String] the name of the notification
+    # @param body [Object, nil] optional body
+    # @param type [String, nil] optional type
+    def send_notification(name, body = nil, type = nil)
+      facade.send_notification(name, body, type)
+    end
+
+    # Return the Multiton Facade instance
+    #
+    # @raise [RuntimeError] if the <code>multiton_key</code> is not set
+    # @return [IFacade] the facade instance for the notifier's key
+    def facade
+      raise MULTITON_MSG if @multiton_key.nil?
+
+      Facade.get_instance(@multiton_key) { |key| Facade.new(key) }
+    end
+  end
+end

data/src/patterns/observer/observer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# observer.rb
+# PureMVC Ruby Multicore
+#
+# Copyright(c) 2025 Saad Shams <saad.shams@puremvc.org>
+# Your reuse is governed by the BSD 3-Clause License
+
+module PureMVC
+  # A base <code>IObserver</code> implementation.
+  #
+  # 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.
+  #
+  # In PureMVC, the <code>Observer</code> class assumes these responsibilities:
+  # - Encapsulate the notification (callback) method of the interested object.
+  # - Encapsulate the notification context (<code>self</code>) of the interested object.
+  # - Provide methods for setting the notification method and context.
+  # - Provide a method for notifying the interested object.
+  #
+  # @see View
+  # @see Notification
+  class Observer
+    # @return [Method | nil] notify The callback method to be called on notification.
+    attr_accessor :notify
+
+    # @return [Object | nil] context The object context for the callback.
+    attr_accessor :context
+
+    # Initialize an Observer with a notify method and context.
+    #
+    # @param notify [Method, nil] the callback method to invoke on notification.
+    # @param context [Object, nil] the object context for the callback.
+    def initialize(notify = nil, context = nil)
+      @notify = notify
+      @context = context
+    end
+
+    # Calls the notify method with the given notification.
+    #
+    # @param notification [INotification] the notification to send.
+    def notify_observer(notification)
+      @notify&.call(notification)
+    end
+
+    # Compares the given object with the Observer's context.
+    #
+    # @param object [Object] the object to compare.
+    # @return [Boolean] true if the given object is the same as the context.
+    def compare_notify_context?(object)
+      object.equal?(@context)
+    end
+  end
+end

data/src/patterns/proxy/proxy.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# proxy.rb
+# PureMVC Ruby Multicore
+#
+# Copyright(c) 2025 Saad Shams <saad.shams@puremvc.org>
+# Your reuse is governed by the BSD 3-Clause License
+
+module PureMVC
+  # A base <code>IProxy</code> implementation.
+  #
+  # In PureMVC, <code>Proxy</code> classes are used to manage parts of the application's data model.
+  #
+  # 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 a synchronous fashion.
+  #
+  # <code>Proxy</code> classes are also used to encapsulate the application's interaction with
+  # remote services to save or retrieve data. In this case, we adopt an asynchronous 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.
+  #
+  # @see Model
+  class Proxy < Notifier
+    # The name of the <code>Proxy</code>.
+    NAME = 'Proxy'
+    public_constant :NAME
+
+    # @return [String] The proxy name
+    attr_reader :name
+
+    # @return [Object, nil] The data managed by the proxy
+    attr_accessor :data
+
+    # Initializes a new Proxy instance.
+    #
+    # @param [String, nil] name the name of the proxy
+    # @param [Object, nil] data optional data to be managed by the proxy
+    def initialize(name = nil, data = nil)
+      super()
+      @name = name || NAME
+      @data = data
+    end
+
+    # Called by the Model when the Proxy is registered
+    def on_register; end
+
+    # Called by the Model when the Proxy is removed
+    def on_remove; end
+  end
+end

data/src/puremvc.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# puremvc.rb
+# PureMVC Ruby Multicore
+#
+# Copyright(c) 2025 Saad Shams <saad.shams@puremvc.org>
+# Your reuse is governed by the BSD 3-Clause License
+
+require_relative 'core/controller'
+require_relative 'core/model'
+require_relative 'core/view'
+require_relative 'patterns/observer/notifier'
+require_relative 'patterns/command/simple_command'
+require_relative 'patterns/command/macro_command'
+require_relative 'patterns/facade/facade'
+require_relative 'patterns/mediator/mediator'
+require_relative 'patterns/observer/notification'
+require_relative 'patterns/observer/observer'
+require_relative 'patterns/proxy/proxy'

metadata

@@ -1,68 +1,83 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: puremvc
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 1.0.0
+version: !ruby/object:Gem::Version
+  version: 1.0.2
 platform: ruby
-authors: 
-- Jake Dempsey
-autorequire: 
+authors:
+- Saad Shams
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2011-07-27 00:00:00 -03:00
-default_executable: 
+date: 2025-08-14 00:00:00.000000000 Z
 dependencies: []
-
-description: 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.
-email: jake.dempsey@puremvc.org
+description: PureMVC is a lightweight framework for Model-View-Controller app development.
+email:
+- saad.shams@puremvc.org
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- version.txt
-files: 
-- 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/command/macro_command.rb
-- src/org/puremvc/ruby/patterns/command/simple_command.rb
-- src/org/puremvc/ruby/patterns/facade/facade.rb
-- src/org/puremvc/ruby/patterns/mediator/mediator.rb
-- 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/proxy.rb
-- puremvc.rb
-- version.txt
-has_rdoc: true
-homepage: http://trac.puremvc.org/PureMVC_Ruby/
-licenses: []
-
-post_install_message: 
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- sig/core/controller.rbs
+- sig/core/model.rbs
+- sig/core/view.rbs
+- sig/interfaces/i_command.rbs
+- sig/interfaces/i_controller.rbs
+- sig/interfaces/i_facade.rbs
+- sig/interfaces/i_mediator.rbs
+- sig/interfaces/i_model.rbs
+- sig/interfaces/i_notification.rbs
+- sig/interfaces/i_notifier.rbs
+- sig/interfaces/i_observer.rbs
+- sig/interfaces/i_proxy.rbs
+- sig/interfaces/i_view.rbs
+- sig/patterns/command/macro_command.rbs
+- sig/patterns/command/simple_command.rbs
+- sig/patterns/facade/facade.rbs
+- sig/patterns/mediator/mediator.rbs
+- sig/patterns/observer/notification.rbs
+- sig/patterns/observer/notifier.rbs
+- sig/patterns/observer/observer.rbs
+- sig/patterns/proxy/proxy.rbs
+- src/core/controller.rb
+- src/core/model.rb
+- src/core/view.rb
+- src/patterns/command/macro_command.rb
+- src/patterns/command/simple_command.rb
+- src/patterns/facade/facade.rb
+- src/patterns/mediator/mediator.rb
+- src/patterns/observer/notification.rb
+- src/patterns/observer/notifier.rb
+- src/patterns/observer/observer.rb
+- src/patterns/proxy/proxy.rb
+- src/puremvc.rb
+homepage: https://github.com/puremvc/puremvc-ruby-multicore-framework
+licenses:
+- BSD-3-Clause
+metadata:
+  steep_types: sig
+  github_repo: https://github.com/puremvc/puremvc-ruby-multicore-framework
+  source_code_uri: https://github.com/puremvc/puremvc-ruby-multicore-framework
+  bug_tracker_uri: https://github.com/puremvc/puremvc-ruby-multicore-framework/issues
+post_install_message:
 rdoc_options: []
-
-require_paths: 
-- .
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+require_paths:
+- src
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.6.2
-signing_key: 
-specification_version: 3
-summary: Lightweight Framework for applications based upon the classic Model-View-Controller design meta-pattern.
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: PureMVC Multicore Framework
 test_files: []
-

data/puremvc.rb

@@ -1,13 +0,0 @@
-$:.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

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

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