PhpDocxTemplate\DocxDocument

Complexity

Total Complexity

118

Size/Duplication

Total Lines	676
Duplicated Lines	0 %

Test Coverage

Coverage

68.4%

Importance

Changes	6
Bugs	2	Features	3

28 Methods

Rating	Name	Duplication	Size	Complexity
A	getHeaderName()	0	3	1
A	addImageToRelations()	0	53	5
A	setValueForPart()	0	6	1
A	readPartWithRels()	0	9	2
A	fixBrokenMacros()	0	8	1
A	getRelationsName()	0	3	1
A	getMainPartName()	0	12	2
F	fixTables()	0	103	29
D	prepareImageAttrs()	0	57	17
B	chooseImageDimension()	0	21	7
A	getDOMDocument()	0	6	1
A	getNextRelationsIndex()	0	12	3
A	getVariablesForPart()	0	5	1
B	getImageArgs()	0	34	8
A	savePartWithRels()	0	9	3
A	getCellLen()	0	17	6
A	getDocumentContentTypesName()	0	3	1
A	ensureMacroCompleted()	0	6	3
A	close()	0	6	2
A	getDocumentMainPart()	0	3	1
A	save()	0	30	4
A	__construct()	0	9	2
A	extract()	0	16	3
A	rrmdir()	0	15	6
A	getFooterName()	0	3	1
A	updateDOMDocument()	0	4	1
A	getImageTemplate()	0	3	1
A	fixImageWidthHeightRatio()	0	13	5

<?php

namespace PhpDocxTemplate;

use DOMDocument;
use Exception;
use RecursiveIteratorIterator;
use RecursiveDirectoryIterator;
use PhpDocxTemplate\Escaper\RegExp;
use ZipArchive;

/**
 * Class DocxDocument
 *
 * @package PhpDocxTemplate
 */
class DocxDocument
{
    private $path;
    private $tmpDir;
    private $document;
    private $zipClass;
    private $tempDocumentMainPart;
    private $tempDocumentRelations = [];
    private $tempDocumentContentTypes = '';
    private $tempDocumentNewImages = [];

    /**
     * Construct an instance of Document
     *
     * @param string $path - path to the document
     *
     * @throws Exception
     */
    public function __construct(string $path)
    {
        if (file_exists($path)) {
            $this->path = $path;
            $this->tmpDir = sys_get_temp_dir() . DIRECTORY_SEPARATOR . uniqid("", true) . date("His");
            $this->zipClass = new ZipArchive();
            $this->extract();
        } else {
            throw new Exception("The template " . $path . " was not found!");
        }
    }

    /**
     * Extract (unzip) document contents
     */
    private function extract(): void
    {
        if (file_exists($this->tmpDir) && is_dir($this->tmpDir)) {
            $this->rrmdir($this->tmpDir);
        }

        mkdir($this->tmpDir);

        $this->zipClass->open($this->path);
        $this->zipClass->extractTo($this->tmpDir);

        $this->tempDocumentMainPart = $this->readPartWithRels($this->getMainPartName());

        $this->tempDocumentContentTypes = $this->zipClass->getFromName($this->getDocumentContentTypesName());

        $this->document = file_get_contents(sprintf('%s%sword%sdocument.xml', $this->tmpDir, DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR));
    }

    /**
     * Get document main part
     *
     * @return string
     */
    public function getDocumentMainPart(): string
    {
        return $this->tempDocumentMainPart;
    }

    /**
     * Get the name of main part document (method from PhpOffice\PhpWord)
     *
     * @return string
     */
    public function getMainPartName(): string
    {
        $contentTypes = $this->zipClass->getFromName('[Content_Types].xml');

        $pattern = '~PartName="\/(word\/document.*?\.xml)" ' .
                   'ContentType="application\/vnd\.openxmlformats-officedocument' .
                   '\.wordprocessingml\.document\.main\+xml"~';

        $matches = [];
        preg_match($pattern, $contentTypes, $matches);

        return array_key_exists(1, $matches) ? $matches[1] : sprintf('word%sdocument.xml', DIRECTORY_SEPARATOR);
    }

    /**
     * @return string
     */
    private function getDocumentContentTypesName(): string
    {
        return '[Content_Types].xml';
    }

    /**
     * Read document part (method from PhpOffice\PhpWord)
     *
     * @param string $fileName
     *
     * @return string
     */
    private function readPartWithRels(string $fileName): string
    {
        $relsFileName = $this->getRelationsName($fileName);
        $partRelations = $this->zipClass->getFromName($relsFileName);
        if ($partRelations !== false) {
            $this->tempDocumentRelations[$fileName] = $partRelations;
        }

        return $this->fixBrokenMacros($this->zipClass->getFromName($fileName));
    }

    /**
     * Get the name of the relations file for document part (method from PhpOffice\PhpWord)
     *
     * @param string $documentPartName
     *
     * @return string
     */
    private function getRelationsName(string $documentPartName): string
    {
        return sprintf('word%s_rels%s%s.rels', DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR, pathinfo($documentPartName, PATHINFO_BASENAME));

It seems like pathinfo($documentPartName, PhpDocxTemplate\PATHINFO_BASENAME) can also be of type array; however, parameter $values of sprintf() does only seem to accept double|integer|string, maybe add an additional type check?

    }

    public function getNextRelationsIndex(string $documentPartName): int
    {
        if (isset($this->tempDocumentRelations[$documentPartName])) {
            $candidate = substr_count($this->tempDocumentRelations[$documentPartName], '<Relationship');
            while (strpos($this->tempDocumentRelations[$documentPartName], 'Id="rId' . $candidate . '"') !== false) {
                $candidate++;
            }

            return $candidate;
        }

        return 1;
    }

    /**
     * Finds parts of broken macros and sticks them together (method from PhpOffice\PhpWord)
     *
     * @param string $documentPart
     *
     * @return string
     */
    private function fixBrokenMacros(string $documentPart): string
    {
        return preg_replace_callback(
            '/\$(?:\{|[^{$]*\>\{)[^}$]*\}/U',
            function ($match) {
                return strip_tags($match[0]);
            },
            $documentPart
        );
    }

    /**
     * @param string $macro
     *
     * @return string
     */
    protected static function ensureMacroCompleted(string $macro): string
    {
        if (substr($macro, 0, 2) !== '{{' && substr($macro, -1) !== '}}') {
            $macro = '{{' . $macro . '}}';
        }
        return $macro;
    }

    /**
     * Get the name of the header file for $index.
     *
     * @param int $index
     *
     * @return string
     */
    private function getHeaderName(int $index): string
    {
        return sprintf('word%sheader%d.xml', DIRECTORY_SEPARATOR, $index);
    }

    /**
     * Get the name of the footer file for $index.
     *
     * @param int $index
     *
     * @return string
     */
    private function getFooterName(int $index): string
    {
        return sprintf('word%sfooter%d.xml', DIRECTORY_SEPARATOR, $index);
    }

    /**
     * Find all variables in $documentPartXML.
     *
     * @param string $documentPartXML
     *
     * @return string[]
     */
    private function getVariablesForPart(string $documentPartXML): array
    {
        $matches = array();
        preg_match_all('/\{\{(.*?)\}\}/i', $documentPartXML, $matches);
        return $matches[1];
    }

    private function getImageArgs(string $varNameWithArgs): array
    {
        $varElements = explode(':', $varNameWithArgs);
        array_shift($varElements); // first element is name of variable => remove it

        $varInlineArgs = array();
        // size format documentation: https://msdn.microsoft.com/en-us/library/documentformat.openxml.vml.shape%28v=office.14%29.aspx?f=255&MSPPError=-2147217396
        foreach ($varElements as $argIdx => $varArg) {
            if (strpos($varArg, '=')) { // arg=value
                list($argName, $argValue) = explode('=', $varArg, 2);
                $argName = strtolower($argName);
                if ($argName == 'size') {
                    list($varInlineArgs['width'], $varInlineArgs['height']) = explode('x', $argValue, 2);
                } else {
                    $varInlineArgs[strtolower($argName)] = $argValue;
                }
            } elseif (preg_match('/^([0-9]*[a-z%]{0,2}|auto)x([0-9]*[a-z%]{0,2}|auto)$/i', $varArg)) { // 60x40
                list($varInlineArgs['width'], $varInlineArgs['height']) = explode('x', $varArg, 2);
            } else { // :60:40:f
                switch ($argIdx) {
                    case 0:
                        $varInlineArgs['width'] = $varArg;
                        break;
                    case 1:
                        $varInlineArgs['height'] = $varArg;
                        break;
                    case 2:
                        $varInlineArgs['ratio'] = $varArg;
                        break;
                }
            }
        }

        return $varInlineArgs;
    }

    /**
     * @param mixed $replaceImage
     * @param array $varInlineArgs
     *
     * @return array
     */
    public function prepareImageAttrs($replaceImage, array $varInlineArgs = []): array
    {
        // get image path and size
        $width = null;
        $height = null;
        $unit = null;
        $ratio = null;

        // a closure can be passed as replacement value which after resolving, can contain the replacement info for the image
        // use case: only when a image if found, the replacement tags can be generated
        if (is_callable($replaceImage)) {
            $replaceImage = $replaceImage();
        }

        if (is_array($replaceImage) && isset($replaceImage['path'])) {
            $imgPath = $replaceImage['path'];
            if (isset($replaceImage['width'])) {
                $width = $replaceImage['width'];
            }
            if (isset($replaceImage['height'])) {
                $height = $replaceImage['height'];
            }
            if (isset($replaceImage['unit'])) {
                $unit = $replaceImage['unit'];
            }
            if (isset($replaceImage['ratio'])) {
                $ratio = $replaceImage['ratio'];
            }
        } else {
            $imgPath = $replaceImage;
        }

        $width = $this->chooseImageDimension($width, $unit ? $unit : 'px', isset($varInlineArgs['width']) ? $varInlineArgs['width'] : null, 115);
        $height = $this->chooseImageDimension($height, $unit ? $unit : 'px', isset($varInlineArgs['height']) ? $varInlineArgs['height'] : null, 70);

        $imageData = @getimagesize($imgPath);
        if (!is_array($imageData)) {
            throw new Exception(sprintf('Invalid image: %s', $imgPath));
        }
        list($actualWidth, $actualHeight, $imageType) = $imageData;

        // fix aspect ratio (by default)
        if (is_null($ratio) && isset($varInlineArgs['ratio'])) {
            $ratio = $varInlineArgs['ratio'];
        }
        if (is_null($ratio) || !in_array(strtolower($ratio), array('', '-', 'f', 'false'))) {
            $this->fixImageWidthHeightRatio($width, $height, $actualWidth, $actualHeight);
        }

        $imageAttrs = array(
            'src' => $imgPath,
            'mime' => image_type_to_mime_type($imageType),
            'width' => $width * 9525,
            'height' => $height * 9525,
        );

        return $imageAttrs;
    }

    /**
     * @param mixed $width
     * @param mixed $height
     * @param int $actualWidth
     * @param int $actualHeight
     */
    private function fixImageWidthHeightRatio(&$width, &$height, int $actualWidth, int $actualHeight): void
    {
        $imageRatio = $actualWidth / $actualHeight;

        if (($width === '') && ($height === '')) { // defined size are empty
            $width = $actualWidth;
            $height = $actualHeight;
        } elseif ($width === '') { // defined width is empty
            $heightFloat = (float)$height;
            $width = $heightFloat * $imageRatio;
        } elseif ($height === '') { // defined height is empty
            $widthFloat = (float)$width;
            $height = $widthFloat / $imageRatio;
        }
    }

    /**
     * @param mixed $baseValue
     * @param string $unit
     * @param int|null $inlineValue
     * @param int $defaultValue
     */
    private function chooseImageDimension($baseValue, string $unit, ?int $inlineValue, int $defaultValue): string
    {
        $value = $baseValue;
        if (is_null($value) && isset($inlineValue)) {
            $value = $inlineValue;
        }
        if (is_null($value)) {
            $value = $defaultValue;
        }
        switch ($unit) {
            case 'mm':
                $value = $value * 3.8; // 1mm = 3.8px
                break;
            case 'pt':
                $value = $value / 3 * 4; // 1pt = 4/3 px
                break;
            case 'pc':
                $value = $value * 16; // 1px = 16px
                break;
        }
        return $value;
    }

    public function addImageToRelations(string $partFileName, string $rid, string $imgPath, string $imageMimeType): void
    {
        // define templates
        $typeTpl = '<Override PartName="/word/media/{IMG}" ContentType="image/{EXT}"/>';
        $relationTpl = '<Relationship Id="{RID}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="media/{IMG}"/>';
        $newRelationsTpl = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' . "\n" . '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
        $newRelationsTypeTpl = '<Override PartName="/{RELS}" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>';
        $extTransform = array(
            'image/jpeg' => 'jpeg',
            'image/png'  => 'png',
            'image/bmp'  => 'bmp',
            'image/gif'  => 'gif',
        );
        //tempDocumentRelations

        // get image embed name
        if (isset($this->tempDocumentNewImages[$imgPath])) {
            $imgName = $this->tempDocumentNewImages[$imgPath];
        } else {
            // transform extension
            if (isset($extTransform[$imageMimeType])) {
                $imgExt = $extTransform[$imageMimeType];
            } else {
                throw new Exception("Unsupported image type $imageMimeType");
            }

            // add image to document
            $imgName = 'image_' . $rid . '_' . pathinfo($partFileName, PATHINFO_FILENAME) . '.' . $imgExt;

Are you sure pathinfo($partFileName, PhpDocxTemplate\PATHINFO_FILENAME) of type array|string can be used in concatenation?

            $this->tempDocumentNewImages[$imgPath] = $imgName;

            $targetDir = sprintf('%s%sword%smedia', $this->tmpDir, DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR);
            if (!file_exists($targetDir)) {
                mkdir($targetDir, 0777, true);
            }
            copy($imgPath, sprintf('%s%s%s', $targetDir, DIRECTORY_SEPARATOR, $imgName));

            // setup type for image
            $xmlImageType = str_replace(array('{IMG}', '{EXT}'), array($imgName, $imgExt), $typeTpl);
            $this->tempDocumentContentTypes = str_replace('</Types>', $xmlImageType, $this->tempDocumentContentTypes) . '</Types>';
        }

        $xmlImageRelation = str_replace(array('{RID}', '{IMG}'), array($rid, $imgName), $relationTpl);

        if (!isset($this->tempDocumentRelations[$partFileName])) {
            // create new relations file
            $this->tempDocumentRelations[$partFileName] = $newRelationsTpl;
            // and add it to content types
            $xmlRelationsType = str_replace('{RELS}', $this->getRelationsName($partFileName), $newRelationsTypeTpl);
            $this->tempDocumentContentTypes = str_replace('</Types>', $xmlRelationsType, $this->tempDocumentContentTypes) . '</Types>';
        }

        // add image to relations
        $this->tempDocumentRelations[$partFileName] = str_replace('</Relationships>', $xmlImageRelation, $this->tempDocumentRelations[$partFileName]) . '</Relationships>';
    }

    public function getImageTemplate(): string
    {
        return '</w:t></w:r><w:r><w:drawing><wp:inline xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"> <wp:extent cx="{WIDTH}" cy="{HEIGHT}"/> <wp:docPr id="{IMAGEID}" name=""/> <wp:cNvGraphicFramePr> <a:graphicFrameLocks noChangeAspect="1"/> </wp:cNvGraphicFramePr> <a:graphic> <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"> <pic:pic> <pic:nvPicPr> <pic:cNvPr id="{IMAGEID}" name=""/> <pic:cNvPicPr/> </pic:nvPicPr> <pic:blipFill> <a:blip r:embed="rId{IMAGEID}"/> <a:stretch> <a:fillRect/> </a:stretch> </pic:blipFill> <pic:spPr> <a:xfrm> <a:off x="0" y="0"/> <a:ext cx="{WIDTH}" cy="{HEIGHT}"/> </a:xfrm> <a:prstGeom prst="rect"> <a:avLst/> </a:prstGeom> </pic:spPr> </pic:pic> </a:graphicData> </a:graphic> </wp:inline> </w:drawing></w:r><w:r><w:t xml:space="preserve">';
    }

    /**
     * Find and replace macros in the given XML section.
     *
     * @param mixed $search
     * @param mixed $replace
     * @param string $documentPartXML
     *
     * @return string
     */
    protected function setValueForPart($search, $replace, string $documentPartXML): string
    {
        // Note: we can't use the same function for both cases here, because of performance considerations.
        $regExpEscaper = new RegExp();

        return preg_replace($regExpEscaper->escape($search), $replace, $documentPartXML);
    }

    /**
     * Get document.xml contents as DOMDocument
     *
     * @return DOMDocument
     */
    public function getDOMDocument(): DOMDocument
    {
        $dom = new DOMDocument();

        $dom->loadXML($this->document);
        return $dom;
    }

    /**
     * Update document.xml contents
     *
     * @param DOMDocument $dom - new contents
     */
    public function updateDOMDocument(DOMDocument $dom): void
    {
        $this->document = $dom->saveXml();
        file_put_contents(sprintf('%s%sword%sdocument.xml', $this->tmpDir, DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR), $this->document);
    }

    /**
     * Fix table corruption
     *
     * @param string $xml - xml to fix
     *
     * @return DOMDocument
     */
    public function fixTables(string $xml): DOMDocument
    {
        $dom = new DOMDocument();
        $dom->loadXML($xml);
        $tables = $dom->getElementsByTagName('tbl');
        foreach ($tables as $table) {
            $columns = [];
            $columnsLen = 0;
            $toAdd = 0;
            $tableGrid = null;
            foreach ($table->childNodes as $el) {
                if ($el->nodeName == 'w:tblGrid') {
                    $tableGrid = $el;
                    foreach ($el->childNodes as $col) {
                        if ($col->nodeName == 'w:gridCol') {
                            $columns[] = $col;
                            $columnsLen += 1;
                        }
                    }
                } elseif ($el->nodeName == 'w:tr') {
                    $cellsLen = 0;
                    foreach ($el->childNodes as $col) {
                        if ($col->nodeName == 'w:tc') {
                            $cellsLen += 1;
                        }
                    }
                    if (($columnsLen + $toAdd) < $cellsLen) {
                        $toAdd = $cellsLen - $columnsLen;
                    }
                }
            }

            // add columns, if necessary
            if (!is_null($tableGrid) && $toAdd > 0) {
                $width = 0;
                foreach ($columns as $col) {
                    if (!is_null($col->getAttribute('w:w'))) {
                        $width += $col->getAttribute('w:w');
                    }
                }
                if ($width > 0) {
                    $oldAverage = $width / $columnsLen;
                    $newAverage = round($width / ($columnsLen + $toAdd));
                    foreach ($columns as $col) {
                        $col->setAttribute('w:w', round($col->getAttribute('w:w') * $newAverage / $oldAverage));
                    }
                    while ($toAdd > 0) {
                        $newCol = $dom->createElement("w:gridCol");
                        $newCol->setAttribute('w:w', $newAverage);
                        $tableGrid->appendChild($newCol);
                        $toAdd -= 1;
                    }
                }
            }

            // remove columns, if necessary
            $columns = [];
            foreach ($tableGrid->childNodes as $col) {
                if ($col->nodeName == 'w:gridCol') {
                    $columns[] = $col;
                }
            }
            $columnsLen = count($columns);

            $cellsLen = 0;
            $cellsLenMax = 0;
            foreach ($table->childNodes as $el) {
                if ($el->nodeName == 'w:tr') {
                    $cells = [];
                    foreach ($el->childNodes as $col) {
                        if ($col->nodeName == 'w:tc') {
                            $cells[] = $col;
                        }
                    }
                    $cellsLen = $this->getCellLen($cells);
                    $cellsLenMax = max($cellsLenMax, $cellsLen);
                }
            }
            $toRemove = $cellsLen - $cellsLenMax;
            if ($toRemove > 0) {
                $removedWidth = 0.0;
                for ($i = $columnsLen - 1; ($i + 1) >= $toRemove; $i -= 1) {
                    $extraCol = $columns[$i];
                    $removedWidth += $extraCol->getAttribute('w:w');
                    $tableGrid->removeChild($extraCol);
                }

                $columnsLeft = [];
                foreach ($tableGrid->childNodes as $col) {
                    if ($col->nodeName == 'w:gridCol') {
                        $columnsLeft[] = $col;
                    }
                }
                $extraSpace = 0;
                if (count($columnsLeft) > 0) {
                    $extraSpace = $removedWidth / count($columnsLeft);
                }
                foreach ($columnsLeft as $col) {
                    $col->setAttribute('w:w', round($col->getAttribute('w:w') + $extraSpace));
                }
            }
        }
        return $dom;
    }

    /**
     * Get total cells length
     *
     * @param array $cells - cells
     *
     * @return int
     */
    private function getCellLen(array $cells): int
    {
        $total = 0;
        foreach ($cells as $cell) {
            foreach ($cell->childNodes as $tc) {
                if ($tc->nodeName == 'w:tcPr') {
                    foreach ($tc->childNodes as $span) {
                        if ($span->nodeName == 'w:gridSpan') {
                            $total += intval($span->getAttribute('w:val'));
                            break;
                        }
                    }
                    break;
                }
            }
        }
        return $total + 1;
    }

    /**
     * @param string $fileName
     */
    protected function savePartWithRels(string $fileName): void
    {
        if (isset($this->tempDocumentRelations[$fileName])) {
            $relsFileName = $this->getRelationsName($fileName);
            $targetDir = dirname($this->tmpDir . DIRECTORY_SEPARATOR . $relsFileName);
            if (!file_exists($targetDir)) {
                mkdir($targetDir, 0777, true);
            }
            file_put_contents($this->tmpDir . DIRECTORY_SEPARATOR . $relsFileName, $this->tempDocumentRelations[$fileName]);
        }
    }

    /**
     * Save the document to the target path
     *
     * @param string $path - target path
     */
    public function save(string $path): void
    {
        $rootPath = realpath($this->tmpDir);

        $zip = new ZipArchive();
        $zip->open($path, ZipArchive::CREATE | ZipArchive::OVERWRITE);

        $this->savePartWithRels($this->getMainPartName());
        file_put_contents($this->tmpDir . DIRECTORY_SEPARATOR . $this->getDocumentContentTypesName(), $this->tempDocumentContentTypes);

        $files = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($rootPath),
            RecursiveIteratorIterator::LEAVES_ONLY
        );

        foreach ($files as $name => $file) {
            if (!$file->isDir()) {
                $filePath = $file->getRealPath();
                $relativePath = substr($filePath, strlen($rootPath) + 1);
                $zip->addFile($filePath, $relativePath);
            }
        }

        $zip->close();

        if (isset($this->zipClass)) {
            $this->zipClass->close();
        }

        $this->rrmdir($this->tmpDir);
    }

    /**
     * Remove recursively directory
     *
     * @param string $dir - target directory
     */
    private function rrmdir(string $dir): void
    {
        $objects = scandir($dir);
        if (is_array($objects)) {

The condition is_array($objects) is always true.

            foreach ($objects as $object) {
                if ($object != "." && $object != "..") {
                    if (filetype($dir . DIRECTORY_SEPARATOR . $object) == "dir") {
                        $this->rrmdir($dir . DIRECTORY_SEPARATOR . $object);
                    } else {
                        unlink($dir . DIRECTORY_SEPARATOR . $object);
                    }
                }
            }
            reset($objects);
            rmdir($dir);
        }
    }

    /**
     * Close document
     */
    public function close(): void
    {
        if (isset($this->zipClass)) {
            $this->zipClass->close();
        }
        $this->rrmdir($this->tmpDir);
    }
}