1. sfI18N.class.php
  2. /**
 * sfI18N wraps the core i18n classes for a symfony context.
 *
 * @package    symfony
 * @subpackage i18n
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfI18N.class.php 24039 2009-11-16 17:52:14Z Kris.Wallsmith $
 */
  3. class sfI18N
  4. {
  5.   protected
  6.     $configuration = null,
  7.     $dispatcher    = null,
  8.     $cache         = null,
  9.     $options       = array(),
  10.     $culture       = 'en',
  11.     $messageSource = null,
  12.     $messageFormat = null;
  14.   /**
  15.    * Class constructor.
  16.    *
  17.    * @see initialize()
  18.    */
  19.   public function __construct(sfApplicationConfiguration $configuration, sfCache $cache = null, $options = array())
  20.   {
  21.     $this->initialize($configuration, $cache, $options);
  22.   }
  24.   /**
  25.    * Initializes this class.
  26.    *
  27.    * Available options:
  28.    *
  29.    *  * culture:             The culture
  30.    *  * source:              The i18n source (XLIFF by default)
  31.    *  * debug:               Whether to enable debug or not (false by default)
  32.    *  * database:            The database name (default by default)
  33.    *  * untranslated_prefix: The prefix to use when a message is not translated
  34.    *  * untranslated_suffix: The suffix to use when a message is not translated
  35.    *
  36.    * @param sfApplicationConfiguration $configuration   A sfApplicationConfiguration instance
  37.    * @param sfCache                    $cache           A sfCache instance
  38.    * @param array                      $options         An array of options
  39.    */
  40.   public function initialize(sfApplicationConfiguration $configuration, sfCache $cache = null, $options = array())
  41.   {
  42.     $this->configuration = $configuration;
  43.     $this->dispatcher = $configuration->getEventDispatcher();
  44.     $this->cache = $cache;
  46.     if (isset($options['culture']))
  47.     {
  48.       $this->culture = $options['culture'];
  49.       unset($options['culture']);
  50.     }
  52.     $this->options = array_merge(array(
  53.       'source'              => 'XLIFF',
  54.       'debug'               => false,
  55.       'database'            => 'default',
  56.       'untranslated_prefix' => '[T]',
  57.       'untranslated_suffix' => '[/T]',
  58.     ), $options);
  60.     $this->dispatcher->connect('user.change_culture', array($this, 'listenToChangeCultureEvent'));
  62.     if($this->isMessageSourceFileBased($this->options['source']))
  63.     {
  64.       $this->dispatcher->connect('controller.change_action', array($this, 'listenToChangeActionEvent'));
  65.     }
  66.   }
  68.   /**
  69.    * Returns the initialization options
  70.    *
  71.    * @return array The options used to initialize sfI18n
  72.    */
  73.   public function getOptions()
  74.   {
  75.     return $this->options;
  76.   }
  78.   /**
  79.    * Returns the configuration instance.
  80.    *
  81.    * @return sfApplicationConfiguration An sfApplicationConfiguration instance
  82.    */
  83.   public function getConfiguration()
  84.   {
  85.     return $this->configuration;
  86.   }
  88.   /**
  89.    * Sets the message source.
  90.    *
  91.    * @param mixed  $dirs    An array of i18n directories if message source is a sfMessageSource_File subclass, null otherwise
  92.    * @param string $culture The culture
  93.    */
  94.   public function setMessageSource($dirs, $culture = null)
  95.   {
  96.     if (null === $dirs)
  97.     {
  98.       $this->messageSource = $this->createMessageSource();
  99.     }
  100.     else
  101.     {
  102.       $this->messageSource = sfMessageSource::factory('Aggregate', array_map(array($this, 'createMessageSource'), $dirs));
  103.     }
  105.     if (null !== $this->cache)
  106.     {
  107.       $this->messageSource->setCache($this->cache);
  108.     }
  110.     if (null !== $culture)
  111.     {
  112.       $this->setCulture($culture);
  113.     }
  114.     else
  115.     {
  116.       $this->messageSource->setCulture($this->culture);
  117.     }
  119.     $this->messageFormat = null;
  120.   }
  122.   /**
  123.    * Returns a new message source.
  124.    *
  125.    * @param  mixed $dir An array of i18n directories to create a XLIFF or gettext message source, null otherwise
  126.    *
  127.    * @return sfMessageSource A sfMessageSource object
  128.    */
  129.   public function createMessageSource($dir = null)
  130.   {
  131.     return sfMessageSource::factory($this->options['source'], self::isMessageSourceFileBased($this->options['source']) ? $dir : $this->options['database']);
  132.   }
  134.   /**
  135.    * Gets the current culture for i18n format objects.
  136.    *
  137.    * @return string The culture
  138.    */
  139.   public function getCulture()
  140.   {
  141.     return $this->culture;
  142.   }
  144.   /**
  145.    * Sets the current culture for i18n format objects.
  146.    *
  147.    * @param string $culture The culture
  148.    */
  149.   public function setCulture($culture)
  150.   {
  151.     $this->culture = $culture;
  153.     // change user locale for formatting, collation, and internal error messages
  154.     setlocale(LC_ALL, 'en_US.utf8', 'en_US.UTF8', 'en_US.utf-8', 'en_US.UTF-8');
  155.     setlocale(LC_COLLATE, $culture.'.utf8', $culture.'.UTF8', $culture.'.utf-8', $culture.'.UTF-8');
  156.     setlocale(LC_CTYPE, $culture.'.utf8', $culture.'.UTF8', $culture.'.utf-8', $culture.'.UTF-8');
  157.     setlocale(LC_MONETARY, $culture.'.utf8', $culture.'.UTF8', $culture.'.utf-8', $culture.'.UTF-8');
  158.     setlocale(LC_TIME, $culture.'.utf8', $culture.'.UTF8', $culture.'.utf-8', $culture.'.UTF-8');
  160.     if ($this->messageSource)
  161.     {
  162.       $this->messageSource->setCulture($culture);
  163.       $this->messageFormat = null;
  164.     }
  165.   }
  167.   /**
  168.    * Gets the message source.
  169.    *
  170.    * @return sfMessageSource A sfMessageSource object
  171.    */
  172.   public function getMessageSource()
  173.   {
  174.     if (!isset($this->messageSource))
  175.     {
  176.       $dirs = ($this->isMessageSourceFileBased($this->options['source'])) ? $this->configuration->getI18NGlobalDirs() : null;
  177.       $this->setMessageSource($dirs, $this->culture);
  178.     }
  180.     return $this->messageSource;
  181.   }
  183.   /**
  184.    * Gets the message format.
  185.    *
  186.    * @return sfMessageFormat A sfMessageFormat object
  187.    */
  188.   public function getMessageFormat()
  189.   {
  190.     if (!isset($this->messageFormat))
  191.     {
  192.       $this->messageFormat = new sfMessageFormat($this->getMessageSource(), sfConfig::get('sf_charset'));
  194.       if ($this->options['debug'])
  195.       {
  196.         $this->messageFormat->setUntranslatedPS(array($this->options['untranslated_prefix'], $this->options['untranslated_suffix']));
  197.       }
  198.     }
  200.     return $this->messageFormat;
  201.   }
  203.   /**
  204.    * Gets the translation for the given string
  205.    *
  206.    * @param  string $string     The string to translate
  207.    * @param  array  $args       An array of arguments for the translation
  208.    * @param  string $catalogue  The catalogue name
  209.    *
  210.    * @return string The translated string
  211.    */
  212.   public function __($string, $args = array(), $catalogue = 'messages')
  213.   {
  214.     return $this->getMessageFormat()->format($string, $args, $catalogue);
  215.   }
  217.   /**
  218.    * Gets a country name.
  219.    *
  220.    * @param  string $iso      The ISO code
  221.    * @param  string $culture  The culture for the translation
  222.    *
  223.    * @return string The country name
  224.    */
  225.   public function getCountry($iso, $culture = null)
  226.   {
  227.     $c = sfCultureInfo::getInstance(null === $culture ? $this->culture : $culture);
  228.     $countries = $c->getCountries();
  230.     return (array_key_exists($iso, $countries)) ? $countries[$iso] : '';
  231.   }
  233.   /**
  234.    * Gets a native culture name.
  235.    *
  236.    * @param  string $culture The culture
  237.    *
  238.    * @return string The culture name
  239.    */
  240.   public function getNativeName($culture)
  241.   {
  242.     return sfCultureInfo::getInstance($culture)->getNativeName();
  243.   }
  245.   /**
  246.    * Returns a timestamp from a date with time formatted with a given culture.
  247.    *
  248.    * @param  string  $dateTime  The formatted date with time as string
  249.    * @param  string  $culture The culture
  250.    *
  251.    * @return integer The timestamp
  252.    */
  253.   public function getTimestampForCulture($dateTime, $culture = null)
  254.   {
  255.     list($day, $month, $year) = $this->getDateForCulture($dateTime, null === $culture ? $this->culture : $culture);
  256.     list($hour, $minute) = $this->getTimeForCulture($dateTime, null === $culture ? $this->culture : $culture);
  258.     return null === $day ? null : mktime($hour, $minute, 0, $month, $day, $year);
  259.   }
  261.   /**
  262.    * Returns the day, month and year from a date formatted with a given culture.
  263.    *
  264.    * @param  string  $date    The formatted date as string
  265.    * @param  string  $culture The culture
  266.    *
  267.    * @return array   An array with the day, month and year
  268.    */
  269.   public function getDateForCulture($date, $culture = null)
  270.   {
  271.     if (!$date)
  272.     {
  273.       return null;
  274.     }
  276.     $dateFormatInfo = @sfDateTimeFormatInfo::getInstance(null === $culture ? $this->culture : $culture);
  277.     $dateFormat = $dateFormatInfo->getShortDatePattern();
  279.     // We construct the regexp based on date format
  280.     $dateRegexp = preg_replace('/[dmy]+/i', '(\d+)', preg_quote($dateFormat));
  282.     // We parse date format to see where things are (m, d, y)
  283.     $a = array(
  284.       'd' => strpos($dateFormat, 'd'),
  285.       'm' => strpos($dateFormat, 'M'),
  286.       'y' => strpos($dateFormat, 'y'),
  287.     );
  288.     $tmp = array_flip($a);
  289.     ksort($tmp);
  290.     $i = 0;
  291.     $c = array();
  292.     foreach ($tmp as $value) $c[++$i] = $value;
  293.     $datePositions = array_flip($c);
  295.     // We find all elements
  296.     if (preg_match("~$dateRegexp~", $date, $matches))
  297.     {
  298.       // We get matching timestamp
  299.       return array($matches[$datePositions['d']], $matches[$datePositions['m']], $matches[$datePositions['y']]);
  300.     }
  301.     else
  302.     {
  303.       return null;
  304.     }
  305.   }
  307.   /**
  308.    * Returns the hour, minute from a date formatted with a given culture.
  309.    *
  310.    * @param  string  $time    The formatted date as string
  311.    * @param  string  $culture The culture
  312.    *
  313.    * @return array   An array with the hour and minute
  314.    */
  315.   public function getTimeForCulture($time, $culture)
  316.   {
  317.     if (!$time) return 0;
  319.     $culture = null === $culture ? $this->culture : $culture;
  321.     $timeFormatInfo = @sfDateTimeFormatInfo::getInstance($culture);
  322.     $timeFormat = $timeFormatInfo->getShortTimePattern();
  324.     // We construct the regexp based on time format
  325.     $timeRegexp = preg_replace(array('/[hm]+/i', '/a/'), array('(\d+)', '(\w+)'), preg_quote($timeFormat));
  327.     // We parse time format to see where things are (h, m)
  328.     $a = array(
  329.       'h' => strpos($timeFormat, 'H') !== false ? strpos($timeFormat, 'H') : strpos($timeFormat, 'h'),
  330.       'm' => strpos($timeFormat, 'm'),
  331.       'a' => strpos($timeFormat, 'a')
  332.     );
  333.     $tmp = array_flip($a);
  334.     ksort($tmp);
  335.     $i = 0;
  336.     $c = array();
  337.     foreach ($tmp as $value) $c[++$i] = $value;
  338.     $timePositions = array_flip($c);
  340.     // We find all elements
  341.     if (preg_match("~$timeRegexp~", $time, $matches))
  342.     {
  343.       // repect am/pm setting if present
  344.       if (isset($timePositions['a']))
  345.       {
  346.         if (strcasecmp($matches[$timePositions['a']], $timeFormatInfo->getAMDesignator()) == 0)
  347.         {
  348.           $hour = $matches[$timePositions['h']];
  349.         }
  350.         else if (strcasecmp($matches[$timePositions['a']], $timeFormatInfo->getPMDesignator()) == 0)
  351.         {
  352.           $hour = $matches[$timePositions['h']] + 12;
  353.         }
  354.         else
  355.         {
  356.           // am/pm marker is invalid
  357.           // return null; would be the preferred solution but this might break a lot of code
  358.           $hour = $matches[$timePositions['h']];
  359.         }
  360.       }
  361.       else
  362.       {
  363.         $hour = $matches[$timePositions['h']];
  364.       }
  366.       // We get matching timestamp
  367.       return array($hour, $matches[$timePositions['m']]);
  368.     }
  369.     else
  370.     {
  371.       return null;
  372.     }
  373.   }
  375.   /**
  376.    * Returns true if messages are stored in a file.
  377.    *
  378.    * @param  string  $source  The source name
  379.    *
  380.    * @return Boolean true if messages are stored in a file, false otherwise
  381.    */
  382.   static public function isMessageSourceFileBased($source)
  383.   {
  384.     $class = 'sfMessageSource_'.$source;
  386.     return class_exists($class) && is_subclass_of($class, 'sfMessageSource_File');
  387.   }
  389.   /**
  390.    * Listens to the user.change_culture event.
  391.    *
  392.    * @param sfEvent $event  An sfEvent instance
  393.    *
  394.    */
  395.   public function listenToChangeCultureEvent(sfEvent $event)
  396.   {
  397.     // change the message format object with the new culture
  398.     $this->setCulture($event['culture']);
  399.   }
  401.   /**
  402.    * Listens to the controller.change_action event.
  403.    *
  404.    * @param sfEvent $event An sfEvent instance
  405.    *
  406.    */
  407.   public function listenToChangeActionEvent(sfEvent $event)
  408.   {
  409.     // change message source directory to our module
  410.     $this->setMessageSource($this->configuration->getI18NDirs($event['module']));
  411.   }
  413. }
Debug toolbar