puremvc 1.0.0 → 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 66bcb05b4710e85999ef1b4d7e223e3269a94b9acc9ef256a046069cf7bc6402
+  data.tar.gz: eac762df289443442fc67ac7a5d54992f5ea73406fb9916d2909a984f98e2c13
+SHA512:
+  metadata.gz: 718373aa1bf508d2ebfd0bf575abb396741c30a4eebd62dfd87deef35cb2678f9fe460927019962e10f2872a3e672ce3469e124c038d71b829a17f295757c4df
+  data.tar.gz: 3e748babb7ac73b47b8e60f354300d11af2dac7ff4bf57c06f8598c0ff11111e1a156e53b8ec7d2374eb3d8b67dcfa807907278ac8ca04bfbed732cff4aaac26

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.0.1] - 2025-08-14
+### Changed
+- Bumped version to 1.0.1 to allow Multicore override after initial 1.0.0 standard release on rubygems.org
+
+## [1.0.0] - 2025-08-14
+### Added
+- Initial release of the framework

data/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Saad Shams <saad.shams@puremvc.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,88 @@
+## [PureMVC](http://puremvc.github.com/) Ruby MultiCore Framework [![Ruby](https://github.com/PureMVC/puremvc-ruby-multicore-framework/actions/workflows/ruby.yml/badge.svg)](https://github.com/PureMVC/puremvc-ruby-multicore-framework/actions/workflows/ruby.yml)
+
+PureMVC is a lightweight framework for creating applications based upon the classic [Model-View-Controller](http://en.wikipedia.org/wiki/Model-view-controller) design meta-pattern. It supports [modular programming](http://en.wikipedia.org/wiki/Modular_programming) through the use of [Multiton](http://en.wikipedia.org/wiki/Multiton) Core actors instead of the [Singletons](http://en.wikipedia.org/wiki/Singleton_pattern) used in the [Standard](https://github.com/PureMVC/puremvc-ruby-standard-framework/wiki) Version.
+
+* [Ruby Gem](https://rubygems.org/gems/puremvc)
+* [API Docs](http://puremvc.org/pages/docs/Ruby/multicore/)
+
+## Installation
+```shell
+gem install puremvc
+```
+
+## Platforms / Technologies
+* [Ruby](https://en.wikipedia.org/wiki/Ruby_(programming_language))
+* [Command-line interface](https://en.wikipedia.org/wiki/Command-line_interface)
+* [Cross-platform software](https://en.wikipedia.org/wiki/Cross-platform_software)
+
+---
+## Development
+
+### Install Dependencies
+```shell
+bundle install
+```
+
+### Lint Code
+```shell
+bundle exec rubocop
+```
+
+### Generate RBS Signatures
+```shell
+rbs prototype rb lib/**/*.rb --out-dir=sig
+```
+
+### Run Type Checking
+```shell
+steep check
+```
+
+### Test
+```shell
+ruby -Itest -e 'Dir["test/**/*_test.rb"].each { |file| require_relative file }'
+RubyMine: Test file name mask: **/{*_test,test_*,*_spec}.rb
+```
+
+### Generate Documentation
+```shell
+yard doc lib/**/*.rb --protected --private
+open doc/index.html
+```
+
+#### Publish
+##### 1. Setup RubyGems API Key
+```shell
+mkdir -p ~/.gem
+cat > ~/.gem/credentials <<EOF
+---
+:rubygems_api_key: API_KEY
+EOF
+chmod 0600 ~/.gem/credentials
+```
+##### 2. Build the gem
+```shell
+gem build puremvc.gemspec
+gem push puremvc-1.0.0.gem
+```
+
+## Reference
+* [Ruby](https://www.ruby-lang.org/en)
+* [RBS](https://github.com/ruby/rbs)
+* [YARD: Yay! A Ruby Documentation Tool](https://rubydoc.info/gems/yard)
+
+---
+
+## License
+* PureMVC MultiCore Framework for Ruby 
+* PureMVC - Copyright © 2025 [Saad Shams](https://www.linkedin.com/in/muizz/)
+* PureMVC - Copyright © 2025 [Futurescale, Inc.](http://futurescale.com/)
+* All rights reserved.
+
+* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of Futurescale, Inc., PureMVC.org, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/core/controller.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+# typed: true
+
+# controller.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 Multiton <code>IController</code> implementation.
+  #
+  # In PureMVC, the <code>Controller</code> class follows the
+  # 'Command and Controller' strategy and assumes these responsibilities:
+  #
+  # * Remembering which <code>ICommand</code>s are intended to handle which <code>INotifications</code>.
+  # * Registering itself as an <code>IObserver</code> with the <code>View</code> for each <code>INotification</code>
+  #   that has an <code>ICommand</code> mapping.
+  # * Creating a new instance of the proper <code>ICommand</code> to handle a given <code>INotification</code>
+  #   when notified by the <code>View</code>.
+  # * Calling the <code>ICommand</code>'s <code>execute</code> method, passing in the <code>INotification</code>.
+  #
+  # Your application must register <code>ICommands</code> with the <code>Controller</code>.
+  #
+  # The simplest way is to subclass <code>Facade</code>, and use its <code>initializeController</code> method.
+  # to add your registrations.
+  #
+  # @see View
+  # @see Observer
+  # @see Notification
+  # @see SimpleCommand
+  # @see MacroCommand
+  class Controller
+    # Message Constants
+    MULTITON_MSG = 'Controller instance for this Multiton key already constructed!'
+    private_constant :MULTITON_MSG
+
+    class << self
+      # The Multiton IController instanceMap.
+      # @return [Hash{String => IController}]
+      def instance_map = (@instance_map ||= {})
+
+      # Mutex used to synchronize access to the instance map for thread safety.
+      # @return [Mutex]
+      def mutex = (@mutex ||= Mutex.new)
+
+      # Gets an instance using the provided factory block
+      #
+      # @param key [String] the unique key identifying the Multiton instance
+      # @param factory [^(String) -> _IController] the unique key passed to the factory block
+      # @return [IController] The controller instance created by the factory
+      def get_instance(key, &factory)
+        mutex.synchronize do
+          instance_map[key] ||= factory.call(key)
+        end
+      end
+
+      # Remove an IController instance
+      #
+      # @param key [String] the multiton key of the IController instance to remove
+      def remove_controller(key)
+        mutex.synchronize do
+          instance_map.delete(key)
+        end
+      end
+    end
+
+    # Constructor.
+    #
+    # This IController implementation is a Multiton, so you should not call the constructor
+    # directly. Instead, call the static factory method, passing the unique key for this instance:
+    # <code>PureMVC::Controller.getInstance(key) { |key| PureMVC::Controller.new(key) }</code>
+    #
+    # @param key [String]
+    # @raise [RuntimeError] if an instance for this Multiton key has already been constructed
+    def initialize(key)
+      raise MULTITON_MSG if self.class.instance_map[key]
+
+      self.class.instance_map[key] = self
+      # The Multiton Key for this Core
+      # @type var multiton_key: String
+      @multiton_key = key
+      # Local reference to View
+      # @type var component: _IView?
+      @view = nil
+      # Mapping of Notification names to Command factories
+      # @type var command_map: Hash[String, ^() -> _ICommand]
+      @command_map = {}
+      # Mutex used to synchronize access to the @command_map
+      # @type var command_mutex: Mutex
+      @command_mutex = Mutex.new
+      initialize_controller
+    end
+
+    # Initialize the Multiton Controller instance.
+    #
+    # Called automatically by the constructor.
+    #
+    # 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:
+    #
+    # @example
+    #   # ensure that the Controller is talking to my IView implementation
+    #   def initialize_controller
+    #     @view = MyView::get_instance(key) { |key| MyView.new(key) }
+    #   end
+    #
+    def initialize_controller
+      @view = View.get_instance(@multiton_key) { |key| View.new(key) }
+    end
+
+    # Register a particular ICommand class as the handler for a particular INotification.
+    #
+    # If an ICommand has already been registered to handle INotifications with this name,
+    # it is replaced by the new ICommand.
+    #
+    # The Observer for the new ICommand is only created if this is the first time
+    # an ICommand has been registered for this notification name.
+    #
+    # @param notification_name [String] the name of the INotification
+    # @param factory [^<() -> ICommand>] the factory to produce an instance of the ICommand
+    def register_command(notification_name, &factory)
+      @command_mutex.synchronize do
+        if @command_map[notification_name].nil?
+          @view&.register_observer(notification_name, Observer.new(method(:execute_command), self))
+        end
+        @command_map[notification_name] = factory
+      end
+    end
+
+    # If an ICommand has previously been registered to handle the given INotification, then it is executed.
+    #
+    # @param notification [INotification] the notification to handle
+    def execute_command(notification)
+      @command_mutex.synchronize do
+        # @type factory: [^() -> ICommand]?
+        factory = @command_map[notification.name]
+        return if factory.nil?
+
+        # @type var command: _ICommand
+        command = factory.call
+        command.initialize_notifier(@multiton_key)
+        command.execute(notification)
+      end
+    end
+
+    # Check if a Command is registered for a given Notification.
+    #
+    # @param notification_name [String] the name of the Notification
+    # @return [Boolean] whether a Command is currently registered for the given notification_name
+    def has_command?(notification_name)
+      @command_mutex.synchronize do
+        @command_map.key?(notification_name)
+      end
+    end
+
+    # Remove a previously registered ICommand to INotification mapping.
+    #
+    # @param notification_name [String] the name of the INotification to remove the ICommand mapping for
+    def remove_command(notification_name)
+      @command_mutex.synchronize do
+        # @type var command: [^() -> ICommand]?
+        command = @command_map[notification_name]
+
+        # if the Command is registered...
+        if command
+          # remove the observer
+          @view&.remove_observer(notification_name, self)
+          # remove the command
+          @command_map.delete(notification_name)
+        end
+      end
+    end
+  end
+end

data/lib/core/model.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+# typed: true
+
+# model.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 Multiton <code>IModel</code> implementation.
+  #
+  # In PureMVC, the <code>Model</code> class provides access to model objects (Proxies) by named lookup.
+  #
+  # The <code>Model</code> assumes these responsibilities:
+  #
+  # - Maintains a cache of <code>IProxy</code> instances.
+  # - Provides methods for registering, retrieving, and removing <code>IProxy</code> instances.
+  #
+  # Your application must register <code>IProxy</code> instances with the <code>Model</code>. Typically,
+  # an <code>ICommand</code> is used to create and register <code>IProxy</code> instances after the <code>Facade<code>
+  # has initialized the Core actors.
+  #
+  # @see Proxy
+  # @see IProxy
+  class Model
+    # Message Constants
+    MULTITON_MSG = 'Model instance for this Multiton key already constructed!'
+    private_constant :MULTITON_MSG
+
+    class << self
+      # The Multiton IModel instanceMap.
+      # @return [Hash{String => IModel}]
+      def instance_map = (@instance_map ||= {})
+
+      # Mutex used to synchronize access to the instance map for thread safety.
+      # @return [Mutex]
+      def mutex = (@mutex ||= Mutex.new)
+
+      # <code>Model</code> Multiton Factory method.
+      #
+      # @param key [String] the unique key identifying the Multiton instance
+      # @param factory [^(String) -> IModel] the unique key passed to the factory block
+      # @return [IModel] the instance for this Multiton key
+      def get_instance(key, &factory)
+        mutex.synchronize do
+          instance_map[key] ||= factory.call(key)
+        end
+      end
+
+      # Remove an IModel instance
+      #
+      # @param key [String] the multiton key of the IModel instance to remove
+      def remove_model(key)
+        mutex.synchronize do
+          instance_map.delete(key)
+        end
+      end
+    end
+
+    # Constructor.
+    #
+    # This <code>IModel</code> implementation is a Multiton,
+    # so you should not call the constructor directly, but instead call the static
+    # Multiton Factory method <code>PureMVC::Model.get_instance(key) { |key| PureMVC::Model.new(key) }</code>.
+    #
+    # @param key [String]
+    # @raise [RuntimeError] Error if an instance for this Multiton key has already been constructed.
+    def initialize(key)
+      raise MULTITON_MSG if self.class.instance_map[key]
+
+      self.class.instance_map[key] = self
+      @multiton_key = key
+      @proxy_map = {}
+      @proxy_mutex = Mutex.new
+      initialize_model
+    end
+
+    # Initialize the <code>Model</code> instance.
+    #
+    # Called automatically by the constructor, this
+    # is your opportunity to initialize the Multiton
+    # instance in your subclass without overriding the
+    # constructor.
+    def initialize_model; end
+
+    # Register an <code>IProxy</code> with the <code>Model</code>.
+    #
+    # @param proxy [_IProxy] an <code>IProxy</code> to be held by the <code>Model</code>.
+    def register_proxy(proxy)
+      proxy.initialize_notifier(@multiton_key)
+      @proxy_mutex.synchronize do
+        @proxy_map[proxy.name] = proxy
+      end
+      proxy.on_register
+    end
+
+    # Retrieve an <code>IProxy</code> from the <code>Model</code>.
+    #
+    # @param proxy_name [String] the name of the proxy to retrieve.
+    # @return [_IProxy, nil] the <code>IProxy</code> instance previously registered with the  <code>proxy_name</code>,
+    # or nil if none found.
+    def retrieve_proxy(proxy_name)
+      @proxy_mutex.synchronize do
+        @proxy_map[proxy_name]
+      end
+    end
+
+    # Check if a Proxy is registered.
+    #
+    # @param proxy_name [String] the name of the proxy to check.
+    # @return [Boolean] whether a Proxy is currently registered with the given <code>proxy_name</code>.
+    def has_proxy?(proxy_name)
+      @proxy_mutex.synchronize do
+        @proxy_map.key?(proxy_name)
+      end
+    end
+
+    # Remove an <code>IProxy</code> from the <code>Model</code>.
+    #
+    # @param proxy_name [String] name of the <code>IProxy</code> instance to be removed.
+    # @return [_IProxy, nil] the <code>IProxy</code> that was removed from the <code>Model</code>, or nil if none found.
+    def remove_proxy(proxy_name)
+      # @type var proxy: _IProxy?
+      proxy = nil
+      @proxy_mutex.synchronize do
+        proxy = @proxy_map.delete(proxy_name)
+      end
+      proxy&.on_remove
+      proxy
+    end
+  end
+end

data/lib/core/view.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+# typed: true
+
+# view.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 Multiton <code>IView</code> implementation.
+  #
+  # In PureMVC, the <code>IView</code> class assumes these responsibilities:
+  #
+  # - Maintains a cache of <code>IMediator</code>instances.
+  # - Provides methods for registering, retrieving, and removing <code>IMediators</code>.
+  # - Notifies <code>IMediators</code>when they are registered or removed.
+  # - Manages the observer lists for each <code>INotification</code>in the application.
+  # - Provides a method for attaching <code>IObservers</code>to an <code>INotification</code>'s observer list.
+  # - Provides a method for broadcasting an <code>INotification</code>.
+  # - Notifies the <code>IObservers</code>of a given <code>INotification</code>when it is broadcast.
+  #
+  # @see Mediator
+  # @see Observer
+  # @see Notification
+  class View
+    MULTITON_MSG = 'View instance for this Multiton key already constructed!'
+    private_constant :MULTITON_MSG
+
+    class << self
+      # The Multiton IModel instanceMap.
+      # @return [Hash{String => IView}]
+      def instance_map = (@instance_map ||= {})
+
+      # Mutex used to synchronize access to the instance map for thread safety.
+      # @return [Mutex]
+      def mutex = (@mutex ||= Mutex.new)
+
+      # View Multiton Factory method.
+      #
+      # @param key [String] the unique key identifying the Multiton instance
+      # @param factory [^(String) -> _IView] the unique key passed to the factory block
+      # @return [_IView] the Multiton instance of <code>View</code>
+      def get_instance(key, &factory)
+        mutex.synchronize do
+          instance_map[key] ||= factory.call(key)
+        end
+      end
+
+      # Remove an <code>IView</code> instance.
+      #
+      # @param key [String] the key of the <code>IView</code> instance to remove
+      def remove_view(key)
+        mutex.synchronize do
+          instance_map.delete(key)
+        end
+      end
+    end
+
+    # Constructor.
+    #
+    # This <code>IView</code> implementation is a Multiton,
+    # so you should not call the constructor directly. Instead, call the static
+    # Multiton factory method <code>View.get_instance(multiton_key) { |key| View.new(key) }</code>.
+    #
+    # @param key [String]
+    # @raise [RuntimeError] if an instance for this Multiton key has already been constructed.
+    def initialize(key)
+      raise MULTITON_MSG if self.class.instance_map[key]
+
+      self.class.instance_map[key] = self
+      # The Multiton Key for this Core
+      # @type var multiton_key: String
+      @multiton_key = key
+      # Mapping of Notification names to Observer lists
+      # @type var observer_map: Hash[String, Array[_IObserver]]
+      @observer_map = {}
+      # Mutex used to synchronize access to the observer_map
+      # @type var observer_mutex: Mutex
+      @observer_mutex = Mutex.new
+      # Mapping of Mediator names to Mediator instances
+      # @type var mediator_map: Hash[String, _IMediator]
+      @mediator_map = {}
+      # Mutex used to synchronize access to the mediator_map
+      # @type var mediator_mutex: Mutex
+      @mediator_mutex = Mutex.new
+      initialize_view
+    end
+
+    # Initialize the Multiton <code>View</code> instance.
+    #
+    # Called automatically by the constructor, this
+    # is your opportunity to initialize the Multiton
+    # instance in your subclass without overriding the
+    # constructor.
+    def initialize_view; end
+
+    # Register an <code>IObserver</code> to be notified
+    # of <code>INotifications</code> with a given name.
+    #
+    # @param notification_name [String] the name of the <code>INotifications</code> to notify <code>IObserver</code> of
+    # @param observer [IObserver] the <code>IObserver</code> to register
+    def register_observer(notification_name, observer)
+      @observer_mutex.synchronize do
+        observers = (@observer_map[notification_name] ||= [])
+        observers << observer
+      end
+    end
+
+    # Notify the <code>IObservers</code> for a particular <code>INotification</code>.
+    #
+    # All previously attached <code>IObservers</code> for this <code>INotification</code>'s
+    # list are notified and are passed a reference to the <code>INotification</code> in
+    # the order in which they were registered.
+    #
+    # @param notification [INotification] the <code>INotification</code> to notify <code>IObservers</code> of.
+    def notify_observers(notification)
+      # @type var observers: Array[_IObserver]?
+      observers = nil
+      @observer_mutex.synchronize do
+        # Get a reference to the observers list for this notification name
+        # Iteration safe, copy observers from reference array to working array,
+        # since the reference array may change during the notification loop
+        observers = @observer_map[notification.name].dup
+      end
+      # Notify Observers from the working array
+      observers&.each { |observer| observer.notify_observer(notification) }
+    end
+
+    # Remove the observer for a given notifyContext from an observer list for a given Notification name.
+    #
+    # @param notification_name [String] which observer list to remove from
+    # @param notify_context [Object] remove the observer with this object as its notifyContext
+    def remove_observer(notification_name, notify_context)
+      @observer_mutex.synchronize do
+        # the observer list for the notification under inspection
+        # @type var observers: Array[_IObserver]?
+        observers = @observer_map[notification_name]
+        # find and remove the sole Observer for the given notify_context
+        # there can only be one Observer for a given notify_context
+        # in any given Observer list, so remove it
+        observers&.reject! { |observer| observer.compare_notify_context?(notify_context) }
+        # Also, when a Notification's Observer list length falls to
+        # zero, delete the notification key from the observer map
+        @observer_map.delete(notification_name) if observers&.empty?
+      end
+    end
+
+    # Register an <code>IMediator</code> instance with the <code>View</code>.
+    #
+    # Registers the <code>IMediator</code> so that it can be retrieved by name,
+    # and further interrogates the <code>IMediator</code> for its
+    # <code>INotification</code> interests.
+    #
+    # If the <code>IMediator</code> returns any <code>INotification</code>
+    # names to be notified about, an <code>Observer</code> is created encapsulating
+    # the <code>IMediator</code> instance's <code>handleNotification</code> method
+    # and registering it as an <code>Observer</code> for all <code>INotifications</code> the
+    # <code>IMediator</code> is interested in.
+    #
+    # @param mediator [IMediator] a reference to the <code>IMediator</code> instance
+    def register_mediator(mediator)
+      @mediator_mutex.synchronize do
+        return if @mediator_map.key?(mediator.name)
+
+        @mediator_map[mediator.name] = mediator
+      end
+
+      mediator.initialize_notifier(@multiton_key)
+
+      # Create Observer referencing this mediator's handleNotification method
+      # @type observer [IObserver]
+      observer = Observer.new(mediator.method(:handle_notification), mediator)
+
+      # Get Notification interests, if any.
+      # @type interests [Array<String>]
+      interests = mediator.list_notification_interests
+      # Register Mediator as Observer for its list of Notification interests
+      interests.each { |interest| register_observer(interest, observer) }
+
+      # alert the mediator that it has been registered
+      mediator.on_register
+    end
+
+    # Retrieve an <code>IMediator</code> from the <code>View</code>.
+    #
+    # @param mediator_name [String] the name of the <code>IMediator</code> instance to retrieve.
+    # @return [IMediator, nil] <code>IMediator</code> previously registered with the given <code>mediatorName</code>.
+    def retrieve_mediator(mediator_name)
+      @mediator_mutex.synchronize do
+        @mediator_map[mediator_name]
+      end
+    end
+
+    # Check if a Mediator is registered or not.
+    #
+    # @param mediator_name [String] the name of the mediator to check.
+    # @return [Boolean] whether a Mediator is registered with the given <code>mediatorName</code>.
+    def has_mediator?(mediator_name)
+      @mediator_mutex.synchronize do
+        @mediator_map.key?(mediator_name)
+      end
+    end
+
+    # Remove an <code>IMediator</code> from the <code>View</code>.
+    #
+    # @param mediator_name [String] name of the <code>IMediator</code> instance to be removed.
+    # @return [IMediator, nil] <code>IMediator</code> that was removed from the <code>View</code>, or nil if none found.
+    def remove_mediator(mediator_name)
+      # @type var mediator: _IMediator?
+      mediator = nil
+      @mediator_mutex.synchronize do
+        # retrieve the named mediator and delete from the mediator map
+        mediator = @mediator_map.delete(mediator_name)
+      end
+      return unless mediator
+
+      # for every notification this mediator is interested in...
+      # @type var interests: Array[String]
+      interests = mediator.list_notification_interests
+      # remove the observer linking the mediator
+      # to the notification interest
+      interests.each { |interest| remove_observer(interest, mediator) }
+
+      # alert the mediator that it has been removed
+      mediator.on_remove
+      mediator
+    end
+  end
+end