Das Skript durchsucht mit zwei kleinen Regular Expressions den Inhalt nach Tabellen und weist dann den Tabellen-Zeilen entsprechende Klassen (even/odd) zu. So können alle Tabellen per CSS formatiert werden. Klar leidet darunter die Performance etwas, aber sicherlich nicht viel mehr, als wenn ich in jeder Schleife in der eine Tabelle aufgebaut wird ein Zähler mitlaufen lasse und eine Bedingsabfrage mache.

	// Convert table rows to even/odd class
	preg_match_all( "/<table.*>(.*)<\/table>/siU", $html, $matches );
	if( $matches )
	{
		foreach( $matches[ 1 ] AS $tbody )
		{
			$new_rows = '';
			if( preg_match_all( "/<tr.*>.+<\/tr>/siU", $tbody, $tbmatches ) )
			{
				$i = 0;
				foreach( $tbmatches[ 0 ] AS $tr )
				{
					// Ignore rows containing th cells
					if( strpos( $tr, '<th' ) === false )
					{
						if( $i % 2 == 0 )
							$new_rows .= str_replace( '<tr', '<tr class="even"', $tr );
						else
							$new_rows .= str_replace( '<tr', '<tr class="odd"', $tr );
						$i++;
					}
					else	$new_rows .= $tr;
				}
				$html = str_replace( $tbody, $new_rows, $html );
			}
		}
	}

Im Grunde ganz einfach: Die erste RegEx sucht alle vorhanden Tabellen und deren Inhalt. Danach werden die Zeilen des Inhalts ebenfalls per RegEx ermittelt und per Zeichenersetzung angepasst.

Vielleicht hilft das ja Jemandem irgendwann mal…

Also habe ich kurzerhand einen neuen Twitter-Account mit dem klangvollen Namen “@subversives” erstellt und ein kleines PHP-Skript geschrieben, dass neue Tweets mit einem #harley Hashtag sucht und eine zufällig ausgewählte Antwort erstellt. Natürlich konfigurierbar. :-)

Dazu gibt es zwei kleine Funktionen. Die erste Funktion sucht Tweets nach einem bestimmten Suchbegriff:

// Twitter search api
function twt_search( $username, $password, $search, $since_id = 0, $rpp = 30, $page = 1 )
{
	// Curl init
	$curl = curl_init();

	// Curl basic settings
	curl_setopt( $curl, CURLOPT_URL, 'http://search.twitter.com/search.json' );
	curl_setopt( $curl, CURLOPT_RETURNTRANSFER, 1 );
	curl_setopt( $curl, CURLOPT_USERPWD, "$username:$password" );
	curl_setopt( $curl, CURLOPT_POST, true );

	// Build POST parameters
	$post_arr = array();
	$post_arr[] = "q=" . urlencode( $search );
	if( !empty( $since_id ) )
		$post_arr[] = "since_id=" . $since_id;
	if( !empty( $rpp ) )
		$post_arr[] = "rpp=" . $rpp;
	if( !empty( $page ) )
		$post_arr[] = "page=" . $page;
	curl_setopt( $curl, CURLOPT_POSTFIELDS, implode( '&', $post_arr ) );

	// Exec, set return
	$return = json_decode( curl_exec( $curl ) );

	// Close curl
	curl_close( $curl );

	return $return;
}

Übergeben werden Benutzername, Passwort, der Suchbegriff und – wenn bekannt – auch die “since_id”, welche es ermöglicht nur Tweets mit einer höheren ID zu ermitteln. Das ist für unser lustiges Protest-Skript wichtig, denn wir wollen die Leute ja nicht zuspammen und immer wieder auf die gleichen Tweets antworten. Nur neue Tweets seit der letzten Suche sollen berücksichtigt werden, also merken wir uns einfach die höchste Tweet ID und übergeben diese wieder bei der nächsten Suche. Der Parameter “rpp” steht übrigens für “results per page” – mit der Voreinstellung werden also maximal 30 Tweets zurückgegeben.

Technisch wird die Abfrage über die CURL-Bibliothek realisiert, theoretisch ginge es aber auch mit “file_get_contents” oder “fopen”, aber ich mag CURL. Ist ganz praktisch.

Die zweite benötigte Funktion erstellt über die Twitter API einen neuen Tweet. Auch hier stehen wieder einige Parameter zur Verfügung:

// Twitter update api
function twt_update( $username, $password, $status, $in_reply_to_status_id = '', $lat = '', $long = '' )
{
	// Curl init
	$curl = curl_init();

	// Curl basic settings
	curl_setopt( $curl, CURLOPT_URL, 'http://twitter.com/statuses/update.json' );
	curl_setopt( $curl, CURLOPT_RETURNTRANSFER, 1 );
	curl_setopt( $curl, CURLOPT_USERPWD, "$username:$password" );
	curl_setopt( $curl, CURLOPT_POST, true );

	// Build POST parameters
	$post_arr = array();
	$post_arr[] = "status=" . urlencode( $status );
	if( !empty( $in_reply_to_status_id ) )
		$post_arr[] = "in_reply_to_status_id=" . $in_reply_to_status_id;
	if( !empty( $lat ) )
		$post_arr[] = "lat=" . $lat;
	if( !empty( $long ) )
		$post_arr[] = "long=" . $long;
	curl_setopt( $curl, CURLOPT_POSTFIELDS, implode( '&', $post_arr ) );

	// Exec, set return
	$return = json_decode( curl_exec( $curl ) );

	// Close curl
	curl_close( $curl );

	return $return;
}

Neben Nutzername und Passwort können an diese Funktion der Statustext (Tweet) und der sehr wichtige Parameter “in_reply_to_status_id” übergeben werden. Wird die ID eines Tweets mit diesem Parameter übergeben, erkennt Twitter, dass es sich um eine @rely zu dem Tweet mit der übergebenen ID handelt. Da wir ja Antworten senden wollen, genau das richtige! Die Parameter “lat” und “long” sind übrigens nur schmückendes Beiwerk und werden von mir nicht genutzt. Ich habe das nur der Vollständigkeit halber mit rein genommen.

Nun zur Anwendung der Funktionen:

// Twitter account settings
$username = 'user';
$password = 'pass';

// Configure some reply variations in english and german
$replys_en = array(
	'Always remember #BUELL if you talk about Harley Davidson!',
	'Hey, remember #BUELL if you talk about Harley Davidson!',
	'Remember #BUELL FOREVER! Harley Davidson? NEVER!',
	'It makes me sick, that you dont talk about #BUELL ;-)',
	'#BUELL #BUELL #BUELL remember the Harley Davidson #FAIL',
	'#BUELL killed by Harley Davidson in 2k9. Remember that!',
	'#BUELL will never die. Harley Davidson will.'
);
$replys_de = array(
	'Erinner dich an #BUELL wenn du über Harley Davidson sprichst!',
	'Harley Davidson? Die Firma, die #BUELL zerstört hat?',
	'#BUELL FOREVER! Harley Davidson? NEVER!',
	'Es macht mich krank, dass nicht auch über #BUELL sprichst!',
	'#BUELL #BUELL #BUELL denk an den Harley Davidson #FAIL',
	'#BUELL wurde von Harley Davidson 2k9 geschlossen. HD is next!',
	'#BUELL wird niemals sterben, aber Harley Davidson. #Rentnerchopper'
);

// Load last parsed tweet id
if( file_exists( 'harley_since_id.dat' ) )
	$harley_since_id = file_get_contents( 'harley_since_id.dat' );
else
	$harley_since_id = 0;

// Search for tag harley
$harley = twt_search( $username, $password, '#harley', $harley_since_id );
if( is_object( $harley ) )
{
	if( count( $harley -> results ) )
	{
		foreach( $harley -> results AS $rkey => $tweet )
		{
			// Descending order, so the first array element has the highest id!
			if( $rkey == 0 )
				$harley_since_id = $tweet -> id;
			// Only reply if buell not found
			if( stripos( $tweet -> text, 'buell' ) === false && $tweet -> from_user != $username )
			{
				if( $tweet -> iso_language_code != 'de' )
					$reply = "@{$tweet->from_user} " . $replys_en[ array_rand( $replys_en ) ];
				else
					$reply = "@{$tweet->from_user} " . $replys_de[ array_rand( $replys_de ) ];

				echo "$reply\n";

				// Send reply
				twt_update( $username, $password, $reply, $tweet -> id );
			}
		}
	}
	else	echo "No new tweets to tag #harley\n";
}

// Store last parsed tweet id
file_put_contents( 'harley_since_id.dat', $harley_since_id );

Zuerst werden in zwei Arrays englische bzw. deutsche Ausdrücke des Protests definiert, danach wird aus einer kleinen Datendatei die ID des letzten gefundenen Tweets geladen und die Suche ausgeführt.
Die Suchfunktion gibt ein Objekt zurück, dass in der Eigenschaft “results” die gefundenen Tweets als Array enthält, welches anschließend durchlaufen wird. Beim ersten gefundenen Tweet wird die “since_id” neu gesetzt. Warum beim ersten? Na, weil die Tweets absteigend sortiert sind – der Erste ist also immer der Aktuellste.
Enthält der Tweet nicht das Wort “buell”, wird in der entsprechenden Sprache (deutsch oder englisch) eine @reply an den Twitter-Account des Tweets gesendet.

Tja, das war’s eigentlich schon. Wer es mal probieren und einen Spruch reingedrückt bekommen will, der zwitschert einfach mal was mit dem Hashtag #harley – es dauert allerdings ein wenig, bis die Antwort kommt, das Skript läuft nur alle 15 Minuten.

Ich bin gespannt, wie lange der Account aktiv ist, ohne als Spam gemeldet zu werden. ;-)

Aber nun zur Definition von SOAP (Quelle: Wikipedia): SOAP (ursprünglich für Simple Object Access Protocol) ist ein Netzwerkprotokoll, mit dessen Hilfe Daten zwischen Systemen ausgetauscht und Remote Procedure Calls durchgeführt werden können. SOAP stützt sich auf andere Standards: XML zur Repräsentation der Daten und Internet-Protokolle der Transport- und Anwendungsschicht (vgl. TCP/IP-Referenzmodell) zur Übertragung der Nachrichten. Die gängigste Kombination ist SOAP über HTTP und TCP.

In der Praxis bedeutet das folgendes: In einer XML Datei (WSDL) werden Nachrichten-Typen definiert und an Operationen gebunden. Dabei gibt es Input-Nachrichten und Output-Nachrichten, sprich Übergaben und Rückgaben. Die WSDL Datei (WSDL = Web Services Description Language) wird dabei vom Client, als auch vom Server genutzt und regelt so die Kommunikation dieser beider Stellen.

Die Vorgehensweise um einen neuen Web-Service zu erstellen ist bei mir immer zuerst die WSDL zu erzeugen, danach die Operationen im Server abzubilden, um diese anschließend mit dem Client zu testen. Eine Beispiel WSDL könnte z.B. so aussehen:

<?xml version="1.0" encoding="UTF-8"?>
<definitions name="TheGeek"
	targetNamespace="http://thegeek.de/wp-soap/thegeek.wsdl"
	xmlns:tns="http://thegeek.de/wp-soap/thegeek.wsdl"
	xmlns="http://schemas.xmlsoap.org/wsdl/"
	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
	xmlns:xsd="http://www.w3.org/2001/XMLSchema">

	<!-- GET LATEST POSTS -->
	<message name="RequestGetPostsIn">
		<part name="apikey" type="xsd:string"/>
		<part name="num" type="xsd:integer"/>
	</message>
	<message name="RequestGetPostsOut">
		<part name="returncode" type="xsd:integer"/>
		<part name="error" type="xsd:string"/>
		<part name="posts" type="xsd:struct"/>
		<part name="posts_count" type="xsd:integer"/>
	</message>
	<portType name="RequestGetPosts_PortType">
		<operation name="GetPosts">
			<input message="tns:RequestGetPostsIn"/>
			<output message="tns:RequestGetPostsOut"/>
		</operation>
	</portType>
	<binding name="GetPosts_Binding" type="tns:RequestGetPosts_PortType">
		<soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
		<operation name="GetPosts">
			<soap:operation soapAction="GetPosts"/>
			<input>
				<soap:body
					encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
					namespace="urn:thegeek-getpostsservice"
					use="encoded"/>
			</input>
			<output>
				<soap:body
					encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
					namespace="urn:thegeek-getpostsservice"
					use="encoded"/>
			</output>
		</operation>
	</binding>
	<service name="GetPosts_Service">
		<documentation>Return latest posts</documentation>
		<port binding="tns:GetPosts_Binding" name="GetPosts_Port">
			<soap:address location="http://thegeek.de/wp-soap/index.php"/>
		</port>
	</service>

</definitions>

Diese WSDL definiert eine einfache Funktion “GetPosts” mit einer eingehenden Nachricht und einer ausgehenden Nachricht. Für die einzelnen Felder der Nachrichten sind entsprechende Typen definiert. Nachdem die Nachrichten an die Operation “GetPosts” gebunden wurden, wird mit dieser Operation ein Soap-Service definiert. Ein Service besteht also aus einem Binding, welches wiederum aus eine Input- und/oder Output-Message besteht. Das klingt nun zugegeben ziemlich kompliziert, ist aber in der Praxis wirklich einfach nachzuvollziehen, wenn wir uns mal den Server-Quellcode zu dieser WSDL Definition ansehen.

<?php

// SOAP config array
$soap_config = array( 'encoding' => 'UTF-8' );

// Don't cache WSDL files, mandatory for development
ini_set( 'soap.wsdl_cache_enabled', '0' );

class thegeek_soapserver
{
	function __construct( $parameters )
	{

	}

	public function GetPosts( $apikey = '', $num = 10 )
	{
		if( $apikey == 'demoapikey' )
		{
			$posts = array( 	array( 'title' => 'Demo Post 1', 'body' => 'Demo content 1' ),
						array( 'title' => 'Demo Post 2', 'body' => 'Demo content 2' ),
						array( 'title' => 'Demo Post 3', 'body' => 'Demo content 3' ),
						array( 'title' => 'Demo Post 4', 'body' => 'Demo content 4' )
			);
			return array(	'return' => true,
					'error' => '',
					'posts' => $posts,
					'posts_count' => 0
			);
		}
		// API KEY FAIL
		else
		{
			return array(	'return' => false,
					'error' => 'API KEY INVALID',
					'posts' => array(),
					'posts_count' => 0
			);
		}
	}
}

// Run SOAP server
$soapserver = new SoapServer( 'http://thegeek.de/wp-soap/thegeek.wsdl', $soap_config );
$soapserver -> setClass( 'thegeek_soapserver', 'some parameters for the constructor (example only...)' );
$soapserver -> handle();

?>

Nachdem die Soap-Config für die PHP Klasse “SoapServer” definiert und das caching von WSDL Dateien per “ini_set” ausgeschaltet wurde, folgt unsere eigene Klasse, die den Web-Service abbildet. Der Konstruktor kann wie gewohnt definiert werden, auch beim Initialisieren unserer Klasse über die PHP Klasse “SoapServer”, können beliebige Parameter übergeben werden. Übrigens sind auch extends problemlos möglich.

Dann findet sich in der Klasse eine Methode, welche unseren SoapService “GetPosts” abbildet, als Übergabeparameter sind die Variablen unserer Input-Nachricht angegeben. Wie die Variablennamen in der Methode gewählt werden ist egal, aber die Methode muss genau so heißen, wie in der WSDL angegeben (soap:operation soapAction=”GetPosts”). Der Code in der Methode dient natürlich nur der Verdeutlichung, wie Rückgaben erfolgen, nämlich als assoziatives Array, welches die in der WSDL definierte Output-Nachricht abbildet.

Um unsere Server-Klasse dann zu initialisieren, wird die PHP Klasse “SoapServer” mit entsprechenden Parametern (Web-Pfad zur WSDL, SoapConfig) aufgerufen. Danach wird mit Hilfe der Methode “setClass” unsere Klasse als Handler ausgewählt und der Server letztendlich mit der Methode “handle” konstruiert.

Fehlt eigentlich nur noch ein kleiner Test-Client:

<?php

// Create new SOAP client
$soap_client = new SoapClient( 'http://thegeek.de/wp-soap/thegeek.wsdl', array( 'encoding' => 'UTF-8' ) );
if( is_object( $soap_client ) )
{
	$soap_result = $soap_client -> GetPosts( 'demoapikey', 10 );
	// Debug output
	echo "<pre>";
	print_r( $soap_result );
	echo "</pre>";
}
else	die( 'SOAP Server not available' );

?>

Der Client ist ziemlich problemlos umzusetzen: Einfach mit der PHP Klasse “SoapClient” ein Client-Objekt erzeugen (Web-Pfad zur WSDL übergeben) und die Methoden (= Operationen) wie in der WSDL definiert nutzen. Obiges Beispiel gibt folgendes aus:

Array
(
    [returncode] =>
    [error] =>
    [posts] => Array
        (
            [0] => Array
                (
                    [title] => Demo Post 1
                    [body] => Demo content 1
                )

            [1] => Array
                (
                    [title] => Demo Post 2
                    [body] => Demo content 2
                )

            [2] => Array
                (
                    [title] => Demo Post 3
                    [body] => Demo content 3
                )

            [3] => Array
                (
                    [title] => Demo Post 4
                    [body] => Demo content 4
                )

        )

    [posts_count] => 0
)

So schwierig ist das mit SOAP und PHP also nicht. Wichtig ist allerdings noch: PHP muss mit der Option “–enable-soap” kompiliert werden, um die SOAP Extension nutzen zu können. Alternativ kann aber auch das SOAP PEAR Paket genutzt oder auf die Klasse nuSoap zurückgegriffen werden.

Wer selbst mal von seinem Webspace aus testen will: http://thegeek.de/wp-soap/thegeek.wsdl

Wer Fragen hat: Comments are open.

Wenn ich an einem Plugin also nur kleine Änderungen gemacht habe, die ich eben schnell ins Repository schubsen will, dann kopiere ich die geänderten Dateien einfach in den trunk, erhöhe die Version im SVN Script und rufe dieses anschließend auf. Die neue Version wird dann eingecheckt und der neue tag erstellt.

<?php
	// Config
	$plugin_src	= '/home/www/example/src/article2pdf/';
	$svn_home	= '/home/www/example/src/article2pdf/svn/article2pdf/';
	$svn_trunk	= '/home/www/example/src/article2pdf/svn/article2pdf/trunk/';
	$svn_tags	= '/home/www/example/src/article2pdf/svn/article2pdf/tags/';
	$svn_user	= 'the_user';
	$svn_passwd	= 'the_password';

	// Version values
	$version	= '0.27';
	$message	= 'Adding some new functions.';

	// Set home for svn, important, or svn will not work!
	putenv( "HOME=$svn_home" );

	// Up
	echo passthru( "cd $svn_home ; svn up", $ret );
	if( $ret === 0 )
	{
		// Stat
		echo passthru( "cd $svn_home ; svn stat", $ret );
		if( $ret === 0 )
		{
			// Check in trunk
			echo passthru( "cd $svn_home ; svn ci --username $svn_user --password $svn_passwd -m '$message'", $ret );
			if( $ret === 0 )
			{
				// Copy new version to tag
				echo passthru( "cd $svn_home ; svn cp trunk tags/$version", $ret );
				if( $ret === 0 )
				{
					// Stat and check in new version
					echo passthru( "cd $svn_home ; svn stat", $ret );
					echo passthru( "cd $svn_home ; svn ci --username $svn_user --password $svn_passwd -m 'Tagging $version'", $ret );
				}
			}
		}
	}
?>

Wichtig ist per putenv das HOME-Verzeichnis auf den Pfad zum SVN Verzeichnis zu setzen, da SVN über PHP sonst nicht funktioniert. SVN braucht zwingend im Environment eine passende HOME-Angabe. Diese Umgebungsvariable scheint aber standardmäßig von PHP nicht gesetzt zu sein.

Die Funktion ist zwar nicht perfekt, mir reichte sie jedoch.

<?php
function get_friends( $screen_name, $page_limit = 200 )
{
	$screen_names = array();
	for( $page = 1; $page < $page_limit; $page++ )
	{
		ob_start();
		$friends_json = file_get_contents( 'http://twitter.com/statuses/friends.json?screen_name=' . $screen_name . '&page=' . $page );
		$errors = ob_get_contents();
		ob_end_clean();
		if( $friends_json !== false )
		{
			$friends = json_decode( $friends_json );
			if( is_array( $friends ) && count( $friends ) )
			{
				foreach( $friends AS $friend )
					$screen_names[ $friend -> id ] = $friend -> screen_name;
			}
			else
			if( !count( $friends ) )
			{
				break;
			}
			else
			{
				$screen_names = array();
				break;
			}
		}
		else	break;
	}
	if( count( $screen_names ) || $errors == '' )
	{
		return $screen_names;
	}
	else
	{
		if( strpos( $errors, '401 Unauthorized' ) !== false )
			return false;
		else
			return null;
	}
}

// Example usage
print_r( get_friends( 'motorradblogger' ) );
?>

Schade übrigens, dass die Anzahl der Requests pro Stunde bei Twitter limitiert ist, sonst ließen sich ziemlich schnell, ziemlich viele Twitter-Accounts crawlen. ;-)

Die Benutzung ist sehr simpel: Einfach den Accountnamen übergeben, die Funktion läd Seitenweise alle Accounts, denen gefolgt wird und gibt diese in einem assoziativen Array (Schlüssel: Account-ID, Wert: Accountname) zurück. Im Falle eines Fehlers wird ‘false’ zurückgegeben, bei einem unbekannten Fehler ‘null’.