Vaites\ApacheTika\Client

Complexity

Total Complexity

62

Size/Duplication

Total Lines	576
Duplicated Lines	0 %

Importance

Changes	12
Bugs	0	Features	1

31 Methods

Rating	Name	Duplication	Size	Complexity
A	isCached()	0	3	1
B	checkRequest()	0	21	8
A	cacheResponse()	0	5	1
A	parseJsonResponse()	0	20	5
A	getCachedResponse()	0	3	1
A	getMetadata()	0	10	2
A	setChecked()	0	5	1
A	getText()	0	8	2
A	getCallback()	0	3	1
A	getVersion()	0	3	1
A	getLanguage()	0	3	1
A	setCallback()	0	21	4
A	getRecursiveMetadata()	0	28	5
A	setDownloadRemote()	0	5	1
A	isVersionSupported()	0	3	1
A	isCacheable()	0	3	1
A	getMainText()	0	8	2
A	isChecked()	0	3	1
A	__construct()	0	3	2
A	downloadFile()	0	31	4
A	getMIME()	0	3	1
A	prepare()	0	3	1
A	getEncoding()	0	3	1
A	setChunkSize()	0	12	2
A	getDownloadRemote()	0	3	1
A	getSupportedVersions()	0	16	3
A	isMIMETypeSupported()	0	3	1
A	setEncoding()	0	12	2
A	getHTML()	0	8	2
A	make()	0	9	2
A	getChunkSize()	0	3	1

<?php

namespace Vaites\ApacheTika;

use Closure;
use Exception;
use stdClass;

use Vaites\ApacheTika\Clients\CLIClient;
use Vaites\ApacheTika\Clients\WebClient;
use Vaites\ApacheTika\Metadata\Metadata;
use Vaites\ApacheTika\Metadata\MetadataInterface;

/**
 * Apache Tika client interface
 *
 * @author  David Martínez <contacto@davidmartinez.net>
 * @link    https://tika.apache.org/1.24/formats.html
 */
abstract class Client
{
    protected const MODE = null;

    /**
     * Checked flag
     *
     * @var bool
     */
    protected $checked = false;

    /**
     * Response using callbacks
     *
     * @var string
     */
    protected $response = null;

    /**
     * Platform (unix or win)
     *
     * @var string
     */
    protected $platform = null;

    /**
     * Cached responses to avoid multiple request for the same file.
     *
     * @var array
     */
    protected $cache = [];

    /**
     * Text encoding
     *
     * @var string|null
     */
    protected $encoding = null;

    /**
     * Callback called on secuential read
     *
     * @var callable|null
     */
    protected $callback = null;

    /**
     * Enable or disable appending when using callback
     *
     * @var bool
     */
    protected $callbackAppend = true;

    /**
     * Size of chunks for callback
     *
     * @var int
     */
    protected $chunkSize = 1048576;

    /**
     * Remote download flag
     *
     * @var bool
     */
    protected $downloadRemote = false;

    /**
     * Configure client
     */
    public function __construct()
    {
        $this->platform = defined('PHP_WINDOWS_VERSION_MAJOR') ? 'win' : 'unix';
    }

    /**
     * Get a class instance throwing an exception if check fails
     *
     * @param string     $param1 path or host
     * @param string|int $param2 Java binary path or port for web client
     * @param array      $options options for cURL request
     * @param bool       $check check JAR file or server connection
     * @return \Vaites\ApacheTika\Clients\CLIClient|\Vaites\ApacheTika\Clients\WebClient
     * @throws \Exception
     */
    public static function make(string $param1 = null, $param2 = null, array $options = [], bool $check = true): Client
    {
        if(preg_match('/\.jar$/', func_get_arg(0)))
        {
            return new CLIClient($param1, $param2, $check);
        }
        else
        {
            return new WebClient($param1, $param2, $options, $check);
        }
    }

    /**
     * Get a class instance delaying the check
     *
     * @param string $param1 path or host
     * @param int    $param2 Java binary path or port for web client
     * @param array  $options options for cURL request
     * @return \Vaites\ApacheTika\Clients\CLIClient|\Vaites\ApacheTika\Clients\WebClient
     * @throws \Exception
     */
    public static function prepare($param1 = null, $param2 = null, $options = []): Client
    {
        return self::make($param1, $param2, $options, false);
    }

    /**
     * Get the encoding
     */
    public function getEncoding(): ?string
    {
        return $this->encoding;
    }

    /**
     * Set the encoding
     *
     * @throws \Exception
     */
    public function setEncoding(string $encoding): self
    {
        if(!empty($encoding))
        {
            $this->encoding = $encoding;
        }
        else
        {
            throw new Exception('Invalid encoding');
        }

        return $this;
    }

    /**
     * Get the callback
     */
    public function getCallback(): ?Closure
    {
        return $this->callback;
    }

    /**
     * Set the callback (callable or closure) for call on secuential read
     *
     * @throws \Exception
     */
    public function setCallback(callable $callback, bool $append = true): self
    {
        if($callback instanceof Closure || is_array($callback))
        {
            $this->callbackAppend = (bool) $append;
            $this->callback = $callback;
        }
        elseif(is_string($callback))
        {
            $this->callbackAppend = (bool) $append;
            $this->callback = function($chunk) use ($callback)
            {
                return call_user_func_array($callback, [$chunk]);
            };
        }
        else
        {
            throw new Exception('Invalid callback');
        }

        return $this;
    }

    /**
     * Get the chunk size
     */
    public function getChunkSize(): int
    {
        return $this->chunkSize;
    }

    /**
     * Set the chunk size for secuential read
     *
     * @throws \Exception
     */
    public function setChunkSize(int $size): self
    {
        if(static::MODE == 'cli')

The condition static::MODE == 'cli' is always false.

        {
            $this->chunkSize = $size;
        }
        else
        {
            throw new Exception('Chunk size is not supported on web mode');
        }

        return $this;
    }

    /**
     * Get the remote download flag
     */
    public function getDownloadRemote(): bool
    {
        return $this->downloadRemote;
    }

    /**
     * Set the remote download flag
     */
    public function setDownloadRemote(bool $download): self
    {
        $this->downloadRemote = (bool) $download;

        return $this;
    }

    /**
     * Gets file metadata
     *
     * @throws \Exception
     */
    public function getMetadata(string $file): MetadataInterface
    {
        $response = $this->parseJsonResponse($this->request('meta', $file));

        if($response instanceof stdClass == false)

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

        {
            throw new Exception("Unexpected metadata response for $file");
        }

        return Metadata::make($response, $file);
    }

    /**
     * Gets recursive file metadata where the returned array indexes are the file name.
     *
     * Example: for a sample.zip with an example.doc file, the return array looks like if be defined as:
     *
     *  [
     *      'sample.zip' => new Metadata()
     *      'sample.zip/example.doc' => new DocumentMetadata()
     *  ]
     *
     * @link https://cwiki.apache.org/confluence/display/TIKA/TikaServer#TikaServer-RecursiveMetadataandContent
     * @throws \Exception
     */
    public function getRecursiveMetadata(string $file, ?string $format = 'ignore'): array
    {
        if(in_array($format, ['text', 'html', 'ignore']) == false)

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

        {
            throw new Exception("Unknown recursive type (must be text, html, ignore or null)");
        }

        $response = $this->parseJsonResponse($this->request("rmeta/$format", $file));

        if(is_array($response) == false)

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

        {
            throw new Exception("Unexpected metadata response for $file");
        }

        $metadata = [];

        foreach($response as $item)
        {
            $name = basename($file);
            if(isset($item->{'X-TIKA:embedded_resource_path'}))
            {
                $name .= $item->{'X-TIKA:embedded_resource_path'};
            }

            $metadata[$name] = Metadata::make($item, $file);
        }

        return $metadata;
    }

    /**
     * Detect language
     *
     * @throws \Exception
     */
    public function getLanguage(string $file): string
    {
        return $this->request('lang', $file);
    }

    /**
     * Detect MIME type
     *
     * @throws \Exception
     */
    public function getMIME(string $file): string
    {
        return $this->request('mime', $file);
    }

    /**
     * Extracts HTML
     *
     * @throws \Exception
     */
    public function getHTML(string $file, callable $callback = null, bool $append = true): string
    {
        if(!is_null($callback))
        {
            $this->setCallback($callback, $append);
        }

        return $this->request('html', $file);
    }

    /**
     * Extracts text
     *
     * @throws \Exception
     */
    public function getText(string $file, callable $callback = null, bool $append = true): string
    {
        if(!is_null($callback))
        {
            $this->setCallback($callback, $append);
        }

        return $this->request('text', $file);
    }

    /**
     * Extracts main text
     *
     * @throws \Exception
     */
    public function getMainText(string $file, callable $callback = null, bool $append = true): string
    {
        if(!is_null($callback))
        {
            $this->setCallback($callback, $append);
        }

        return $this->request('text-main', $file);
    }

    /**
     * Returns current Tika version
     *
     * @throws \Exception
     */
    public function getVersion(): string
    {
        return $this->request('version');
    }

    /**
     * Return the list of Apache Tika supported versions
     *
     * @throws \Exception
     */
    public function getSupportedVersions(): array
    {
        static $versions = null;

        if(is_null($versions))
        {
            $composer = json_decode(file_get_contents(dirname(__DIR__) . '/composer.json'), true);
            $versions = $composer['extra']['supported-versions'] ?? null;

            if(empty($versions))
            {
                throw new Exception("An error ocurred trying to read package's composer.json file");
            }
        }

        return $versions;
    }

    /**
     * Sets the checked flag
     */
    public function setChecked(bool $checked): self
    {
        $this->checked = (bool) $checked;

        return $this;
    }

    /**
     * Checks if instance is checked
     */
    public function isChecked(): bool
    {
        return $this->checked;
    }

    /**
     * Check if a response is cached
     */
    protected function isCached(string $type, string $file): bool
    {
        return isset($this->cache[sha1($file)][$type]);
    }

    /**
     * Get a cached response
     */
    protected function getCachedResponse(string $type, string $file)
    {
        return $this->cache[sha1($file)][$type] ?? null;
    }

    /**
     * Check if a request type must be cached
     */
    protected function isCacheable(string $type): bool
    {
        return in_array($type, ['lang', 'meta']);
    }

    /**
     * Caches a response
     */
    protected function cacheResponse(string $type, $response, string $file): bool
    {
        $this->cache[sha1($file)][$type] = $response;

        return true;
    }

    /**
     * Checks if a specific version is supported
     */
    public function isVersionSupported(string $version): bool
    {
        return in_array($version, $this->getSupportedVersions());
    }

    /**
     * Check if a mime type is supported
     *
     * @param string $mime
     * @return bool
     * @throws \Exception
     */
    public function isMIMETypeSupported(string $mime): bool
    {
        return array_key_exists($mime, $this->getSupportedMIMETypes());
    }

    /**
     * Check the request before executing
     *
     * @throws \Exception
     */
    public function checkRequest(string $type, string $file = null): ?string
    {
        // no checks for getters
        if(in_array($type, ['detectors', 'mime-types', 'parsers', 'version']))
        {
            //
        } // invalid local file
        elseif(!preg_match('/^http/', $file) && !file_exists($file))
        {
            throw new Exception("File $file can't be opened");
        } // invalid remote file
        elseif(preg_match('/^http/', $file) && !preg_match('/200/', get_headers($file)[0]))
        {
            throw new Exception("File $file can't be opened", 2);
        } // download remote file if required only for integrated downloader
        elseif(preg_match('/^http/', $file) && $this->downloadRemote)
        {
            $file = $this->downloadFile($file);

It seems like $file can also be of type null; however, parameter $file of Vaites\ApacheTika\Client::downloadFile() does only seem to accept string, maybe add an additional type check?

        }

        return $file;
    }

    /**
     * Parse the response returned by Apache Tika
     *
     * @return mixed
     * @throws \Exception
     */
    protected function parseJsonResponse(string $response)
    {
        // an empty response throws an error
        if(empty($response) || trim($response) == '')
        {
            throw new Exception('Empty response');
        }

        // decode the JSON response
        $json = json_decode($response);

        // exceptions if metadata is not valid
        if(json_last_error())
        {
            $message = function_exists('json_last_error_msg') ? json_last_error_msg() : 'Error parsing JSON response';

            throw new Exception($message, json_last_error());
        }

        return $json;
    }

    /**
     * Download file to a temporary folder
     *
     * @link https://wiki.apache.org/tika/TikaJAXRS#Specifying_a_URL_Instead_of_Putting_Bytes
     * @throws \Exception
     */
    protected function downloadFile(string $file): string
    {
        $dest = tempnam(sys_get_temp_dir(), 'TIKA');

        $fp = fopen($dest, 'w+');

        if($fp === false)
        {
            throw new Exception("$dest can't be opened");
        }

        $ch = curl_init($file);
        curl_setopt($ch, CURLOPT_FILE, $fp);

It seems like $ch can also be of type false; however, parameter $ch of curl_setopt() does only seem to accept resource, maybe add an additional type check?

        curl_setopt($ch, CURLOPT_TIMEOUT, 5);
        curl_exec($ch);

It seems like $ch can also be of type false; however, parameter $ch of curl_exec() does only seem to accept resource, maybe add an additional type check?

        if(curl_errno($ch))

It seems like $ch can also be of type false; however, parameter $ch of curl_errno() does only seem to accept resource, maybe add an additional type check?

        {
            throw new Exception(curl_error($ch));

It seems like $ch can also be of type false; however, parameter $ch of curl_error() does only seem to accept resource, maybe add an additional type check?

        }

        $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

It seems like $ch can also be of type false; however, parameter $ch of curl_getinfo() does only seem to accept resource, maybe add an additional type check?

        curl_close($ch);

It seems like $ch can also be of type false; however, parameter $ch of curl_close() does only seem to accept resource, maybe add an additional type check?

        if($code != 200)
        {
            throw new Exception("$file can't be downloaded", $code);
        }

        return $dest;
    }

    /**
     * Must return the supported MIME types
     *
     * @throws \Exception
     */
    abstract public function getSupportedMIMETypes(): array;

    /**
     * Must return the available detectors
     *
     * @throws \Exception
     */
    abstract public function getAvailableDetectors(): array;

    /**
     * Must return the available parsers
     *
     * @throws \Exception
     */
    abstract public function getAvailableParsers(): array;

    /**
     * Check Java binary, JAR path or server connection
     */
    abstract public function check(): void;

    /**
     * Configure and make a request and return its results.
     *
     * @throws \Exception
     */
    abstract public function request(string $type, string $file = null): string;
}