phpBB/plugins/bootstrap.php

   1 <?php
   2 /**
   3 *
   4 * @package plugins
   5 * @version $Id$
   6 * @copyright (c) 2008 phpBB Group
   7 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
   8 *
   9 */
  10
  11 /**
  12 * Class used by plugins/modules/etc. for installation/uninstallation
  13 * @package plugins
  14 */
  15 class phpbb_install
  16 {
  17         public function install() {}
  18         public function uninstall() {}
  19 }
  20
  21 /**
  22 * This class holds plugin information.
  23 * One instance will be assigned to each plugin.
  24 * @package plugins
  25 */
  26 class phpbb_plugin_structure
  27 {
  28         /**
  29         * @var string The plugins plain phpBB name. This is also the directory name.
  30         */
  31         public $phpbb_name;
  32
  33         /**
  34         * @var string The plugins full name as the plugin defines it
  35         */
  36         public $name;
  37
  38         /**
  39         * @var string The plugins full description as the plugin defines it
  40         */
  41         public $description;
  42
  43         /**
  44         * @var string The plugins author
  45         */
  46         public $author;
  47
  48         /**
  49         * @var string The plugins version string
  50         */
  51         public $version;
  52
  53         /**
  54         * @var array The plugins defined includes
  55         */
  56         public $includes = array();
  57
  58         /**
  59         * @var array The plugins defined objects to plug in
  60         */
  61         public $objects = array();
  62
  63         /**
  64         * @var array The plugins defined hooks/functions to plug in
  65         */
  66         public $functions = array();
  67
  68         /**
  69         * Set up information object
  70         *
  71         * @param string $phpbb_name     The plugins directory/simple/plain name
  72         * @access public
  73         */
  74         public function __construct($phpbb_name)
  75         {
  76                 $this->phpbb_name = $phpbb_name;
  77
  78                 $class = 'phpbb_' . $phpbb_name . '_info';
  79
  80                 if (!class_exists($class))
  81                 {
  82                         trigger_error('Plugin ' . $phpbb_name . ' does not define required ' . $class . ' info class.', E_USER_ERROR);
  83                 }
  84
  85                 $this->setup = new $class();
  86
  87                 foreach (array('name', 'description', 'author', 'version') as $required_property)
  88                 {
  89                         if (!property_exists($this->setup, $required_property))
  90                         {
  91                                 trigger_error('Plugin ' . $phpbb_name . ' does not define required property ' . $required_property . ' in info class ' . $class . '.', E_USER_ERROR);
  92                         }
  93
  94                         $this->$required_property = $this->setup->$required_property;
  95                 }
  96         }
  97 }
  98
  99 /**
 100 * Main class handling plugins/hooks
 101 * @package plugins
 102 */
 103 class phpbb_plugins
 104 {
 105         /**
 106         * @var array required phpBB objects
 107         */
 108         public $phpbb_required = array();
 109
 110         /**
 111         * @var array Optional phpBB objects
 112         */
 113         public $phpbb_optional = array();
 114
 115         /**
 116         * @var string Plugin path plugins are searched at.
 117         */
 118         public $plugin_path = false;
 119
 120         /**
 121         * @var array Collection of assigned plugins
 122         */
 123         private $plugins = array();
 124
 125         /**
 126         * @var array Collection of assigned hooks (functions)
 127         */
 128         private $hooks = array();
 129
 130         /**
 131         * Pointer to currently processed plugin.
 132         */
 133         private $current_plugin = false;
 134
 135         /**
 136         * Plugins/Functions already set up
 137         */
 138         private $already_parsed_plugins = array();
 139
 140         /**
 141         * @var array Collection of assigned functions and their params (merged from plugins and custom additions)
 142         */
 143         private $functions = array();
 144
 145         /**
 146         * Init plugins
 147         *
 148         * Search {@link $plugin_path plugin path} for plugins and include the information for later processing.
 149         * Plugins will not be called here, just collected.
 150         *
 151         * @param string $plugin_path    The plugin path to search.
 152         * @access public
 153         */
 154         public function init($plugin_path)
 155         {
 156                 $this->plugin_path = $plugin_path;
 157                 $this->plugins = array();
 158
 159                 // search for plugin files
 160                 if ($dh = @opendir($this->plugin_path))
 161                 {
 162                         while (($file = readdir($dh)) !== false)
 163                         {
 164                                 // If is directory and a PHP file with the same name as the directory within this dir?
 165                                 if ($file[0] != '.' && is_readable($this->plugin_path . $file) && is_dir($this->plugin_path . $file) && file_exists($this->plugin_path . $file . '/' . $file . '.' . PHP_EXT))
 166                                 {
 167                                         $this->add_plugin($file);
 168                                 }
 169                         }
 170                         closedir($dh);
 171                 }
 172
 173                 $this->already_parsed_plugins = array('plugin' => array(), 'hook' => array());
 174         }
 175
 176         /**
 177         * Add information about specific plugin
 178         *
 179         * @param string $name   Plugin directory name
 180         * @return bool  False if plugin does not exist
 181         * @access public
 182         */
 183         public function add_plugin($name)
 184         {
 185                 if (!file_exists($this->plugin_path . $name . '/' . $name . '.' . PHP_EXT))
 186                 {
 187                         return false;
 188                 }
 189
 190                 // Include desired plugin
 191                 require_once $this->plugin_path . $name . '/' . $name . '.' . PHP_EXT;
 192
 193                 // Create new setup for this plugin
 194                 $this->plugins[$name] = new phpbb_plugin_structure($name);
 195                 $this->current_plugin = $this->plugins[$name];
 196
 197                 // Setup plugin
 198                 $this->current_plugin->setup->setup_plugin($this);
 199
 200                 return true;
 201         }
 202
 203         /**
 204         * Setup all previously collected plugins
 205         *
 206         * @return bool  False if there are no plugins to setup
 207         * @access public
 208         */
 209         public function setup()
 210         {
 211                 foreach ($this->plugins as $name => $plugin)
 212                 {
 213                         if (isset($this->already_parsed_plugins['plugin'][$name]))
 214                         {
 215                                 continue;
 216                         }
 217
 218                         // Add includes
 219                         foreach ($plugin->includes as $file)
 220                         {
 221                                 include_once $this->plugin_path . $name . '/' . $file . '.' . PHP_EXT;
 222                         }
 223
 224                         // Setup objects
 225                         foreach ($plugin->objects as $key => $class)
 226                         {
 227                                 $object = new $class();
 228
 229                                 if (!property_exists($object, 'phpbb_plugin') && !property_exists($object, 'class_plugin'))
 230                                 {
 231                                         trigger_error('Class ' . get_class($object) . ' does not define public $phpbb_plugin and public $class_plugin.', E_USER_ERROR);
 232                                 }
 233
 234                                 if (property_exists($object, 'phpbb_plugin') && !empty($object->phpbb_plugin))
 235                                 {
 236                                         // Is the plugin the mod author wants to influence pluggable?
 237                                         if (!is_subclass_of(phpbb::get_instance($object->phpbb_plugin), 'phpbb_plugin_support'))
 238                                         {
 239                                                 trigger_error('The phpBB Class ' . get_class(phpbb::get_instance($object->phpbb_plugin)) . ' defined in ' . get_class($object) . ' is not pluggable.', E_USER_ERROR);
 240                                         }
 241
 242                                         // Get instance of phpBB Object to pass later
 243                                         $instance = phpbb::get_instance($object->phpbb_plugin);
 244                                 }
 245                                 else
 246                                 {
 247                                         // Assign custom object...
 248                                         $instance = ${$object->class_plugin};
 249
 250                                         if (!is_subclass_of($instance, 'phpbb_plugin_support'))
 251                                         {
 252                                                 trigger_error('The Class ' . get_class($instance) . ' defined in ' . get_class($object) . ' is not pluggable.', E_USER_ERROR);
 253                                         }
 254                                 }
 255
 256                                 // Setup/Register plugin...
 257                                 $object->setup_plugin($instance);
 258                         }
 259                 }
 260
 261                 // Now setup hooks... this is a special case...
 262                 foreach ($this->functions as $key => $params)
 263                 {
 264                         if (isset($this->already_parsed_plugins['hook'][$key]))
 265                         {
 266                                 continue;
 267                         }
 268
 269                         $function = array_shift($params);
 270                         $hook = array_shift($params);
 271                         $mode = (!empty($params)) ? array_shift($params) : phpbb::FUNCTION_INJECT;
 272                         $action = (!empty($params)) ? array_shift($params) : 'default';
 273
 274                         // Check if the function is already overridden.
 275                         if ($mode == phpbb::FUNCTION_OVERRIDE && isset($this->hooks[$function][$mode]))
 276                         {
 277                                 trigger_error('Function ' . $function . ' is already overridden by ' . $this->hooks[$function][$mode] . '.', E_USER_ERROR);
 278                         }
 279
 280                         if ($mode == phpbb::FUNCTION_OVERRIDE)
 281                         {
 282                                 $this->hooks[$function][$mode] = $hook;
 283                         }
 284                         else
 285                         {
 286                                 $this->hooks[$function][$mode][$action][] = $hook;
 287                         }
 288
 289                         $this->already_parsed_plugins['hook'][$key] = true;
 290                 }
 291
 292                 // Init method call and setting as finished
 293                 foreach ($this->plugins as $name => $plugin)
 294                 {
 295                         if (isset($this->already_parsed_plugins['plugin'][$name]))
 296                         {
 297                                 continue;
 298                         }
 299
 300                         // Call plugins init method?
 301                         if (method_exists($plugin->setup, 'init'))
 302                         {
 303                                 $plugin->setup->init();
 304                         }
 305
 306                         $this->already_parsed_plugins['plugin'][$name] = true;
 307                 }
 308         }
 309
 310         /**
 311         * Register files to be included on plugin setup
 312         * Used by plugin setup
 313         *
 314         * @param string $arguments,...  List of files to include
 315         * @access public
 316         */
 317         public function register_includes()
 318         {
 319                 $arguments = func_get_args();
 320                 $this->current_plugin->includes = $arguments;
 321         }
 322
 323         /**
 324         * Define the plugins classes registered within the setup process.
 325         * Used by plugin setup.
 326         *
 327         * @param string $arguments,...  List of classes to instantiate
 328         * @access public
 329         */
 330         public function register_plugins()
 331         {
 332                 $arguments = func_get_args();
 333
 334                 // Make sure the class names are unique by checking for the phpbb name
 335                 foreach ($arguments as $class)
 336                 {
 337                         if (strpos($class, '_' . $this->current_plugin->phpbb_name . '_') === false)
 338                         {
 339                                 trigger_error('Class ' . $class . ' has an invalid name in plugin ' . $this->current_plugin->phpbb_name . '. The class must include the name of the plugin.', E_USER_ERROR);
 340                         }
 341                 }
 342
 343                 $this->current_plugin->objects = $arguments;
 344         }
 345
 346         /**
 347         * Define the hook setup for functions.
 348         * Used by plugin setup.
 349         *
 350         * @param string $function       The function name to hook into
 351         * @param string $hook           The hooks function name
 352         * @param phpbb::FUNCTION_OVERRIDE|phpbb::FUNCTION_INJECT        $mode
 353         *                                                       If set to phpbb::FUNCTION_OVERRIDE, the hook is called instead of the function and returns the result.
 354         *                                                       If set to phpbb::FUNCTION_INJECT (default), then the hook is called based on the $action parameter
 355         * @param string $action         Defines the hooks action. Default parameters are 'default' and 'return'.
 356         *                                                       Other actions are defined within the relevant functions and are documented within the plugins documentation.
 357         *                                                       'default':      This is the default action used for the first hook called, usually at the start of the function. Parameter are passed by reference.
 358         *                                                       'return':       This is the action used to specify the hook used at the end of the function. Result is passed, returns the result.
 359         *
 360         * @access public
 361         */
 362         public function register_function()
 363         {
 364                 $arguments = func_get_args();
 365                 $this->current_plugin->functions[] = $this->functions[] = $arguments;
 366         }
 367
 368         /**
 369         * Checks if a specific function is overridden by a hook
 370         * Called within functions to check if they are overridden.
 371         *
 372         * @param string $function       The functions name, usually passed as __FUNCTION__
 373         *
 374         * @return bool  True if the function is overridden, false if not
 375         * @access public
 376         */
 377         public function function_override($function)
 378         {
 379                 return isset($this->hooks[$function][phpbb::FUNCTION_OVERRIDE]);
 380         }
 381
 382         /**
 383         * Checks if a specific function is injected by a hook
 384         * Called within functions to check if they are injected.
 385         *
 386         * @param string $function       The functions name, usually passed as __FUNCTION__
 387         * @param string $action         The action to check. Can be 'default', 'return' or any other action defined.
 388         *
 389         * @return bool  True if the function is injected for the particular action, false if not
 390         * @access public
 391         */
 392         public function function_inject($function, $action = 'default')
 393         {
 394                 return isset($this->hooks[$function][phpbb::FUNCTION_INJECT][$action]);
 395         }
 396
 397         /**
 398         * Call hook function overriding function.
 399         * This is called within a function to actually override the function with the hook.
 400         *
 401         * @param string $function               The function name, usually passed as __FUNCTION__
 402         * @param mixed  $arguments,...  Optional number of arguments passed by the function to the hook
 403         *
 404         * @return mixed The hooks result
 405         * @access public
 406         */
 407         public function call_override()
 408         {
 409                 $arguments = func_get_args();
 410                 $function = array_shift($arguments);
 411
 412                 return call_user_func_array($this->hooks[$function][phpbb::FUNCTION_OVERRIDE], $arguments);
 413         }
 414
 415         /**
 416         * Call injected function.
 417         * This is called within functions to call hooks for specific actions.
 418         *
 419         * @param string $function               The function name, usually passed as __FUNCTION__
 420         * @param array  $arguments              Arguments passed to the hook as an array
 421         *                                                               The first parameter is the action.
 422         *                                                               If the action is 'return', the second parameter is the result
 423         *                                                               The remaining parameter are the functions parameter, passed by reference if action is not 'return'.
 424         *
 425         * @return mixed Returns result if action is 'return'
 426         * @access public
 427         */
 428         public function call_inject($function, $arguments)
 429         {
 430                 $result = NULL;
 431
 432                 if (!is_array($arguments))
 433                 {
 434                         $action = $arguments;
 435                         $arguments = array();
 436                 }
 437                 else
 438                 {
 439                         $action = array_shift($arguments);
 440                 }
 441
 442                 // Return action... handle like override
 443                 if ($action == 'return')
 444                 {
 445                         $result = array_shift($arguments);
 446
 447                         foreach ($this->hooks[$function][phpbb::FUNCTION_INJECT][$action] as $key => $hook)
 448                         {
 449                                 $args = array_merge(array($result), $arguments);
 450                                 $result = call_user_func_array($hook, $args);
 451                         }
 452
 453                         return $result;
 454                 }
 455
 456                 foreach ($this->hooks[$function][phpbb::FUNCTION_INJECT][$action] as $key => $hook)
 457                 {
 458                         call_user_func_array($hook, $arguments);
 459                 }
 460         }
 461 }
 462
 463 /**
 464 * Plugin support class.
 465 * Objects supporting plugins must extend this class
 466 * @package plugins
 467 */
 468 abstract class phpbb_plugin_support
 469 {
 470         /**
 471         * @var array Methods injected
 472         */
 473         private $plugin_methods;
 474
 475         /**
 476         * @var array Attributes injected
 477         */
 478         private $plugin_attributes;
 479
 480         /**
 481         * Register a new method, overrides one or inject into one.
 482         *
 483         * @param string $name           The method name to inject into. False if a new method is registered.
 484         * @param string $method         The hook name to use.
 485         * @param object $object         Always $this
 486         * @param phpbb::METHOD_ADD|phpbb::METHOD_OVERRIDE|phpbb::METHOD_INJECT  $mode
 487         *                                                       If set to phpbb::METHOD_ADD (default) the $name is added as a new method for the object plugged into.
 488         *                                                       If set to phpbb::METHOD_OVERRIDE the hook is called instead of the method and returns the result.
 489         *                                                       If set to phpbb::METHOD_INJECT, then the hook is called based on the $action parameter
 490         * @param string $action         Defines the hooks action. Default parameters are 'default' and 'return'.
 491         *                                                       Other actions are defined within the relevant methods and are documented within the plugins documentation.
 492         *                                                       'default':      This is the default action used for the first hook called, usually at the start of the method. Parameter are passed by reference.
 493         *                                                       'return':       This is the action used to specify the hook used at the end of the method. Result is passed, returns the result.
 494         *
 495         * @access public
 496         */
 497         public function register_method($name, $method, $object, $mode = phpbb::METHOD_ADD, $action = 'default')
 498         {
 499                 // Method reachable by:
 500                 // For plugin_add: plugin_methods[method] = object
 501                 // For plugin_override: plugin_methods[name][mode][method] = object
 502                 // For plugin_inject: plugin_methods[name][mode][action][method] = object
 503
 504                 // Set to PLUGIN_ADD if method does not exist
 505                 if ($name === false || !method_exists($this, $name))
 506                 {
 507                         $mode = phpbb::METHOD_ADD;
 508                 }
 509
 510                 // But if it exists and we try to add one, then print out an error
 511                 if ($mode == phpbb::METHOD_ADD && (method_exists($this, $method) || isset($this->plugin_methods[$method])))
 512                 {
 513                         trigger_error('Method ' . $method. ' in class ' . get_class($object) . ' is not able to be added, because it conflicts with the existing method ' . $method . ' in ' . get_class($this) . '.', E_USER_ERROR);
 514                 }
 515
 516                 // Check if the same method name is already used for $name for overriding the method.
 517                 if ($mode == phpbb::METHOD_OVERRIDE && isset($this->plugin_methods[$name][$mode][$method]))
 518                 {
 519                         trigger_error('Method ' . $method . ' in class ' . get_class($object) . ' is not able to override . ' . $name . ' in ' . get_class($this) . ', because it is already overridden in ' . get_class($this->plugin_methods[$name][$mode][$method]) . '.', E_USER_ERROR);
 520                 }
 521
 522                 // Check if another method is already defined...
 523                 if ($mode == phpbb::METHOD_INJECT && isset($this->plugin_methods[$name][$mode][$action][$method]))
 524                 {
 525                         trigger_error('Method ' . $method . ' in class ' . get_class($object) . ' for ' . $name . ' is already defined in class ' . get_class($this->plugin_methods[$name][$mode][$action][$method]), E_USER_ERROR);
 526                 }
 527
 528                 if (($function_signature = $this->valid_parameter($object, $method, $mode, $action)) !== true)
 529                 {
 530                         trigger_error('Method ' . $method . ' in class ' . get_class($object) . ' has invalid function signature. Please use: ' . $function_signature, E_USER_ERROR);
 531                 }
 532
 533                 if ($mode == phpbb::METHOD_ADD)
 534                 {
 535                         $this->plugin_methods[$method] = $object;
 536                 }
 537                 else if ($mode == phpbb::METHOD_OVERRIDE)
 538                 {
 539                         $this->plugin_methods[$name][$mode][$method] = $object;
 540                 }
 541                 else
 542                 {
 543                         $this->plugin_methods[$name][$mode][$action][$method] = $object;
 544                 }
 545         }
 546
 547         /**
 548         * Register a new attribute.
 549         * If the attribute already exists within the object then it will be overwritten.
 550         *
 551         * @param string $name   Attribute name to register.
 552         * @param object $object Always $this
 553         *
 554         * @access public
 555         */
 556         public function register_attribute($name, $object)
 557         {
 558                 if (property_exists($this, $name))
 559                 {
 560                         unset($this->$name);
 561                 }
 562
 563                 if (isset($this->plugin_attributes[$name]))
 564                 {
 565                         trigger_error('Attribute ' . $name . ' in class ' . get_class($object) . ' already defined in class ' . get_class($this->plugin_attributes[$name]), E_USER_ERROR);
 566                 }
 567
 568                 $this->plugin_attributes[$name] = $object;
 569         }
 570
 571         /**#@+
 572         * Magic method for attributes. See {@link register_attribute() register_attribute}.
 573         * @access public
 574         */
 575         public function __get($name)
 576         {
 577                 if (isset($this->plugin_attributes[$name]))
 578                 {
 579                         return $this->plugin_attributes[$name]->$name;
 580                 }
 581
 582                 return $this->$name;
 583         }
 584
 585         public function __set($name, $value)
 586         {
 587                 if (isset($this->plugin_attributes[$name]))
 588                 {
 589                         return $this->plugin_attributes[$name]->$name = $value;
 590                 }
 591
 592                 return $this->$name = $value;
 593         }
 594
 595         public function __isset($name)
 596         {
 597                 if (isset($this->plugin_attributes[$name]))
 598                 {
 599                         return isset($this->plugin_attributes[$name]->$name);
 600                 }
 601
 602                 return isset($this->$name);
 603         }
 604
 605         public function __unset($name)
 606         {
 607                 if (isset($this->plugin_attributes[$name]))
 608                 {
 609                         unset($this->plugin_attributes[$name]->$name);
 610                 }
 611
 612                 unset($this->$name);
 613         }
 614         /**#@-*/
 615
 616         /**
 617         * Call added method. See {@link register_method() register_method} with phpbb::METHOD_ADD mode.
 618         * @access public
 619         */
 620         public function __call($name, $arguments)
 621         {
 622                 if (isset($this->plugin_methods[$name]) && !is_array($this->plugin_methods[$name]))
 623                 {
 624                         array_unshift($arguments, $this);
 625                         return call_user_func_array(array($this->plugin_methods[$name], $name), $arguments);
 626                 }
 627
 628                 trigger_error('Call to undefined method ' . $name . '() in ' . get_class($this) . '.', E_USER_ERROR);
 629         }
 630
 631         /**
 632         * Checks if a specific method is overridden by a hook
 633         * Called within methods to check if they are overridden.
 634         *
 635         * @param string $name   The methods name, usually passed as __FUNCTION__
 636         *
 637         * @return bool  True if the method is overridden, false if not
 638         * @access protected
 639         */
 640         protected function method_override($name)
 641         {
 642                 return isset($this->plugin_methods[$name][phpbb::METHOD_OVERRIDE]);
 643         }
 644
 645         /**
 646         * Checks if a specific method is injected by a hook
 647         * Called within methods to check if they are injected.
 648         *
 649         * @param string $name           The methods name, usually passed as __FUNCTION__
 650         * @param string $action         The action to check. Can be 'default', 'return' or any other action defined.
 651         *
 652         * @return bool  True if the method is injected for the particular action, false if not
 653         * @access protected
 654         */
 655         protected function method_inject($name, $action = 'default')
 656         {
 657                 return isset($this->plugin_methods[$name][phpbb::METHOD_INJECT][$action]);
 658         }
 659
 660         /**
 661         * Call hook method overriding method.
 662         * This is called within a method to actually override the method with the hook.
 663         *
 664         * @param string $name                   The method name, usually passed as __FUNCTION__
 665         * @param mixed  $arguments,...  Optional number of arguments passed by the method to the hook
 666         *
 667         * @return mixed The hooks result
 668         * @access protected
 669         */
 670         protected function call_override()
 671         {
 672                 $arguments = func_get_args();
 673                 $name = array_shift($arguments);
 674
 675                 list($method, $object) = each($this->plugin_methods[$name][phpbb::METHOD_OVERRIDE]);
 676                 return call_user_func_array(array($object, $method), array_merge(array($this), $arguments));
 677         }
 678
 679         /**
 680         * Call injected method.
 681         * This is called within methods to call hooks for specific actions.
 682         *
 683         * @param string $name                   The method name, usually passed as __FUNCTION__
 684         * @param array  $arguments              Arguments passed to the hook as an array
 685         *                                                               The first parameter is the action.
 686         *                                                               If the action is 'return', the second parameter is the result
 687         *                                                               The remaining parameter are the methods parameter, passed by reference if action is not 'return'.
 688         *
 689         * @return mixed Returns result if action is 'return'
 690         * @access protected
 691         */
 692         protected function call_inject($name, $arguments)
 693         {
 694                 $result = NULL;
 695
 696                 if (!is_array($arguments))
 697                 {
 698                         $action = $arguments;
 699                         $arguments = array();
 700                 }
 701                 else
 702                 {
 703                         $action = array_shift($arguments);
 704                 }
 705
 706                 // Return action... handle like override
 707                 if ($action == 'return')
 708                 {
 709                         $result = array_shift($arguments);
 710
 711                         foreach ($this->plugin_methods[$name][phpbb::METHOD_INJECT][$action] as $method => $object)
 712                         {
 713                                 $args = array_merge(array($this, $result), $arguments);
 714                                 $result = call_user_func_array(array($object, $method), $args);
 715                         }
 716
 717                         return $result;
 718                 }
 719
 720                 foreach ($this->plugin_methods[$name][phpbb::METHOD_INJECT][$action] as $method => $object)
 721                 {
 722                         call_user_func_array(array($object, $method), array_merge(array($this), $arguments));
 723                 }
 724         }
 725
 726         /**
 727         * Check function signature for passed methods in {@link register_method() register_method()}.
 728         *
 729         * @param object $object         The plugin
 730         * @param string $method         The method name
 731         * @param phpbb::METHOD_ADD|phpbb::METHOD_OVERRIDE|phpbb::METHOD_INJECT  $mode   The mode
 732         * @param string $action         The action
 733         *
 734         * @return mixed True if the signature is valid, else the correct function signature
 735         * @access private
 736         */
 737         private function valid_parameter($object, $method, $mode, $action)
 738         {
 739                 // We cache the results... no worry. These checks are quite resource intensive, but will hopefully educate and guide developers
 740
 741                 // Check for correct first parameter. This must be an instance of phpbb_$phpbb_plugin
 742                 $instance_of = 'phpbb_' . $object->phpbb_plugin;
 743
 744                 // Define the required function layout
 745                 $function_layout = 'public function ' . $method . '(' . $instance_of . ' $object';
 746
 747                 // Result for METHOD_INJECT and action == 'return'
 748                 if ($mode == phpbb::METHOD_INJECT && $action == 'return')
 749                 {
 750                         $function_layout .= ', $result';
 751                 }
 752
 753                 // Optional method parameter
 754                 $function_layout .= ', [...]) { [...] }';
 755
 756                 // Now check the method
 757                 $reflection = new ReflectionMethod($object, $method);
 758                 $parameters = $reflection->getParameters();
 759
 760                 // First parameter needs to be defined
 761                 $first_param = array_shift($parameters);
 762
 763                 // Signature is wrong if first parameter is empty
 764                 if (empty($first_param))
 765                 {
 766                         return $function_layout;
 767                 }
 768
 769                 // Try to get class from first parameter
 770                 try
 771                 {
 772                         $first_param->getClass()->name;
 773                 }
 774                 catch (Exception $e)
 775                 {
 776                         return $function_layout;
 777                 }
 778
 779                 // First parameter needs to be an instance of phpbb_$phpbb_plugin and parameter must be $object
 780                 if ($first_param->getClass()->name !== $instance_of || $first_param->getName() !== 'object')
 781                 {
 782                         return $function_layout;
 783                 }
 784
 785                 // If the action is 'return' we also check for an existing $result parameter
 786                 if ($mode == phpbb::METHOD_INJECT && $action == 'return')
 787                 {
 788                         $first_param = array_shift($parameters);
 789
 790                         // If no result is passed, or the name not $result or the $result being optional, then the signature is wrong
 791                         if (empty($first_param) || $first_param->getName() !== 'result' || $first_param->isOptional())
 792                         {
 793                                 return $function_layout;
 794                         }
 795                 }
 796
 797                 // Everything ok
 798                 return true;
 799         }
 800 }
 801
 802 /**
 803 * Interface for phpBB plugin info
 804 */
 805 interface phpbb_plugin_info
 806 {
 807         /**
 808         * Setup plugin information
 809         *
 810         * @param phpbb_plugins $object  The {@link phpbb_plugins plugins object} passed
 811         */
 812         public function setup_plugin(phpbb_plugins $object);
 813 }
 814
 815 /**
 816 * Interface for phpBB plugin setup
 817 */
 818 interface phpbb_plugin_setup
 819 {
 820         /**
 821         * Setup specific class within the plugin
 822         *
 823         * @param phpbb_plugin_support $object   The injected object... supports {@link phpbb_plugin_support plugins}
 824         */
 825         function setup_plugin(phpbb_plugin_support $object);
 826 }
 827
 828 ?>