I wanted to access protected or private methods of Objects from the outside, in order to test them in isolation. On other occasions I wanted to check if the internal state of a object was affected by my test.

I took several approaches to the problem and I finally found a nice solution.

Bild "Canis Lupus" von Joriel "Joz" Jimenez (CC BY-NC-ND 2.0)

The fools approach

The fool’s approach would be to remove the private or protected keywords from the classes. It might work well if you are the only programmer in a project and are sure that you can remember what you did last year. I can’t and I am no fan of this.

These keywords are used for a good reason: You want to avoid interference from the outside and let the Object be master over its internal state.

The manual approach

Another aproach is to extend the class, change the method-declaration to be public and point to the parent-class.

class Subject
{
  protected function fooBar($abc){}
}

class Mock_Subject
{
  public function fooBar($abc)
  {
   return parent::fooBar($abc);
  }
}

This works fine. Its a decent solution for testing one class – though it has problems:

• You have to duplicate every protected method declaration
• The code is very specific to the subject in question
• The tests get longer and longer
• Knowledge about how the methods look like is in the Mock_Subject class as well and if you want to change a method you have to touch 2 classes
• You can only test protected function but not private ones

I tried to take this road and in general it works fine. The biggest problem was really that it bloated my tests and I got very impatient, because I felt that creating these Mock-Classes was completely uninteresting work.

Since I am a lazy guy I really wanted something else.

The Reflection approach

A Google search came up with another suggestion. Since PHP 5.3 we can reflect on Objects and Classes and access protected properties and methods.

class Subject
{
  private function fooBar()
  {
    return "foobar";
  }
}

$subject = new Subject();
$reflector = new ReflectionObject($subject);
$method = $reflector->getMethod("fooBar")
$method->setAccessible(true);
$result = $method->invoke($subject);
echo $result;

This works just fine. Though of course its quite verbose. I didn’t want to go this road, because I thought that this might make my tests even more complicated.

The “Decapsulator” approach

I sticked with my Mock classes. But yesterday it dawned on me that there might be a very simple general concept. I realized that it is possible to write a nice Class that can decapsulate objects and act as a proxy between the object and my tests.

The api looks a lot like accessing the real object:

class Subject
{
  private $foobar = "hello";
}

$proxy = new Proxy(new Subject());
echo $proxy->foobar;

Quite nice. And reusable.

The implementation

How did I achieved it? Basically I combined the magic method __get(), __set(), __call(), __callStatic() with the Reflection API.

The magic methods intercept the calls to the object, and the Decapsulator tries to forwards it to the Subject, using the Reflection API.

class Decapsulator
{
  private $subject;
   public function __construct($subject)
   {
      $this->subject = $subject;
   }

   public function __get($name)
   {
     $reflector = new ReflectionObject($subject);
     $property= $reflector->getProperty($name)
     $property->setAccessible(true);
     return  $property->getValue($subject);
   }
}

The rest of the class follows the same scheme.

The end result looks like this:

<?php
class Decapsulator
{
  private $subject;
  private $reflector;

  public function __construct($subject)
  {
    $this->subject = $subject;
    $this->reflector = new ReflectionObject($this->subject);
  }

  public function __set($name, $value)
  {
   try{
     $this->setProperty($name, $value);
   }
   catch(ReflectionException $e)
   {
     $this->subject->$name = $value;
   }
  }

  public function __get($name)
  {
    try{
      return $this->getProperty($name);
    }
    catch(ReflectionException $e)
    {
      return NULL;
    }
  }

  public function __call($name, $params)
  {
    return $this->callMethod($name, $params);
  }

  public function setStatic($name, $value)
  {
    $this->setProperty($name, $value);
  }

  public function getStatic($name)
  {
    return $this->getProperty($name);
  }

  public function callStatic($name, $params=array())
  {
    return $this->callMethod($name, $params);
  }

  /**
   * Calls a method on $subject
   * @param String $name of the method
   * @param Array $params of the method
   * @return mixed
   */
  private function callMethod($name, $params)
  {
    $method = $this->reflector->getMethod($name);
    $method->setAccessible(true);
    $params = array_merge(array($this->subject), $params);
    return call_user_func_array(array($method, "invoke"), $params);
  }

  /**
   * Returns a property from $subject
   * @param String $name of property
   * @return mixed
   */
  private function getProperty($name)
  {
    $property = $this->reflector->getProperty($name);
    $property->setAccessible(true);
    return $property->getValue($this->subject);
  }

  /**
   * Sets a property on $subject
   * @param String $name of property
   * @param mixed $val to set it to
   * @return void
   */
  private function setProperty($name, $val)
  {
    $property = $this->reflector->getProperty($name);
    $property->setAccessible(true);
    return $property->setValue($this->subject, $val);
  }
}

Clearly this is not made for use in production or to fight against bad design – but I think it will be very handy for testing.

You can have a look at the complete code at GitHub https://github.com/shostakovich/Decapsulator (Feel free to fork it and add to it if you want)

As always I would be interested in your feedback. Are there better ways to decapsulate objects?

Verwandte Artikel:

1. PHP-Snippet: Nabaztag per API Textnachrichten schicken

This function returns an unsigned integer from a 64-bit Linux platform. It does return the signed integer from other 32-bit platforms even a 64-bit Windows one.

The reason is because the two constants PHP_INT_SIZE and PHP_INT_MAX have different values on the 64-bit Linux platform.

Letztendlich kann man also von keinem echten Problem mit Mint selber sprechen. Da Shaun Inman offensichtlich recht viele Leute um Hilfe gefragt haben hat er ein kleines Script geschrieben, dass die Prüfsummen korrigiert. Danach arbeitet Mint wieder wie gewohnt

Verwandte Artikel:

1. Eagle: Probleme mit Lib beheben
2. Arduino + EthernetShield + Shaun Inman’s Mint + LCD-Display = ZipfelMint
3. Zahlendreher und ihre Folgen und andere Probleme

Fever° ist ein RSS-Reader, den man auf dem eigenen Webspace installiert. Das Programm basiert auf PHP und MySQL, kostet 30$ und wird von Shaun Inman (der unter anderem auch durch Mint bekannt ist) entwickelt.

Fever° bietet neben einer Ansicht, die Google sehr an Google Reader erinnert. Man scrollt durch eine lange Liste der Feedeinträge, die dann automatisch als gelesen markiert werden. Was Fever aber besonders macht, ist eine tolle Funktion mit der man relevante Einträge herausfiltern kann. Fever wertet hierzu die in den Feedeinträgen enthaltenen Links aus und zeigt die besten Stories in einer Übersicht an. Dabei ordnet Fever den ‘heißen’ Links auch jeweils auch jeweils eine Temperatur in Grad Celcius/Fahrenheit zu. Wie das aussieht sieht man schön in folgendem Video:

Die Feeds sind in Must-reads und “Sparks” eingeteilt. Sparks sind einfach Feeds, in denen täglich was los ist und die einen wirklich nicht immer interessieren. Desto mehr Sparks abonniert sind umso nützlicher ist Fever° und desto zuverlässiger kann Fever° wirklich interessante Stories in den Links der vielen Artikel finden.

Heraus kommt dann am Ende eine Liste mit dem besten Stories aus seinen Lieblingsblogs.

Am praktischsten finde ich persönlich aber, dass ich das Programm komplett mit der Tastatur bedienen kann und dabei sogar eigene Hotkeys belegen darf. So habe ich z.B. die Taste Y für YiGG reserviert und lande nach Tastendruck automatisch auf einem fast vollständig ausgefüllten Formular zum einstellen meiner Nachrichten. Auf die Taste “T habe ich mir Tweetie gelegt, was absolut ideal ist um interessante Links direkt zu Twittern.

Den größten Nachteil an Fever° sehe ich darin, dass man die Software nicht vor dem Kauf testen kann. Lediglich ein Script, dass die Kompatiblität des Webservers testet steht bereit. Trotzdem habe ich den Kauf in den letzten Monaten nicht bereut. Fever° ermöglicht mir mich vom Rauschen des Internets abzulösen, wann ich es will und daher auch meine Empfehlung sich das ganze mal näher anzusehen.

Links zu diesem Eintrag

• Fever°

Verwandte Artikel:

1. Yacy – Eine verteilte Suchmaschine
2. Bau dir deinen eigenen Gartentisch

Inszwischen ist YaCy in der Version 0.91 und das spürt man. Die Performance hat sich nach einer Umstellung auf die neue IndexCell Datenstruktur vervielfacht. Die Suche wurde optisch und Funktional wunderbar durch ein wenig Javascript aufgewertet. Man muss seinen Peer nicht mehr alle paar Stunden neustarten: Kurz es macht immer mehr Spaß YaCy zu benutzen.

Nun lenkt YaCy aber natürlich auch ein wenig vom Bloggen ab und daher habe ich mir mal ein paar  Stunden Zeit genommen und schnell ein kleines WordPress-Plugin zusammengestrickt. Es zeigt den Status eines YaCy Peers in einem WordPress-Widget an und kann in jedem Theme benutzt werden, dass Widgets unterstützt.

Die Daten bezieht das Plugin über die in YaCy integrierte API und benutzt SimpleXML um sie aus der Antwort zu picken.

Um den Peer nicht mit sinnlosen anfragen zu belasten und die Antwortzeiten des Blogs gering zu halten, werden die Statistiken für einen selbst einstellbaren Zeitraum in der Blogdatenbank zwischengespeichert.

Angezeigt werden der Name des Peers, PPM,Wörter und die Anzahl der indexierten URLs.

Das Plugin läuft bei mir stabil – wie immer übernehme ich aber keine Gewähr für perfektes funktionieren, helfe aber gerne bei Fehlern weiter und freue mich über eure Kommentare, Patches oder Anregungen.

Entgegen der sonst bei Zipfelmaus üblichen Lizenz steht das Plugin  unter GNU General Public License (Version 3) um später von WordPress.org gehostet werden zu dürfen.

Version-History

Version 0.1.1 Alpha

- Unterdrücke PHP-Warnung, wenn Peer nicht erreichbar
- Bug beghoben, bei dem das Widget möglw. nicht ausgeblendet wird, wenn Peer nicht erreichbar

Download: yacyPlugin_0.1.1.php

Version 0.1 Alpha

- Hinzufügen von Konfigurationsmöglichkeiten für die URL des Peers und die Zeit des vorhaltens der Ergebnisse im lokalen Cache
Download: yacyStatsPlugin_0.1

Verwandte Artikel:

1. Comment to Nabaztag WordPress Plugin
2. Comments to Nabaztag Version 0.1
3. Tracking in YaCy einbauen

Worum geht es also bei Damagedealer.com? Einerseits ist die Seite eine Videoplattform, die Videos in einer wirklich exzellenten Qualität anbietet. Zur Zeit befinden sich eine ganze Stange von Eve-Online Videos auf Damagedealer, die von der Vorgängerseite EveTube-Online stammen. Auf der anderern Seite soll Damagedealer aber auch eine Art Facebook für Onlinerollenspieler sein.

Von seiner Grundidee ist das eine Anwendung, von der ich bisher nicht wusste, dass ich sie unbedingt haben will – aber das Problem “des sich über Spielegrenzen hinweg Wiederfindens” besteht ja definitiv. Beispielsweise würde ich gerne wissen, was meine alten Diablo II -Kollegen den so treiben und ob vielleicht einige von ihnen auch World of Warcraft spielen – allerdings hatte ich bisher natürlich keine Chance das rauszufinden. Mit Damagedealer soll sich das ändern. Nach der Anmeldung kann man die Daten aller Charaktere hinterlegen, die man bislang gespielt hat. Meldet sich dann ein ein Clanmember aus alten Zeiten an, führt Damagedealer virtuell die Familie wieder zusammen.

Das Ganze wird natürlich nur funktionieren, wenn Damagedealer eine gewisse kritische Masse an Usern überschritten hat – da wir so gut wie keine Informationen von euch für die Anmeldung verlangen (weil wir sie für unser Konzept ja auch gar nicht benötigen), könnt ihr euch einfach anmelden, eure alten/aktuellen Charaktere eintragen und abwarten was passiert – E-Mail Junk habt ihr nicht zu erwarten.

Neben Videos und den sozialen Funktionen haben wir noch Foren, einen Bilderservice, Spieleportale und einen Twitter-Abklatsch nahmens Smash The Bird eingebaut – wir hoffen es gefällt

Genauso wie bei unseren anderen Projekten sind wir für euch erreichbar und haben DamageDealer gebaut, weil wir die Funktionen vor allen Dingen für uns selber haben wollten. Ihr könnt uns unter den Namen rocu und phantom als Freunde hinzufügen.

Damagedealer befindet sich noch im Aufbau und wir hoffen auf konstruktives Feedback, Kritik und Ideen von eurer Seite um das Portal so nett wie möglich zu machen.

So aber jetzt nichts wie ab und anmelden liebe rollenspielende Zipfelleser! Wie ihr in der Überschirft lest, steht das mit der Community in Gänsefüsschen – helft mit, dass wir sie eines Tages entfernen können

Verwandte Artikel:

1. Eine neue Haut für mein Netbook
2. Neue Einsichten, dank USB-Mikroskop
3. 2 neue Projekte

When the cache was switched on in settings.yml a partial’s variables were always passed through md5(serialize($vars))

Weiterhin schreibt Kris Wallsmith, das MD5 auf riesige Datenmengen anzuwenden doch recht langsam ist – wo ich nur zustimmen kann

Vor 3 Tagen hat Kris das ganze gefixt (von md5() ) befreit und es scheint, dass wir bei YiGG nun endlich noch mehr Zeug cachen werden können. Leider hatten wir bisher das Problem, dass besonders bei vielen gecachten Fragmenten die Performance anstelle sich zu verbessern in den Keller ging.

Vielen dank Kris! Manchmal stecken solche Fehler im Detail. Wen die ganze Story interessiert, der möge doch bitte einfach im Symfony-Blog nachlesen.

Verwandte Artikel:

1. nahoMailPlugin für Symfony
2. Continous Integration with Hudson, GIT and Symfony
3. Langsam nährt sich das Eichhörnchen

Möglicherweise ist der schlechte Ruf von PHP sicher darin verwurzelt, dass man sehr unsauber damit programmieren kann und oft kräuseln sich einem beim lesen von Codefragmenten die Zehennägel.

In meiner neuen Kategorie PHP 5 möchte ich euch ein paar Kniffe zeigen, mit denen man seinen eigenen Programmierstyl verbessern kann. Inwiefern diese Ratschläge nützlich sind, sei dem Leser überlassen.

Heute geht es um das leidige Thema Kommentare.

Warum sind Kommentare wichtig?

Bei YiGG haben wir im laufe der Zeit viele zehntausend Zeilen Quellcode erzeugt. Wir sind ein kleines Team und jeder von uns hat einen Großteil des Codes schon einmal gesehen. Würden wir nicht akribisch auf die Dokumentation des Codes achten, hätten wir schnell einen echtes Problem und würden Stunden damit verbringen herauszufinden, was Funktion xyz genau macht.

Writing good documentation is essential to the success of any software project. The quality of documentation can be even more important than the quality of the code itself, as a good first impression will prompt developers to look further into your code.

Um ein guter PHP-Entwickler zu werden, sollte man also gleich von Anfang an darauf achten, vernünftige Kommentare zu schreiben.

Industriestandard phpDocumentor

Es empfiehlt sich für seine Kommentare ein einheitliches Format zu verwenden, dass von jedem anderen professionellen PHP-Programmierer verstanden wird.

In der PHP-Welt hat sich in den letzten Jahren zusehends das phpDocumentor-Format durchgesetzt. Es hat den großen Vorteil, dass die Dokumentation nicht nur gut für Menschen sondern auch gut durch Maschinen lesbar ist. Konkret bedeutet das: Wer seine Dokumentation mit phpDocumentor schreibt, wird auch in allen IDE’s später den Komfort der Autocompletion für seinen eigenen Code genießen können.

Ein weiterer Vorteil ist das man mit phpDocumentor auch eine komplette und klickbare Dokumentation all seiner Klassen und Funktionen erstellen lassen kann

Aber lassen wir kurz mal den Code sprechen, damit ihr am Beispiel einer Datei aus einem beliebigen großen PHP-Projekt mal sehen könnt wie so etwas aussieht.

< ?php
/**
 * Piwik - Open source web analytics
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html Gpl v3 or later
 * @version $Id: Auth.php 581 2008-07-27 23:07:52Z matt $
 *
 * @package Piwik
 */

interface Piwik_Auth {
	/**
	 * @return Piwik_Auth_Result
	 */
	public function authenticate();
}

/**
 *
 * @package Piwik
 */
class Piwik_Auth_Result extends Zend_Auth_Result

Sowohl jede Datei, als auch jede Klasse und Funktion werden dokumentiert. Die Tags sind dabei genau festgelegt. Als Einstieg empfiehlt es sich folgendes Cheatsheet von 2tbsb.com herunterzuladen. Es lohnt sich, das PDF auszudrucken und immer in Sichtweite zu haben, bis man die wichtigsten Tags verinnerlicht hat.

Nützlich können ausserdem IDE's sein, die die phpDocumentor-Tags automatisch ergänzen.

Sonstige Konventionen

Oft benutz und auch von vielen IDEs erkannt werden auch Kommentare wie:
//@todo Eine bessere Lösung finden

Man kann auch zu viel kommentieren!

Leider sieht man manchmal auch Dateien mit zu vielen Kommentaren - Trivialitäten sollten nicht kommentiert werden. Auch wenn sich das einfach anhört, aber zumindest ich habe am Anfang zu viel kommentiert und auch das macht den Code unübersichtlich.

Die Oftmals bessere Lösung ist z.b. das vergeben besserer Variablennamen oder das extrahieren einer Methode, die einen logischen Namen hat.

Der Code sollte an sich kommunizieren, was er tut. Solltet ihr also innerhalb einer Funktion den Drang verspüren zu kommentieren, lohnt es sich eine Sekunde innezuhalten und zu überlegen - kann ich das eleganter lösen? Sollte ich ein refactoring anwenden? Ist die Funktion zu lang? Meistens lautet die Antwort, dass man lieber nachpolieren sollte.

Wie haltet ihr es mit Kommentaren?

Verwandte Artikel:

1. EEE Box: EEE-Box – Xandros + Ubuntu = die bessere EEE Box
2. Comments to Nabaztag Version 0.1

Es war nicht weiter schwer ein kleines Script zu schreiben, dass dem Hasen Text To Speech Nachrichten schickt.

Da ich euch gerne an meiner Arbeit teilhaben lassen will, hier der Quellcode.

class NabaztagAPI
< ?php
{
  private $endpoint = "http://api.nabaztag.com/vl/FR/api.jsp?";
  private $auth_params; // Associative array with Sn + Token
  private $call_params; // Associative array with the params for this API-Call
  private $settings;

  /**
   * Constructs the first part of the nabaztag url, including credentials
   * @param string Serialnumber of the nabaztag ($sn)
   * @param string Auth-Token of the nabaztag ($token)
   * @param array settings
   */
  function __construct($sn, $token, $settings = array())
  {
    $this->auth_params = array("sn" => $sn, "token" => $token);
    $this->settings = $settings;
  }

  /**
   * Sends a TTS (text to speech) message to the nabaztag
   * @param string $message
   * @return string
   */

  public function sendTts($message)
  {
    $this->call_params = array("tts" => $message);
    return $this->callNabaztag();
  }

  /**
   * Constructs url and fires the request returns answer
   */

  private function callNabaztag()
  {
    $params = array_merge($this->auth_params, $this->call_params);
    $url = "";

    $param_url = "";
    foreach($params as $key => $val){
      $param_url .= sprintf("&%s=%s", $key, urlencode($val));
    }

    $url = $this->endpoint.substr($param_url, 1);
    return file_get_contents($url);
  }
}

Benutz wird die Klasse einfach so:

$api = new NabaztagApi($nab_id, $nab_token);
$api->sendTts($message);
</pre>

Verwandte Artikel:

1. Advanced PHP: Decapsulating Objects
2. Comment to Nabaztag WordPress Plugin
3. Comments to Nabaztag Version 0.1

Ich muss sagen, dass sich in den letzten Monaten wirklich erfreulich viel am und um das Framework getan hat und ich war nicht nur überrascht von den zahlreichen Verbesserungen in Symfony 1.2, sondern auch von der reichaltigen Auswahl an Plugins, die es inzwischen gibt.

So bin ich unter anderem auch über das Plugin nahoMail gestolpert, dass es einem ermöglicht elegant E-Mails über Swift zu versenden. Es ähnelt eigentlich sehr dem, was wir bei YiGG selber auf Basis von Swift gebaut haben und kann z.B. Partials sauber in eine E-Mail rendern. Ich glaube, dass es für jemanden der selber noch keinen Code in der Richtung hat eine sehr gute Basis ist.

Zum senden einer E-Mail sind so im Grunde nur 2 Zeilen nötig und man hat die Präsentation schön sauber getrennt von seinem Code.

Besonders gut gefallen mir die Einstellungen: Man kann in seiner app.yml einfach ein Namensformat für seine Mails angeben:
[Mein Projekt] – %s

Beide Teile des Strings laufen dann sauber durch die Internationalisierungsfunktion von Symfony.

Links zum Thema:
nahoMailPlugin auf www.symfony-project.org
Swift Mailer

Verwandte Artikel:

1. Symfony – Whoops. Hashfunktionen sind langsam :)
2. Continous Integration with Hudson, GIT and Symfony
3. Mail.app? Ich benutze lieber Postbox.