<!--p
class ApplicationController extends AbstractApplicationController
{
   public function requireUser()
   {
     if (!$thi-->session()-&gt;hasRole(array('User')))
     {
        $this-&gt;flash()-&gt;error = 'You must be logged in to do that.';
	$this-&gt;redirect(array('controller' =&gt; 'home', 'action' =&gt; 'index'));
     }
   }
};
?&gt;

As you can see my application controller doesn't extend "Controller", but I'm still calling upon its methods. By having it extend from another class I get the easy benefit of not allowing the controller to be a "page" controller which means I cannot place action functions inside of it and render pages. Instead, it is simply there to DRY up some code and allow my other page controllers to access its methods. So how do we accomplish this and what does AbstractApplicationController look like? We'll get to that in a second. First, let me show you the two parts of the parent controller which we will need. Basically, directly before our method actionIndex in HomeController is invoked, we will create a new ApplicationController object in our parent controller so we can start communication.

$this->applicationController = new ApplicationController($this);

We pass $this to its constructor because the AbstractionApplicationController is basically a placeholder (or proxy) for the controller object.

<!--p
abstract class AbstractApplicationController
{
   private $controller;
 
   public function _construct(&#038;$controller)
   {
      if (is_subclass_of($controller, 'Controller'))
         $thi-->controller =&amp; $controller;
      else
         throw new Exception(get_class($controller) .' must be a subclass of Controller');
   }
 
   public function getController()
   {
     return $this-&gt;controller;
   }
 
   public function __call($meth, $args)
   {
     return call_user_func_array(array($this-&gt;controller, $meth), $args);
   }
};
?&gt;

The beauty is in the magic method __call()
As you can see any method not found in your ApplicationController will find the magic __call() method and attempt to execute the method on the cached controller. This means when we redirect or add messages to the flash, we can use the same syntax as we would in our page controllers. This gives us one-way communication. What about accessing the "requireUser" method from the page controller? Again, there is beauty in __call(). We place the same thing in the base controller so that any method invoked from our page controller that isn't part of the base/page controller should be redirected to the ApplicationController object. Let's take a look.

<!--p
public function __call($meth, $args)
{
   return $thi-->applicationController-&gt;$meth();
}
?&gt;

This allows us to call $this->requireUser() in our HomeController' actionIndex() method and it will invoke through base controller's __call() on the ApplicationController object. Now we have two-way communication between our page controllers and our application controller. Keep in mind that since the ApplicationController is not a child of Controller, we can only call upon public methods inside Controller and our page controllers.

<!--p
class GamesController extends Controller
{
   protected $BEFORE_FILTER = array(
     'requireUser'--> array('except' =&gt; array('myExceptionAction'))
   );	
 
   public function actionIndex()
   {
      //before filter method will be invoked before this method is invoked
   }
 
   public function actionMyExceptionAction()
   {
      //before filter method will not be invoked for this
   }
};
?&gt;

If you aren't familiar with rails, don't fret, the logic is simple. I'm using the protected $BEFORE_FILTER to tell my parent controller to execute the requireUser() method before it executes any of the action methods except actionMyExceptionAction(). You can change the "except" key to "only" to change from a black-list to a white-list. Where is the requireUser() method? Well, If you haven't fallen asleep yet, you should know that requireUser() resides in our ApplicationController. How does this code work?

<!--p
//instaniate our ApplicationController before
//the current page's action is invoked
$thi-->applicationController = new ApplicationController($this);
//run before filter
$this-&gt;filter('before');
 
private function filter($temporality)
{
  $filter = strtoupper($temporality.'_FILTER');
  $controllerName = $this-&gt;getControllerName().'Controller';
  $controller = new ReflectionClass($controllerName);
 
  foreach ($controller-&gt;getProperties() as $property)
  {
    if ($property-&gt;name === $filter)
    {
      $filter = $this-&gt;{$property-&gt;name};
      if (!is_array($filter))
      {
 	settype($filter, 'array');
 	$filter[$filter[0]] = $filter[0];
 	unset($filter[0]);
      }
 
      foreach ($filter as $method =&gt; $options)
      {
 	$action = $this-&gt;currentAction();
 	if(!is_array($options) || (!isset($options['only'])
          &amp;&amp; !isset($options['except'])))
	      $this-&gt;$method();
	elseif (isset($options['only'])
          &amp;&amp; in_array($action, $options['only']))
	      $this-&gt;$method();
	elseif (isset($options['except'])
          &amp;&amp; !in_array($action, $options['except']))
	      $this-&gt;$method();
      }
    }
  }
}
?&gt;

Basically, we use reflection on our GamesController and then find any properties that match our filter name (BEFORE_FILTER). We make sure to turn it into an array if it isn't (which means we can do BEFORE_FILTER = 'requireUser';), and then invoke the method based on whether or not it fits the description. If "only" and "except" do not exist then it should be invoked. Otherwise, it should not be invoked if the current page's action is not in the "only" array or if it is in the "except" array. As you can see, you simply need to add protected $AFTER_FILTER = 'someMethodHere'; to have an after filter invoke some method. There you have it!