The Observer pattern (also known as publish/subscribe) provides a simple mechanism for one object to inform a set of interested third-party objects when its state changes.


The notifying class mixes in the Observable module, which provides the methods for managing the associated observer objects.

The observable object must:

  • assert that it has #changed

  • call #notify_observers

An observer subscribes to updates using Observable#add_observer, which also specifies the method called via notify_observers. The default method for notify_observers is update.


The following example demonstrates this nicely. A Ticker, when run, continually receives the stock Price for its @symbol. A Warner is a general observer of the price, and two warners are demonstrated, a WarnLow and a WarnHigh, which print a warning if the price is below or above their set limits, respectively.

The update callback allows the warners to run without being explicitly called. The system is set up with the Ticker and several observers, and the observers do their duty without the top-level code having to interfere.

Note that the contract between publisher and subscriber (observable and observer) is not declared or enforced. The Ticker publishes a time and a price, and the warners receive that. But if you don’t ensure that your contracts are correct, nothing else can warn you.

require "observer"

class Ticker          ### Periodically fetch a stock price.
  include Observable

  def initialize(symbol)
    @symbol = symbol

  def run
    last_price = nil
    loop do
      price = Price.fetch(@symbol)
      print "Current price: #{price}\n"
      if price != last_price
        changed                 # notify observers
        last_price = price
        notify_observers(, price)
      sleep 1

class Price           ### A mock class to fetch a stock price (60 - 140).
  def self.fetch(symbol)
    60 + rand(80)

class Warner          ### An abstract observer of Ticker objects.
  def initialize(ticker, limit)
    @limit = limit

class WarnLow < Warner
  def update(time, price)       # callback for observer
    if price < @limit
      print "--- #{time.to_s}: Price below #@limit: #{price}\n"

class WarnHigh < Warner
  def update(time, price)       # callback for observer
    if price > @limit
      print "+++ #{time.to_s}: Price above #@limit: #{price}\n"

ticker ="MSFT"), 80), 120)


Current price: 83
Current price: 75
--- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 75
Current price: 90
Current price: 134
+++ Sun Jun 09 00:10:25 CDT 2002: Price above 120: 134
Current price: 134
Current price: 112
Current price: 79
--- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 79

Usage with procs

The #notify_observers method can also be used with +proc+s by using the :call as func parameter.

The following example illustrates the use of a lambda:

require 'observer'

class Ticker
  include Observable

  def run
    # logic to retrieve the price (here 77.0)

ticker =
warner = ->(price) { puts "New price received: #{price}" }
ticker.add_observer(warner, :call)
No documentation available
Instance Methods

Add observer as an observer on this object. So that it will receive notifications.


the object that will be notified of changes.


Symbol naming the method that will be called when this Observable has changes.

This method must return true for observer.respond_to? and will receive *arg when notify_observers is called, where *arg is the value passed to notify_observers by this Observable

Set the changed state of this object. Notifications will be sent only if the changed state is true.


Boolean indicating the changed state of this Observable.

Returns true if this object’s state has been changed since the last notify_observers call.

Return the number of observers associated with this object.

Remove observer as an observer on this object so that it will no longer receive notifications.


An observer of this Observable

Remove all observers associated with this object.

Notify observers of a change in state if this object’s changed state is true.

This will invoke the method named in add_observer, passing *arg. The changed state is then set to false.


Any arguments to pass to the observers.