SourPHPTest
Current file: /var/www/github/SourPHP/classes/SourPHPCore.php
Legend: executed not executed dead code

  Coverage
  Classes Functions / Methods Lines
Total
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 10 / 10
100.00%100.00%
100.00% 76 / 76
 
SourPHPCore
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 10 / 10
100.00%100.00%
100.00% 76 / 76
 public function __construct()
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 3 / 3
 function fetchUrl($url)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 3 / 3
 function fetchId( $entryId )
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 5 / 5
 function fetchEntry( $entryName , $page=1)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 11 / 11
 function createDomDocumentFromData($data)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 5 / 5
 function XPathQueryToDoc($doc, $queryString)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 3 / 3
 function getEntryTitleFromDoc($doc)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 6 / 6
 function getNumberOfPages($doc)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 6 / 6
 function parseAuthorAndDateFromString($string)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 10 / 10
 function getContentOfEntriesFromDoc($doc)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 24 / 24


       1                 : <?                                                                                                                 
       2                 : /**                                                                                                                
       3                 :  * SourPHPCore                                                                                                     
       4                 :  *                                                                                                                 
       5                 :  * LICENSE                                                                                                         
       6                 :  *                                                                                                                 
       7                 :  * This file can be distributed under terms of LGPL                                                                
       8                 :  *                                                                                                                 
       9                 :  * @package    SourPHP                                                                                             
      10                 :  * @copyright  Osman Yuksel                                                                                        
      11                 :  * @LICENSE    http://www.gnu.org/licenses/lgpl-3.0.txt                                                            
      12                 :  * @version    0.1                                                                                                 
      13                 :  */                                                                                                                
      14                 :                                                                                                                    
      15                 :                                                                                                                    
      16                 :                                                                                                                    
      17                 : /**                                                                                                                
      18                 :  * SourPHPCore                                                                                                     
      19                 :  *                                                                                                                 
      20                 :  * PHP Client to fetch data from http://sozluk.sourtimes.org                                                       
      21                 :  * @author    Osman Yuksel <yuxel |AT| sonsuzdongu |DOT| com>                                                      
      22                 :  */                                                                                                                
      23                 : class SourPHPCore{                                                                                                 
      24                 :                                                                                                                    
      25                 :     /**                                                                                                            
      26                 :      * Default request address                                                                                     
      27                 :      *                                                                                                             
      28                 :      * @var String                                                                                                  
      29                 :      */                                                                                                            
      30                 :     protected static $url = null;                                                                                  
      31                 :                                                                                                                    
      32                 :     /**                                                                                                            
      33                 :      * Num of entries per page                                                                                     
      34                 :      *                                                                                                             
      35                 :      * @var String                                                                                                  
      36                 :      */                                                                                                            
      37                 :     protected static $contentPerPage = null;                                                                       
      38                 :                                                                                                                    
      39                 :                                                                                                                    
      40                 :                                                                                                                    
      41                 :     /**                                                                                                            
      42                 :      * Init default parameters                                                                                     
      43                 :      */                                                                                                            
      44                 :     public function __construct() {                                                                                
      45              27 :         $this->url = "http://sozluk.sourtimes.org/";                                                               
      46              27 :         $this->contentPerPage = 25;                                                                                 
      47              27 :     }                                                                                                              
      48                 :                                                                                                                    
      49                 :                                                                                                                    
      50                 :                                                                                                                    
      51                 :     /**                                                                                                            
      52                 :      * fetchs data from Url                                                                                        
      53                 :      *                                                                                                             
      54                 :      * @param  string $url                                                                                         
      55                 :      * @return string Content of url, returns false if fails                                                       
      56                 :      */                                                                                                            
      57                 :     function fetchUrl($url) {                                                                                      
      58              21 :         if( $data = @file_get_contents($url) ) {                                                                   
      59              20 :             return $data;                                                                                          
      60                 :         }                                                                                                          
      61               1 :         return false;                                                                                              
      62                 :     }                                                                                                              
      63                 :                                                                                                                    
      64                 :     /**                                                                                                            
      65                 :      * fetchs an entry id's data                                                                                   
      66                 :      *                                                                                                             
      67                 :      * @param  int $entryId                                                                                        
      68                 :      * @return string Content of url                                                                               
      69                 :      */                                                                                                            
      70                 :     function fetchId( $entryId ) {                                                                                 
      71               7 :         $entryId = (int) $entryId;                                                                                 
      72               7 :         if($entryId < 1) {                                                                                         
      73                 :             /**                                                                                                    
      74                 :              * if entry id is not valid                                                                            
      75                 :              */                                                                                                    
      76               1 :             return false;                                                                                          
      77                 :         }                                                                                                          
      78               6 :         $url = $this->url."show.asp?id=".$entryId;                                                                 
      79                 :                                                                                                                    
      80               6 :         return $this->fetchUrl($url);                                                                              
      81                 :     }                                                                                                              
      82                 :                                                                                                                    
      83                 :     /**                                                                                                            
      84                 :      * fetchs an entry per page                                                                                    
      85                 :      *                                                                                                             
      86                 :      * @param  string $entryName                                                                                   
      87                 :      * @param  int $page                                                                                           
      88                 :      * @return string Content of entry                                                                             
      89                 :      */                                                                                                            
      90                 :     function fetchEntry( $entryName , $page=1) {                                                                   
      91              14 :         $page = (int) $page;                                                                                       
      92              14 :         $entryName = (string) $entryName;                                                                          
      93              14 :         if(strlen($entryName) < 1 ) {                                                                              
      94                 :             /**                                                                                                    
      95                 :              * if entry name is not valid                                                                          
      96                 :              */                                                                                                    
      97               1 :             return false;                                                                                          
      98                 :         }                                                                                                          
      99              13 :         $encodedEntryName = urlencode( trim($entryName) );                                                         
     100                 :                                                                                                                    
     101              13 :         $pageToGo = 1;                                                                                             
     102              13 :         if($page > 1 ) {                                                                                           
     103               5 :             $pageToGo = $page;                                                                                     
     104               5 :         }                                                                                                          
     105                 :                                                                                                                    
     106              13 :         $url = $this->url."show.asp?t=".$encodedEntryName."&p=".$pageToGo;                                         
     107                 :                                                                                                                    
     108              13 :         return $this->fetchUrl($url);                                                                              
     109                 :     }                                                                                                              
     110                 :                                                                                                                    
     111                 :                                                                                                                    
     112                 :                                                                                                                    
     113                 :    /**                                                                                                             
     114                 :      * creates new DomDocument from data retreived from url                                                        
     115                 :      *                                                                                                             
     116                 :      * @param string $data                                                                                         
     117                 :      * @return DomDucument object                                                                                  
     118                 :      */                                                                                                            
     119                 :     function createDomDocumentFromData($data) {                                                                    
     120              17 :         if(!$data) {                                                                                               
     121               1 :             return false;                                                                                          
     122                 :         }                                                                                                          
     123              16 :         $doc = new DOMDocument();                                                                                  
     124              16 :         $doc->loadHTML ($data);                                                                                    
     125              16 :         return $doc;                                                                                               
     126                 :     }                                                                                                              
     127                 :                                                                                                                    
     128                 :                                                                                                                    
     129                 :     /**                                                                                                            
     130                 :      * executes and XPathQuery to Document and returns results                                                     
     131                 :      * as array                                                                                                    
     132                 :      *                                                                                                             
     133                 :      * @param DomDocument $doc                                                                                     
     134                 :      * @param string XPathQuery like "//div"                                                                       
     135                 :      * @return array $results                                                                                      
     136                 :      */                                                                                                            
     137                 :     function XPathQueryToDoc($doc, $queryString){                                                                  
     138              15 :         $xpath = new DOMXpath($doc);                                                                               
     139              15 :         $elements = $xpath->query($queryString);                                                                   
     140                 :                                                                                                                            
     141              15 :         return $elements;                                                                                           
     142                 :                                                                                                                    
     143                 :     }                                                                                                              
     144                 :                                                                                                                    
     145                 :     /**                                                                                                            
     146                 :      * finds entry title from read document                                                                        
     147                 :      *                                                                                                             
     148                 :      * @param DomDucument $doc                                                                                     
     149                 :      * @return string title                                                                                        
     150                 :      */                                                                                                            
     151                 :     function getEntryTitleFromDoc($doc) {                                                                          
     152                 :                                                                                                                           
     153              11 :         $query = "//html/body/h1[@class='title']";                                                                 
     154              11 :         $nodeList = $this->XPathQueryToDoc($doc, $query);                                                          
     155                 :                                                                                                                    
     156              11 :         foreach($nodeList as $node) {                                                                              
     157              10 :             return trim($node->nodeValue);                                                                         
     158               1 :         }                                                                                                          
     159                 :                                                                                                                            
     160               1 :         return false;                                                                                              
     161                 :     }                                                                                                              
     162                 :                                                                                                                    
     163                 :                                                                                                                    
     164                 :     /**                                                                                                            
     165                 :      * returns number of total pages from read document                                                            
     166                 :      *                                                                                                             
     167                 :      * @param DomDucument $doc                                                                                     
     168                 :      * @return int number of pages                                                                                 
     169                 :      */                                                                                                            
     170                 :     function getNumberOfPages($doc) {                                                                              
     171                 :                                                                                                                    
     172               7 :         $query = "//select[@class='pagis']/option";                                                                
     173               7 :         $nodeList = $this->XPathQueryToDoc($doc, $query);                                                          
     174                 :                                                                                                                    
     175               7 :         foreach($nodeList as $node) {                                                                              
     176               6 :             $totalPageNum = $node->nodeValue;                                                                      
     177               7 :         }                                                                                                          
     178                 :                                                                                                                    
     179               7 :         return (int) $totalPageNum;                                                                                
     180                 :     }                                                                                                              
     181                 :                                                                                                                    
     182                 :                                                                                                                    
     183                 :     /**                                                                                                            
     184                 :      * parses author, dateCreated and dateEdited from $string                                                      
     185                 :      */                                                                                                            
     186                 :     function parseAuthorAndDateFromString($string){                                                                
     187               8 :         $trimSpaces = trim($string);                                                                               
     188               8 :         $trimmed = trim($trimSpaces, "(");                                                                         
     189               8 :         $exploded = explode(")", $trimmed);                                                                        
     190               8 :         $content = $exploded[0];                                                                                   
     191                 :                                                                                                                    
     192               8 :         list($author, $dates) = explode(",", $content);                                                            
     193               8 :         list($dateCreated, $dateEdited) = explode("~", $dates);                                                    
     194                 :                                                                                                                    
     195               8 :         $author = trim($author);                                                                                   
     196               8 :         $dateCreated = strtotime( trim( $dateCreated) );                                                           
     197               8 :         $dateEdited = strtotime( trim ( $dateEdited) );                                                            
     198                 :                                                                                                                    
     199               8 :         return array($author, $dateCreated, $dateEdited);                                                          
     200                 :     }                                                                                                              
     201                 :                                                                                                                    
     202                 :                                                                                                                    
     203                 :     /**                                                                                                            
     204                 :      * returns content of entry from read document                                                                 
     205                 :      *                                                                                                             
     206                 :      * @param DomDucument $doc                                                                                     
     207                 :      * @return array entries[content, author, id, order, datetime]                                                 
     208                 :      */                                                                                                            
     209                 :     function getContentOfEntriesFromDoc($doc) {                                                                    
     210              10 :         if(!$doc) {                                                                                                
     211               1 :             return false;                                                                                          
     212                 :         }                                                                                                          
     213                 :                                                                                                                    
     214                 :         // this xpath query etches li element which as all details of entry                                        
     215               9 :         $query = "//ol[@id='el']/li";                                                                              
     216                 :                                                                                                                    
     217                 :         //find title                                                                                               
     218               9 :         $title = $this->getEntryTitleFromDoc($doc);                                                                
     219                 :                                                                                                                    
     220               9 :         $nodeList = $this->XPathQueryToDoc($doc, $query);                                                          
     221                 :                                                                                                                            
     222               9 :         foreach($nodeList as $node) {                                                                              
     223               8 :             $childCount = $node->childNodes->length;                                                               
     224                 :                                                                                                                    
     225                 :             //lastNode has information about author and dates                                                      
     226               8 :             $lastNode = $node->childNodes->item($childCount-1);                                                    
     227               8 :             list($author, $dateCreated, $dateEdited) = $this->parseAuthorAndDateFromString($lastNode->textContent);
     228                 :                                                                                                                    
     229                 :             //if we remove lastChild, our node is our content                                                      
     230               8 :             $node->removeChild ($lastNode );                                                                       
     231               8 :             $contentNode = $node;                                                                                  
     232                 :                                                                                                                    
     233               8 :             $content = $contentNode->textContent;                                                                  
     234                 :                                                                                                                    
     235               8 :             $entryId = $node->getAttribute('id');                                                                  
     236               8 :             $entryId = (int) preg_replace ( '/[^0-9]/', '', $entryId );                                            
     237                 :                                                                                                                    
     238               8 :             $order = (int) $node->getAttribute("value");                                                           
     239                 :                                                                                                                    
     240               8 :             $results[] = array("entryId"=>$entryId,                                                                
     241               8 :                                "title"=>$title,                                                                    
     242               8 :                                "content"=>$content,                                                                
     243               8 :                                "order"=>$order,                                                                    
     244               8 :                                "author"=>$author,                                                                  
     245               8 :                                "dateCreated"=>$dateCreated,                                                        
     246                 :                                "dateEdited"=>$dateEdited                                                            
     247               8 :                                );                                                                                  
     248                 :                                                                                                                    
     249               9 :         }                                                                                                          
     250                 :                                                                                                                    
     251               9 :         return empty($results)?false:$results;                                                                     
     252                 :                                                                                                                    
     253                 :     }                                                                                                              
     254                 : }                                                                                                                  

Generated by PHPUnit 3.4.1 and Xdebug 2.0.5 at Sat Dec 19 12:27:11 EET 2009.