interface ButterflyDocument {
  function getContents();
  function writeContents();
}

interface ButterflyXmlDocument extends ButterflyDocument {
  function getDom();
}

				
class ButterflyTransformer {

  private $processor;

  public function __construct ($xslSource) {
    $this->processor = new XSLTProcessor();
    $this->processor->importStylesheet ($xslSource->getDom());
  }

  public function transformToFile ($xmlSource, $filepath) {
    $file = fopen ($filepath, "w");
    fwrite ($file, $this->processor->transformToXml ($xmlSource->getDom()));
    fclose($file);
  }

  public function transformToString ($xmlSource, $filepath) {
    return $this->processor->transformToXml ($xmlSource->getDom());
  }
}

				
class Butterfly implements ButterflyXmlDocument {
                 
  private $transformer;
  private $xmlDoc;
  private $cache;

  public function __construct ($transformer, $xmlDoc, $cache=null) {
    $this->transformer = $transformer;
    $this->xmlSource = $xmlDoc;
    $this->cache = $cache;
  }

  public function getDom() {
    return $this->getTransformedDoc()->getDom();
  }

  public function getContents() {
    return $this->getTransformedDoc()->getContents();
  }

  public function writeContents() {
    $this->getTransformedDoc()->writeContents();
  }

  protected function getTransformedDoc() {
    return ($this->cache != null
        ? $this->getTransformedCache ()
        : $this->getTransformedString ());
  }
 
  protected function getTransformedCache () {
    if (! $this->cache->isPresent()) {    
      $this->transformer->transformToFile ($this->xmlSource,
                       $this->cache->getFilepath());
    }
    return $this->cache;  
  }

  protected function getTransformedString () {
    return new ButterflyXmlString
      ($this->transformer->transformToString ($xmlDoc));
  }
}

				
class ButterflyFile implements ButterflyDocument {

  private $filepath;

  public function __construct($filepath) {
    $this->filepath = $filepath;
  }

  public function getFilepath() {
    return $this->filepath;
  }

  public function isPresent() {
    return file_exists ($this->filepath);
  }

  public function getContents() {
    return file_get_contents($this->filepath);
  }

  public function writeContents() {
    $file = fopen($this->filepath, "r");
    fpassthru($file);
    fclose($file);
  }

  public function delete() {
    unlink ($this->filepath);
  }
}

				
class ButterflyCache extends ButterflyFile {

  public function __construct($filepath) {
    parent::__construct ($filepath);
  }  

}

				
class ButterflyXmlFile extends ButterflyFile implements 
ButterflyXmlDocument {

  public static function create ($filepath) {
    return new ButterflyXmlFile ($filepath);
  }

  public function __construct($filepath) {
    parent::__construct ($filepath);
  }

  public function getDom() {
    $dom = DOMDocument::load($this->getFilepath());
    if (! $dom) {
      throw new Exception ("Couldn't load DOM object from filepath " . 
$this->getFilepath());
    }
    return $dom;
  }
}

				
class ButterflyXmlString implements ButterflyXmlDocument {

  protected $xml;

  public function __construct($xmlString) {
    $this->xml = $xmlString;
  }

  public function getDom() {
    return DOMDocument::load($this->xml);
  }

  public function getContents() {
    return $this->xml;
  }

  public function writeContents() {
    echo ($this->xml);
  }
}

				
<butterfly-config>
  <chain>
    <name>resume</name>
    <source type="ButterflyXmlFile">
      <arg>resume.xml</arg>
    </source>
    <xslt file="resume-restructured.xsl"/>
    <xslt file="resume-restructured-to-view.xsl"/>
    <xslt file="resume-view-to-html.xsl"/>
  </chain>
</butterfly-config>

				
class ButterflyFactory {

  private $cacheDir;
  private $chains;

  public function __construct ($configFile, $cacheDir) {
    $this->cacheDir = $cacheDir;
    $config = simplexml_load_file($configFile);
    $this->chains = $this->mapChainsByName
       (is_array($config->chain) ? $config->chain : array($config->chain));
  }

  protected function mapChainsByName ($chains) {
    $byName = array();
    foreach ($chains as $chain) {
      $name = (string) $chain->name;
      if (isset($byName[$name])) {
    throw new Exception ("Two Butterfly chains defined with the same 
name: $name");
      }
      $byName[$name] = $chain;
    }
    return $byName;
  }

  protected function getChainByName ($name) {
    if (! isset($this->chains[$name])) {
      throw new Exception ("ButterflyFactory: no chain with specified 
name: $name");
    }
    return $this->chains[$name];
  }


  protected function createCacheFactory ($cacheDir) {
    return new ButterflyCacheFactory ($cacheDir);
  }

  protected function createButterflyObject ($transformer, $xmlDoc, $cache) {
    return new Butterfly ($transformer, $xmlDoc, $cache);
  }

  public function createButterfly ($xsltFilepath, $xmlDoc, $cache) {
    return $this->createButterflyObject
      ($this->createTransformerFromFilepath ($xsltFilepath), $xmlDoc, 
$cache);
  }
 
  protected function createTransformerFromFilepath ($xsltFilepath) {
    return new ButterflyTransformer (new ButterflyXmlFile($xsltFilepath));
  }

  public function getButterfly ($chainName) {

    $chain = $this->getChainByName ($chainName);  

    $source = $this->createChainSource ($chain);

    $invalidateCache = false;
    for ($i = 0; $i < count($chain->xslt); $i++) {
      $xslt = $chain->xslt[$i];

      $cache = $this->createButterflyCache
     ($this->createCacheFilename ((string) $chain->name, $i));

      if ($invalidateCache && $cache->isPresent()) {  
    $cache->delete();
      }

      $source = $this->createButterfly ((string) $xslt['file'], $source, 
$cache);

      $invalidateCache = $invalidateCache || ! $cache->isPresent();
    }

    return $source;
  }

  protected function createChainSource ($chain) {

    if (! isset($chain->source)) {
      throw new Exception ("Butterfly chain has no source element: 
$chainName");
    }
  
    $args = is_array($chain->source->arg)
       ? $chain->source->arg
       : array($chain->source->arg);

    $argsAsStrings = array();
    foreach ($args as $arg) {
      $argsAsStrings[] = (string) $arg;
    }

    return $this->createSourceFromType ((string) $chain->source['type'],
                    $argsAsStrings);
  }

  protected function createCacheFilename ($chainName, $xsltNumber) {
    return $this->cacheDir . '/' . $chainName . '_' . $xsltNumber . 
'.cache';
  }

  protected function createSourceFromType ($type, $args) {
    return call_user_func_array (array($type, 'create'), $args);
  }

  protected function createButterflyCache ($cacheFilePath) {
    return new ButterflyCache ($cacheFilePath);
  }    
}