1. sfMessageSource_XLIFF.class.php
  2. /**
 * sfMessageSource_XLIFF class.
 *
 * Using XML XLIFF format as the message source for translation.
 * Details and example of XLIFF can be found in the following URLs.
 *
 * # http://www.opentag.com/xliff.htm
 * # http://www-106.ibm.com/developerworks/xml/library/x-localis2/
 *
 * See the MessageSource::factory() method to instantiate this class.
 *
 * @author Xiang Wei Zhuo 
 * @version v1.0, last update on Fri Dec 24 16:18:44 EST 2004
 * @package    symfony
 * @subpackage i18n
 */
  3. class sfMessageSource_XLIFF extends sfMessageSource_File
  4. {
  5.   /**
  6.    * Message data filename extension.
  7.    * @var string
  8.    */
  9.   protected $dataExt = '.xml';
  11.   /**
  12.    * Loads the messages from a XLIFF file.
  13.    *
  14.    * @param string $filename  XLIFF file.
  15.    * @return array|false An array of messages or false if there was a problem loading the file.
  16.    */
  17.   public function &loadData($filename)
  18.   {
  19.     libxml_use_internal_errors(true);
  20.     if (!$xml = simplexml_load_file($filename))
  21.     {
  22.       $error = false;
  24.       return $error;
  25.     }
  26.     libxml_use_internal_errors(false);
  28.     $translationUnit = $xml->xpath('//trans-unit');
  30.     $translations = array();
  32.     foreach ($translationUnit as $unit)
  33.     {
  34.       $source = (string) $unit->source;
  35.       $translations[$source][] = (string) $unit->target;
  36.       $translations[$source][] = (string) $unit['id'];
  37.       $translations[$source][] = (string) $unit->note;
  38.     }
  40.     return $translations;
  41.   }
  43.   /**
  44.    * Creates and returns a new DOMDocument instance
  45.    *
  46.    * @param  string  $xml  XML string
  47.    *
  48.    * @return DOMDocument
  49.    */
  50.   protected function createDOMDocument($xml = null)
  51.   {
  52.     $domimp = new DOMImplementation();
  53.     $doctype = $domimp->createDocumentType('xliff', '-//XLIFF//DTD XLIFF//EN', 'http://www.oasis-open.org/committees/xliff/documents/xliff.dtd');
  54.     $dom = $domimp->createDocument('', '', $doctype);
  55.     $dom->formatOutput = true;
  56.     $dom->preserveWhiteSpace = false;
  58.     if (null !== $xml && is_string($xml))
  59.     {
  60.       // Add header for XML with UTF-8
  61.       if (!preg_match('/<\?xml/', $xml))
  62.       {
  63.         $xml = '<?xml version="1.0" encoding="UTF-8"?>'."\n".$xml;
  64.       }
  66.       $dom->loadXML($xml);
  67.     }
  69.     return $dom;
  70.   }
  72.   /**
  73.    * Gets the variant for a catalogue depending on the current culture.
  74.    *
  75.    * @param string $catalogue catalogue
  76.    * @return string the variant.
  77.    * @see save()
  78.    * @see update()
  79.    * @see delete()
  80.    */
  81.   protected function getVariants($catalogue = 'messages')
  82.   {
  83.     if (null === $catalogue)
  84.     {
  85.       $catalogue = 'messages';
  86.     }
  88.     foreach ($this->getCatalogueList($catalogue) as $variant)
  89.     {
  90.       $file = $this->getSource($variant);
  91.       if (is_file($file))
  92.       {
  93.         return array($variant, $file);
  94.       }
  95.     }
  97.     return false;
  98.   }
  100.   /**
  101.    * Saves the list of untranslated blocks to the translation source.
  102.    * If the translation was not found, you should add those
  103.    * strings to the translation source via the <b>append()</b> method.
  104.    *
  105.    * @param string $catalogue the catalogue to add to
  106.    * @return boolean true if saved successfuly, false otherwise.
  107.    */
  108.   public function save($catalogue = 'messages')
  109.   {
  110.     $messages = $this->untranslated;
  111.     if (count($messages) <= 0)
  112.     {
  113.       return false;
  114.     }
  116.     $variants = $this->getVariants($catalogue);
  117.     if ($variants)
  118.     {
  119.       list($variant, $filename) = $variants;
  120.     }
  121.     else
  122.     {
  123.       list($variant, $filename) = $this->createMessageTemplate($catalogue);
  124.     }
  126.     if (is_writable($filename) == false)
  127.     {
  128.       throw new sfException(sprintf("Unable to save to file %s, file must be writable.", $filename));
  129.     }
  131.     // create a new dom, import the existing xml
  132.     $dom = $this->createDOMDocument();
  133.     @$dom->load($filename);
  135.     // find the body element
  136.     $xpath = new DomXPath($dom);
  137.     $body = $xpath->query('//body')->item(0);
  139.     if (null === $body)
  140.     {
  141.       //create and try again
  142.       $this->createMessageTemplate($catalogue);
  143.       $dom->load($filename);
  144.       $xpath = new DomXPath($dom);
  145.       $body = $xpath->query('//body')->item(0);
  146.     }
  148.     // find the biggest "id" used
  149.     $lastNodes = $xpath->query('//trans-unit[not(@id <= preceding-sibling::trans-unit/@id) and not(@id <= following-sibling::trans-unit/@id)]');
  150.     if (null !== $last = $lastNodes->item(0))
  151.     {
  152.       $count = intval($last->getAttribute('id'));
  153.     }
  154.     else
  155.     {
  156.       $count = 0;
  157.     }
  159.     // for each message add it to the XML file using DOM
  160.     foreach ($messages as $message)
  161.     {
  162.       $unit = $dom->createElement('trans-unit');
  163.       $unit->setAttribute('id', ++$count);
  165.       $source = $dom->createElement('source');
  166.       $source->appendChild($dom->createTextNode($message));
  167.       $target = $dom->createElement('target');
  168.       $target->appendChild($dom->createTextNode(''));
  170.       $unit->appendChild($source);
  171.       $unit->appendChild($target);
  173.       $body->appendChild($unit);
  174.     }
  176.     $fileNode = $xpath->query('//file')->item(0);
  177.     $fileNode->setAttribute('date', @date('Y-m-d\TH:i:s\Z'));
  179.     $dom = $this->createDOMDocument($dom->saveXML());
  181.     // save it and clear the cache for this variant
  182.     $dom->save($filename);
  183.     if ($this->cache)
  184.     {
  185.       $this->cache->remove($variant.':'.$this->culture);
  186.     }
  188.     return true;
  189.   }
  191.   /**
  192.    * Updates the translation.
  193.    *
  194.    * @param string $text      the source string.
  195.    * @param string $target    the new translation string.
  196.    * @param string $comments  comments
  197.    * @param string $catalogue the catalogue to save to.
  198.    * @return boolean true if translation was updated, false otherwise.
  199.    */
  200.   public function update($text, $target, $comments, $catalogue = 'messages')
  201.   {
  202.     $variants = $this->getVariants($catalogue);
  203.     if ($variants)
  204.     {
  205.       list($variant, $filename) = $variants;
  206.     }
  207.     else
  208.     {
  209.       return false;
  210.     }
  212.     if (is_writable($filename) == false)
  213.     {
  214.       throw new sfException(sprintf("Unable to update file %s, file must be writable.", $filename));
  215.     }
  217.     // create a new dom, import the existing xml
  218.     $dom = $this->createDOMDocument();
  219.     $dom->load($filename);
  221.     // find the body element
  222.     $xpath = new DomXPath($dom);
  223.     $units = $xpath->query('//trans-unit');
  225.     // for each of the existin units
  226.     foreach ($units as $unit)
  227.     {
  228.       $found = false;
  229.       $targetted = false;
  230.       $commented = false;
  232.       //in each unit, need to find the source, target and comment nodes
  233.       //it will assume that the source is before the target.
  234.       foreach ($unit->childNodes as $node)
  235.       {
  236.         // source node
  237.         if ($node->nodeName == 'source' && $node->firstChild->wholeText == $text)
  238.         {
  239.           $found = true;
  240.         }
  242.         // found source, get the target and notes
  243.         if ($found)
  244.         {
  245.           // set the new translated string
  246.           if ($node->nodeName == 'target')
  247.           {
  248.             $node->nodeValue = $target;
  249.             $targetted = true;
  250.           }
  252.           // set the notes
  253.           if (!empty($comments) && $node->nodeName == 'note')
  254.           {
  255.             $node->nodeValue = $comments;
  256.             $commented = true;
  257.           }
  258.         }
  259.       }
  261.       // append a target
  262.       if ($found && !$targetted)
  263.       {
  264.         $targetNode = $dom->createElement('target');
  265.         $targetNode->appendChild($dom->createTextNode($target));
  266.         $unit->appendChild($targetNode);
  267.       }
  269.       // append a note
  270.       if ($found && !$commented && !empty($comments))
  271.       {
  272.         $commentsNode = $dom->createElement('note');
  273.         $commentsNode->appendChild($dom->createTextNode($comments));
  274.         $unit->appendChild($commentsNode);
  275.       }
  277.       // finished searching
  278.       if ($found)
  279.       {
  280.         break;
  281.       }
  282.     }
  284.     $fileNode = $xpath->query('//file')->item(0);
  285.     $fileNode->setAttribute('date', @date('Y-m-d\TH:i:s\Z'));
  287.     if ($dom->save($filename) > 0)
  288.     {
  289.       if ($this->cache)
  290.       {
  291.         $this->cache->remove($variant.':'.$this->culture);
  292.       }
  294.       return true;
  295.     }
  297.     return false;
  298.   }
  300.   /**
  301.    * Deletes a particular message from the specified catalogue.
  302.    *
  303.    * @param string $message   the source message to delete.
  304.    * @param string $catalogue the catalogue to delete from.
  305.    * @return boolean true if deleted, false otherwise.
  306.    */
  307.   public function delete($message, $catalogue='messages')
  308.   {
  309.     $variants = $this->getVariants($catalogue);
  310.     if ($variants)
  311.     {
  312.       list($variant, $filename) = $variants;
  313.     }
  314.     else
  315.     {
  316.       return false;
  317.     }
  319.     if (is_writable($filename) == false)
  320.     {
  321.       throw new sfException(sprintf("Unable to modify file %s, file must be writable.", $filename));
  322.     }
  324.     // create a new dom, import the existing xml
  325.     $dom = $this->createDOMDocument();
  326.     $dom->load($filename);
  328.     // find the body element
  329.     $xpath = new DomXPath($dom);
  330.     $units = $xpath->query('//trans-unit');
  332.     // for each of the existin units
  333.     foreach ($units as $unit)
  334.     {
  335.       //in each unit, need to find the source, target and comment nodes
  336.       //it will assume that the source is before the target.
  337.       foreach ($unit->childNodes as $node)
  338.       {
  339.         // source node
  340.         if ($node->nodeName == 'source' && $node->firstChild->wholeText == $message)
  341.         {
  342.           // we found it, remove and save the xml file.
  343.           $unit->parentNode->removeChild($unit);
  345.           $fileNode = $xpath->query('//file')->item(0);
  346.           $fileNode->setAttribute('date', @date('Y-m-d\TH:i:s\Z'));
  348.           if ($dom->save($filename) > 0)
  349.           {
  350.             if (!empty($this->cache))
  351.             {
  352.               $this->cache->remove($variant.':'.$this->culture);
  353.             }
  355.             return true;
  356.           }
  357.           else
  358.           {
  359.             return false;
  360.           }
  361.         }
  362.       }
  363.     }
  365.     return false;
  366.   }
  368.   protected function createMessageTemplate($catalogue)
  369.   {
  370.     if (null === $catalogue)
  371.     {
  372.       $catalogue = 'messages';
  373.     }
  375.     $variants = $this->getCatalogueList($catalogue);
  376.     $variant = array_shift($variants);
  377.     $file = $this->getSource($variant);
  378.     $dir = dirname($file);
  379.     if (!is_dir($dir))
  380.     {
  381.       @mkdir($dir);
  382.       @chmod($dir, 0777);
  383.     }
  385.     if (!is_dir($dir))
  386.     {
  387.       throw new sfException(sprintf("Unable to create directory %s.", $dir));
  388.     }
  390.     $dom = $this->createDOMDocument($this->getTemplate($catalogue));
  391.     file_put_contents($file, $dom->saveXML());
  392.     chmod($file, 0777);
  394.     return array($variant, $file);
  395.   }
  397.   protected function getTemplate($catalogue)
  398.   {
  399.     $date = date('c');
  401.     return <<<EOD
  402. <?xml version="1.0" encoding="UTF-8"?>
  403. <!DOCTYPE xliff PUBLIC "-//XLIFF//DTD XLIFF//EN" "http://www.oasis-open.org/committees/xliff/documents/xliff.dtd" >
  404. <xliff version="1.0">
  405.   <file source-language="EN" target-language="{$this->culture}" datatype="plaintext" original="$catalogue" date="$date" product-name="$catalogue">
  406.     <header />
  407.     <body>
  408.     </body>
  409.   </file>
  410. </xliff>
  411. EOD;
  412.   }
  413. }
Debug toolbar