module LSync::EventHandler

Basic event handling and delegation.

Public Instance Methods

abort!(persistent = false) click to toggle source

Abort the current event handler. Aborting an event handler persistently implies that in the future it will still be aborted; thus calling try will have no effect.

# File lib/lsync/event_handler.rb, line 85
def abort!(persistent = false)
        @aborted = true if persistent
        
        throw abort_name
end
fire(event, *args) click to toggle source

Fire an event which calls all registered event handlers in the order they were defined. The first argument is used to instance_eval any handlers.

# File lib/lsync/event_handler.rb, line 35
def fire(event, *args)
        handled = false
        
        scope = args.shift
        
        if @events && @events[event]
                @events[event].each do |handler|
                        handled = true

                        if scope
                                scope.instance_exec *args, &handler
                        else
                                handler.call
                        end
                end
        end
        
        return handled
end
on(event, &block) click to toggle source

Register an event handler which may be triggered when an event is fired.

# File lib/lsync/event_handler.rb, line 26
def on(event, &block)
        @events ||= {}

        @events[event] ||= []
        @events[event] << block
end
try(*arguments) { || ... } click to toggle source

Try executing a given block of code and fire appropriate events.

The sequence of events (registered via on) are as follows:

:prepare

Fired before the block is executed. May call abort! to cancel execution.

:success

Fired after the block of code has executed without raising an exception.

:failure

Fired if an exception is thrown during normal execution.

:done

Fired at the end of execution regardless of failure.

If abort! has been called in the past, this function returns immediately.

# File lib/lsync/event_handler.rb, line 64
def try(*arguments)
        return if @aborted
        
        begin
                catch(abort_name) do
                        fire(:prepare, *arguments)
                        
                        yield
                        
                        fire(:success, *arguments)
                end
        rescue Exception => error
                # Propagage the exception unless it was handled in some specific way.
                raise unless fire(:failure, *arguments + [error])
        ensure
                fire(:done, *arguments)
        end
end

Private Instance Methods

abort_name() click to toggle source

The name used for throwing abortions.

# File lib/lsync/event_handler.rb, line 94
def abort_name
        ("abort_" + self.class.name).downcase.to_sym
end