Gettext\Translation

Complexity

Total Complexity

78

Size/Duplication

Total Lines	583
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	0

Importance

Changes	9
Bugs	1	Features	0

41 Methods

Rating	Name	Duplication	Size	Complexity
A	getOriginal()	0	4	1
A	hasOriginal()	0	4	2
A	setTranslation()	0	6	1
A	getTranslation()	0	4	1
A	hasTranslation()	0	4	2
A	setPlural()	0	6	1
A	getPlural()	0	4	1
A	hasPlural()	0	4	2
A	setPluralTranslations()	0	6	1
A	getPluralTranslations()	0	18	4
A	generateId()	0	4	1
A	__construct()	0	7	1
A	getClone()	0	14	3
A	getId()	0	4	1
A	is()	0	4	3
A	hasPluralTranslations()	0	8	2
A	deletePluralTranslation()	0	6	1
A	getContext()	0	4	1
A	hasContext()	0	4	3
A	addReference()	0	7	1
A	hasReferences()	0	4	1
A	getReferences()	0	4	1
A	deleteReferences()	0	6	1
A	addComment()	0	8	2
A	hasComments()	0	4	1
A	getComments()	0	4	1
A	deleteComments()	0	6	1
A	addExtractedComment()	0	8	2
A	hasExtractedComments()	0	4	1
A	getExtractedComments()	0	4	1
A	deleteExtractedComments()	0	6	1
A	addFlag()	0	8	2
A	hasFlags()	0	4	1
A	getFlags()	0	4	1
A	deleteFlags()	0	6	1
A	mergeWith()	0	10	1
B	mergeTranslation()	0	16	10
A	mergeReferences()	0	12	4
A	mergeComments()	0	12	4
A	mergeExtractedComments()	0	12	4
A	mergeFlags()	0	12	4

<?php

namespace Gettext;

/**
 * Class to manage a translation string.
 */
class Translation
{
    const MERGE_TRANSLATION_OVERRIDE = 64;
    const MERGE_PLURAL_OVERRIDE = 128;
    const MERGE_COMMENTS_MINES = 256;
    const MERGE_COMMENTS_THEIRS = 512;
    const MERGE_EXTRACTED_COMMENTS_MINES = 1024;
    const MERGE_EXTRACTED_COMMENTS_THEIRS = 2048;
    const MERGE_FLAGS_MINES = 4096;
    const MERGE_FLAGS_THEIRS = 8192;
    const MERGE_REFERENCES_MINES = 16384;
    const MERGE_REFERENCES_THEIRS = 32768;

    protected $context;
    protected $original;
    protected $translation = '';
    protected $plural;
    protected $pluralTranslation = [];
    protected $references = [];
    protected $comments = [];
    protected $extractedComments = [];
    protected $flags = [];

    /**
     * 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
     * 
     * @return Translation
     */
    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;

        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;

        return $this;
    }

    /**
     * Gets all plural translations.
     * 
     * @param int $limit
     *
     * @return array
     */
    public function getPluralTranslations($limit = null)
    {
        if ($limit === null) {
            return $this->pluralTranslation;
        }

        $current = count($this->pluralTranslation);

        if ($limit > $current) {
            return $this->pluralTranslation + array_fill(0, $limit, '');
        }

        if ($limit < $current) {
            return array_slice($this->pluralTranslation, 0, $limit);
        }

        return $this->pluralTranslation;
    }

    /**
     * Checks if there are any plural translation.
     * 
     * @param bool $checkContent
     *
     * @return bool
     */
    public function hasPluralTranslations($checkContent = false)
    {
        if ($checkContent) {
            return implode('', $this->pluralTranslation) !== '';
        }

        return !empty($this->pluralTranslation);
    }

    /**
     * Removes all plural translations.
     * 
     * @return self
     */
    public function deletePluralTranslation()
    {
        $this->pluralTranslation = [];

        return $this;
    }

    /**
     * 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
     * 
     * @return self
     */
    public function addReference($filename, $line = null)
    {
        $key = "{$filename}:{$line}";
        $this->references[$key] = [$filename, $line];

        return $this;
    }

    /**
     * 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.
     * 
     * @return self
     */
    public function deleteReferences()
    {
        $this->references = [];

        return $this;
    }

    /**
     * Adds a new comment for this translation.
     *
     * @param string $comment
     * 
     * @return self
     */
    public function addComment($comment)
    {
        if (!in_array($comment, $this->comments, true)) {
            $this->comments[] = $comment;
        }

        return $this;
    }

    /**
     * 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.
     * 
     * @return self
     */
    public function deleteComments()
    {
        $this->comments = [];

        return $this;
    }

    /**
     * Adds a new extracted comment for this translation.
     *
     * @param string $comment
     * 
     * @return self
     */
    public function addExtractedComment($comment)
    {
        if (!in_array($comment, $this->extractedComments, true)) {
            $this->extractedComments[] = $comment;
        }

        return $this;
    }

    /**
     * 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.
     * 
     * @return self
     */
    public function deleteExtractedComments()
    {
        $this->extractedComments = [];

        return $this;
    }

    /**
     * Adds a new flag for this translation.
     *
     * @param string $flag
     * 
     * @return self
     */
    public function addFlag($flag)
    {
        if (!in_array($flag, $this->flags, true)) {
            $this->flags[] = $flag;
        }

        return $this;
    }

    /**
     * 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.
     * 
     * @return self
     */
    public function deleteFlags()
    {
        $this->flags = [];

        return $this;
    }

    /**
     * Merges this translation with other translation.
     *
     * @param Translation $translation The translation to merge with
     * @param int         $options     The merging options
     * 
     * @return self
     */
    public function mergeWith(Translation $translation, $options = self::MERGE_TRANSLATION_OVERRIDE)
    {
        $this->mergeTranslation($translation, $options);
        $this->mergeReferences($translation, $options);
        $this->mergeComments($translation, $options);
        $this->mergeExtractedComments($translation, $options);
        $this->mergeFlags($translation, $options);

        return $this;
    }

    /**
     * Merge the translations of two translations
     * 
     * @param Translation $translation
     * @param int         $options
     */
    private function mergeTranslation(Translation $translation, $options)
    {
        $override = (boolean) ($options & self::MERGE_TRANSLATION_OVERRIDE);

        if (!$this->hasTranslation() || ($translation->hasTranslation() && $override)) {
            $this->setTranslation($translation->getTranslation());
        }

        if (!$this->hasPlural() || ($translation->hasPlural() && ($options & self::MERGE_PLURAL_OVERRIDE))) {
            $this->setPlural($translation->getPlural());
        }

        if (!$this->hasPluralTranslations() || ($translation->hasPluralTranslations() && $override)) {
            $this->setPluralTranslations($translation->getPluralTranslations());
        }
    }

    /**
     * Merge the references of two translations
     * 
     * @param Translation $translation
     * @param int         $options
     */
    private function mergeReferences(Translation $translation, $options)
    {
        if ($options & self::MERGE_REFERENCES_THEIRS) {
            $this->deleteReferences();
        }

        if (!($options & self::MERGE_REFERENCES_MINES)) {
            foreach ($translation->getReferences() as $reference) {
                $this->addReference($reference[0], $reference[1]);
            }
        }
    }

    /**
     * Merge the comments of two translations
     * 
     * @param Translation $translation
     * @param int         $options
     */
    private function mergeComments(Translation $translation, $options)
    {
        if ($options & self::MERGE_COMMENTS_THEIRS) {
            $this->deleteComments();
        }

        if (!($options & self::MERGE_COMMENTS_MINES)) {
            foreach ($translation->getComments() as $comment) {
                $this->addComment($comment);
            }
        }
    }

    /**
     * Merge the extracted comments of two translations
     * 
     * @param Translation $translation
     * @param int         $options
     */
    private function mergeExtractedComments(Translation $translation, $options)
    {
        if ($options & self::MERGE_EXTRACTED_COMMENTS_THEIRS) {
            $this->deleteExtractedComments();
        }

        if (!($options & self::MERGE_EXTRACTED_COMMENTS_MINES)) {
            foreach ($translation->getExtractedComments() as $comment) {
                $this->addExtractedComment($comment);
            }
        }
    }

    /**
     * Merge the flags of two translations
     * 
     * @param Translation $translation
     * @param int         $options
     */
    private function mergeFlags(Translation $translation, $options)
    {
        if ($options & self::MERGE_FLAGS_THEIRS) {
            $this->deleteFlags();
        }

        if (!($options & self::MERGE_FLAGS_MINES)) {
            foreach ($translation->getFlags() as $flag) {
                $this->addFlag($flag);
            }
        }
    }
}