GravityMedia\Ghostscript\Ghostscript

Complexity

Total Complexity

16

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

100%

Importance

Changes	13
Bugs	0	Features	4

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	getOption()	0	8	2
A	createProcessBuilder()	0	11	2
A	getVersion()	0	15	3
A	createProcessArguments()	0	11	2
A	createPdfDevice()	0	17	2
A	createNullDevice()	0	7	1
A	createPdfInfoDevice()	0	7	1
A	createBboxDevice()	0	13	1

<?php
/**
 * This file is part of the Ghostscript package
 *
 * @author Daniel Schröder <daniel.schroeder@gravitymedia.de>
 */

namespace GravityMedia\Ghostscript;

use GravityMedia\Ghostscript\Device\BoundingBoxInfo;
use GravityMedia\Ghostscript\Device\NoDisplay;
use GravityMedia\Ghostscript\Device\PdfInfo;
use GravityMedia\Ghostscript\Device\PdfWrite;
use GravityMedia\Ghostscript\Process\Arguments as ProcessArguments;
use Symfony\Component\Process\ProcessBuilder;

/**
 * The Ghostscript class
 *
 * @package GravityMedia\Ghostscript
 */
class Ghostscript
{
    /**
     * The default binary
     */
    const DEFAULT_BINARY = 'gs';

    /**
     * The options
     *
     * @var array
     */
    protected $options;

    /**
     * The version
     *
     * @var string
     */
    protected $version;

    /**
     * Create Ghostscript object
     *
     * @param array $options
     *
     * @throws \RuntimeException
     */
    public function __construct(array $options = [])
    {
        $this->options = $options;

        if (version_compare('9.00', $this->getVersion()) > 0) {
            throw new \RuntimeException('Ghostscript version 9.00 or higher is required');
        }
    }

    /**
     * Get option
     *
     * @param string $name
     * @param mixed  $default
     *
     * @return mixed
     */
    public function getOption($name, $default = null)
    {
        if (array_key_exists($name, $this->options)) {
            return $this->options[$name];
        }

        return $default;
    }

    /**
     * Create process builder object
     *
     * @param array $arguments
     *
     * @return ProcessBuilder
     */
    protected function createProcessBuilder(array $arguments = [])
    {
        $processBuilder = new ProcessBuilder($arguments);
        $processBuilder->setPrefix($this->getOption('bin', self::DEFAULT_BINARY));
        $processBuilder->addEnvironmentVariables($this->getOption('env', []));
        if (($timeout = $this->getOption('timeout', -1)) != -1) {
            $processBuilder->setTimeout($timeout);
        }

        return $processBuilder;
    }

    /**
     * Get version
     *
     * @throws \RuntimeException
     *
     * @return string
     */
    public function getVersion()
    {
        if (null === $this->version) {
            $process = $this->createProcessBuilder(['--version'])->getProcess();
            $process->run();

            if (!$process->isSuccessful()) {
                throw new \RuntimeException($process->getErrorOutput());
            }

            $this->version = $process->getOutput();
        }

        return $this->version;
    }

    /**
     * Create process arguments object
     *
     * @param array $arguments
     *
     * @return ProcessArguments
     */
    protected function createProcessArguments(array $arguments = [])
    {
        $processArguments = new ProcessArguments();
        $processArguments->addArguments($arguments);

        if ($this->getOption('quiet', true)) {
            $processArguments->addArgument('-q');
        }

        return $processArguments;
    }

    /**
     * Create PDF device object
     *
     * @param null|string $outputFile
     *
     * @return PdfWrite
     */
    public function createPdfDevice($outputFile = null)
    {
        $builder = $this->createProcessBuilder();
        $arguments = $this->createProcessArguments();

        $device = new PdfWrite($builder, $arguments);
        $device
            ->setSafer()
            ->setBatch()
            ->setNoPause();

        if (null !== $outputFile) {
            $device->setOutputFile($outputFile);
        }

        return $device;
    }

    /**
     * Create null device object
     *
     * @return NoDisplay
     */
    public function createNullDevice()
    {
        $builder = $this->createProcessBuilder();
        $arguments = $this->createProcessArguments();

        return new NoDisplay($builder, $arguments);
    }

    /**
     * Create PDF info device object
     *
     * @param string $pdfInfoPath Path to toolbin/pdf_info.ps 
     * @return PdfInfo
     */
    public function createPdfInfoDevice($pdfInfoPath)
    {
        $builder = $this->createProcessBuilder();
        $arguments = $this->createProcessArguments();

        return new PdfInfo($builder, $arguments, $pdfInfoPath);
    }

    /**
     * Create bounding box info device object
     *
     * @return BoundingBoxInfo
     */
    public function createBboxDevice()
    {
        $builder = $this->createProcessBuilder();
        $arguments = $this->createProcessArguments();

        $device = new BoundingBoxInfo($builder, $arguments);
        $device
            ->setSafer()
            ->setBatch()
            ->setNoPause();

        return $device;
    }
}