1. sfMessageSource_gettext.class.php
  2. /**
 * sfMessageSource_gettext class.
 * 
 * Using Gettext MO format as the message source for translation.
 * The gettext classes are based on PEAR's gettext MO and PO classes.
 * 
 * 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_gettext extends sfMessageSource_File
  4. { 
  5.   /**
  6.    * Message data filename extension.
  7.    * @var string 
  8.    */
  9.   protected $dataExt = '.mo';
  11.   /**
  12.    * PO data filename extension
  13.    * @var string 
  14.    */
  15.   protected $poExt = '.po';
  17.   /**
  18.    * Loads the messages from a MO file.
  19.    *
  20.    * @param string $filename MO file.
  21.    * @return array of messages.
  22.    */
  23.   public function &loadData($filename)
  24.   {
  25.     $mo = TGettext::factory('MO',$filename);
  26.     $mo->load();
  27.     $result = $mo->toArray();
  29.     $results = array();
  30.     $count = 0;
  31.     foreach ($result['strings'] as $source => $target)
  32.     {
  33.       $results[$source][] = $target;  //target
  34.       $results[$source][] = $count++; //id
  35.       $results[$source][] = '';       //comments
  36.     }
  38.     return $results;
  39.   }
  41.   /**
  42.    * Gets the variant for a catalogue depending on the current culture.
  43.    *
  44.    * @param string $catalogue catalogue
  45.    * @return string the variant. 
  46.    * @see save()
  47.    * @see update()
  48.    * @see delete()
  49.    */
  50.   protected function getVariants($catalogue = 'messages')
  51.   {
  52.     if (empty($catalogue))
  53.     {
  54.       $catalogue = 'messages';
  55.     }
  57.     foreach ($this->getCatalogueList($catalogue) as $variant)
  58.     {
  59.       $file = $this->getSource($variant);
  60.       $po = $this->getPOFile($file);
  61.       if (is_file($file) || is_file($po))
  62.       {
  63.         return array($variant, $file, $po);
  64.       }
  65.     }
  67.     return false;
  68.   }
  70.   protected function getPOFile($MOFile)
  71.   {
  72.     return substr($MOFile, 0, strlen($MOFile) - strlen($this->dataExt)).$this->poExt;
  73.   }
  75.   /**
  76.    * Saves the list of untranslated blocks to the translation source. 
  77.    * If the translation was not found, you should add those
  78.    * strings to the translation source via the <b>append()</b> method.
  79.    *
  80.    * @param string $catalogue the catalogue to add to
  81.    * @return boolean true if saved successfuly, false otherwise.   
  82.    */
  83.   function save($catalogue = 'messages')
  84.   {
  85.     $messages = $this->untranslated;
  87.     if (count($messages) <= 0)
  88.     {
  89.       return false;
  90.     }
  92.     $variants = $this->getVariants($catalogue);
  94.     if ($variants)
  95.     {
  96.       list($variant, $MOFile, $POFile) = $variants;
  97.     }
  98.     else
  99.     {
  100.       list($variant, $MOFile, $POFile) = $this->createMessageTemplate($catalogue);
  101.     }
  103.     if (is_writable($MOFile) == false)
  104.     {
  105.       throw new sfException(sprintf("Unable to save to file %s, file must be writable.", $MOFile));
  106.     }
  107.     if (is_writable($POFile) == false)
  108.     {
  109.       throw new sfException(sprintf("Unable to save to file %s, file must be writable.", $POFile));
  110.     }
  112.     // set the strings as untranslated.
  113.     $strings = array();
  114.     foreach ($messages as $message)
  115.     {
  116.       $strings[$message] = ''; 
  117.     }
  119.     // load the PO
  120.     $po = TGettext::factory('PO',$POFile);
  121.     $po->load();
  122.     $result = $po->toArray();
  124.     $existing = count($result['strings']);
  126.     // add to strings to the existing message list
  127.     $result['strings'] = array_merge($result['strings'],$strings);
  129.     $new = count($result['strings']);
  131.     if ($new > $existing)
  132.     {
  133.       // change the date 2004-12-25 12:26
  134.       $result['meta']['PO-Revision-Date'] = @date('Y-m-d H:i:s');
  136.       $po->fromArray($result);
  137.       $mo = $po->toMO();
  138.       if ($po->save() && $mo->save($MOFile))
  139.       {
  140.         if ($this->cache)
  141.         {
  142.           $this->cache->remove($variant.':'.$this->culture);
  143.         }
  145.         return true;
  146.       }
  147.       else
  148.       {
  149.         return false;
  150.       }
  151.     }
  153.     return false;
  154.   }
  156.   /**
  157.    * Deletes a particular message from the specified catalogue.
  158.    *
  159.    * @param string $message   the source message to delete.
  160.    * @param string $catalogue the catalogue to delete from.
  161.    * @return boolean true if deleted, false otherwise. 
  162.    */
  163.   function delete($message, $catalogue = 'messages')
  164.   {
  165.     $variants = $this->getVariants($catalogue);
  166.     if ($variants)
  167.     {
  168.       list($variant, $MOFile, $POFile) = $variants;
  169.     }
  170.     else
  171.     {
  172.       return false;
  173.     }
  175.     if (is_writable($MOFile) == false)
  176.     {
  177.       throw new sfException(sprintf("Unable to modify file %s, file must be writable.", $MOFile));
  178.     }
  180.     if (is_writable($POFile) == false)
  181.     {
  182.       throw new sfException(sprintf("Unable to modify file %s, file must be writable.", $POFile));
  183.     }
  185.     $po = TGettext::factory('PO', $POFile);
  186.     $po->load();
  187.     $result = $po->toArray(); 
  189.     foreach ($result['strings'] as $string => $value)
  190.     {
  191.       if ($string == $message)
  192.       {
  193.         $result['meta']['PO-Revision-Date'] = @date('Y-m-d H:i:s');
  194.         unset($result['strings'][$string]);
  196.         $po->fromArray($result);
  197.         $mo = $po->toMO();
  198.         if ($po->save() && $mo->save($MOFile))
  199.         {
  200.           if ($this->cache)
  201.           {
  202.             $this->cache->remove($variant.':'.$this->culture);
  203.           }
  205.           return true;
  206.         }
  207.         else
  208.         {
  209.           return false;
  210.         }
  211.       }
  212.     }
  214.     return false;
  215.   }
  217.   /**
  218.    * Updates the translation.
  219.    *
  220.    * @param string $text      the source string.
  221.    * @param string $target    the new translation string.
  222.    * @param string $comments  comments
  223.    * @param string $catalogue the catalogue of the translation.
  224.    * @return boolean true if translation was updated, false otherwise.
  225.    */
  226.   function update($text, $target, $comments, $catalogue = 'messages')
  227.   {
  228.     $variants = $this->getVariants($catalogue);
  229.     if ($variants)
  230.     {
  231.       list($variant, $MOFile, $POFile) = $variants;
  232.     }
  233.     else
  234.     {
  235.       return false;
  236.     }
  238.     if (is_writable($MOFile) == false)
  239.     {
  240.       throw new sfException(sprintf("Unable to update file %s, file must be writable.", $MOFile));
  241.     }
  243.     if (is_writable($POFile) == false)
  244.     {
  245.       throw new sfException(sprintf("Unable to update file %s, file must be writable.", $POFile));
  246.     }
  248.     $po = TGettext::factory('PO',$POFile);
  249.     $po->load();
  250.     $result = $po->toArray();
  252.     foreach ($result['strings'] as $string => $value)
  253.     {
  254.       if ($string == $text)
  255.       {
  256.         $result['strings'][$string] = $target;
  257.         $result['meta']['PO-Revision-Date'] = @date('Y-m-d H:i:s');
  259.         $po->fromArray($result);
  260.         $mo = $po->toMO();
  262.         if ($po->save() && $mo->save($MOFile))
  263.         {
  264.           if ($this->cache)
  265.           {
  266.             $this->cache->remove($variant.':'.$this->culture);
  267.           }
  269.           return true;
  270.         }
  271.         else
  272.         {
  273.           return false;
  274.         }
  275.       }
  276.     }
  278.     return false;
  279.   }
  281.   protected function createMessageTemplate($catalogue)
  282.   {
  283.     if (null === $catalogue)
  284.     {
  285.       $catalogue = 'messages';
  286.     }
  288.     $variants = $this->getCatalogueList($catalogue);
  289.     $variant = array_shift($variants);
  290.     $mo_file = $this->getSource($variant);
  291.     $po_file = $this->getPOFile($mo_file);
  293.     $dir = dirname($mo_file);
  294.     if (!is_dir($dir))
  295.     {
  296.       @mkdir($dir);
  297.       @chmod($dir, 0777);
  298.     }
  300.     if (!is_dir($dir))
  301.     {
  302.       throw new sfException(sprintf("Unable to create directory %s.", $dir));
  303.     }
  305.     $po = TGettext::factory('PO', $po_file);
  306.     $result['meta']['PO-Revision-Date'] = date('Y-m-d H:i:s');
  307.     $result['strings'] = array();
  309.     $po->fromArray($result);
  310.     $mo = $po->toMO();
  311.     if ($po->save() && $mo->save($mo_file))
  312.     {
  313.       return array($variant, $mo_file, $po_file);
  314.     }
  315.     else
  316.     {
  317.       throw new sfException(sprintf("Unable to create file %s and %s.", $po_file, $mo_file));
  318.     }
  319.   }
  320. }
Debug toolbar