Terah\Wkhtml\Wkhtml

Complexity

Total Complexity

39

Size/Duplication

Total Lines	362
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	1

Importance

Changes	12
Bugs	0	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	3
B	findWkhtml()	0	15	5
B	findXvfb()	0	15	5
A	wkhtmlBinary()	0	6	1
A	wkhtmlArgs()	0	5	1
A	xvfbBinary()	0	6	1
A	xvfbArgs()	0	5	1
A	tempPath()	0	11	1
A	tempFile()	0	10	1
A	fromUri()	0	8	1
A	fromFile()	0	8	1
A	fromString()	0	8	1
A	orientation()	0	8	1
B	generate()	0	33	5
A	saveStringSourceToFile()	0	12	3
A	toBrowser()	0	9	2
A	toFile()	0	10	2
A	toString()	0	8	1
A	getTempFullPath()	0	4	1
A	error()	0	6	2

<?php

namespace Terah\Wkhtml;

use function Terah\Assert\Assert;
use function Terah\Assert\Validate;

use Terah\ColourLog\LoggerTrait;

class Wkhtml
{
    use LoggerTrait;

    /** @var string */
    protected $tempPath     = '';

    /** @var string */
    protected $tempFile     = '';

    /** @var bool */
    protected $doCacheFile  = true;

    /** @var string */
    protected $wkhtmlBinary = '';

    /** @var string  */
    protected $wkhtmlArgs   = '';

    /** @var string */
    protected $orientation  = 'portrait';

    /** @var string */
    protected $uriSource    = '';

    /** @var string */
    protected $fileSource   = '';

    /** @var string */
    protected $stringSource = '';

    /** @var string */
    protected $content      = '';

    /** @var bool */
    protected $generated    = false;

    /** @var array */
    protected $xvfbLocations = [
        '/usr/bin/xvfb-run', // Ubuntu
    ];

    /** @var null|string */
    protected $xvfbBinary   = '/usr/bin/xvfb-run';

    /** @var null|string */
    protected $xvfbArgs     = '--server-args="-screen 0, 1024x768x24"';
    protected $xvfbLog      = null;

    /** @var array */
    protected $wkhtmlLocations = [
        '/usr/bin/wkhtmltopdf', // Ubuntu
        '/usr/local/bin/wkhtmltopdf', // Mac
    ];

    /**
     * @param array $settings
     */
    public function __construct(array $settings)
    {
        $wkhtmltopdf = $xvfb = $xvfb_args = null;
        extract($settings);
        $wkhtmltopdf = $this->findWkhtml($wkhtmltopdf);
        Assert($wkhtmltopdf)->notEmpty()->file();
        $this->wkhtmlBinary = $wkhtmltopdf;
        if ( $xvfb === false )
        {
            $this->xvfbBinary = $this->xvfbArgs = '';
        }
        if ( $xvfb )
        {
            $this->xvfbBinary($this->findXvfb($xvfb));
            $this->xvfbArgs     = $xvfb_args;
        }
        $this->tempPath(sys_get_temp_dir());
        $this->tempFile(str_replace($this->tempPath, '', tempnam($this->tempPath, 'pdf')));
    }

    /**
     * @param string $wkhtmlBinary
     * @return string|null
     */
    protected function findWkhtml($wkhtmlBinary)
    {
        if ( ! is_null($wkhtmlBinary) && file_exists($wkhtmlBinary) )
        {
            return $wkhtmlBinary;
        }
        foreach ( $this->wkhtmlLocations as $path )
        {
            if ( file_exists($path) )
            {
                return $path;
            }
        }
        return null;
    }

    /**
     * @param string $xvfbBinary
     * @return string|null
     */
    protected function findXvfb($xvfbBinary=null)
    {
        if ( ! is_null($xvfbBinary) && file_exists($xvfbBinary) )
        {
            return $xvfbBinary;
        }
        foreach ( $this->xvfbLocations as $path )
        {
            if ( file_exists($path) )
            {
                return $path;
            }
        }
        return null;
    }

    /**
     * @param string $wkhtmlBinary
     * @return $this
     */
    public function wkhtmlBinary($wkhtmlBinary)
    {
        Assert($wkhtmlBinary)->file("The wkhtml binary does not exist.");
        $this->wkhtmlBinary = $wkhtmlBinary;
        return $this;
    }

    /**
     * @param string $wkhtmlArgs
     * @return $this
     */
    public function wkhtmlArgs($wkhtmlArgs)
    {
        $this->wkhtmlArgs = $wkhtmlArgs;
        return $this;
    }

    /**
     * @param string $xvfbBinary
     * @return $this
     */
    public function xvfbBinary($xvfbBinary)
    {
        Assert($xvfbBinary)->file("The xvfb binary does not exist.");
        $this->xvfbBinary = $xvfbBinary;
        return $this;
    }

    /**
     * @param string $xvfbArgs
     * @return $this
     */
    public function xvfbArgs($xvfbArgs)
    {
        $this->xvfbArgs = $xvfbArgs;
        return $this;
    }

    /**
     * @param string $tempPath
     * @return $this
     */
    public function tempPath($tempPath)
    {
        Assert($tempPath)
            ->notEmpty('tmp_path cannot be empty')
            ->directory('tmp_path must be a directory')
            ->writeable('tmp_path must be writable.');
        $sep                = DIRECTORY_SEPARATOR;
        $this->tempPath     = str_replace($sep . $sep, $sep, $tempPath . $sep);
        $this->generated    = false;
        return $this;
    }

    /**
     * @param string $tempFile
     * @param bool $doCacheFile
     * @return $this
     */
    public function tempFile($tempFile, $doCacheFile=true)
    {
        $tempFile = str_replace(DIRECTORY_SEPARATOR, '', $tempFile);
        Assert($tempFile)->notEmpty('tmp_path cannot be empty');
        Assert($doCacheFile)->boolean();
        $this->tempFile     = $tempFile;
        $this->doCacheFile  = false;
        $this->generated    = false;
        return $this;
    }

    /**
     * @param string $source
     * @return $this
     */
    public function fromUri($source)
    {
        $this->uriSource    = $source;
        $this->fileSource   = '';
        $this->stringSource = '';
        $this->generated    = false;
        return $this;
    }

    /**
     * @param string $source
     * @return $this
     */
    public function fromFile($source)
    {
        $this->uriSource    = '';
        $this->fileSource   = $source;
        $this->stringSource = '';
        $this->generated    = false;
        return $this;
    }

    /**
     * @param string $source
     * @return $this
     */
    public function fromString($source)
    {
        $this->uriSource    = '';
        $this->fileSource   = '';
        $this->stringSource = $source;
        $this->generated    = false;
        return $this;
    }

    /**
     * @param string $orientation
     * @return $this
     */
    public function orientation($orientation)
    {
        $orientation        = ucfirst(strtolower($orientation));
        Assert($orientation)->inArray(['Landscape', 'Portrait'], "The orientation must be either landscape or portrait.");
        $this->orientation  = $orientation;
        $this->generated    = false;
        return $this;
    }

    /**
     * @return $this|bool
     * @throws \Exception
     */
    public function generate()
    {
        if ( $this->generated )
        {
            return true;
        }
        $fullTempPath   = $this->getTempFullPath();
        Assert($fullTempPath)->notEmpty();
        $this->saveStringSourceToFile($fullTempPath);
        $source         = $this->uriSource;
        if ( $this->fileSource )
        {
            $source         = $this->fileSource;
            clearstatcache();
            Assert($source)->file('A PDF source file does not exist.');
        }
        $orientation    = '--orientation ' . escapeshellarg($this->orientation);
        $source         = escapeshellarg($source);
        $fullTempPath   = escapeshellarg($fullTempPath);
        $command        = "{$this->wkhtmlBinary} -q {$orientation} {$this->wkhtmlArgs} {$source} {$fullTempPath}";
        if ( $this->xvfbBinary )

The expression $this->xvfbBinary of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

        {
            $command    = str_replace('wkhtmltopdf', 'wkhtmltopdf --use-xserver --page-size A4', $command);
            $command    = "{$this->xvfbBinary} {$this->xvfbArgs} {$command}";
        }
        exec($command, $output, $result);
        if ( $result !== 0 )
        {
            $this->error('Failed to generate PDF. Command: ' . $command, $output);
        }
        $this->generated = true;
        return $this;
    }

    /**
     * @param string $fullTempPath
     * @return bool
     * @throws \Exception
     */
    protected function saveStringSourceToFile($fullTempPath)
    {
        if ( ! empty($this->stringSource) )
        {
            $this->fileSource = $fullTempPath . '.html';
            if ( ! file_put_contents($this->fileSource, $this->stringSource) )
            {
                $this->error("Failed to save tmp file ({$this->fileSource}).");
            }
        }
        return true;
    }

    /**
     * @param string|null $fileName
     */
    public function toBrowser($fileName=null)
    {
        $this->generate();
        $fileName = $fileName ? $fileName : $this->tempFile;
        header("Content-Disposition:attachment;filename='{$fileName}'");
        header('Content-type: application/pdf');
        readfile($this->getTempFullPath());
        exit;
    }

    /**
     * @param string $fullPath
     * @return bool
     * @throws \Exception
     */
    public function toFile($fullPath)
    {
        $this->generate();
        $tempFile = $this->getTempFullPath();
        if ( ! copy($tempFile, $fullPath) )
        {
            $this->error("Failed to copy PDF from {$tempFile} to {$fullPath}");
        }
        return true;
    }

    /**
     * @return string
     * @throws \Exception
     */
    public function toString()
    {
        $this->generate();
        $tempFile = $this->getTempFullPath();
        $fileData =  file_get_contents($tempFile);
        Assert($fileData)->notEmpty("The generated pdf file is empty");
        return $fileData;
    }

    /**
     * @return string
     */
    protected function getTempFullPath()
    {
        return $this->tempPath . $this->tempFile;
    }

    /**
     * @param string $message
     * @param array $context
     * @throws \Exception
     */
    protected function error($message, array $context=[])
    {
        $this->logger->error($message, $context);
        $context = $context ? ": " . print_r($context, true) : '';
        throw new \Exception($message . $context);
    }
}