Terah\Wkhtml\Wkhtml

Complexity

Total Complexity

31

Size/Duplication

Total Lines	317
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	3
B	findWkhtml()	0	16	5
B	findXvfb()	0	16	5
A	wkhtmlBinary()	0	7	1
A	wkhtmlArgs()	0	6	1
A	xvfbBinary()	0	7	1
A	xvfbArgs()	0	6	1
A	fromUri()	0	9	1
A	fromFile()	0	9	1
A	fromString()	0	9	1
A	orientation()	0	9	1
B	generate()	0	38	4
A	toBrowser()	0	9	1
A	toFile()	0	11	2
A	toString()	0	7	1
A	error()	0	6	2

<?php declare(strict_types=1);

namespace Terah\Wkhtml;

use function Terah\Assert\Assert;

use Psr\Log\LoggerAwareTrait;

class Wkhtml
{
    use LoggerAwareTrait;

    /** @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 = '';
        extract($settings);
        $wkhtmltopdf            = $this->findWkhtml($wkhtmltopdf);
        Assert($wkhtmltopdf)->notEmpty('Could not find the wkhtmltopdf binary installed on your system.')->file('Could not find the wkhtmltopdf binary installed on your system.');
        $this->wkhtmlBinary     = $wkhtmltopdf;
        if ( $xvfb === false )
        {
            $this->xvfbBinary       = $this->xvfbArgs = '';
        }
        if ( $xvfb )
        {
            $this->xvfbBinary($this->findXvfb($xvfb));
            $this->xvfbArgs         = $xvfb_args;
        }
    }

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

        return '';
    }

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

        return '';
    }

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

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

    /**
     * @param string $orientation
     * @return Wkhtml
     */
    public function orientation(string $orientation) : Wkhtml
    {
        $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 Wkhtml
     * @throws \Exception
     */
    public function generate()
    {
        if ( $this->generated )
        {
            return $this;
        }
        $descriptorSpec     = [
            0                   => ['pipe', 'r'], // stdin
            1                   => ['pipe', 'w'], // stdout
            2                   => ['pipe', 'w'], // stderr
        ];

        $orientation    = '--orientation ' . escapeshellarg($this->orientation);
        $wkhtmlBinary   = escapeshellarg($this->wkhtmlBinary);
        $command        = "{$wkhtmlBinary} -q {$orientation} {$this->wkhtmlArgs} - -";
        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}";
        }
        $process        = proc_open($command, $descriptorSpec, $pipes);
        fwrite($pipes[0], $this->stringSource);
        fclose($pipes[0]);
        // Read the outputs
        $this->content  = stream_get_contents($pipes[1]);
        $errors         = stream_get_contents($pipes[2]);
        // Close the process
        fclose($pipes[1]);
        proc_close($process);

        if ( $errors )
        {
            $this->error('Failed to generate PDF. Command: ' . $command, [$errors]);
        }
        $this->generated = true;

        return $this;
    }

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

        exit;
    }

    /**
     * @param string $fullPath
     * @return bool
     * @throws \Exception
     */
    public function toFile(string $fullPath) : bool
    {
        $this->generate();
        Assert($this->content)->notEmpty("The generated pdf file is empty");
        if ( ! file_put_contents($fullPath, $this->content) )
        {
            $this->error("Failed to copy PDF to {$fullPath}");
        }

        return true;
    }

    /**
     * @return string
     * @throws \Exception
     */
    public function toString() : string
    {
        $this->generate();
        Assert($this->content)->notEmpty("The generated pdf file is empty");

        return $this->content;
    }

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