Gettext\Translation

Complexity

Total Complexity

69

Size/Duplication

Total Lines	509
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes	6
Bugs	1	Features	0

41 Methods

Rating	Name	Duplication	Size	Complexity
A	generateId()	0	4	1
A	getId()	0	4	1
A	getOriginal()	0	4	1
A	hasOriginal()	0	4	2
A	__construct()	0	7	1
A	getClone()	0	14	3
A	is()	0	4	3
A	setTranslation()	0	6	1
A	getTranslation()	0	4	1
A	hasTranslation()	0	4	2
A	setPlural()	0	8	1
A	getPlural()	0	4	1
A	hasPlural()	0	4	2
A	setPluralTranslations()	0	7	1
A	setPluralTranslation()	0	7	1
A	getPluralTranslation()	0	4	2
A	getPluralTranslations()	0	4	1
A	hasPluralTranslation()	0	4	1
A	deletePluralTranslation()	0	6	1
A	setTranslationCount()	0	8	2
A	getTranslationCount()	0	4	2
B	normalizeTranslationCount()	0	19	5
A	getContext()	0	4	1
A	hasContext()	0	4	3
A	addReference()	0	5	1
A	hasReferences()	0	4	1
A	getReferences()	0	4	1
A	deleteReferences()	0	4	1
A	addComment()	0	4	1
A	hasComments()	0	4	1
A	getComments()	0	4	1
A	deleteComments()	0	4	1
A	addExtractedComment()	0	4	1
A	hasExtractedComments()	0	4	1
A	getExtractedComments()	0	4	1
A	deleteExtractedComments()	0	4	1
A	addFlag()	0	4	1
A	hasFlags()	0	4	1
A	getFlags()	0	4	1
A	deleteFlags()	0	4	1
C	mergeWith()	0	30	13

<?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 bool
     */
    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 bool
     */
    public function hasOriginal()
    {
        return ($this->original !== '') ? true : false;
    }

    /**
     * Sets the translation string.
     *
     * @param string $translation
     * 
     * @return self
     */
    public function setTranslation($translation)
    {
        $this->translation = (string) $translation;

        return $this;
    }

    /**
     * Gets the translation string.
     *
     * @return string
     */
    public function getTranslation()
    {
        return $this->translation;
    }

    /**
     * Checks if the translation string is empty or not.
     *
     * @return bool
     */
    public function hasTranslation()
    {
        return ($this->translation !== '') ? true : false;
    }

    /**
     * Sets the plural translation string.
     *
     * @param string $plural
     * 
     * @return self
     */
    public function setPlural($plural)
    {
        $this->plural = (string) $plural;

        $this->normalizeTranslationCount();

        return $this;
    }

    /**
     * Gets the plural translation string.
     *
     * @return string
     */
    public function getPlural()
    {
        return $this->plural;
    }

    /**
     * Checks if the plural translation string is empty or not.
     *
     * @return bool
     */
    public function hasPlural()
    {
        return ($this->plural !== '') ? true : false;
    }

    /**
     * Set a new plural translation.
     *
     * @param array $plural
     * 
     * @return self
     */
    public function setPluralTranslations(array $plural)
    {
        $this->pluralTranslation = $plural;
        $this->normalizeTranslationCount();

        return $this;
    }

    /**
     * Set a new plural translation.
     *
     * @param string $plural The plural string to add
     * @param int    $key    The key of the plural translation.
     * 
     * @return self
     */
    public function setPluralTranslation($plural, $key = 0)
    {
        $this->pluralTranslation[$key] = $plural;
        $this->normalizeTranslationCount();

        return $this;
    }

    /**
     * Gets one or all plural translations.
     *
     * @param int|null $key The key to return. If is null, return all translations
     *
     * @return string|array
     */
    public function getPluralTranslation($key = 0)
    {
        return isset($this->pluralTranslation[$key]) ? (string) $this->pluralTranslation[$key] : '';
    }

    /**
     * Gets all plural translations.
     *
     * @return array
     */
    public function getPluralTranslations()
    {
        return $this->pluralTranslation;
    }

    /**
     * Checks if there are any plural translation.
     *
     * @return bool
     */
    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 int $count
     * 
     * @return self
     */
    public function setTranslationCount($count)
    {
        $this->translationCount = is_null($count) ? null : intval($count);

        $this->normalizeTranslationCount();

        return $this;
    }

    /**
     * Returns the number of singular + plural translations
     * Returns null if this Translation is not a plural one.
     *
     * @return int|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 bool
     */
    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|int $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 bool
     */
    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 bool
     */
    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 bool
     */
    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 bool
     */
    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 int|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() || ($translation->hasTranslation() && ($method & Translations::MERGE_OVERRIDE))) {
            $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();

It seems like $translation->getPluralTranslation() of type string is incompatible with the declared type array of property $pluralTranslation.

        }

        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)));
        }
    }
}