Redéfinir les Méthodes de la Classe ou de la Classe

runkit semble être une bonne solution, mais n'est pas activé par défaut et certaines parties sont encore expérimentales. J'ai donc bidouillé une petite classe qui remplace des définitions de fonction dans un fichier de classe. Exemple d'utilisation:

class Patch {

private $_code;

public function __construct($include_file = null) {
    if ( $include_file ) {
        $this->includeCode($include_file);
    }
}

public function setCode($code) {
    $this->_code = $code;
}

public function includeCode($path) {

    $fp = fopen($path,'r');
    $contents = fread($fp, filesize($path));
    $contents = str_replace('<?php','',$contents);
    $contents = str_replace('?>','',$contents);
    fclose($fp);        

    $this->setCode($contents);
}

function redefineFunction($new_function) {

    preg_match('/function (.+)\(/', $new_function, $aryMatches);
    $func_name = trim($aryMatches[1]);

    if ( preg_match('/((private|protected|public) function '.$func_name.'[\w\W\n]+?)(private|protected|public)/s', $this->_code, $aryMatches) ) {

        $search_code = $aryMatches[1];

        $new_code = str_replace($search_code, $new_function."\n\n", $this->_code);

        $this->setCode($new_code);

        return true;

    } else {

        return false;

    }

}

function getCode() {
    return $this->_code;
}
}

Puis d'inclure la classe à modifier et redéfinir ses méthodes:

$objPatch = new Patch('path_to_class_file.php');
$objPatch->redefineFunction("
    protected function foo($arg1, $arg2)
    {   
        return $arg1+$arg2;
    }");

Ensuite eval le nouveau code:

eval($objPatch->getCode());

Un peu brut, mais il fonctionne!

Comment sur en l'enveloppant dans une autre classe comme

class Wrapper {
 private $third_party_library;
 function __construct() { $this->third_party_library = new Third_party_library(); }
 function __call($method, $args) {
  return call_user_func_array(array($this->third_party_library, $method), $args);
 }
}

Oui, il est appelé extend:

<?php
class sd_third_party_library extends third_party_library
{
    function buggy_function() {
        return 'good result';
    }
    function other_functions(){
        return 'blah';
    }
}

Je le préfixe "sd". 😉

Gardez à l'esprit que lorsque vous étendez une classe de remplacer les méthodes, la signature de la méthode doit correspondre à l'original. Ainsi par exemple, si l'original dit buggy_function($foo, $bar), il doit correspondre aux paramètres de la classe de l'étendre.

PHP est assez détaillé à ce sujet.

Si la bibliothèque est explicitement la création de la mauvaise classe, et non pas à l'aide d'une localisation ou un système de dépendance, vous êtes hors de la chance. Il n'existe aucun moyen de remplacer une méthode sur une autre classe, à moins que vous sous-classe.
La solution pourrait être de créer un fichier de correctif qui résout la bibliothèque, de sorte que vous pouvez mettre à niveau la bibliothèque et ré-appliquer le patch correctif de la méthode spécifique.

Il y a toujours l'extension de la classe avec une nouvelle, bon, de la méthode et de l'appel de cette classe au lieu de la poussette un.

class my_better_class Extends some_buggy_class {
    function non_buggy_function() {
        return 'good result';
    }
}

(Désolé pour la mise en forme de merde)

Depuis que vous avez toujours accès à la base de code en PHP, redéfinir les principales fonctions de classe que vous souhaitez remplacer comme suit, ce qui devrait laisser vos interfaces intacte:

class third_party_library {
    public static $buggy_function;
    public static $ranOnce=false;

    public function __construct(){
        if(!self::$ranOnce){
            self::$buggy_function = function(){ return 'bad result'; };
            self::$ranOnce=true;
        }
        .
        .
        .
    }
    function buggy_function() {
        return self::$buggy_function();
    }        
}

Vous pouvez pour une raison d'utiliser une variable privée, mais alors vous aurez seulement être en mesure d'accéder à la fonction par l'extension de la classe ou de la logique à l'intérieur de la classe. De même, il est possible que vous voudriez avoir différents objets de la même classe ont des fonctions différentes. Si oui, n'utilisez pas statique, mais en général, vous voulez qu'il soit statique afin de ne pas dupliquer l'utilisation de la mémoire pour chaque objet. Le " ranOnce code tout à fait sûr que vous avez seulement besoin de l'initialiser une fois pour la classe, pas pour tous les $myObject = new third_party_library()

Maintenant, plus tard dans votre code ou d'une autre classe - chaque fois que la logique atteint un point où vous en avez besoin pour remplacer la fonction - il suffit de faire comme suit:

$backup['buggy_function'] = third_party_library::$buggy_function;
third_party_library::$buggy_function = function(){
    //do stuff
    return $great_calculation;
}
.
.
.  //do other stuff that needs the override
.  //when finished, restore the original function
.
third_party_library::$buggy_function=$backup['buggy_function'];

Comme une note de côté, si vous faites tout votre classe fonctionne de cette manière et l'utilisation d'une chaîne de clé/valeur en magasin comme public static $functions['function_name'] = function(...){...}; cela peut être utile pour la réflexion. Pas autant en PHP comme les autres langues, mais parce que vous pouvez déjà saisir la classe et les noms de fonction, mais vous pouvez économiser de traitement et les futurs utilisateurs de votre classe peut utiliser des remplacements en PHP. Il est, cependant, un niveau supplémentaire d'indirection, je voudrais donc éviter de l'utiliser sur des primitives de classes dans la mesure du possible.