479 lines
11 KiB
PHP
479 lines
11 KiB
PHP
<?php
|
|
namespace Gettext;
|
|
|
|
/**
|
|
* Class to manage a translation string
|
|
*/
|
|
class Translation
|
|
{
|
|
protected $context;
|
|
protected $original;
|
|
protected $translation = '';
|
|
protected $plural;
|
|
protected $pluralTranslation = array();
|
|
protected $references = array();
|
|
protected $comments = array();
|
|
protected $extractedComments = array();
|
|
protected $flags = array();
|
|
protected $translationCount;
|
|
|
|
/**
|
|
* Generates the id of a translation (context + glue + original)
|
|
*
|
|
* @param string $context
|
|
* @param string $original
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function generateId($context, $original)
|
|
{
|
|
return "{$context}\004{$original}";
|
|
}
|
|
|
|
/**
|
|
* Construct
|
|
*
|
|
* @param string $context The context of the translation
|
|
* @param string $original The original string
|
|
* @param string $plural The original plural string
|
|
*/
|
|
public function __construct($context, $original, $plural = '')
|
|
{
|
|
$this->context = (string) $context;
|
|
$this->original = (string) $original;
|
|
|
|
$this->setPlural($plural);
|
|
}
|
|
|
|
/**
|
|
* Clones this translation
|
|
*
|
|
* @param null|string $context Optional new context
|
|
* @param null|string $original Optional new original
|
|
*/
|
|
public function getClone($context = null, $original = null)
|
|
{
|
|
$new = clone $this;
|
|
|
|
if ($context !== null) {
|
|
$new->context = (string) $context;
|
|
}
|
|
|
|
if ($original !== null) {
|
|
$new->original = (string) $original;
|
|
}
|
|
|
|
return $new;
|
|
}
|
|
|
|
/**
|
|
* Returns the id of this translation
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getId()
|
|
{
|
|
return static::generateId($this->context, $this->original);
|
|
}
|
|
|
|
/**
|
|
* Checks whether the translation matches with the arguments
|
|
*
|
|
* @param string $context
|
|
* @param string $original
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function is($context, $original = '')
|
|
{
|
|
return (($this->context === $context) && ($this->original === $original)) ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Gets the original string
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getOriginal()
|
|
{
|
|
return $this->original;
|
|
}
|
|
|
|
/**
|
|
* Checks if the original string is empty or not
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasOriginal()
|
|
{
|
|
return ($this->original !== '') ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Sets the translation string
|
|
*
|
|
* @param string $translation
|
|
*/
|
|
public function setTranslation($translation)
|
|
{
|
|
$this->translation = (string) $translation;
|
|
}
|
|
|
|
/**
|
|
* Gets the translation string
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getTranslation()
|
|
{
|
|
return $this->translation;
|
|
}
|
|
|
|
/**
|
|
* Checks if the translation string is empty or not
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasTranslation()
|
|
{
|
|
return ($this->translation !== '') ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Sets the plural translation string
|
|
*
|
|
* @param string $plural
|
|
*/
|
|
public function setPlural($plural)
|
|
{
|
|
$this->plural = (string) $plural;
|
|
|
|
$this->normalizeTranslationCount();
|
|
}
|
|
|
|
/**
|
|
* Gets the plural translation string
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getPlural()
|
|
{
|
|
return $this->plural;
|
|
}
|
|
|
|
/**
|
|
* Checks if the plural translation string is empty or not
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasPlural()
|
|
{
|
|
return ($this->plural !== '') ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Set a new plural translation
|
|
*
|
|
* @param string $plural The plural string to add
|
|
* @param integer $key The key of the plural translation.
|
|
*/
|
|
public function setPluralTranslation($plural, $key = 0)
|
|
{
|
|
$this->pluralTranslation[$key] = $plural;
|
|
$this->normalizeTranslationCount();
|
|
}
|
|
|
|
/**
|
|
* Gets one or all plural translations
|
|
*
|
|
* @param integer|null $key The key to return. If is null, return all translations
|
|
*
|
|
* @return string|array
|
|
*/
|
|
public function getPluralTranslation($key = null)
|
|
{
|
|
if ($key === null) {
|
|
return $this->pluralTranslation;
|
|
}
|
|
|
|
return isset($this->pluralTranslation[$key]) ? (string) $this->pluralTranslation[$key] : '';
|
|
}
|
|
|
|
/**
|
|
* Checks if there are any plural translation
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasPluralTranslation()
|
|
{
|
|
return implode('', $this->pluralTranslation) !== '';
|
|
}
|
|
|
|
/**
|
|
* Removes all plural translations
|
|
*/
|
|
public function deletePluralTranslation()
|
|
{
|
|
$this->pluralTranslation = array();
|
|
|
|
$this->normalizeTranslationCount();
|
|
}
|
|
|
|
/**
|
|
* Set the number of singular + plural translations allowed
|
|
*
|
|
* @param integer $count
|
|
*/
|
|
public function setTranslationCount($count)
|
|
{
|
|
$this->translationCount = is_null($count) ? null : intval($count);
|
|
|
|
$this->normalizeTranslationCount();
|
|
}
|
|
|
|
/**
|
|
* Returns the number of singular + plural translations
|
|
* Returns null if this Translation is not a plural one
|
|
*
|
|
* @return integer|null
|
|
*/
|
|
public function getTranslationCount()
|
|
{
|
|
return $this->hasPlural() ? $this->translationCount : null;
|
|
}
|
|
|
|
/**
|
|
* Normalizes the translation count
|
|
*/
|
|
protected function normalizeTranslationCount()
|
|
{
|
|
if ($this->translationCount === null) {
|
|
return;
|
|
}
|
|
|
|
if ($this->hasPlural()) {
|
|
$allowed = $this->translationCount - 1;
|
|
$current = count($this->pluralTranslation);
|
|
|
|
if ($allowed > $current) {
|
|
$this->pluralTranslation = $this->pluralTranslation + array_fill(0, $allowed, '');
|
|
} elseif ($current > $allowed) {
|
|
$this->pluralTranslation = array_slice($this->pluralTranslation, 0, $allowed);
|
|
}
|
|
} else {
|
|
$this->pluralTranslation = array();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the context of this translation
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getContext()
|
|
{
|
|
return $this->context;
|
|
}
|
|
|
|
/**
|
|
* Checks if the context is empty or not
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasContext()
|
|
{
|
|
return (isset($this->context) && ($this->context !== '')) ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Adds a new reference for this translation
|
|
*
|
|
* @param string $filename The file path where the translation has been found
|
|
* @param null|integer $line The line number where the translation has been found
|
|
*/
|
|
public function addReference($filename, $line = null)
|
|
{
|
|
$key = "{$filename}:{$line}";
|
|
$this->references[$key] = array($filename, $line);
|
|
}
|
|
|
|
/**
|
|
* Checks if the translation has any reference
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasReferences()
|
|
{
|
|
return !empty($this->references);
|
|
}
|
|
|
|
/**
|
|
* Return all references for this translation
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getReferences()
|
|
{
|
|
return array_values($this->references);
|
|
}
|
|
|
|
/**
|
|
* Removes all references
|
|
*/
|
|
public function deleteReferences()
|
|
{
|
|
$this->references = array();
|
|
}
|
|
|
|
/**
|
|
* Adds a new comment for this translation
|
|
*
|
|
* @param string $comment
|
|
*/
|
|
public function addComment($comment)
|
|
{
|
|
$this->comments[] = $comment;
|
|
}
|
|
|
|
/**
|
|
* Checks if the translation has any comment
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasComments()
|
|
{
|
|
return isset($this->comments[0]);
|
|
}
|
|
|
|
/**
|
|
* Returns all comments for this translation
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getComments()
|
|
{
|
|
return $this->comments;
|
|
}
|
|
|
|
/**
|
|
* Removes all comments
|
|
*/
|
|
public function deleteComments()
|
|
{
|
|
$this->comments = array();
|
|
}
|
|
|
|
/**
|
|
* Adds a new extracted comment for this translation
|
|
*
|
|
* @param string $comment
|
|
*/
|
|
public function addExtractedComment($comment)
|
|
{
|
|
$this->extractedComments[] = $comment;
|
|
}
|
|
|
|
/**
|
|
* Checks if the translation has any extracted comment
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasExtractedComments()
|
|
{
|
|
return isset($this->extractedComments[0]);
|
|
}
|
|
|
|
/**
|
|
* Returns all extracted comments for this translation
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getExtractedComments()
|
|
{
|
|
return $this->extractedComments;
|
|
}
|
|
|
|
/**
|
|
* Removes all extracted comments
|
|
*/
|
|
public function deleteExtractedComments()
|
|
{
|
|
$this->extractedComments = array();
|
|
}
|
|
|
|
/**
|
|
* Adds a new flat for this translation
|
|
*
|
|
* @param string $flag
|
|
*/
|
|
public function addFlag($flag)
|
|
{
|
|
$this->flags[] = $flag;
|
|
}
|
|
|
|
/**
|
|
* Checks if the translation has any flag
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasFlags()
|
|
{
|
|
return isset($this->flags[0]);
|
|
}
|
|
|
|
/**
|
|
* Returns all extracted flags for this translation
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getFlags()
|
|
{
|
|
return $this->flags;
|
|
}
|
|
|
|
/**
|
|
* Removes all flags
|
|
*/
|
|
public function deleteFlags()
|
|
{
|
|
$this->flags = array();
|
|
}
|
|
|
|
/**
|
|
* Merges this translation with other translation
|
|
*
|
|
* @param Translation $translation The translation to merge with
|
|
* @param integer|null $method One or various Translations::MERGE_* constants to define how to merge the translations
|
|
*/
|
|
public function mergeWith(Translation $translation, $method = null)
|
|
{
|
|
if ($method === null) {
|
|
$method = Translations::$mergeDefault;
|
|
}
|
|
|
|
if (!$this->hasTranslation()) {
|
|
$this->setTranslation($translation->getTranslation());
|
|
}
|
|
|
|
if (($method & Translations::MERGE_PLURAL) && !$this->hasPlural()) {
|
|
$this->setPlural($translation->getPlural());
|
|
}
|
|
|
|
if ($this->hasPlural() && !$this->hasPluralTranslation() && $translation->hasPluralTranslation()) {
|
|
$this->pluralTranslation = $translation->getPluralTranslation();
|
|
}
|
|
|
|
if ($method & Translations::MERGE_REFERENCES) {
|
|
foreach ($translation->getReferences() as $reference) {
|
|
$this->addReference($reference[0], $reference[1]);
|
|
}
|
|
}
|
|
|
|
if ($method & Translations::MERGE_COMMENTS) {
|
|
$this->comments = array_values(array_unique(array_merge($translation->getComments(), $this->comments)));
|
|
$this->extractedComments = array_values(array_unique(array_merge($translation->getExtractedComments(), $this->extractedComments)));
|
|
$this->flags = array_values(array_unique(array_merge($translation->getFlags(), $this->flags)));
|
|
}
|
|
}
|
|
}
|