Zunächst zwei Klassen, eine davon definieren wir als abstract class:

<?php
    class AnotherRealObject {
    
        public function __call($method, $args) {
            return 'AnotherRealObject->'.$method.'()'; 
        }
    
    }

    abstract class SomeAbstractClassWithConcreteMethods {

        private $anotherObject;
    
        abstract public function abstractMethod();
    
       public function concreteMethodToSetObject($o) {
            $this->anotherObject = $o;
        }

        public function concreteMethod() {
            return $this->anotherObject->aMethod();
        }
    
    }        
?>   

Soweit nichts aufregendes. AnotherRealObject enthält lediglich eine Methode, die bei einem beliebigen Methoden-Aufruf einen String zurückgibt, der angibt welche Methode auf dem Objekt aufgerufen wurde. Mal kurz in einer interaktiven PHP-Shell getestet sieht das ganze so aus:

    php > $stub = new AnotherRealObject();
    php > echo $stub->blubb();
    AnotherRealObject->blubb()
    php > echo $stub->someMethodWithAnArbitraryName();
    AnotherRealObject->someMethodWithAnArbitraryName()  

Die zweite Klasse ist abstract definiert. Das hat für diesen Beitrag keinen besonderen Grund, ich wollte in meinen Tests einfach nur ausschließen, dass das Problem darauf zurückzuführen ist. Die Klasse hat zwei konkrete Methoden. Eine zum Setzen der Abhängigkeit $anotherObject und eine weitere, die auf diesem Objekt eine Methode aufruft und deren Rückgabewert zurückgibt.

Ein phpUnit Test um die abstrakte Klasse zu testen könnte wie folgt aussehen:

    class phpUnitBugTest extends PHPUnit_Framework_TestCase {

        private $uut;
        private $stub;

        public function setUp() {

            $this->uut = $this->getMockForAbstractClass('SomeAbstractClassWithConcreteMethods');

            $this->stub = $this->getMock('AnotherRealObject');
            $this->stub->expects( $this->any() )
                          ->method('aMethod')
                       ->will ( $this->returnValue('StubOfAnotherRealObject->aMethod()') );

            $this->uut->concreteMethodToSetObject($this->stub);
        }


        public function testBug() {
            $this->assertEquals('StubOfAnotherRealObject->aMethod()', $this->uut->concreteMethod());
        }


    }

Mit der durch phpUnit bereitgestellten Methode getMockForAbstractClass() instanzieren wir eine Instanz der abstrakten Klasse (das Testobjekt). Außerdem instanzieren wir ein Stub von AnotherRealObject und legen fest, dass beim Aufruf der Methode aMethod auf diesem Stub der String StubOfAnotherRealObject->aMethod() zurückgegeben wird. Anschließend wird das Stub noch in die Instanz der abstrakten Klasse injected.

Soweit so gut – fehlt der eigentliche Test. Was sollte passieren, wenn auf dem TestObjekt die Methode concreteMethod() aufgerufen wird? Nun ja, die Methode ruft auf dem Feld $anotherObject die Methode aMethod auf. Dem Feld $anotherObject ist unser Stub zugewiesen und dem Stub haben wir gesagt, dass es beim Aufruf von anotherMethod den String StubOfAnotherRealObject->aMethod() zurückgeben soll. Dementsprechend sollte ein aufruf von concreteMethod() genau diesen String zurückliefern.

Leider spielt phpUnit hier nicht mit. Der Test schlägt fehl:

    There was 1 failure:

    1) phpUnitBugTest::testBug
    Failed asserting that two strings are equal.
    --- Expected
    +++ Actual
    @@ @@
    -StubOfAnotherRealObject->aMethod()
    +

    dev/phpUnitBugTest.php:45   

Wie man sieht gibt es gar keinen Rückgabewert. Aber warum ist das so? PhpUnit erstellt nur Method-Stubs für Methoden, die es tatsächlich in der Klasse gibt. Die Methode aMethod gibt es aber nicht wirklich, also erstellt phpUnit auch kein Stub dafür. Es gibt allerdings eine einfache Lösung für das Problem – auch wenn ich sie nicht besonders schön finde: Man sagt phpUnit einfach explizit, dass es einen Stub für die Methode aMethod erstellen soll. Dies geschieht beim erzeugen des Stubs:

    $this->stub = $this->getMock('AnotherRealObject', array('aMethod'));

Mit dieser Änderung läuft der Test durch. Aber Vorsicht: PhpUnit erstellt jetzt nur Stubs, die durch den Parameter festgelegt wurden. D.h. es müssen alle Methoden in diesem Array übergeben werden, für die Subs angelegt werden sollen – egal ob diese in der eigentlichen Klassen existieren oder nicht. Und genau dies ist auch der Grund, warum ich diese Lösung nicht schön finde.

Nach einer kurzen Google Recherche musste ich feststellen, dass im Netz auch kein brauchbarer PHP Getter/Setter Generator aufzutreiben ist. Also, nicht lange rumdümpeln, schreibe ich mir halt schnell selbst einen – sowieso die Gelegenheit sich mal die PHP Reflection API anzuschauen. Hier das Ergebnis nach 10 Minuten Arbeit:

#!/usr/bin/php
<?php

    if (!is_file($argv[2])) 
        die('Use this way: '.$argv[0].' <class_name> <path_to_your_class`s_php_file>'."\n");

    require_once($argv[2]);

    $class = new $argv[1]();
    $reflection = new ReflectionClass($argv[1]);
    $fields = $reflection->getProperties(
        ReflectionProperty::IS_PRIVATE
        | ReflectionProperty::IS_PROTECTED
    );

    foreach ($fields AS $f) {

        // getter
        echo 'public function get'.ucfirst($f->getName()).'() {'."\n";
        echo "\t".'return $this->'.$f->getName().';'."\n";
        echo '}'."\n";
        // setter
        echo 'public function set'.ucfirst($f->getName()).'($val) {'."\n";
        echo "\t".'$this->'.$f->getName().' = $val;'."\n";
        echo '}'."\n\n";

    }
    echo 'Generated Getter and Setter for '.count($fields).' fields'."\n\n";
?>   

Das ganze ist ein PHP-Konsolenscript. Als Parameter den Namen eurer Klasse und den Pfad zur PHP Datei mitgeben in der die Klasse deklariert ist. Als Ausgabe erhält man die Getter- und Setter-Methoden für alle Felder, die als private oder protected deklariert sind. Vielleicht hat ja noch jemand anders Verwendung dafür – mir hats eine Menge Zeit gespart

Zum Glück muss man bei WordPress mit solchen Schönheitsfehlern nicht leben – ein kleines MiniPlugin genügt um seine eigene Email-Adresse und den Absendernamen festzulegen. Hier erstmal der Code:

<?php
/*
Plugin Name: myemail
Plugin URI: http://blog.kips-world.de
Description: Some wordpress hacks for my website
Version: 1.0
Author: Dennis Saenger
Author URI: http://blog.kips-world.de
*/

function kip_from_mail($f) {

        $admin = get_userdata(1);
        return $admin->user_email;
}
function kip_from_name($f) {

        $admin = get_userdata(1);
        return $admin->display_name;
}
add_filter('wp_mail_from', 'kip_from_mail', 0, 1);
add_filter('wp_mail_from_name', 'kip_from_name', 0, 1);
?>

Um den Absendernamen und die Emailadresse zu ändern benutze ich hier je einen WordPress-Filter. Immer wenn WordPress eine Email verschicken will, werden diese beiden Filter automatisch aufgerufen. Als Parameter übergibt WordPress die Default-Werte an die Funktionen. Bei kip_from_mail() übergibt WordPress “wordpress -ät- blog.kips-world.de”, bei kip_from_name() wird “WordPress” übergeben. Man könnte diese Werte jetzt modifizieren und zurückgeben, aber ich habe mich dafür entschieden einfach den Nickname und die Emailadresse des Admin als Absender zu nutzen. Ich ignoriere die Variablen ($f) in beiden Funktionen also einfach und hole mir mit der Funktion get_userdata() einfach die Werte des admin Users (der admin hat die User-ID 1).

Um das ganze selbst auszuprobieren erstellst du in deinem WordPress-Pluginordner einfach eine Datei “myemail.php” und kopierst den obigen PHP-Code dort hinein. Im Admin-Bereich von WordPress wird es dann ein neues Plugin “myemail” geben. Dieses noch schnell aktivieren und schon sendet WordPress Emails mit einem schönen Absender!

Wer jetzt Lust bekommen hat selbst kleine Modifikationen an WordPress vorzunehmen findet im WordPress-Codex alles was er wissen muss. In der Plugin-API gibt es eine Einführung zu Filtern und Actions (die beiden Plugin-Schnittstellen von WordPress). In der Function Reference werden alle WordPress-Funktionen inklusive Beschreibung aufgelistet. Und auf der Homepage von Adam findet man eine komplette Liste mit allen Filtern und Actions (sehr wichtig!).

Ich arbeite schon seit längerem mit Aptana. Die Standard Version von Aptana Studio ist kostenlos und bringt alle wichtigen Funktionen die ich benötige mit sich. Das schöne an Aptana, es basiert auf Eclipse und ist als Standalone Anwendung aber auch als Eclipse Plugin zu haben. Da ich Eclipse sowieso auf dem Rechner habe, benutze ich die Plugin-Version von Aptana.

Die Plugin-Version von Aptana wird wie jede andere Erweiterung für Eclipse installiert. In der Eclipse IDE auf “Hilfe” > “Neue Software installieren” und die Aptana Update Seite hinzufügen. In den folgenden Dialogen sicherstellen, dass die Kästchen für Aptana Studio aktiviert sind – fertig.

Wenn Aptana Studio installiert ist und Eclipse neu gestartet wurde, wird man mit einem neuen Fenster begrüßt. In diesem Fenster können weitere Aptana Plugins installiert werden. Ich habe hier Aptana PHP, jQuery Support und Subversive nachinstalliert. Der Aptana CSS und HTML Editor ist im Studio schon integriert.

Wenn alles fertig installiert ist sollte man noch ein paar Einstellungen machen. Unter den Eclipse Einstellungen findet man nun einen neuen Unterpunkt “Aptana”. In “Aptana” unter “Editoren” > “PHP” > “PHP Bibliotheken” kann man zunächst Smarty aktivieren und dann zusätzlich eigene Bibliotheken hinzufügen. Ich habe hier mein PHP Framework pew hinzugefügt. Die hier aktivierten Bibliotheken liest Apatana ein und bietet eine Autovervollständigung für die Befehle der Bibliotheken an. Für PHP, HTML und CSS macht Aptana das selbstverständlich schon standardmäßig.

So, jetzt kann es endlich losgehen. Über “Datei” > “Neu” > “Aptana Projekte” > “PHP Projekt” kann nun ein neues Aptana PHP Projekt gestartet werden! Demnächst werde ich dann noch beschreiben wie man das SVN Plugin Subversive richtig installiert und konfiguriert.

Wem der Funktionsumfang von Eclipse + Aptana immernoch nicht genug ist, der kann sich einmal auf eclipseplugincentral.com umschauen. Dort finden sich noch über 1000 andere Plugins für Eclipse! Wer was gutes findet darf mir gerne Bescheid sagen