File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby33/share/ruby

ðŸ“ ..
ðŸ“„ English.rb(5.54 KB)
ðŸ“„ abbrev.rb(3.47 KB)
ðŸ“„ base64.rb(13.22 KB)
ðŸ“„ benchmark.rb(18.42 KB)
ðŸ“ bigdecimal
ðŸ“„ bigdecimal.rb(130 B)
ðŸ“„ bundled_gems.rb(6.86 KB)
ðŸ“ cgi
ðŸ“„ cgi.rb(9.83 KB)
ðŸ“„ coverage.rb(368 B)
ðŸ“ csv
ðŸ“„ csv.rb(92.46 KB)
ðŸ“„ date.rb(1.17 KB)
ðŸ“„ delegate.rb(11.68 KB)
ðŸ“ did_you_mean
ðŸ“„ did_you_mean.rb(5.36 KB)
ðŸ“ digest
ðŸ“„ digest.rb(3.3 KB)
ðŸ“ drb
ðŸ“„ drb.rb(50 B)
ðŸ“ erb
ðŸ“„ erb.rb(14.53 KB)
ðŸ“ error_highlight
ðŸ“„ error_highlight.rb(84 B)
ðŸ“„ expect.rb(2.19 KB)
ðŸ“ fiddle
ðŸ“„ fiddle.rb(2.88 KB)
ðŸ“„ fileutils.rb(78.69 KB)
ðŸ“„ find.rb(2.52 KB)
ðŸ“ forwardable
ðŸ“„ forwardable.rb(9.03 KB)
ðŸ“„ getoptlong.rb(20.26 KB)
ðŸ“ io
ðŸ“„ ipaddr.rb(20.93 KB)
ðŸ“ json
ðŸ“„ json.rb(19.62 KB)
ðŸ“„ kconv.rb(5.72 KB)
ðŸ“ logger
ðŸ“„ logger.rb(22.03 KB)
ðŸ“„ mkmf.rb(88.69 KB)
ðŸ“„ monitor.rb(6.75 KB)
ðŸ“„ mutex_m.rb(2.36 KB)
ðŸ“ net
ðŸ“ objspace
ðŸ“„ objspace.rb(4.14 KB)
ðŸ“„ observer.rb(6.38 KB)
ðŸ“„ open-uri.rb(25.84 KB)
ðŸ“ open3
ðŸ“„ open3.rb(47.51 KB)
ðŸ“ openssl
ðŸ“„ openssl.rb(1.03 KB)
ðŸ“„ optionparser.rb(59 B)
ðŸ“ optparse
ðŸ“„ optparse.rb(61.82 KB)
ðŸ“„ ostruct.rb(14.22 KB)
ðŸ“„ pathname.rb(16.85 KB)
ðŸ“„ pp.rb(17.24 KB)
ðŸ“„ prettyprint.rb(15.93 KB)
ðŸ“ prism
ðŸ“„ prism.rb(3.17 KB)
ðŸ“„ pstore.rb(20.36 KB)
ðŸ“ psych
ðŸ“„ psych.rb(24.44 KB)
ðŸ“ random
ðŸ“„ readline.rb(215 B)
ðŸ“ reline
ðŸ“„ reline.rb(14.7 KB)
ðŸ“„ resolv-replace.rb(1.76 KB)
ðŸ“„ resolv.rb(85.03 KB)
ðŸ“ rinda
ðŸ“ ripper
ðŸ“„ ripper.rb(2.44 KB)
ðŸ“ ruby_vm
ðŸ“„ securerandom.rb(2.06 KB)
ðŸ“ set
ðŸ“„ set.rb(24.94 KB)
ðŸ“„ shellwords.rb(7.11 KB)
ðŸ“„ singleton.rb(3.94 KB)
ðŸ“„ socket.rb(44.04 KB)
ðŸ“ syntax_suggest
ðŸ“„ syntax_suggest.rb(74 B)
ðŸ“ syslog
ðŸ“„ tempfile.rb(14.73 KB)
ðŸ“„ time.rb(23.74 KB)
ðŸ“„ timeout.rb(5.69 KB)
ðŸ“„ tmpdir.rb(4.93 KB)
ðŸ“„ tsort.rb(14.29 KB)
ðŸ“„ un.rb(11.17 KB)
ðŸ“ unicode_normalize
ðŸ“ uri
ðŸ“„ uri.rb(3.06 KB)
ðŸ“ vendor_ruby
ðŸ“„ weakref.rb(1.36 KB)
ðŸ“ yaml
ðŸ“„ yaml.rb(2.13 KB)

Editing: observer.rb

# frozen_string_literal: true
#
# Implementation of the _Observer_ object-oriented design pattern.  The
# following documentation is copied, with modifications, from "Programming
# Ruby", by Hunt and Thomas; http://www.ruby-doc.org/docs/ProgrammingRuby/html/lib_patterns.html.
#
# See Observable for more info.

# 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.
#
# == Mechanism
#
# 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.
#
# === Example
#
# The following example demonstrates this nicely.  A +Ticker+, when run,
# continually receives the stock +Price+ for its <tt>@symbol</tt>.  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
#     end
#
#     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(Time.now, price)
#         end
#         sleep 1
#       end
#     end
#   end
#
#   class Price           ### A mock class to fetch a stock price (60 - 140).
#     def self.fetch(symbol)
#       60 + rand(80)
#     end
#   end
#
#   class Warner          ### An abstract observer of Ticker objects.
#     def initialize(ticker, limit)
#       @limit = limit
#       ticker.add_observer(self)
#     end
#   end
#
#   class WarnLow < Warner
#     def update(time, price)       # callback for observer
#       if price < @limit
#         print "--- #{time.to_s}: Price below #@limit: #{price}\n"
#       end
#     end
#   end
#
#   class WarnHigh < Warner
#     def update(time, price)       # callback for observer
#       if price > @limit
#         print "+++ #{time.to_s}: Price above #@limit: #{price}\n"
#       end
#     end
#   end
#
#   ticker = Ticker.new("MSFT")
#   WarnLow.new(ticker, 80)
#   WarnHigh.new(ticker, 120)
#   ticker.run
#
# Produces:
#
#   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)
#       changed
#       notify_observers(77.0)
#     end
#   end
#
#   ticker = Ticker.new
#   warner = ->(price) { puts "New price received: #{price}" }
#   ticker.add_observer(warner, :call)
#   ticker.run
module Observable
  VERSION = "0.1.2"

#
  # Add +observer+ as an observer on this object. So that it will receive
  # notifications.
  #
  # +observer+:: the object that will be notified of changes.
  # +func+:: 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 <tt>*arg</tt> when #notify_observers is called, where
  #          <tt>*arg</tt> is the value passed to #notify_observers by this
  #          Observable
  def add_observer(observer, func=:update)
    @observer_peers = {} unless defined? @observer_peers
    unless observer.respond_to? func
      raise NoMethodError, "observer does not respond to `#{func}'"
    end
    @observer_peers[observer] = func
  end

#
  # Remove +observer+ as an observer on this object so that it will no longer
  # receive notifications.
  #
  # +observer+:: An observer of this Observable
  def delete_observer(observer)
    @observer_peers.delete observer if defined? @observer_peers
  end

#
  # Remove all observers associated with this object.
  #
  def delete_observers
    @observer_peers.clear if defined? @observer_peers
  end

#
  # Return the number of observers associated with this object.
  #
  def count_observers
    if defined? @observer_peers
      @observer_peers.size
    else
      0
    end
  end

#
  # Set the changed state of this object.  Notifications will be sent only if
  # the changed +state+ is +true+.
  #
  # +state+:: Boolean indicating the changed state of this Observable.
  #
  def changed(state=true)
    @observer_state = state
  end

#
  # Returns true if this object's state has been changed since the last
  # #notify_observers call.
  #
  def changed?
    if defined? @observer_state and @observer_state
      true
    else
      false
    end
  end

#
  # 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 <tt>*arg</tt>.
  # The changed state is then set to +false+.
  #
  # <tt>*arg</tt>:: Any arguments to pass to the observers.
  def notify_observers(*arg)
    if defined? @observer_state and @observer_state
      if defined? @observer_peers
        @observer_peers.each do |k, v|
          k.__send__(v, *arg)
        end
      end
      @observer_state = false
    end
  end

end

X7ROOT File Manager

Editing: observer.rb

Upload File

Create Folder