Module: Lolita::Hooks

Included in:

Configuration::Field::Array, Navigation::Tree, RestController

Defined in:

lib/lolita/hooks.rb,
lib/lolita/hooks/named_hook.rb

Overview

Provide hook mechanism for Lolita. To use hooks for class start with including this in your own class. Next step is hook definition. This may be done using Lolita::Hooks#add_hook method. Hooks are stored in class @hooks variable, that is Hash and each key is hook name and each hook also is Hash that have :methods and :blocks keys. Both of those are Array, and each time you call callback method, like before_save and so on, block and/or methods is stored. Each time #run is called all blocks and methods will be executed. It may look like this. class MyClass include Lolita::Hooks add_hook :before_save, :after_save end

This will define two hooks for MyClass.

To add hook callback just call hook name on class and pass method(-s) or block. MyClass.after_save :write_log MyClass.before_save do validate(self) end ==Scopes Most times hook callbacks are defined for class like in previous example, but also it's possible to do it on class instances. Difference between calling it on class or on instance is that instance callbacks will be called only when event is runned on instance. Class callbacks will be called on class and also on instance callbacks. my_object=MyClass.new MyClass.before_save do puts "class callback" end my_object.before_save do puts "instance callback" end

MyClass.run(:before_save) #=>
 class_callback

my_object.run(:before_save) #=>
 class_callback
 instance_callback
# As you can see, first class callbacks is called and after that instance callbacks.

==Firing events To execute callbacks, events should be called on object. Event names is same hooks names. #run can be called on class or on instance. Also it is possible to pass block to run event, that will replace callback block or if #let_content is called than it will work like wrapper, like this

this is continuation of previous code

MyClass.run(:before_save) do puts "replaced text" end

will produce #=> replaced text

MyClass.run(:before_save) do
 puts "before callback"
 let_content
 puts "after callback"
end
# this will produce #=>
#  before callback
#  class callback
#  after callback

==Named hooks See Lolita::Hooks::NamedHook for details.

Defined Under Namespace

Modules: ClassMethods, CommonMethods, InstanceMethods Classes: NamedHook, Runner

Class Method Summary

• .included(base) ⇒ Object

  end of Runner.

• .method_missing(method_name, *args, &block) ⇒ Object

  Look for named hook with singular or plural name of method.

Class Method Details

.included(base) ⇒ Object

end of Runner

# File 'lib/lolita/hooks.rb', line 210

def self.included(base)
  base.extend(ClassMethods)
  base.extend(CommonMethods)
  base.class_eval{
    include CommonMethods
    include InstanceMethods
  }
end

.method_missing(method_name, *args, &block) ⇒ Object

Look for named hook with singular or plural name of method.

# File 'lib/lolita/hooks.rb', line 220

def self.method_missing method_name,*args, &block
  if named_hook=(Lolita::Hooks::NamedHook.by_name(method_name))
    named_hook[:_class]
  else
    super
  end
end