home *** CD-ROM | disk | FTP | other *** search
/ Cricao de Sites - 650 Layouts Prontos / WebMasters.iso / Servidores / xampp-win32-1.6.7-installer.exe / php / PEAR / phing / parser / TaskHandler.php < prev   
Encoding:
PHP Script  |  2007-02-06  |  8.9 KB  |  235 lines
  1. <?php
  2. /*
  3.  *  $Id: TaskHandler.php 147 2007-02-06 20:32:22Z hans $
  4.  *
  5.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  6.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  7.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  8.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  9.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  10.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  11.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  12.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  13.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  14.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  15.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  16.  *
  17.  * This software consists of voluntary contributions made by many individuals
  18.  * and is licensed under the LGPL. For more information please see
  19.  * <http://phing.info>.
  20.  */
  21.  
  22. include_once 'phing/UnknownElement.php';
  23.  
  24. /**
  25.  * The task handler class.
  26.  *
  27.  * This class handles the occurance of a <task> tag and it's possible
  28.  * nested tags (datatypes and tasks) that may be unknown off bat and are
  29.  * initialized on the fly.
  30.  *
  31.  * @author      Andreas Aderhold <andi@binarycloud.com>
  32.  * @copyright ∩┐╜ 2001,2002 THYRELL. All rights reserved
  33.  * @version   $Revision: 1.10 $
  34.  * @package   phing.parser
  35.  */
  36. class TaskHandler extends AbstractHandler {
  37.  
  38.     /**
  39.      * Reference to the target object that contains the currently parsed
  40.      * task
  41.      * @var object the target instance
  42.      */
  43.     private $target;
  44.  
  45.     /**
  46.      * Reference to the target object that represents the currently parsed
  47.      * target. This must not necessarily be a target, hence extra variable.
  48.      * @var object the target instance
  49.      */
  50.     private $container;
  51.  
  52.     /**
  53.      * Reference to the task object that represents the currently parsed
  54.      * target.
  55.      * @var Task
  56.      */
  57.     private $task;
  58.     
  59.     /**
  60.       * Wrapper for the parent element, if any. The wrapper for this
  61.      * element will be added to this wrapper as a child.
  62.      * @var RuntimeConfigurable
  63.      */
  64.     private $parentWrapper;
  65.     
  66.     /**
  67.      * Wrapper for this element which takes care of actually configuring
  68.      * the element, if this element is contained within a target.
  69.      * Otherwise the configuration is performed with the configure method.
  70.      * @see ProjectHelper::configure(Object,AttributeList,Project)
  71.      */
  72.     private $wrapper;
  73.  
  74.     /**
  75.      * The phing project configurator object
  76.      * @var ProjectConfigurator
  77.      */
  78.     private $configurator;
  79.  
  80.     /**
  81.      * Constructs a new TaskHandler and sets up everything.
  82.      *
  83.      * @param AbstractSAXParser The ExpatParser object
  84.      * @param object $parentHandler The parent handler that invoked this handler
  85.      * @param ProjectConfigurator $configurator
  86.      * @param TaskContainer $container The container object this task is contained in (null for top-level tasks).
  87.      * @param RuntimeConfigurable $parentWrapper  Wrapper for the parent element, if any.
  88.      * @param Target $target The target object this task is contained in (null for top-level tasks).
  89.      */
  90.     function __construct(AbstractSAXParser $parser, $parentHandler, ProjectConfigurator $configurator, $container = null, $parentWrapper = null, $target = null) {
  91.         
  92.         parent::__construct($parser, $parentHandler);
  93.     
  94.         if (($container !== null) && !($container instanceof TaskContainer)) {
  95.             throw new Exception("Argument expected to be a TaskContainer, got something else");
  96.         }
  97.         if (($parentWrapper !== null) && !($parentWrapper instanceof RuntimeConfigurable)) {
  98.             throw new Exception("Argument expected to be a RuntimeConfigurable, got something else.");
  99.         }
  100.         if (($target !== null) && !($target instanceof Target)) {
  101.             throw new Exception("Argument expected to be a Target, got something else");
  102.         }
  103.  
  104.         $this->configurator = $configurator;
  105.         $this->container = $container;
  106.         $this->parentWrapper = $parentWrapper;
  107.         $this->target = $target;
  108.     }
  109.  
  110.     /**
  111.      * Executes initialization actions required to setup the data structures
  112.      * related to the tag.
  113.      * <p>
  114.      * This includes:
  115.      * <ul>
  116.      * <li>creation of the task object</li>
  117.      * <li>calling the setters for attributes</li>
  118.      * <li>adding the task to the container object</li>
  119.      * <li>adding a reference to the task (if id attribute is given)</li>
  120.      * <li>executing the task if the container is the <project>
  121.      * element</li>
  122.      * </ul>
  123.      *
  124.      * @param string $tag The tag that comes in
  125.      * @param array $attrs Attributes the tag carries
  126.      * @throws ExpatParseException if attributes are incomplete or invalid
  127.      */
  128.     function init($tag, $attrs) {
  129.         // shorthands
  130.         try {
  131.             $configurator = $this->configurator;
  132.             $project = $this->configurator->project;
  133.             
  134.             $this->task = $project->createTask($tag);
  135.         } catch (BuildException $be) {
  136.             // swallow here, will be thrown again in
  137.             // UnknownElement->maybeConfigure if the problem persists.
  138.             print("Swallowing exception: ".$be->getMessage() . "\n");
  139.         }
  140.  
  141.         // the task is not known of bat, try to load it on thy fly
  142.         if ($this->task === null) {
  143.             $this->task = new UnknownElement($tag);
  144.             $this->task->setProject($project);
  145.             $this->task->setTaskType($tag);
  146.             $this->task->setTaskName($tag);
  147.         }
  148.  
  149.         // add file position information to the task (from parser)
  150.         // should be used in task exceptions to provide details
  151.         $this->task->setLocation($this->parser->getLocation());
  152.         $configurator->configureId($this->task, $attrs);
  153.         
  154.         if ($this->container) {
  155.             $this->container->addTask($this->task);
  156.         }
  157.         
  158.         // Top level tasks don't have associated targets
  159.         // FIXME: if we do like Ant 1.6 and create an implicitTarget in the projectconfigurator object
  160.         // then we don't need to check for null here ... but there's a lot of stuff that will break if we
  161.         // do that at this point.
  162.         if ($this->target !== null) {
  163.             $this->task->setOwningTarget($this->target);
  164.             $this->task->init();
  165.             $this->wrapper = $this->task->getRuntimeConfigurableWrapper();
  166.             $this->wrapper->setAttributes($attrs);
  167.             /*
  168.             Commenting this out as per thread on Premature configurate of ReuntimeConfigurables 
  169.             with Matthias Pigulla: http://phing.tigris.org/servlets/ReadMsg?list=dev&msgNo=251
  170.             
  171.             if ($this->parentWrapper !== null) { // this may not make sense only within this if-block, but it
  172.                                                 // seems to address current use cases adequately
  173.                 $this->parentWrapper->addChild($this->wrapper);
  174.             }
  175.             */
  176.         } else {
  177.             $this->task->init();
  178.             $configurator->configure($this->task, $attrs, $project);
  179.         }
  180.     }
  181.  
  182.     /**
  183.      * Executes the task at once if it's directly beneath the <project> tag.
  184.      */
  185.     protected function finished() {
  186.         if ($this->task !== null && $this->target === null && $this->container === null) {
  187.             try {
  188.                 $this->task->perform();
  189.             } catch (Exception $e) {
  190.                 $this->task->log($e->getMessage(), Project::MSG_ERR);
  191.                 throw $e;
  192.             }
  193.         }
  194.     }
  195.  
  196.     /**
  197.      * Handles character data.
  198.      *
  199.      * @param string $data The CDATA that comes in
  200.      */
  201.     function characters($data) {
  202.         if ($this->wrapper === null) {
  203.             $configurator = $this->configurator;
  204.             $project = $this->configurator->project;
  205.             try { // try
  206.                 $configurator->addText($project, $this->task, $data);
  207.             } catch (BuildException $exc) {
  208.                 throw new ExpatParseException($exc->getMessage(), $this->parser->getLocation());
  209.             }
  210.         } else {
  211.             $this->wrapper->addText($data);
  212.         }
  213.     }
  214.  
  215.     /**
  216.      * Checks for nested tags within the current one. Creates and calls
  217.      * handlers respectively.
  218.      *
  219.      * @param string $name The tag that comes in
  220.      * @param array $attrs Attributes the tag carries
  221.      */
  222.     function startElement($name, $attrs) {
  223.         $project = $this->configurator->project;
  224.         if ($this->task instanceof TaskContainer) {
  225.             //print("TaskHandler::startElement() (TaskContainer) name = $name, attrs = " . implode(",",$attrs) . "\n");
  226.             $th = new TaskHandler($this->parser, $this, $this->configurator, $this->task, $this->wrapper, $this->target);
  227.             $th->init($name, $attrs);
  228.         } else {
  229.             //print("TaskHandler::startElement() name = $name, attrs = " . implode(",",$attrs) . "\n");
  230.             $tmp = new NestedElementHandler($this->parser, $this, $this->configurator, $this->task, $this->wrapper, $this->target);
  231.             $tmp->init($name, $attrs);
  232.         }
  233.     }
  234. }
  235.