An unhandled exception was thrown

 495        $methods = static::instanceMethods(); 
 496        if (isset($methods[$method]) && is_callable($methods[$method])) { 
 497            return call_user_func_array($methods[$method], $params); 
 498        } 
 499        $message = "Unhandled method call `{$method}`."; 
 500        throw new BadMethodCallException($message); 
 501    } 
 502 
 503    /** 
 504     * Determines if a given method can be called. 
 505     * 

 54     } 
 55  
 56     public function subdestinations($record) { 
 57         return Destinations::all(array( 
 58             'conditions' => array('parent_id' => $record->id), 
 59             'order' => 'sort ASC' 
 60         )); 
 61     } 
 62  
 63     public function trip_report_destinations($record) { 
 64         return TripReportDestinations::all(array( 

 194     * @return mixed 
 195     */ 
 196    public function __call($method, $params) { 
 197        if (($model = $this->_model) && method_exists($model, 'object')) { 
 198            array_unshift($params, $this); 
 199            return call_user_func_array([$model::object(), $method], $params); 
 200        } 
 201        $message = "No model bound to call `{$method}`."; 
 202        throw new BadMethodCallException($message); 
 203    } 
 204 

 43     <url> 
 44         <loc>https://www.naturalistjourneys.com/destinations/ echo $h($destination->slug); </loc> 
 45         <changefreq>weekly</changefreq> 
 46         <priority>0.69</priority> 
 47     </url> 
 48      foreach ($destination->subdestinations() as $subdestination):  
 49     <url> 
 50         <loc>https://www.naturalistjourneys.com/destinations/ echo $h($destination->slug); / echo $h($subdestination->slug); </loc> 
 51         <changefreq>weekly</changefreq> 
 52         <priority>0.56</priority> 
 53     </url> 

 118        } elseif ($this->_view) { 
 119            extract((array) $this->_view->outputFilters, EXTR_OVERWRITE); 
 120        } 
 121 
 122        ob_start(); 
 123        include $template__; 
 124        return ob_get_clean(); 
 125    } 
 126 
 127    /** 
 128     * Returns a template file name 

 391            'renderer' => $_renderer 
 392        ]; 
 393 
 394        $result = Filters::run($this, __FUNCTION__, $params, function($params) { 
 395            $template = $params['loader']->template($params['step']['path'], $params['params']); 
 396            return $params['renderer']->render($template, $params['data'], $params['options']); 
 397        }); 
 398 
 399        if (is_array($step['capture'])) { 
 400            switch (key($step['capture'])) { 
 401                case 'context': 

 226     */ 
 227    public static function run($class, $method, array $params, $implementation) { 
 228        $implementation = static::_bcImplementation($class, $method, $params, $implementation); 
 229 
 230        if (!static::hasApplied($class, $method)) { 
 231            return $implementation($params); 
 232        } 
 233        return static::_chain($class, $method)->run($params, $implementation); 
 234    } 
 235 
 236    /** 

 392        ]; 
 393 
 394        $result = Filters::run($this, __FUNCTION__, $params, function($params) { 
 395            $template = $params['loader']->template($params['step']['path'], $params['params']); 
 396            return $params['renderer']->render($template, $params['data'], $params['options']); 
 397        }); 
 398 
 399        if (is_array($step['capture'])) { 
 400            switch (key($step['capture'])) { 
 401                case 'context': 
 402                    $options['context'][current($step['capture'])] = $result; 

 326                    $params[$name] = $value; 
 327                    $result = $this->_step($step, $params, $data, $options); 
 328                } 
 329                continue; 
 330            } 
 331            $result = $this->_step((array) $step, $params, $data, $options); 
 332        } 
 333        return $result; 
 334    } 
 335 
 336    /** 

 840                case ($handler['template'] === false) && is_string($data): 
 841                    return $data; 
 842                case $handler['view']: 
 843                    unset($options['view']); 
 844                    $instance = static::view($handler, $data, $response, $options); 
 845                    return $instance->render('all', (array) $data, $options); 
 846                default: 
 847                    throw new MediaException("Could not interpret type settings for handler."); 
 848            } 
 849        }); 
 850    } 

 226     */ 
 227    public static function run($class, $method, array $params, $implementation) { 
 228        $implementation = static::_bcImplementation($class, $method, $params, $implementation); 
 229 
 230        if (!static::hasApplied($class, $method)) { 
 231            return $implementation($params); 
 232        } 
 233        return static::_chain($class, $method)->run($params, $implementation); 
 234    } 
 235 
 236    /** 

 844                    $instance = static::view($handler, $data, $response, $options); 
 845                    return $instance->render('all', (array) $data, $options); 
 846                default: 
 847                    throw new MediaException("Could not interpret type settings for handler."); 
 848            } 
 849        }); 
 850    } 
 851 
 852    /** 
 853     * Helper method for listing registered media types. Returns all types, or a single 
 854     * content type if a specific type is specified. 

 690 
 691                $header  = current($mimeTypes); 
 692                $header .= $response->encoding ? "; charset={$response->encoding}" : ''; 
 693                $response->headers('Content-Type', $header); 
 694            } 
 695            $response->body(static::_handle($handler, $data, $response)); 
 696 
 697            return $response; 
 698        }); 
 699    } 
 700 

 226     */ 
 227    public static function run($class, $method, array $params, $implementation) { 
 228        $implementation = static::_bcImplementation($class, $method, $params, $implementation); 
 229 
 230        if (!static::hasApplied($class, $method)) { 
 231            return $implementation($params); 
 232        } 
 233        return static::_chain($class, $method)->run($params, $implementation); 
 234    } 
 235 
 236    /** 

 693                $response->headers('Content-Type', $header); 
 694            } 
 695            $response->body(static::_handle($handler, $data, $response)); 
 696 
 697            return $response; 
 698        }); 
 699    } 
 700 
 701    /** 
 702     * Configures a template object instance, based on a media handler configuration. 
 703     * 

 288 
 289        if ($options['head']) { 
 290            return; 
 291        } 
 292        $response = $media::render($this->response, $this->_render['data'], $options + [ 
 293            'request' => $this->request 
 294        ]); 
 295        return ($this->response = $response ?: $this->response); 
 296    } 
 297 
 298    /** 

 217                    $this->set($result); 
 218                } 
 219            } 
 220 
 221            if (!$this->_render['hasRendered'] && $this->_render['auto']) { 
 222                $this->render(); 
 223            } 
 224            return $this->response; 
 225        }); 
 226    } 
 227 

 226     */ 
 227    public static function run($class, $method, array $params, $implementation) { 
 228        $implementation = static::_bcImplementation($class, $method, $params, $implementation); 
 229 
 230        if (!static::hasApplied($class, $method)) { 
 231            return $implementation($params); 
 232        } 
 233        return static::_chain($class, $method)->run($params, $implementation); 
 234    } 
 235 
 236    /** 

 220 
 221            if (!$this->_render['hasRendered'] && $this->_render['auto']) { 
 222                $this->render(); 
 223            } 
 224            return $this->response; 
 225        }); 
 226    } 
 227 
 228    /** 
 229     * This method is used to pass along any data from the controller to the view and layout 
 230     * 

 272     */ 
 273    protected static function _call($callable, $request, $params) { 
 274        $params = compact('callable', 'request', 'params'); 
 275        return Filters::run(get_called_class(), __FUNCTION__, $params, function($params) { 
 276            if (is_callable($callable = $params['callable'])) { 
 277                return $callable($params['request'], $params['params']); 
 278            } 
 279            throw new DispatchException('Result not callable.'); 
 280        }); 
 281    } 
 282} 

 226     */ 
 227    public static function run($class, $method, array $params, $implementation) { 
 228        $implementation = static::_bcImplementation($class, $method, $params, $implementation); 
 229 
 230        if (!static::hasApplied($class, $method)) { 
 231            return $implementation($params); 
 232        } 
 233        return static::_chain($class, $method)->run($params, $implementation); 
 234    } 
 235 
 236    /** 

 275        return Filters::run(get_called_class(), __FUNCTION__, $params, function($params) { 
 276            if (is_callable($callable = $params['callable'])) { 
 277                return $callable($params['request'], $params['params']); 
 278            } 
 279            throw new DispatchException('Result not callable.'); 
 280        }); 
 281    } 
 282} 
 283 
 284 

 164 
 165            if (!$params) { 
 166                throw new DispatchException('Could not route request.'); 
 167            } 
 168            $callable = static::_callable($result, $params, $options); 
 169            return static::_call($callable, $result, $params); 
 170        }); 
 171    } 
 172 
 173    /** 
 174     * Attempts to apply a set of formatting rules from `$_rules` to a `$params` array, where each 

 151        if (($filter = next($this->_filters)) !== false) { 
 152            return $filter($params, $this); 
 153        } 
 154 
 155        $implementation = $this->_implementation; 
 156        return $implementation($params); 
 157    } 
 158 
 159    /* Deprecated / BC */ 
 160 
 161    /** 

 40             continue; 
 41         } 
 42         $file = "{$config['path']}/config/routes.php"; 
 43         file_exists($file) ? call_user_func(function() use ($file) { include $file; }) : null; 
 44     } 
 45     return $next($params); 
 46 }); 
 47  
 48 /** 
 49  * This filter protects against HTTP host header attacks, by matching the `Host` header 
 50  * sent by the client against a known list of good hostnames. You'll need to modify 

 147     * @return mixed The return value of the next filter. If there is no 
 148     *         next filter, the return value of the implementation. 
 149     */ 
 150    public function __invoke(array $params) { 
 151        if (($filter = next($this->_filters)) !== false) { 
 152            return $filter($params, $this); 
 153        } 
 154 
 155        $implementation = $this->_implementation; 
 156        return $implementation($params); 
 157    } 

 241 
 242        Filters::apply($class, $method, function($params, $next) use ($conditions, $handler) { 
 243            $wrap = static::$_exceptionHandler; 
 244 
 245            try { 
 246                return $next($params); 
 247            } catch (Exception $e) { 
 248                if (!static::matches($e, $conditions)) { 
 249                    throw $e; 
 250                } 
 251                return $handler($wrap($e, true), $params); 

 118     */ 
 119    public function run(array $params, $implementation) { 
 120        $this->_implementation = $implementation; 
 121 
 122        $filter = reset($this->_filters); 
 123        $result = $filter($params, $this); 
 124 
 125        $this->_implementation = null; 
 126        return $result; 
 127    } 
 128 

 228        $implementation = static::_bcImplementation($class, $method, $params, $implementation); 
 229 
 230        if (!static::hasApplied($class, $method)) { 
 231            return $implementation($params); 
 232        } 
 233        return static::_chain($class, $method)->run($params, $implementation); 
 234    } 
 235 
 236    /** 
 237     * Clears filters optionally constrained by class or class and method combination. 
 238     * 

 165            if (!$params) { 
 166                throw new DispatchException('Could not route request.'); 
 167            } 
 168            $callable = static::_callable($result, $params, $options); 
 169            return static::_call($callable, $result, $params); 
 170        }); 
 171    } 
 172 
 173    /** 
 174     * Attempts to apply a set of formatting rules from `$_rules` to a `$params` array, where each 
 175     * formatting rule is applied if the key of the rule in `$_rules` is present and not empty in 

 38  * @see lithium\action\Response 
 39  * @see lithium\action\Dispatcher 
 40  * @see lithium\net\http\Router 
 41  * @see lithium\action\Controller 
 42  */ 
 43 echo lithium\action\Dispatcher::run(new lithium\action\Request()); 
 44  
 45