FluentDOM Package
Current file: /tmp/FluentDOM/FluentDOM/Handler.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% 4 / 4
100.00%100.00%
100.00% 44 / 44
 
FluentDOMHandler
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 4 / 4
100.00%100.00%
100.00% 44 / 44
 public static function insertNodesAfter($targetNode, $contentNodes)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 11 / 11
 public static function insertNodesBefore($targetNode, $contentNodes)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 10 / 10
 public static function appendChildren($targetNode, $contentNodes)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 10 / 10
 public static function insertChildrenBefore($targetNode, $contentNodes)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 13 / 13


       1                 : <?php                                                                                      
       2                 : /**                                                                                        
       3                 : * FluentDOMHandler provides dom manipulation functions                                     
       4                 : *                                                                                          
       5                 : * @version $Id: Handler.php 429 2010-03-29 08:05:32Z subjective $                          
       6                 : * @license http://www.opensource.org/licenses/mit-license.php The MIT License              
       7                 : * @copyright Copyright (c) 2009-2010 Bastian Feder, Thomas Weinert                         
       8                 : *                                                                                          
       9                 : * @package FluentDOM                                                                       
      10                 : */                                                                                         
      11                 :                                                                                            
      12                 : /**                                                                                        
      13                 : * FluentDOMHandler provides dom manipulation functions                                     
      14                 : *                                                                                          
      15                 : * @package FluentDOM                                                                       
      16                 : */                                                                                         
      17                 : class FluentDOMHandler {                                                                   
      18                 :                                                                                            
      19                 :   /**                                                                                      
      20                 :   * Insert nodes after the target node.                                                    
      21                 :   * @param DOMNode $targetNode                                                             
      22                 :   * @param array|DOMNodeList|FluentDOM $contentNodes                                       
      23                 :   */                                                                                       
      24                 :   public static function insertNodesAfter($targetNode, $contentNodes) {                    
      25               1 :     $result = array();                                                                     
      26               1 :     if (isset($targetNode->parentNode) &&                                                  
      27               1 :         !empty($contentNodes)) {                                                           
      28               1 :       $beforeNode = $targetNode->nextSibling;                                              
      29               1 :       foreach ($contentNodes as $contentNode) {                                            
      30               1 :         $result[] = $targetNode->parentNode->insertBefore(                                 
      31               1 :           $contentNode->cloneNode(TRUE), $beforeNode                                       
      32               1 :         );                                                                                 
      33               1 :       }                                                                                    
      34               1 :     }                                                                                      
      35               1 :     return $result;                                                                        
      36                 :   }                                                                                        
      37                 :                                                                                            
      38                 :   /**                                                                                      
      39                 :   * Insert nodes before the target node.                                                   
      40                 :   * @param DOMNode $targetNode                                                             
      41                 :   * @param array|DOMNodeList|FluentDOM $contentNodes                                       
      42                 :   */                                                                                       
      43                 :   public static function insertNodesBefore($targetNode, $contentNodes) {                   
      44               2 :     $result = array();                                                                     
      45               2 :     if (isset($targetNode->parentNode) &&                                                  
      46               2 :         !empty($contentNodes)) {                                                           
      47               2 :       foreach ($contentNodes as $contentNode) {                                            
      48               2 :         $result[] = $targetNode->parentNode->insertBefore(                                 
      49               2 :           $contentNode->cloneNode(TRUE), $targetNode                                       
      50               2 :         );                                                                                 
      51               2 :       }                                                                                    
      52               2 :     }                                                                                      
      53               2 :     return $result;                                                                        
      54                 :   }                                                                                        
      55                 :                                                                                            
      56                 :   /**                                                                                      
      57                 :   * Append nodes into target.                                                              
      58                 :   *                                                                                        
      59                 :   * @param DOMNode $targetNode                                                             
      60                 :   * @param array|DOMNodeList|FluentDOM $contentNodes                                       
      61                 :   */                                                                                       
      62                 :   public static function appendChildren($targetNode, $contentNodes) {                      
      63               1 :     $result = array();                                                                     
      64               1 :     if ($targetNode instanceof DOMElement) {                                               
      65               1 :       foreach ($contentNodes as $contentNode) {                                            
      66               1 :         if ($contentNode instanceof DOMElement ||                                          
      67               1 :             $contentNode instanceof DOMText) {                                             
      68               1 :           $result[] = $targetNode->appendChild($contentNode->cloneNode(TRUE));             
      69               1 :         }                                                                                  
      70               1 :       }                                                                                    
      71               1 :     }                                                                                      
      72               1 :     return $result;                                                                        
      73                 :   }                                                                                        
      74                 :                                                                                            
      75                 :   /**                                                                                      
      76                 :   * Insert nodes into target as first childs.                                              
      77                 :   *                                                                                        
      78                 :   * @param DOMNode $targetNode                                                             
      79                 :   * @param array|DOMNodeList|FluentDOM $contentNodes                                       
      80                 :   */                                                                                       
      81                 :   public static function insertChildrenBefore($targetNode, $contentNodes) {                
      82               1 :     $result = array();                                                                     
      83               1 :     if ($targetNode instanceof DOMElement) {                                               
      84               1 :       $firstChild = $targetNode->hasChildNodes() ? $targetNode->childNodes->item(0) : NULL;
      85               1 :       foreach ($contentNodes as $contentNode) {                                            
      86               1 :         if ($contentNode instanceof DOMElement ||                                          
      87               1 :             $contentNode instanceof DOMText) {                                             
      88               1 :           $result[] = $targetNode->insertBefore(                                           
      89               1 :             $contentNode->cloneNode(TRUE),                                                 
      90                 :             $firstChild                                                                    
      91               1 :           );                                                                               
      92               1 :         }                                                                                  
      93               1 :       }                                                                                    
      94               1 :     }                                                                                      
      95               1 :     return $result;                                                                        
      96                 :   }                                                                                        

Generated by PHPUnit 3.4.12 and Xdebug 2.0.5 using PHP 5.2.13 at Sun Sep 26 1:00:19 CEST 2010.