Google Ranking Script funktioniert nicht Bitte um Hilfe

#!/usr/bin/php
<?php
/**
 * alle benötigten Klassen liegen in Dateien, die heißen
 * wie die Klassen, im selben Verzeichnis.
 */
function __autoload($class)
{
    require_once($class.'.php');
}


// der Suchbegriff
$keyword = 'seo';


// die Ziel-Domain
$domain = 'webspurt.de';


// die maximale Suchtiefe
$searchDepth = 50;


// die Verbindung zu Google
$google = new googleEngine();


// der Ranking-Checker
$checker = new rankingChecker($google);


/**
 * Einlesen der Parameter
 */


// der erste Parameter gibt den Suchbegriff an
if (!$keyword = $argv[1]) {
    die("SEO");
}


// der zweite Parameter gibt die Ziel-Domain an
if (!$domain = $argv[2]) {
    die("www.webspurt.de");
}


// der dritte Parameter ist optional und gibt die maximale Suchtiefe an
if ($argv[3]) {
    $searchDepth = (int) $argv[3];
}


/**
 * Starten der Abfrage
 */


$checker->setDomain($domain)
        ->setSearchDepth($searchDepth);


$rank = $checker->getRanking($keyword);


if ($rank <= $searchDepth) {
    printf("Die Domain %s steht für das Keyword \"%s\" an %d. Stelle.\n", $domain, $keyword, $rank);
} else {
    printf("Die Domain %s wird von Google für das Keyword \"%s\" leider nicht unter den ersten %d Treffern geführt.\n", $domain, $keyword, $searchDepth);
}

<?php
/**
 * Ermittelt Suchergebnisse von Google
 * 
 * @author    Nikolas Schmidt-Voigt
 */
 class googleEngine implements searchEngineInterface
{    
    // die Google-Domain, die angefragt wird
    const GOOGLE_DOMAIN = 'www.google.de';
    
    // parameter für die Suche
    protected $_parameter = array();
    
    /**
     * Gibt ein Array mit Suchergebnissen zurück
     * 
     * @param    string    $keyword    die Suchphrase
     * @param    int        $start        die Nummer des ersten Ergebnisses
     * @param    int        $number        die Anzahl der Ergebnisse
     * @return    array                die Suchergebnisse
     */
    public function getResults($keyword, $start = 0, $number = 10)
    {
        // die Ergebnisseite
        $html = '';
        
        // die Ergebnis-URLs
        $resultURLs = array();
        
        $this->setParameter('q', $keyword);
        $this->setParameter('start', $start);
        $this->setParameter('num', $number);
        
        $url  = $this->_getSearchURL();
        $html = file_get_contents($url);        
        $resultURLs = $this->_getLinksFromHTML($html);
        
        return $resultURLs;
    }
    
    /**
     * Setzt den Wert für einen Suchparameter
     * 
     * @param    string    $parameter    der Parameter
     * @param    string    $value        der Wert
     */
    public function setParameter($parameter, $value)
    {
        $this->_parameter[$parameter] = $value;
        return $this;
    }
    
    /**
     * Gibt alle Links von einer Google-Ergebnisseite zurück
     * 
     * die einzelnen Links auf der Ergebnisseite von Google werden über einen Vergleich mit
     * einem regulären Ausdruck ermittelt. Damit arbeitet die Methode auf einer sehr basalen
     * Ebene. Natürlich ließe sich auch ein Vorgehen auf einer abstrakteren Ebene vorstellen. Es 
     * nützt hier aber nur wenig, da wir auf höherer Ebene ebensowenig über den Aufbau der 
     * Suchergebnisseiten wissen wie auf der Ebene des Codes.
     * 
     * @param    string    $html    der HTML-Code
     */
    protected function _getLinksFromHTML ($html)
   {
     $matches = array();
     $links  = array();
   
     $regExRank = '/url\?q=http:\/\/([^\&]+)\&/';
   
     if(preg_match_all($regExRank, $html, $matches)) {
       $links = $matches[1];
     }
   
     return $links;
   }
    
    /**
     * Gibt die URL für eine Suche bei Google zurück
     * 
     * @return    string    die URL
     */
    protected function _getSearchURL()
    {
        return 'http://'.self::GOOGLE_DOMAIN.'/search?'.http_build_query($this->_parameter);
    }
}

<?php
/**
 * Gibt zu einem bestimmten Sucherbegriff das Ranking einer Domain aus
 * 
 * @author    Nikolas Schmidt-Voigt
 */
class rankingChecker
{
    // die Domain, nach der gesucht wird
    protected $_domain = '';
    
    // die Suchtiefe
    protected $_searchDepth = 30;
    
    // die zu nutzende Suchmaschine
    protected $_searchEngine = null;
    
    // die Zeit, die vor einer erneuten Abfrage der Suchergebnisse gewartet werden soll
    protected $_sleeping = 3;
    
    /**
     * Erstellt einen neuen Rankingchecker
     * 
     * der Rankingchecker nutzt die übergebene Verbindung zur Suchmaschine, um die Ergebnisse zu holen.
     * 
     * @param    searchEngineInterface    $searchEngine    die genutzte Suchmaschine
     */
    public function __construct(searchEngineInterface $searchEngine)
    {
        $this->_searchEngine = $searchEngine;
    }
    
    /**
     * Ermittelt das Ranking für ein Keyword
     * 
     * @param    array    $keyword    das Keyword
     */
    public function getRanking($keyword)
    {
        $links        = array();
        $pageLength    = 10;
        
        for ($i = 0; $i < $this->_searchDepth; $i = $i + $pageLength) {
            
            $links = $this->_searchEngine->getResults($keyword, $i, $pageLength);        
        
            foreach ($links as $nr => $li) {
                if(stripos($li, $this->_domain) !== false) {
                    return $nr + $i + 1;
                }
            }
            
            sleep($this->_sleeping);            
        }
        
        return $this->_searchDepth + 1;
    }
    
    /**
     * Legt die Domain fest, nach der gesucht wird
     * 
     * @param    string    $domain    die Domain
     */
    public function setDomain($domain)
    {
        $this->_domain = $domain;
        return $this;
    }
    
    /**
     * Legt die Suchtiefe fest
     * 
     * @param    int        $depth    die Anzahl der Ergebnisse, die untersucht werden sollen
     */
    public function setSearchDepth($depth)
    {
        $this->_searchDepth = $depth;
        return $this;
    }
    
    /**
     * Legt fest, wie viele Sekunden zwischen den einzelnen Anfragen vergehen
     * 
     * wenn zu viele Anfrage zu schnell aufeinander folgen nimmt Google an, dass
     * automatisch abgefragt wird und führt für eine Weile bei allen Zugriffen
     * dieser IP einen Captcha aus
     * 
     * @param    int        $secondsToSleep        die Zahl der Sekunden, die gewartet werden soll
     */
    public function setSleeping($secondsToSleep)
    {
        $this->_sleeping = $secondToSleep;
    }
}

<?php
/**
 * Interface für die Verbindung zu einer Suchmaschine
 */
interface searchEngineInterface
{
    /**
     * Gibt ein Array mit Suchergebnissen zurück
     * 
     * @param    string    $keyword    die Suchphrase
     * @param    int        $start        die Nummer des ersten Ergebnisses
     * @param    int        $number        die Anzahl der Ergebnisse
     * @return    array                die Suchergebnisse
     */
    public function getResults($keyword, $start = 0, $number = 10);
}