silverstripe / silverstripe-textextraction

src/Rest/TikaRestClient.php

<?php

namespace SilverStripe\TextExtraction\Rest;

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Psr7\Response;
use Psr\Log\LoggerInterface;
use SilverStripe\Core\Convert;
use SilverStripe\Core\Environment;
use SilverStripe\Core\Injector\Injector;

class TikaRestClient extends Client
{
    /**
     * Authentication options to be sent to the Tika server
     *
     * @var array
     */
    protected $options = ['username' => null, 'password' => null];

    /**
     * @var array
     */
    protected $mimes = [];

    /**
     *
     * @param string $baseUrl
     * @param array $config
     */
    public function __construct($baseUrl = '', $config = [])
    {
        $password = Environment::getEnv('SS_TIKA_PASSWORD');

        if (!empty($password)) {
            $this->options = [
                'username' => Environment::getEnv('SS_TIKA_USERNAME'),
                'password' => $password,
            ];
        }

        $config['base_uri'] = $baseUrl;

        parent::__construct($config);
    }

    /**
     * Detect if the service is available
     *
     * @return bool
     */
    public function isAvailable()
    {
        try {
            /** @var Response $result */
            $result = $this->get('/', $this->getGuzzleOptions());

            if ($result->getStatusCode() == 200) {
                return true;
            }
        } catch (RequestException $ex) {
            $msg = sprintf("Tika unavailable - %s", $ex->getMessage());
            Injector::inst()->get(LoggerInterface::class)->info($msg);

            return false;
        }
    }

    /**
     * Get version code
     *
     * @return string
     */
    public function getVersion()
    {
        /** @var Response $response */
        $response = $this->get('version', $this->getGuzzleOptions());
        $version = 0;

        // Parse output
        if ($response->getStatusCode() == 200
            && preg_match('/Apache Tika (?<version>[\.\d]+)/', $response->getBody(), $matches)
        ) {
            $version = $matches['version'];
        }

        return (string) $version;
    }

    /**
     * Gets supported mime data. May include aliased mime types.
     *
     * @return array
     */
    public function getSupportedMimes()
    {
        if ($this->mimes) {

The expression $this->mimes of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return $this->mimes;
        }

        $response = $this->get(
            'mime-types',
            $this->getGuzzleOptions([
                'headers' => [
                    'Accept' => 'application/json',
                ],
            ])
        );

        return $this->mimes = Convert::json2array($response->getBody());

It seems like SilverStripe\Core\Convert::json2array($response->getBody()) can also be of type boolean. However, the property $mimes is declared as type array. Maybe add an additional type check?

The expression return $this->mimes = SilverStripe\Core\Convert::json2array($response->getBody()) also could return the type boolean which is incompatible with the documented return type array.

The function SilverStripe\Core\Convert::json2array() has been deprecated: 4.4.0:5.0.0 Use json_decode() instead

    }

    /**
     * Extract text content from a given file.
     * Logs a notice-level error if the document can't be parsed.
     *
     * @param  string $file Full filesystem path to a file to post
     * @return string Content of the file extracted as plain text
     */
    public function tika($file)
    {
        $text = null;
        try {
            /** @var Response $response */
            $response = $this->put(
                'tika',
                $this->getGuzzleOptions([
                    'headers' => [
                        'Accept' => 'text/plain',
                    ],
                    'body' => file_get_contents($file),
                ])
            );
            $text = $response->getBody();
        } catch (RequestException $e) {
            $msg = sprintf(
                'TikaRestClient was not able to process %s. Response: %s %s.',
                $file,
                $e->getResponse()->getStatusCode(),
                $e->getResponse()->getReasonPhrase()
            );
            // Only available if tika-server was started with --includeStack
            $body = $e->getResponse()->getBody();
            if ($body) {

$body is of type Psr\Http\Message\StreamInterface, thus it always evaluated to true.

                $msg .= ' Body: ' . $body;
            }

            Injector::inst()->get(LoggerInterface::class)->info($msg);
        }

        return (string) $text;
    }

    /**
     * Assembles an array of request options to pass to Guzzle
     *
     * @param array $options Authentication (etc) will be merged into this array and returned
     * @return array
     */
    protected function getGuzzleOptions($options = [])
    {
        if (!empty($this->options['username']) && !empty($this->options['password'])) {
            $options['auth'] = [
                $this->options['username'],
                $this->options['password']
            ];
        }
        return $options;
    }
}