Changeset 2525480

redisearch/tags/0.3.3/README.md

-                      r2455651
+                      r2525480
 ### Changelog
+##### 0.3.3
+* **Added**: Ability to connect via UNIX sockets
 ##### 0.3.2

redisearch/tags/0.3.3/readme.txt

-                      r2455651
+                      r2525480
 Tags: search, redisearch, redis, fuzzy, aggregation, searching, autosuggest, suggest, advanced search, woocommerce
 Requires at least: 5.0
 Tested up to: 5.6
 Stable tag: 0.3.2
+Tested up to: 5.7
+Stable tag: 0.3.3
 Requires PHP: 7.2
 License: GPLv2 or later
 …
 == Changelog ==
+= 0.3.3 =
+* Added: Ability to connect via UNIX sockets
 = 0.3.2 =

redisearch/tags/0.3.3/src/Admin/Admin.php

-                      r2455651
+                      r2525480
   public static function RedisServerConf() {
     Fields::add( 'header', null, __( 'Redis server configurations', 'wp-redisearch' ) );
+    Fields::add( 'text', 'wp_redisearch_server', __( 'Redis server', 'wp-redisearch' ), __( 'Redis server url, usually it is 127.0.0.1', 'wp-redisearch' ) );
+    Fields::add( 'select', 'wp_redisearch_connection_scheme', __( 'Server communication scheme', 'wp-redisearch' ), __( 'Choose Redis server communication scheme.', 'wp-redisearch'), array('tcp' => 'TCP', 'unix' => 'UNIX') );
+    Fields::add( 'text', 'wp_redisearch_server', __( 'Redis server/path', 'wp-redisearch' ), __( 'Redis server url, usually it is 127.0.0.1 and in case of using UNIX socket, the socket path.', 'wp-redisearch' ) );
     Fields::add( 'text', 'wp_redisearch_port', __( 'Redis port', 'wp-redisearch' ), __( 'Redis port number, by default it is 6379', 'wp-redisearch' ) );
     Fields::add( 'password', 'wp_redisearch_password', __( 'Redis server password', 'wp-redisearch' ), __( 'If your redis server is not password protected, leave this field blank', 'wp-redisearch' ) );

redisearch/tags/0.3.3/src/RediSearch/Client.php

-                      r2452159
+                      r2525480
       Settings::RedisPort(),
       Settings::RedisPassword(),
+,
+      Settings::RedisScheme()
     );
+  }

redisearch/tags/0.3.3/src/RedisRaw/PredisAdapter.php

-                      r2452159
+                      r2525480
   public $redis;
+  public function connect($hostname = '127.0.0.1', $port = 6379, $db = 0, $password = null): RedisRawClientInterface {
+    $this->redis = new Client([
+      'scheme' => 'tcp',
+      'host' => $hostname,
+      'port' => $port,
+      'database' => $db,
+      'password' => $password,
+    ]);
+  public function connect($hostname = '127.0.0.1', $port = 6379, $db = 0, $password = null, $scheme = 'tcp'): RedisRawClientInterface {
+    $clientArgs = array();
+    if ( $scheme === 'tcp' ) {
+      $clientArgs = array(
+      'scheme'    => 'tcp',
+      'host'      => $hostname,
+      'port'      => $port,
+      'database'  => $db,
+      'password'  => $password,
+      );
+    } else {
+      $clientArgs = array(
+        'scheme'    => 'unix',
+        'path'      => $host
+      );
+    }
+    $this->redis = new Client( $clientArgs );
     $this->redis->connect();
     return $this;

redisearch/tags/0.3.3/src/Settings.php

-                      r2452159
+                      r2525480
     return isset( $redis_server ) && !empty( $redis_server ) ? $redis_server : '127.0.0.1';
+  }
+  /**
+  * Using UNIX socket for communicating with Redis server or not.
+  * @since    0.1.0
+  * @param
+  * @return bool    $unixServer
+  */
+  public static function RedisScheme() {
+    /**
+     * First we try to get the WP_REDIS_SCHEME option from wp-config.php
+     * @since 0.3.3
+     */
+    $redis_server = ( defined( 'WP_REDIS_SCHEME' ) ) ? WP_REDIS_SCHEME : get_option( 'wp_redisearch_connection_scheme' );
+    return get_option( 'wp_redisearch_connection_scheme' );
+  }

redisearch/tags/0.3.3/vendor/foadyousefi/seven-fields/src/Fields/Fields.php

-                      r2013762
+                      r2525480
           update_option( $name, $value );
           break;
+        case 'select':
+          update_option( $name, $value );
+          break;
         case 'checkbox':
           $value = isset( $value ) ? true : false;

redisearch/tags/0.3.3/vendor/foadyousefi/seven-fields/src/Fields/Select.php

r1949960	r2525480
39	39	self::$description = $description;
40	40	self::$options = $options;
	41	// Save value in as wp_option in database
	42	parent::save( self::$name, 'select' );
41	43	return $this->field_html();
42	44	}

redisearch/tags/0.3.3/vendor/front/redisearch/src/RedisRaw/PredisAdapter.php

-                      r2452159
+                      r2525480
   public $redis;
+  public function connect($hostname = '127.0.0.1', $port = 6379, $db = 0, $password = null): RedisRawClientInterface {
+    $this->redis = new Client([
+      'scheme' => 'tcp',
+      'host' => $hostname,
+      'port' => $port,
+      'database' => $db,
+      'password' => $password,
+    ]);
+  public function connect($hostname = '127.0.0.1', $port = 6379, $db = 0, $password = null, $scheme = 'tcp'): RedisRawClientInterface {
+    $clientArgs = array(
+      'database'  => $db,
+      'password'  => $password
+    );
+    if ( $scheme === 'tcp' ) {
+      $clientArgs = array(
+        'scheme'    => 'tcp',
+        'port'      => $port,
+        'host'      => $hostname
+      );
+    } else if ( $scheme === 'unix' ) {
+      $clientArgs = array(
+        'scheme'    => 'unix',
+        'path'      => $host
+      );
+    }
+    $this->redis = new Client( $clientArgs );
     $this->redis->connect();
     return $this;

redisearch/tags/0.3.3/vendor/front/redisearch/src/Setup.php

-                      r2452159
+                      r2525480
    * @return PredisAdapter
    */
   public static function connect( $server = '127.0.0.1', $port = 6379, $password = null, $database = 0 ) {
+  public static function connect( $server = '127.0.0.1', $port = 6379, $password = null, $database = 0, $scheme = 'tcp' ) {
     // Connect to server
     $client = ( new PredisAdapter() )->connect( $server, $port, $database, $password );
+    $client = ( new PredisAdapter() )->connect( $server, $port, $database, $password, $database, $scheme );
     return $client;
+  }

redisearch/tags/0.3.3/vendor/vaites/php-apache-tika/src/Client.php

-                      r2002534
+                      r2525480
 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;
 /**
 …
+ *
  * @author  David Martínez <contacto@davidmartinez.net>
+ * @link    http://wiki.apache.org/tika/TikaJAXRS
+ * @link    https://tika.apache.org/1.10/formats.html
+ * @link    https://tika.apache.org/1.24/formats.html
  */
 abstract class Client
+{
+    /**
+     * List of supported Apache Tika versions
+    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 static $supportedVersions =
+    [
-        '1.7', '1.8', '1.9', '1.10', '1.11', '1.12', '1.13', '1.14', '1.15', '1.16', '1.17', '1.18', '1.19', '1.19.1'
-    ];
-    /**
-     * Response using callbacks
+     *
-     * @var string
-     */
-    protected $response = 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 \Closure
+     * @var callable|null
      */
     protected $callback = null;
     /**
+     * Enable or disable appending when using callback
+     *
+     * @var bool
+     */
+    protected $callbackAppend = true;
+    /**
      * Size of chunks for callback
+     *
 …
     /**
+     * Get a class instance
+     *
+     * @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 make($param1 = null, $param2 = null, $options = [])
+    {
+        if (preg_match('/\.jar$/', func_get_arg(0)))
+        {
+            return new CLIClient($param1, $param2);
+     * 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);
+        }
+            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
+     *
+     * @return  \Closure|null
+     */
+    public function getCallback()
+     */
+    public function getCallback(): ?Closure
+    {
         return $this->callback;
 …
      * Set the callback (callable or closure) for call on secuential read
+     *
+     * @param   mixed   $callback
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setCallback($callback)
+    {
+        if($callback instanceof Closure)
+        {
+     * @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_callable($callback))
+        {
+            $this->callback = function($chunk) use($callback)
+        elseif(is_string($callback))
+        {
+            $this->callbackAppend = (bool) $append;
+            $this->callback = function($chunk) use ($callback)
+            {
                 return call_user_func_array($callback, [$chunk]);
 …
     /**
      * Get the chunk size
+     *
+     * @return  int
+     */
+    public function getChunkSize()
+     */
+    public function getChunkSize(): int
+    {
         return $this->chunkSize;
 …
      * Set the chunk size for secuential read
+     *
+     * @param   int     $size
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setChunkSize($size)
+    {
+        if(static::MODE == 'cli' && is_numeric($size))
+        {
+            $this->chunkSize = (int)$size;
+        }
+        elseif(static::MODE == 'web')
+     * @throws \Exception
+     */
+    public function setChunkSize(int $size): self
+    {
+        if(static::MODE == 'cli')
+        {
+            $this->chunkSize = $size;
+        }
+        else
+        {
             throw new Exception('Chunk size is not supported on web mode');
+        }
-        else
+        {
-            throw new Exception("$size is not a valid chunk size");
+        }
         return $this;
 …
     /**
      * Get the remote download flag
+     *
+     * @return  bool
+     */
+    public function getDownloadRemote()
+     */
+    public function getDownloadRemote(): bool
+    {
         return $this->downloadRemote;
 …
     /**
      * Set the remote download flag
+     *
+     * @param   bool    $download
+     * @return  $this
+     */
+    public function setDownloadRemote($download)
+     */
+    public function setDownloadRemote(bool $download): self
+    {
         $this->downloadRemote = (bool) $download;
 …
      * Gets file metadata
+     *
+     * @param   string  $file
+     * @return  \Vaites\ApacheTika\Metadata\Metadata
+     * @throws  \Exception
+     */
+    public function getMetadata($file)
+    {
+        return $this->request('meta', $file);
+     * @throws \Exception
+     */
+    public function getMetadata(string $file): MetadataInterface
+    {
+        $response = $this->parseJsonResponse($this->request('meta', $file));
+        if($response instanceof stdClass == false)
+        {
+            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)
+        {
+            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)
+        {
+            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
+     *
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getLanguage($file)
+     * @throws \Exception
+     */
+    public function getLanguage(string $file): string
+    {
         return $this->request('lang', $file);
 …
      * Detect MIME type
+     *
+     * @param   string  $file
+     * @return  string
+     * @throws \Exception
+     */
+    public function getMIME($file)
+     * @throws \Exception
+     */
+    public function getMIME(string $file): string
+    {
         return $this->request('mime', $file);
 …
      * Extracts HTML
+     *
+     * @param   string  $file
+     * @param   mixed   $callback
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getHTML($file, $callback = null)
+     * @throws \Exception
+     */
+    public function getHTML(string $file, callable $callback = null, bool $append = true): string
+    {
         if(!is_null($callback))
+        {
             $this->setCallback($callback);
+            $this->setCallback($callback, $append);
+        }
 …
     /**
+     * Extracts XHTML
+     *
+     * @throws \Exception
+     */
+    public function getXHTML(string $file, callable $callback = null, bool $append = true): string
+    {
+        if(!is_null($callback))
+        {
+            $this->setCallback($callback, $append);
+        }
+        return $this->request('xhtml', $file);
+    }
+    /**
      * Extracts text
+     *
+     * @param   string  $file
+     * @param   mixed   $callback
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getText($file, $callback = null)
+     * @throws \Exception
+     */
+    public function getText(string $file, callable $callback = null, bool $append = true): string
+    {
         if(!is_null($callback))
+        {
             $this->setCallback($callback);
+            $this->setCallback($callback, $append);
+        }
 …
      * Extracts main text
+     *
+     * @param   string  $file
+     * @param   mixed   $callback
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getMainText($file, $callback = null)
+     * @throws \Exception
+     */
+    public function getMainText(string $file, callable $callback = null, bool $append = true): string
+    {
         if(!is_null($callback))
+        {
             $this->setCallback($callback);
+            $this->setCallback($callback, $append);
+        }
 …
     /**
-     * Returns the supported MIME types
+     *
-     * @return  string
-     * @throws  \Exception
-     */
-    public function getSupportedMIMETypes()
+    {
-        return $this->request('mime-types');
+    }
-    /**
-     * Returns the available detectors
+     *
-     * @return  string
-     * @throws  \Exception
-     */
-    public function getAvailableDetectors()
+    {
-        return $this->request('detectors');
+    }
-    /**
-     * Returns the available parsers
+     *
-     * @return  string
-     * @throws  \Exception
-     */
-    public function getAvailableParsers()
+    {
-        return $this->request('parsers');
+    }
-    /**
      * Returns current Tika version
+     *
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getVersion()
+     * @throws \Exception
+     */
+    public function getVersion(): string
+    {
         return $this->request('version');
 …
      * Return the list of Apache Tika supported versions
+     *
+     * @return array
+     */
+    public static function getSupportedVersions()
+    {
+        return self::$supportedVersions;
+     * @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
+     *
+     * @param   string  $version
+     * @return  bool
+     */
+    public static function isVersionSupported($version)
+    {
+        return in_array($version, self::getSupportedVersions());
+     */
+    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
+     *
+     * @param   string  $type
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    public function checkRequest($type, $file)
+     * @throws \Exception
+     */
+    public function checkRequest(string $type, string $file = null): ?string
+    {
         // no checks for getters
 …
+        {
             //
+        }
+        // invalid local file
+        } // invalid local file
         elseif(!preg_match('/^http/', $file) && !file_exists($file))
+        {
             throw new Exception("File $file can't be opened");
+        }
+        // invalid remote file
+        } // 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
+        } // download remote file if required only for integrated downloader
         elseif(preg_match('/^http/', $file) && $this->downloadRemote)
+        {
 …
     /**
+     * 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
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    protected function downloadFile($file)
+     * @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');
 …
     /**
+     * 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.
+     *
+     * @param   string  $type
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    abstract public function request($type, $file);
+     * @throws \Exception
+     */
+    abstract public function request(string $type, string $file = null): string;
+}

redisearch/tags/0.3.3/vendor/vaites/php-apache-tika/src/Clients/CLIClient.php

-                      r2002534
+                      r2525480
 use Vaites\ApacheTika\Client;
-use Vaites\ApacheTika\Metadata\Metadata;
 /**
 …
+ *
  * @author  David Martínez <contacto@davidmartinez.net>
+ * @link    http://wiki.apache.org/tika/TikaJAXRS
+ * @link    https://tika.apache.org/1.12/formats.html
+ * @link    https://tika.apache.org/1.23/gettingstarted.html#Using_Tika_as_a_command_line_utility
  */
 class CLIClient extends Client
+{
     const MODE = 'cli';
+    protected const MODE = 'cli';
     /**
 …
     /**
+     * Java arguments
+     *
+     * @var string
+     */
+    protected $javaArgs = null;
+    /**
      * Configure client
+     *
+     * @param   string  $path
+     * @param   string  $java
+     *
+     * @throws Exception
+     */
+    public function __construct($path = null, $java = null)
+    {
+     * @throws \Exception
+     */
+    public function __construct(string $path = null, string $java = null, bool $check = true)
+    {
+        parent::__construct();
         if($path)
+        {
 …
             $this->setJava($java);
+        }
+        if($check === true)
+        {
+            $this->check();
+        }
+    }
     /**
      * Get the path
+     *
+     * @return  null|string
+     */
+    public function getPath()
+     */
+    public function getPath(): ?string
+    {
         return $this->path;
 …
     /**
      * Set the path
+     *
+     * @param   string  $path
+     * @return  $this
+     */
+    public function setPath($path)
+     */
+    public function setPath($path): self
+    {
         $this->path = $path;
 …
     /**
      * Get the Java path
+     *
+     * @return  null|int
+     */
+    public function getJava()
+     */
+    public function getJava(): ?string
+    {
         return $this->java;
 …
     /**
      * Set the Java path
+     *
+     * @param   string    $java
+     * @return  $this
+     */
+    public function setJava($java)
+     */
+    public function setJava(string $java): self
+    {
         $this->java = $java;
 …
     /**
+     * Get the Java arguments
+     */
+    public function getJavaArgs(): ?string
+    {
+        return $this->javaArgs;
+    }
+    /**
+     * Set the Java arguments
+     *
+     * NOTE: to modify child process jvm args, prepend "J" to each argument (-JXmx4g)
+     */
+    public function setJavaArgs(string $args): self
+    {
+        $this->javaArgs = $args;
+        return $this;
+    }
+    /**
+     * Returns the supported MIME types
+     *
+     * NOTE: the data provided by the CLI must be parsed: mime type has no spaces, aliases go next prefixed with spaces
+     *
+     * @throws \Exception
+     */
+    public function getSupportedMIMETypes(): array
+    {
+        $mime = null;
+        $mimeTypes = [];
+        $response = preg_split("/\n/", $this->request('mime-types'));
+        foreach($response as $line)
+        {
+            if(preg_match('/^\w+/', $line))
+            {
+                $mime = trim($line);
+                $mimeTypes[$mime] = ['alias' => []];
+            }
+            else
+            {
+                [$key, $value] = preg_split('/:\s+/', trim($line));
+                if($key == 'alias')
+                {
+                    $mimeTypes[$mime]['alias'][] = $value;
+                }
+                else
+                {
+                    $mimeTypes[$mime][$key] = $value;
+                }
+            }
+        }
+        return $mimeTypes;
+    }
+    /**
+     * Returns the available detectors
+     *
+     * @throws \Exception
+     */
+    public function getAvailableDetectors(): array
+    {
+        $detectors = [];
+        $split = preg_split("/\n/", $this->request('detectors'));
+        $parent = null;
+        foreach($split as $line)
+        {
+            if(preg_match('/composite/i', $line))
+            {
+                $parent = trim(preg_replace('/\(.+\):/', '', $line));
+                $detectors[$parent] = ['children' => [], 'composite' => true, 'name' => $parent];
+            }
+            else
+            {
+                $child = trim($line);
+                $detectors[$parent]['children'][$child] = ['composite' => false, 'name' => $child];
+            }
+        }
+        return $detectors;
+    }
+    /**
+     * Returns the available parsers
+     *
+     * @throws \Exception
+     */
+    public function getAvailableParsers(): array
+    {
+        $parsers = [];
+        $split = preg_split("/\n/", $this->request('parsers'));
+        array_shift($split);
+        $parent = null;
+        foreach($split as $line)
+        {
+            if(preg_match('/composite/i', $line))
+            {
+                $parent = trim(preg_replace('/\(.+\):/', '', $line));
+                $parsers[$parent] = ['children' => [], 'composite' => true, 'name' => $parent, 'decorated' => false];
+            }
+            else
+            {
+                $child = trim($line);
+                $parsers[$parent]['children'][$child] = ['composite' => false, 'name' => $child, 'decorated' => false];
+            }
+        }
+        return $parsers;
+    }
+    /**
+     * Check Java binary, JAR path or server connection
+     *
+     * @throws \Exception
+     */
+    public function check(): void
+    {
+        if($this->isChecked() === false)
+        {
+            // Java command must not return an error
+            try
+            {
+                $this->exec(($this->java ?: 'java') . ' -version');
+            }
+            catch(Exception $exception)
+            {
+                throw new Exception('Java command not found');
+            }
+            // JAR path must exists
+            if(file_exists($this->path) === false)
+            {
+                throw new Exception('Apache Tika app JAR not found');
+            }
+            $this->setChecked(true);
+        }
+    }
+    /**
      * Configure and make a request and return its results
+     *
      * @param   string  $type
      * @param   string  $file
      * @return  string
      * @throws  \Exception
      */
     public function request($type, $file = null)
+    {
+     * @throws \Exception
+     */
+    public function request(string $type, string $file = null): string
+    {
+        // check if not checked
+        $this->check();
         // check if is cached
         if(isset($this->cache[sha1($file)][$type]))
+        {
             return $this->cache[sha1($file)][$type];
+        if($file !== null && $this->isCached($type, $file))
+        {
+            return $this->getCachedResponse($type, $file);
+        }
 …
         // check the request
         $file = parent::checkRequest($type, $file);
+        $file = $this->checkRequest($type, $file);
         // add last argument
 …
         // build command
         $jar = escapeshellarg($this->path);
         $command = ($this->java ?: 'java') . " -jar $jar " . implode(' ', $arguments);
+        $command = trim(($this->java ?: 'java') . " -jar $jar " . implode(' ', $arguments) . " {$this->javaArgs}");
         // run command
 …
         // metadata response
         if($type == 'meta')
+        if(in_array(preg_replace('/\/.+/', '', $type), ['meta', 'rmeta']))
+        {
             // fix for invalid? json returned only with images
             $response = str_replace(basename($file) . '"}{', '", ', $response);
+            // on Windows, response comes in another charset
+            if(defined('PHP_WINDOWS_VERSION_MAJOR'))
+            {
+                $response = utf8_encode($response);
+            }
+            $response = Metadata::make($response, $file);
+            // on Windows, response must be encoded to UTF8
+            $response = $this->platform == 'win' ? utf8_encode($response) : $response;
+        }
         // cache certain responses
         if(in_array($type, ['lang', 'meta']))
+        {
             $this->cache[sha1($file)][$type] = $response;
+        if($this->isCacheable($type))
+        {
+            $this->cacheResponse($type, $response, $file);
+        }
 …
      * Run the command and return its results
+     *
+     * @param   string  $command
+     * @return  null|string
+     * @throws  \Exception
+     */
+    public function exec($command)
+     * @throws \Exception
+     */
+    public function exec(string $command): ?string
+    {
         // run command
 …
+                }
+                $this->response .= $chunk;
+                if($this->callbackAppend === true)
+                {
+                    $this->response .= $chunk;
+                }
+            }
             fclose($pipes[1]);
 …
      * Get the arguments to run the command
+     *
-     * @param   string  $type
-     * @param   string  $file
-     * @return  array
      * @throws  Exception
      */
     protected function getArguments($type, $file = null)
+    {
         // parameters for command
+        $arguments = [];
+    protected function getArguments(string $type, string $file = null): array
+    {
+        $arguments = $this->encoding ? ["--encoding={$this->encoding}"] : [];
         switch($type)
+        {
 …
                 break;
+            case 'rmeta/ignore':
+                $arguments[] = '--metadata --jsonRecursive';
+                break;
+            case 'rmeta/html':
+                $arguments[] = '--html --jsonRecursive';
+                break;
+            case 'rmeta/text':
+                $arguments[] = '--text --jsonRecursive';
+                break;
+            case 'xhtml':
+                $arguments[] = '--xml';
+                break;
             default:
                 throw new Exception("Unknown type $type");
+                throw new Exception($file ? "Unknown type $type for $file" : "Unknown type $type");
+        }

redisearch/tags/0.3.3/vendor/vaites/php-apache-tika/src/Clients/WebClient.php

-                      r2002534
+                      r2525480
 use Vaites\ApacheTika\Client;
-use Vaites\ApacheTika\Metadata\Metadata;
 /**
 …
+ *
  * @author  David Martínez <contacto@davidmartinez.net>
+ * @link    http://wiki.apache.org/tika/TikaJAXRS
+ * @link    https://tika.apache.org/1.12/formats.html
+ * @link    https://cwiki.apache.org/confluence/display/TIKA/TikaServer
  */
 class WebClient extends Client
+{
     const MODE = 'web';
+    protected const MODE = 'web';
     /**
 …
      * @var string
      */
     protected $host = '127.0.0.1';
+    protected $host = null;
     /**
 …
      * @var int
      */
     protected $port = 9998;
+    protected $port = null;
     /**
 …
     protected $options =
+    [
         CURLINFO_HEADER_OUT    => true,
         CURLOPT_HTTPHEADER     => [],
         CURLOPT_PUT            => true,
         CURLOPT_RETURNTRANSFER => true,
         CURLOPT_TIMEOUT        => 5,
+        CURLINFO_HEADER_OUT     => true,
+        CURLOPT_HTTPHEADER      => [],
+        CURLOPT_PUT             => true,
+        CURLOPT_RETURNTRANSFER  => true,
+        CURLOPT_TIMEOUT         => 5
     ];
 …
      * Configure class and test if server is running
+     *
+     * @param   string  $host
+     * @param   int     $port
+     * @param   array   $options
+     * @throws  \Exception
+     */
+    public function __construct($host = null, $port = null, $options = [])
+    {
+        if($host)
+     * @throws \Exception
+     */
+    public function __construct(string $host = null, int $port = null, array $options = [], bool $check = true)
+    {
+        parent::__construct();
+        if(is_string($host) && filter_var($host, FILTER_VALIDATE_URL))
+        {
+            $this->setUrl($host);
+        }
+        elseif($host)
+        {
             $this->setHost($host);
+        }
         if($port)
+        if(is_numeric($port))
+        {
             $this->setPort($port);
 …
         $this->setDownloadRemote(true);
+        $this->getVersion(); // exception if not running
+        if($check === true)
+        {
+            $this->check();
+        }
+    }
+    /**
+     * Get the base URL
+     */
+    public function getUrl(): string
+    {
+        return sprintf('http://%s:%d', $this->host, $this->port ?: 9998);
+    }
+    /**
+     * Set the host and port using an URL
+     */
+    public function setUrl(string $url): self
+    {
+        $url = parse_url($url);
+        $this->setHost($url['host']);
+        if(isset($url['port']))
+        {
+            $this->setPort($url['port']);
+        }
+        return $this;
+    }
     /**
      * Get the host
+     *
+     * @return  null|string
+     */
+    public function getHost()
+     */
+    public function getHost(): ?string
+    {
         return $this->host;
 …
     /**
      * Set the host
+     *
+     * @param   string  $host
+     * @return  $this
+     */
+    public function setHost($host)
+     */
+    public function setHost(string $host): self
+    {
         $this->host = $host;
 …
     /**
      * Get the port
+     *
+     * @return  null|int
+     */
+    public function getPort()
+     */
+    public function getPort(): ?int
+    {
         return $this->port;
 …
     /**
      * Set the port
+     *
+     * @param   int     $port
+     * @return  $this
+     */
+    public function setPort($port)
+     */
+    public function setPort(int $port): self
+    {
         $this->port = $port;
 …
     /**
      * Get the number of retries
+     *
+     * @return  int
+     */
+    public function getRetries()
+     */
+    public function getRetries(): int
+    {
         return $this->retries;
 …
     /**
      * Set the number of retries
+     *
+     * @param   int     $retries
+     * @return  $this
+     */
+    public function setRetries($retries)
+     */
+    public function setRetries(int $retries): self
+    {
         $this->retries = $retries;
 …
     /**
      * Get all the options
+     *
+     * @return  null|array
+     */
+    public function getOptions()
+     */
+    public function getOptions(): array
+    {
         return $this->options;
 …
      * Get an specified option
+     *
-     * @param   string  $key
      * @return  mixed
      */
     public function getOption($key)
+    {
         return isset($this->options[$key]) ? $this->options[$key] : null;
+    public function getOption(int $key)
+    {
+        return $this->options[$key] ?? null;
+    }
 …
      * Set a cURL option to be set with curl_setopt()
+     *
+     * @link    http://php.net/manual/en/curl.constants.php
+     * @link    http://php.net/manual/en/function.curl-setopt.php
+     * @param   string  $key
+     * @param   mixed   $value
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setOption($key, $value)
+     * @link http://php.net/manual/en/curl.constants.php
+     * @link http://php.net/manual/en/function.curl-setopt.php
+     * @throws \Exception
+     */
+    public function setOption(int $key, $value): self
+    {
         if(in_array($key, [CURLINFO_HEADER_OUT, CURLOPT_PUT, CURLOPT_RETURNTRANSFER]))
 …
      * Set the cURL options
+     *
+     * @param   array   $options
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setOptions($options)
+     * @throws \Exception
+     */
+    public function setOptions(array $options): self
+    {
         foreach($options as $key => $value)
 …
     /**
      * Get the timeout value for cURL
+     *
+     * @return  int
+     */
+    public function getTimeout()
+     */
+    public function getTimeout(): int
+    {
         return $this->getOption(CURLOPT_TIMEOUT);
 …
      * Set the timeout value for cURL
+     *
+     * @param   int     $value
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setTimeout($value)
+     * @throws \Exception
+     */
+    public function setTimeout(int $value): self
+    {
         $this->setOption(CURLOPT_TIMEOUT, (int) $value);
 …
     /**
+     * Returns the supported MIME types
+     *
+     * @throws \Exception
+     */
+    public function getSupportedMIMETypes(): array
+    {
+        $mimeTypes = json_decode($this->request('mime-types'), true);
+        ksort($mimeTypes);
+        return $mimeTypes;
+    }
+    /**
+     * Returns the available detectors
+     *
+     * @throws \Exception
+     */
+    public function getAvailableDetectors(): array
+    {
+        $detectors = [json_decode($this->request('detectors'), true)];
+        foreach($detectors as $index => $parent)
+        {
+            $detectors[$parent['name']] = $parent;
+            if(isset($parent['children']))
+            {
+                foreach($parent['children'] as $subindex => $child)
+                {
+                    $detectors[$parent['name']]['children'][$child['name']] = $child;
+                    unset($detectors[$parent['name']]['children'][$subindex]);
+                }
+            }
+            unset($detectors[$index]);
+        }
+        return $detectors;
+    }
+    /**
+     * Returns the available parsers
+     *
+     * @throws \Exception
+     */
+    public function getAvailableParsers(): array
+    {
+        $parsers = [json_decode($this->request('parsers'), true)];
+        foreach($parsers as $index => $parent)
+        {
+            $parsers[$parent['name']] = $parent;
+            if(isset($parent['children']))
+            {
+                foreach($parent['children'] as $subindex => $child)
+                {
+                    $parsers[$parent['name']]['children'][$child['name']] = $child;
+                    unset($parsers[$parent['name']]['children'][$subindex]);
+                }
+            }
+            unset($parsers[$index]);
+        }
+        return $parsers;
+    }
+    /**
+     * Check if server is running
+     *
+     * @throws \Exception
+     */
+    public function check(): void
+    {
+        if($this->isChecked() === false)
+        {
+            $this->setChecked(true);
+            // throws an exception if server is unreachable or can't connect
+            $this->request('version');
+        }
+    }
+    /**
      * Configure, make a request and return its results
+     *
+     * @param   string  $type
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    public function request($type, $file = null)
+     * @throws \Exception
+     */
+    public function request(string $type, string $file = null): string
+    {
         static $retries = [];
+        // check if not checked
+        $this->check();
         // check if is cached
         if(isset($this->cache[sha1($file)][$type]))
+        {
             return $this->cache[sha1($file)][$type];
+        if($file !== null && $this->isCached($type, $file))
+        {
+            return $this->getCachedResponse($type, $file);
+        }
         elseif(!isset($retries[sha1($file)]))
 …
         // parameters for cURL request
         list($resource, $headers) = $this->getParameters($type, $file);
+        [$resource, $headers] = $this->getParameters($type, $file);
         // check the request
         $file = parent::checkRequest($type, $file);
+        $file = $this->checkRequest($type, $file);
         // cURL options
 …
         // cURL init and options
         $options[CURLOPT_URL] = "http://{$this->host}:{$this->port}" . "/$resource";
+        $options[CURLOPT_URL] = $this->getUrl() . "/$resource";
         // get the response and the HTTP status code
+        list($response, $status) = $this->exec($options);
+        [$response, $status] = $this->exec($options);
+        // reduce memory usage closing cURL resource
+        if(isset($options[CURLOPT_INFILE]) && is_resource($options[CURLOPT_INFILE]))
+        {
+            fclose($options[CURLOPT_INFILE]);
+        }
         // request completed successfully
         if($status == 200)
+        {
+            if($type == 'meta')
+            // cache certain responses
+            if($this->isCacheable($type))
+            {
                 $response = Metadata::make($response, $file);
+                $this->cacheResponse($type, $response, $file);
+            }
+            // cache certain responses
+            if(in_array($type, ['lang', 'meta']))
+            {
+                $this->cache[sha1($file)][$type] = $response;
+            }
+        }
+        // request completed successfully but result is empty
+        } // request completed successfully but result is empty
         elseif($status == 204)
+        {
             $response = null;
+        }
+        // retry on request failed with error 500
+        } // retry on request failed with error 500
         elseif($status == 500 && $retries[sha1($file)]--)
+        {
             $response = $this->request($type, $file);
+        }
+        // other status code is an error
+        } // other status code is an error
         else
+        {
             $this->error($status, $resource);
+            $this->error($status, $resource, $file);
+        }
 …
      * Make a request to Apache Tika Server
+     *
+     * @param   array   $options
+     * @return  array
+     * @throws  \Exception
+     */
+    protected function exec(array $options = [])
+     * @throws \Exception
+     */
+    protected function exec(array $options = []): array
+    {
         // cURL init and options
         $curl = curl_init();
         // we avoid curl_setopt_array($curl, $options) because extrange Windows behaviour (issue #8)
+        // we avoid curl_setopt_array($curl, $options) because strange Windows behaviour (issue #8)
         foreach($options as $option => $value)
+        {
 …
+        }
         // make the request
+        // make the request directly
         if(is_null($this->callback))
+        {
             $this->response = curl_exec($curl);
+        }
+            $this->response = curl_exec($curl) ?: '';
+        } // with a callback, the response is appended on each block inside the callback
         else
+        {
 …
      * Throws an exception for an error status code
+     *
+     * @codeCoverageIgnore
+     *
+     * @param   int       $status
+     * @param   string    $resource
+     * @throws  \Exception
+     */
+    protected function error($status, $resource)
+     * @throws \Exception
+     */
+    protected function error(int $status, string $resource, string $file = null): void
+    {
         switch($status)
 …
             //  method not allowed
             case 405:
                 throw new Exception('Method not allowed', 405);
+                $message = 'Method not allowed';
                 break;
             //  unsupported media type
             case 415:
                 throw new Exception('Unsupported media type', 415);
+                $message = 'Unsupported media type';
                 break;
             //  unprocessable entity
             case 422:
+                throw new Exception('Unprocessable document', 422);
+                $message = 'Unprocessable document';
+                // using remote files require Tika server to be launched with specific options
+                if($this->downloadRemote == false && preg_match('/^http/', $file))
+                {
+                    $message .= ' (is server launched using "-enableUnsecureFeatures -enableFileUrl" arguments?)';
+                }
                 break;
             // server error
             case 500:
                 throw new Exception('Error while processing document', 500);
+                $message = 'Error while processing document';
                 break;
             // unexpected
             default:
+                throw new Exception("Unexpected response for /$resource ($status)", 501);
+        }
+                $message = "Unexpected response for /$resource ($status)";
+                $status = 501;
+        }
+        throw new Exception($message, $status);
+    }
 …
      * Get the parameters to make the request
+     *
+     * @link    https://wiki.apache.org/tika/TikaJAXRS#Specifying_a_URL_Instead_of_Putting_Bytes
+     * @param   string  $type
+     * @param   string  file
+     * @return  array
+     * @throws  \Exception
+     */
+    protected function getParameters($type, $file = null)
+     * @link https://wiki.apache.org/tika/TikaJAXRS#Specifying_a_URL_Instead_of_Putting_Bytes
+     * @throws \Exception
+     */
+    protected function getParameters(string $type, string $file = null): array
+    {
         $headers = [];
+        $callback = null;
         if(!empty($file) && preg_match('/^http/', $file))
 …
                 break;
+            case 'detectors':
+            case 'parsers':
             case 'meta':
+                $resource = 'meta';
+            case 'mime-types':
+            case 'rmeta/html':
+            case 'rmeta/ignore':
+            case 'rmeta/text':
+                $resource = $type;
                 $headers[] = 'Accept: application/json';
+                $callback = function($response)
+                {
+                    return json_decode($response, true);
+                };
                 break;
 …
                 break;
-            case 'detectors':
-            case 'parsers':
-            case 'mime-types':
             case 'version':
                 $resource = $type;
                 break;
+            case 'xhtml':
+                throw new Exception("Tika Server does not support XHTML output");
+                break;
             default:
                 throw new Exception("Unknown type $type");
+        }
         return [$resource, $headers];
+        return [$resource, $headers, $callback];
+    }
 …
      * Get the cURL options
+     *
+     * @param   string  $type
+     * @param   string  file
+     * @return  array
+     * @throws  \Exception
+     */
+    protected function getCurlOptions($type, $file = null)
+     * @throws \Exception
+     */
+    protected function getCurlOptions(string $type, string $file = null): array
+    {
         // base options
 …
             $callback = $this->callback;
             $options[CURLOPT_WRITEFUNCTION] = function($handler, $data) use($callback)
+            $options[CURLOPT_WRITEFUNCTION] = function($handler, $data) use ($callback)
+            {
+                $this->response .= $data;
+                if($this->callbackAppend === true)
+                {
+                    $this->response .= $data;
+                }
                 $callback($data);
 …
+        {
             //
+        }
+        // local file options
+        } // local file options
         elseif($file && file_exists($file) && is_readable($file))
+        {
             $options[CURLOPT_INFILE] = fopen($file, 'r');
             $options[CURLOPT_INFILESIZE] = filesize($file);
+        }
+        // other options for specific requests
+        elseif(in_array($type,  ['detectors', 'mime-types', 'parsers', 'version']))
+        } // other options for specific requests
+        elseif(in_array($type, ['detectors', 'mime-types', 'parsers', 'version']))
+        {
             $options[CURLOPT_PUT] = false;
+        }
+        // file not accesible
+        } // file not accesible
         else
+        {

redisearch/tags/0.3.3/vendor/vaites/php-apache-tika/tests/BaseTest.php

-                      r2002534
+                      r2525480
 namespace Vaites\ApacheTika\Tests;
+use PHPUnit_Framework_TestCase;
+use Exception;
+use PHPUnit\Framework\TestCase;
 /**
  * Common test functionality
  */
 abstract class BaseTest extends PHPUnit_Framework_TestCase
+abstract class BaseTest extends TestCase
+{
     /**
 …
     /**
      * Get env variables
+     *
+     * @param null      $name
+     * @param array     $data
+     * @param string    $dataName
+     */
+    public function __construct($name = null, array $data = array(), $dataName = '')
+     *
+     * @throws \Exception
+     */
+    public function __construct(string $name = null, array $data = array(), $dataName = '')
+    {
         self::$version = getenv('APACHE_TIKA_VERSION');
         self::$binaries = getenv('APACHE_TIKA_BINARIES');
+        if(empty(self::$version))
+        {
+            throw new Exception('APACHE_TIKA_VERSION environment variable not defined');
+        }
         parent::__construct($name, $data, $dataName);
+    }
 …
      * Version test
      */
     public function testVersion()
+    public function testVersion(): void
+    {
         $this->assertEquals('Apache Tika ' . self::$version, self::$client->getVersion());
 …
      * Metadata test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @param   string $class
+     * @throws  \Exception
+     */
+    public function testMetadata($file, $class = 'Metadata')
+     * @dataProvider documentProvider
+     */
+    public function testMetadata(string $file, string $class = 'Metadata'): void
+    {
+        $this->assertInstanceOf("\\Vaites\\ApacheTika\\Metadata\\$class", self::$client->getMetadata($file));
+    }
+    /**
+     * Metadata test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadata(string $file, string $class = 'DocumentMetadata'): void
+    {
+        $this->testMetadata($file, $class);
+    }
+    /**
+     * Metadata title test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataTitle(string $file): void
+    {
+        $this->assertEquals('Lorem ipsum dolor sit amet', self::$client->getMetadata($file)->title);
+    }
+    /**
+     * Metadata author test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataAuthor(string $file): void
+    {
+        $this->assertEquals('David Martínez', self::$client->getMetadata($file)->author);
+    }
+    /**
+     * Metadata dates test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataCreated(string $file): void
+    {
+        $this->assertInstanceOf('DateTime', self::$client->getMetadata($file)->created);
+    }
+    /**
+     * Metadata dates test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataUpdated(string $file): void
+    {
+        $this->assertInstanceOf('DateTime', self::$client->getMetadata($file)->updated);
+    }
+    /**
+     * Metadata keywords test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataKeywords(string $file): void
+    {
+        $this->assertContains('ipsum', self::$client->getMetadata($file)->keywords);
+    }
+    /**
+     * Recursive text metadata test
+     *
+     * @dataProvider recursiveProvider
+     */
+    public function testTextRecursiveMetadata(string $file): void
+    {
+        $nested = 'sample8.zip/sample1.doc';
+        $metadata = self::$client->getRecursiveMetadata($file, 'text');
+        $this->assertStringContainsString('Zenonis est, inquam, hoc Stoici', $metadata[$nested]->content ?? 'ERROR');
+    }
+    /**
+     * Recursive HTML metadata test
+     *
+     * @dataProvider recursiveProvider
+     */
+    public function testHtmlRecursiveMetadata(string $file): void
+    {
+        $nested = 'sample8.zip/sample1.doc';
+        $metadata = self::$client->getRecursiveMetadata($file, 'html');
+        $this->assertStringContainsString('Zenonis est, inquam, hoc Stoici', $metadata[$nested]->content ?? 'ERROR');
+    }
+    /**
+     * Recursive ignore metadata test
+     *
+     * @dataProvider ocrProvider
+     */
+    public function testIgnoreRecursiveMetadata(string $file): void
+    {
+        $metadata = self::$client->getRecursiveMetadata($file, 'ignore');
+        $this->assertNull(array_shift($metadata)->content);
+    }
+    /**
+     * Language test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentLanguage(string $file): void
+    {
+        $this->assertRegExp('/^[a-z]{2}$/', self::$client->getLanguage($file));
+    }
+    /**
+     * MIME test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMIME(string $file): void
+    {
+        $this->assertNotEmpty(self::$client->getMIME($file));
+    }
+    /**
+     * HTML test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentHTML(string $file): void
+    {
+        $this->assertStringContainsString('Zenonis est, inquam, hoc Stoici', self::$client->getHTML($file));
+    }
+    /**
+     * Text test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentText(string $file): void
+    {
+        $this->assertStringContainsString('Zenonis est, inquam, hoc Stoici', self::$client->getText($file));
+    }
+    /**
+     * Main text test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMainText(string $file): void
+    {
+        $this->assertStringContainsString('Lorem ipsum dolor sit amet', self::$client->getMainText($file));
+    }
+    /**
+     * Metadata test
+     *
+     * @dataProvider imageProvider
+     */
+    public function testImageMetadata(string $file, string $class = 'ImageMetadata'): void
+    {
+        $this->testMetadata($file, $class);
+    }
+    /**
+     * Metadata width test
+     *
+     * @dataProvider imageProvider
+     */
+    public function testImageMetadataWidth(string $file): void
+    {
+        $meta = self::$client->getMetadata($file);
+        $this->assertEquals(1600, $meta->width, basename($file));
+    }
+    /**
+     * Metadata height test
+     *
+     * @dataProvider imageProvider
+     */
+    public function testImageMetadataHeight(string $file): void
+    {
+        $meta = self::$client->getMetadata($file);
+        $this->assertEquals(900, $meta->height, basename($file));
+    }
+    /**
+     * OCR test
+     *
+     * @dataProvider ocrProvider
+     */
+    public function testImageOCR(string $file): void
+    {
+        $text = self::$client->getText($file);
+        $this->assertRegExp('/voluptate/i', $text);
+    }
+    /**
+     * Text callback test
+     *
+     * @dataProvider callbackProvider
+     */
+    public function testTextCallback(string $file): void
+    {
+        BaseTest::$shared = 0;
+        self::$client->getText($file, [$this, 'callableCallback']);
+        $this->assertGreaterThan(1, BaseTest::$shared);
+    }
+    /**
+     * Text callback test
+     *
+     * @dataProvider callbackProvider
+     */
+    public function testTextCallbackWithoutAppend(string $file): void
+    {
+        BaseTest::$shared = 0;
+        $response = self::$client->getText($file, [$this, 'callableCallback'], false);
+        $this->assertEmpty($response);
+    }
+    /**
+     * Main text callback test
+     *
+     * @dataProvider callbackProvider
+     */
+    public function testMainTextCallback(string $file): void
+    {
+        BaseTest::$shared = 0;
+        self::$client->getMainText($file, function()
+        {
+            BaseTest::$shared++;
+        });
+        $this->assertGreaterThan(1, BaseTest::$shared);
+    }
+    /**
+     * Main text callback test
+     *
+     * @dataProvider callbackProvider
+     */
+    public function testHtmlCallback(string $file): void
+    {
+        BaseTest::$shared = 0;
+        self::$client->getHtml($file, function()
+        {
+            BaseTest::$shared++;
+        });
+        $this->assertGreaterThan(1, BaseTest::$shared);
+    }
+    /**
+     * Remote file test with integrated download
+     *
+     * @dataProvider remoteProvider
+     */
+    public function testRemoteDocumentText(string $file): void
+    {
+        $this->assertStringContainsString('Rationis enim perfectio est virtus', self::$client->getText($file));
+    }
+    /**
+     * Remote file test with internal downloader
+     *
+     * @dataProvider remoteProvider
+     */
+    public function testDirectRemoteDocumentText(string $file): void
+    {
         $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertInstanceOf("\\Vaites\\ApacheTika\\Metadata\\$class", self::$client->getMetadata($file));
+        }
+    }
+    /**
+     * Metadata test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @param   string $class
+     * @throws  \Exception
+     */
+    public function testDocumentMetadata($file, $class = 'DocumentMetadata')
+        $client->setDownloadRemote(false);
+        $this->assertStringContainsString('Rationis enim perfectio est virtus', $client->getText($file));
+    }
+    /**
+     * Encoding tests
+     *
+     * @dataProvider encodingProvider
+     */
+    public function testEncodingDocumentText(string $file): void
+    {
         $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->testMetadata($file, $class);
+        }
+    }
+    /**
+     * Metadata title test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataTitle($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertEquals('Lorem ipsum dolor sit amet', self::$client->getMetadata($file)->title);
+        }
+    }
+    /**
+     * Metadata author test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataAuthor($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertEquals('David Martínez', self::$client->getMetadata($file)->author);
+        }
+    }
+    /**
+     * Metadata dates test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataCreated($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertInstanceOf('DateTime', self::$client->getMetadata($file)->created);
+        }
+    }
+    /**
+     * Metadata dates test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataUpdated($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertInstanceOf('DateTime', self::$client->getMetadata($file)->updated);
+        }
+    }
+    /**
+     * Metadata keywords test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataKeywords($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertContains('ipsum', self::$client->getMetadata($file)->keywords);
+        }
+    }
+    /**
+     * Language test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentLanguage($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') < 0)
+        {
+            $this->markTestSkipped('Apache Tika ' . self::$version . ' lacks REST language identification');
+        }
+        else
+        {
+            $this->assertRegExp('/^[a-z]{2}$/', self::$client->getLanguage($file));
+        }
+    }
+    /**
+     * MIME test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMIME($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertNotEmpty(self::$client->getMIME($file));
+        }
+    }
+    /**
+     * HTML test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentHTML($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertContains('Zenonis est, inquam, hoc Stoici', self::$client->getHTML($file));
+        }
+    }
+    /**
+     * Text test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentText($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertContains('Zenonis est, inquam, hoc Stoici', self::$client->getText($file));
+        }
+    }
+    /**
+     * Main text test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMainText($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.15') < 0)
+        {
+            $this->markTestSkipped('Apache Tika ' . self::$version . ' lacks main content extraction');
+        }
+        else
+        {
+            $this->assertContains('Lorem ipsum dolor sit amet', self::$client->getMainText($file));
+        }
+    }
+    /**
+     * Metadata test
+     *
+     * @dataProvider    imageProvider
+     *
+     * @param   string $file
+     * @param   string $class
+     * @throws  \Exception
+     */
+    public function testImageMetadata($file, $class = 'ImageMetadata')
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.14') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.14 throws "Expected \';\', got \',\'> when parsing some images');
+        }
+        else
+        {
+            $this->testMetadata($file, $class);
+        }
+    }
+    /**
+     * Metadata width test
+     *
+     * @dataProvider    imageProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testImageMetadataWidth($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.14') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.14 throws "Expected \';\', got \',\'> when parsing some images');
+        }
+        else
+        {
+            $meta = self::$client->getMetadata($file);
+            $this->assertEquals(1600, $meta->width, basename($file));
+        }
+    }
+    /**
+     * Metadata height test
+     *
+     * @dataProvider    imageProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testImageMetadataHeight($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.14') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.14 throws "Expected \';\', got \',\'> when parsing some images');
+        }
+        else
+        {
+            $meta = self::$client->getMetadata($file);
+            $this->assertEquals(900, $meta->height, basename($file));
+        }
+    }
+    /**
+     * OCR test
+     *
+     * @dataProvider    ocrProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testImageOCR($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.14') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.14 throws "Expected \';\', got \',\'> when parsing some images');
+        }
+        else
+        {
+            $text = self::$client->getText($file);
+            $this->assertRegExp('/voluptate/i', $text);
+        }
+    }
+    /**
+     * Text callback test
+     *
+     * @dataProvider    callbackProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testTextCallback($file)
+    {
+        $client =& self::$client;
+    if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            BaseTest::$shared = 0;
+            self::$client->getText($file, [$this, 'callableCallback']);
+            $this->assertGreaterThan(1, BaseTest::$shared);
+        }
+    }
+    /**
+     * Main text callback test
+     *
+     * @dataProvider    callbackProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testMainTextCallback($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.15') < 0)
+        {
+            $this->markTestSkipped('Apache Tika ' . self::$version . ' lacks main content extraction');
+        }
+        else
+        {
+            BaseTest::$shared = 0;
+            self::$client->getMainText($file, function ($chunk) {
+                BaseTest::$shared++;
+            });
+            $this->assertGreaterThan(1, BaseTest::$shared);
+        }
+    }
+    /**
+     * Main text callback test
+     *
+     * @dataProvider    callbackProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testHtmlCallback($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            BaseTest::$shared = 0;
+            self::$client->getHtml($file, function($chunk)
+            {
+                BaseTest::$shared++;
+            });
+            $this->assertGreaterThan(1, BaseTest::$shared);
+        }
+    }
+    /**
+     * Remote file test with integrated download
+     *
+     * @dataProvider    remoteProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testRemoteDocumentText($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertContains('This is a small demonstration .pdf file', $client->getText($file));
+        }
+    }
+    /**
+     * Remote file test with internal downloader
+     *
+     * @dataProvider    remoteProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDirectRemoteDocumentText($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.15') < 0)
+        {
+            $this->markTestSkipped('Apache Tika between 1.10 and 1.14 doesn\'t supports unsecure features');
+        }
+        else
+        {
+            $client->setDownloadRemote(false);
+            $this->assertContains('This is a small demonstration .pdf file', $client->getText($file));
+        }
+        $client->setEncoding('UTF-8');
+        $this->assertThat($client->getText($file), $this->logicalAnd
+        (
+            $this->stringContains('L’espéranto'),
+            $this->stringContains('世界語'),
+            $this->stringContains('Эспера́нто')
+        ));
+    }
     /**
      * Test available detectors
+     *
      * @throws  \Exception
      */
     public function testAvailableDetectors()
+    {
         $this->assertContains('org.apache.tika.mime.MimeTypes', self::$client->getAvailableDetectors());
+     */
+    public function testAvailableDetectors(): void
+    {
+        $detectors = self::$client->getAvailableDetectors();
+        $this->assertArrayHasKey('org.apache.tika.detect.DefaultDetector', $detectors);
+    }
     /**
      * Test available parsers
+     *
      * @throws  \Exception
      */
     public function testAvailableParsers()
+    {
         $this->assertContains('org.apache.tika.parser.DefaultParser', self::$client->getAvailableParsers());
+     */
+    public function testAvailableParsers(): void
+    {
+        $parsers = self::$client->getAvailableParsers();
+        $this->assertArrayHasKey('org.apache.tika.parser.DefaultParser', $parsers);
+    }
     /**
      * Test supported MIME types
+     *
+     * @throws  \Exception
+     */
+    public function testSupportedMIMETypes()
+    {
+        $this->assertContains('application/x-pdf', self::$client->getSupportedMIMETypes());
+     */
+    public function testSupportedMIMETypes(): void
+    {
+        $this->assertArrayHasKey('application/pdf', self::$client->getSupportedMIMETypes());
+    }
+    /**
+     * Test supported MIME types
+     */
+    public function testIsMIMETypeSupported(): void
+    {
+        $this->assertTrue(self::$client->isMIMETypeSupported('application/pdf'));
+    }
     /**
      * Static method to test callback
+     *
+     * @param   string  $chunk
+     */
+    public static function callableCallback($chunk)
+     */
+    public static function callableCallback(): void
+    {
         BaseTest::$shared++;
 …
     /**
      * Document file provider
+     *
+     * @return  array
+     */
+    public function documentProvider()
+     */
+    public function documentProvider(): array
+    {
         return $this->samples('sample1');
 …
     /**
      * Image file provider
+     *
+     * @return array
+     */
+    public function imageProvider()
+     */
+    public function imageProvider(): array
+    {
         return $this->samples('sample2');
 …
     /**
      * File provider for OCR testing
+     *
+     * @return array
+     */
+    public function ocrProvider()
+     */
+    public function ocrProvider(): array
+    {
         return $this->samples('sample3');
 …
     /**
      * File provider for callback testing
+     *
+     * @return array
+     */
+    public function callbackProvider()
+     */
+    public function callbackProvider(): array
+    {
         return $this->samples('sample5');
 …
     /**
      * File provider for remote testing
+     *
+     * @return array
+     */
+    public function remoteProvider()
+     */
+    public function remoteProvider(): array
+    {
         return
+        [
+            [
                 'http://www.africau.edu/images/default/sample.pdf'
+                'https://raw.githubusercontent.com/vaites/php-apache-tika/master/samples/sample6.pdf'
+            ]
         ];
 …
     /**
+     * File provider for encoding testing
+     */
+    public function encodingProvider(): array
+    {
+        return $this->samples('sample7');
+    }
+    /**
+     * File provider for recursive testing
+     */
+    public function recursiveProvider(): array
+    {
+        return $this->samples('sample8');
+    }
+    /**
      * File provider using "samples" folder
+     *
+     * @param   string $sample
+     * @return  array
+     */
+    protected function samples($sample)
+     */
+    protected function samples(string $sample): array
+    {
         $samples = [];

redisearch/tags/0.3.3/vendor/vaites/php-apache-tika/tests/CLITest.php

-                      r2002534
+                      r2525480
      * Create shared instances of clients
      */
     public static function setUpBeforeClass()
+    public static function setUpBeforeClass(): void
+    {
         self::$client = Client::make(self::getPathForVersion(self::$version));
 …
     /**
+     * XHTML test
+     *
+     * @dataProvider encodingProvider
+     */
+    public function testDocumentHTML(string $file): void
+    {
+        $this->assertStringStartsWith('<?xml version="1.0"', self::$client->getXHTML($file));
+    }
+    /**
      * Set path test
      */
     public function testSetPath()
+    public function testSetPath(): void
+    {
         $client = Client::make(self::getPathForVersion('1.0'));
+        $path = self::getPathForVersion(self::$version);
+        $this->assertEquals(self::getPathForVersion('1.0'), $client->getPath());
+        $client = Client::make($path);
+        $this->assertEquals($path, $client->getPath());
+    }
 …
      * Set Java test
      */
     public function testSetPort()
+    public function testSetBinary(): void
+    {
         $client = Client::make(self::getPathForVersion('1.0'), '/opt/jdk/bin/java');
+        $path = self::getPathForVersion(self::$version);
+        $this->assertEquals('/opt/jdk/bin/java', $client->getJava());
+        $client = Client::make($path, 'java');
+        $this->assertEquals('java', $client->getJava());
+    }
+    /**
+     * Set Java test
+     */
+    public function testSetArguments(): void
+    {
+        $path = self::getPathForVersion(self::$version);
+        $client = Client::make($path);
+        $client->setJavaArgs('-JXmx4g');
+        $this->assertEquals('-JXmx4g', $client->getJavaArgs());
+    }
+    /**
+     * Test delayed check
+     */
+    public function testDelayedCheck(): void
+    {
+        $path = self::getPathForVersion(self::$version);
+        $client = Client::prepare('/nonexistent/path/to/apache-tika.jar');
+        $client->setPath($path);
+        $this->assertStringEndsWith(self::$version, $client->getVersion());
+    }
     /**
      * Get the full path of Tika app for a specified version
+     *
-     * @param   string  $version
-     * @return  string
      */
     private static function getPathForVersion($version)
+    private static function getPathForVersion(string $version): string
+    {
         return self::$binaries . "/tika-app-{$version}.jar";

redisearch/tags/0.3.3/vendor/vaites/php-apache-tika/tests/CommonTest.php

-                      r2002534
+                      r2525480
 <?php namespace Vaites\ApacheTika\Tests;
 use PHPUnit_Framework_TestCase;
+use PHPUnit\Framework\TestCase;
 use Vaites\ApacheTika\Client;
 …
  * Common test functionality
  */
 class CommonTest extends PHPUnit_Framework_TestCase
+class CommonTest extends TestCase
+{
     /**
 …
     /**
      * Get env variables
+     *
-     * @param null      $name
-     * @param array     $data
-     * @param string    $dataName
-     * @throws \Exception
      */
     public function __construct($name = null, array $data = array(), $dataName = '')
+    public function __construct(string $name = null, array $data = array(), $dataName = '')
+    {
         self::$version = getenv('APACHE_TIKA_VERSION');
 …
      * Set chunk size test
      */
     public function testSetChunkSize()
+    public function testSetChunkSize(): void
+    {
         self::$client->setChunkSize(42);
 …
     /**
+     * Set download remote
+     */
+    public function testDownloadRemote(): void
+    {
+        self::$client->setDownloadRemote(true);
+        $this->assertTrue(self::$client->getDownloadRemote());
+    }
+    /**
      * Set callback (closure) test
      */
     public function testSetClosureCallback()
+    public function testSetClosureCallback(): void
+    {
         self::$client->setCallback(function($chunk)
 …
      * Set callback (callable) test
      */
     public function testSetCallableCallback()
+    public function testSetCallableCallback(): void
+    {
         self::$client->setCallback('trim');
 …
      * Get supported versions test
      */
     public function testGetSupportedVersions()
+    public function testGetSupportedVersions(): void
+    {
         $this->assertTrue(in_array('1.10', Client::getSupportedVersions()));
+        $this->assertTrue(in_array(self::$version, self::$client->getSupportedVersions()));
+    }
 …
      * Is version supported vtest
      */
     public function testIsVersionSupported()
+    public function testIsVersionSupported(): void
+    {
         $this->assertTrue(Client::isVersionSupported('1.10'));
+        $this->assertTrue(self::$client->isVersionSupported(self::$version));
+    }
+}

redisearch/tags/0.3.3/vendor/vaites/php-apache-tika/tests/ErrorTest.php

-                      r2002534
+                      r2525480
 use Exception;
+use PHPUnit_Framework_TestCase;
+use PHPUnit\Framework\TestCase;
 use Vaites\ApacheTika\Client;
 …
  * Error tests
  */
 class ErrorTest extends PHPUnit_Framework_TestCase
+class ErrorTest extends TestCase
+{
     /**
 …
     /**
      * Get env variables
+     *
+     * @param null      $name
+     * @param array     $data
+     * @param string    $dataName
+     */
+    public function __construct($name = null, array $data = array(), $dataName = '')
+     */
+    public function __construct(string $name = null, array $data = array(), $dataName = '')
+    {
         self::$version = getenv('APACHE_TIKA_VERSION');
 …
      * Test wrong command line mode path
      */
     public function testAppPath()
+    {
         try
+        {
             $client = Client::make('/nonexistent/path/to/apache-tika.jar');
+    public function testAppPath(): void
+    {
+        try
+        {
+            $client = Client::prepare('/nonexistent/path/to/apache-tika.jar');
             $client->getVersion();
+        }
         catch(Exception $exception)
+        {
             $this->assertContains('Unexpected exit value', $exception->getMessage());
+            $this->assertStringContainsString('Apache Tika app JAR not found', $exception->getMessage());
+        }
+    }
 …
      * Test unexpected exit value for command line mode
      */
     public function testAppExitValue()
+    public function testAppExitValue(): void
+    {
         $path = self::getPathForVersion(self::$version);
 …
             rename($path . '.bak', $path);
             $this->assertContains('Unexpected exit value', $exception->getMessage());
+            $this->assertStringContainsString('Unexpected exit value', $exception->getMessage());
+        }
+    }
 …
      * Test invalid Java binary path for command line mode
      */
     public function testAppJavaBinary()
+    public function testJavaBinary(): void
+    {
         $path = self::getPathForVersion(self::$version);
 …
         catch(Exception $exception)
+        {
             $this->assertContains('Unexpected exit value', $exception->getMessage());
+            $this->assertStringContainsString('Java command not found', $exception->getMessage());
+        }
+    }
 …
      * Test wrong server
      */
+    public function testServerConnection()
+    {
+        try
+        {
+            Client::make('localhost', 9997);
+            $this->fail();
+        }
+        catch(Exception $exception)
+        {
+            $this->assertEquals(7, $exception->getCode());
+    public function testServerConnection(): void
+    {
+        try
+        {
+            $client = Client::prepare('localhost', 9997);
+            $client->getVersion();
+            $this->fail();
+        }
+        catch(Exception $exception)
+        {
+            $this->assertThat($exception->getCode(), $this->logicalOr
+            (
+                $this->equalTo(CURLE_COULDNT_CONNECT),
+                $this->equalTo(CURLE_OPERATION_TIMEDOUT)
+            ));
+        }
+    }
 …
      * Test wrong request options
      */
     public function testRequestOptions()
+    {
         try
+        {
             $client = Client::make('localhost', 9998, [CURLOPT_PROXY => 'localhost']);
+    public function testRequestOptions(): void
+    {
+        try
+        {
+            $client = Client::make('localhost', 9998);
             $client->request('bad');
 …
         catch(Exception $exception)
+        {
             $this->assertEquals(7, $exception->getCode());
+            $this->assertStringContainsString('Unknown type bad', $exception->getMessage());
+        }
+    }
 …
      * Test invalidrequest options
      */
     public function testRequestRestrictedOptions()
+    {
         try
+        {
             $client = Client::make('localhost', 9998, [CURLOPT_PUT => false]);
+    public function testRequestRestrictedOptions(): void
+    {
+        try
+        {
+            Client::make('localhost', 9998, [CURLOPT_PUT => false]);
+        }
         catch(Exception $exception)
 …
     /**
+     * Test wrong recursive metadata type
+     */
+    public function testRequestMetadataType(): void
+    {
+        try
+        {
+            $client = Client::make('localhost', 9998);
+            $client->getRecursiveMetadata(dirname(__DIR__) . '/samples/sample3.png', 'bad');
+            $this->fail();
+        }
+        catch(Exception $exception)
+        {
+            $this->assertStringContainsString('Unknown recursive type', $exception->getMessage());
+        }
+    }
+    /**
      * Test unsupported media type
+     */
+    public function testUnsupportedMedia()
+     *
+     * NOTE: return value was changed in version 1.23
+     *
+     * @link    https://github.com/apache/tika/blob/master/CHANGES.txt
+     */
+    public function testUnsupportedMedia(): void
+    {
         try
 …
         catch(Exception $exception)
+        {
+            $this->assertEquals(415, $exception->getCode());
+        }
+    }
+    /**
+     * Test invalid callback
+     */
+    public function testInvalidCallback()
+    {
+        try
+        {
+            $client = Client::make(self::$binaries . '/tika-app-' . self::$version . '.jar');
+            $client->setCallback('unknown_function');
+        }
+        catch(Exception $exception)
+        {
+            $this->assertContains('Invalid callback', $exception->getMessage());
+            if(version_compare(self::$version, '1.23') < 0)
+            {
+                $this->assertEquals(415, $exception->getCode());
+            }
+            else
+            {
+                $this->assertEquals(0, $exception->getCode());
+            }
+        }
+    }
+    /**
+     * Test unknown recursive metadata type
+     */
+    public function testUnknownRecursiveMetadataType(): void
+    {
+        try
+        {
+            $client = Client::make('localhost', 9998);
+            $client->getRecursiveMetadata('example.doc', 'error');
+            $this->fail();
+        }
+        catch(Exception $exception)
+        {
+            $this->assertStringContainsString('Unknown recursive type', $exception->getMessage());
+        }
+    }
 …
      * Test invalid chunk size
      */
+    public function testInvalidChunkSize()
+    {
+        try
+        {
+            $client = Client::make(self::$binaries . '/tika-app-' . self::$version . '.jar');
+            $client->setChunkSize('string');
+        }
+        catch(Exception $exception)
+        {
+            $this->assertContains('is not a valid chunk size', $exception->getMessage());
+        }
+    }
+    /**
+     * Test invalid chunk size
+     */
+    public function testUnsupportedChunkSize()
+    public function testUnsupportedChunkSize(): void
+    {
         try
 …
         catch(Exception $exception)
+        {
+            $this->assertContains('Chunk size is not supported', $exception->getMessage());
+        }
+    }
+    /**
+     * Test invalid metadata
+     */
+    public function testInvalidMetadata()
+    {
+        try
+        {
+            $metadata = Metadata::make('InvalidJsonString', './samples/sample1.doc');
+        }
+        catch(Exception $exception)
+        {
+            $this->assertEquals(JSON_ERROR_SYNTAX, $exception->getCode());
+        }
+    }
+    /**
+     * Test empty metadata
+     */
+    public function testEmptyMetadata()
+    {
+        try
+        {
+            $metadata = Metadata::make('', './samples/sample1.doc');
+        }
+        catch(Exception $exception)
+        {
+            $this->assertContains('Empty response', $exception->getMessage());
+            $this->assertStringContainsString('Chunk size is not supported', $exception->getMessage());
+        }
+    }
 …
+     *
      * @dataProvider    parameterProvider
+     *
+     * @param   array   $parameters
+     */
+    public function testRequestType($parameters)
+     */
+    public function testRequestType(array $parameters): void
+    {
         try
 …
         catch(Exception $exception)
+        {
             $this->assertContains('Unknown type bad', $exception->getMessage());
+            $this->assertStringContainsString('Unknown type bad', $exception->getMessage());
+        }
+    }
 …
+     *
      * @dataProvider    parameterProvider
+     *
+     * @param   array   $parameters
+     */
+    public function testLocalFile($parameters)
+     */
+    public function testLocalFile(array $parameters): void
+    {
         try
 …
+     *
      * @dataProvider    parameterProvider
+     *
+     * @param   array   $parameters
+     */
+    public function testRemoteFile($parameters)
+     */
+    public function testRemoteFile(array $parameters): void
+    {
         try
 …
     /**
      * Client parameters provider
+     *
+     * @return array
+     */
+    public function parameterProvider()
+     */
+    public function parameterProvider(): array
+    {
         return
 …
     /**
      * Get the full path of Tika app for a specified version
+     *
+     * @param   string  $version
+     * @return  string
+     */
+    private static function getPathForVersion($version)
+     */
+    private static function getPathForVersion(string $version): string
+    {
         return self::$binaries . "/tika-app-{$version}.jar";

redisearch/tags/0.3.3/vendor/vaites/php-apache-tika/tests/WebTest.php

-                      r2002534
+                      r2525480
      * Start Tika server and create shared instance of clients
      */
     public static function setUpBeforeClass()
+    public static function setUpBeforeClass(): void
+    {
         self::$client = Client::make('localhost', 9998, [CURLOPT_TIMEOUT => 30]);
 …
      * cURL multiple options test
      */
     public function testCurlOptions()
+    public function testCurlOptions(): void
+    {
         $client = Client::make('localhost', 9998, [CURLOPT_TIMEOUT => 3]);
 …
      * cURL single option test
      */
     public function testCurlSingleOption()
+    public function testCurlSingleOption(): void
+    {
         $client = Client::make('localhost', 9998)->setOption(CURLOPT_TIMEOUT, 3);
 …
      * cURL timeout option test
      */
     public function testCurlTimeoutOption()
+    public function testCurlTimeoutOption(): void
+    {
         $client = Client::make('localhost', 9998)->setTimeout(3);
 …
      * cURL headers test
      */
     public function testCurlHeaders()
+    public function testCurlHeaders(): void
+    {
         $header = 'Content-Type: image/jpeg';
 …
      * Set host test
      */
     public function testSetHost()
+    public function testSetHost(): void
+    {
         $client = Client::make('localhost', 9998);
 …
      * Set port test
      */
     public function testSetPort()
+    public function testSetPort(): void
+    {
         $client = Client::make('localhost', 9998);
 …
     /**
+     * Set url host test
+     */
+    public function testSetUrlHost(): void
+    {
+        $client = Client::make('http://localhost:9998');
+        $this->assertEquals('localhost', $client->getHost());
+    }
+    /**
+     * Set url port test
+     */
+    public function testSetUrlPort(): void
+    {
+        $client = Client::make('http://localhost:9998');
+        $this->assertEquals(9998, $client->getPort());
+    }
+    /**
      * Set retries test
      */
     public function testRetriesPort()
+    public function testSetRetries(): void
+    {
         $client = Client::make('localhost', 9998);
 …
         $this->assertEquals(5, $client->getRetries());
+    }
+    /**
+     * Test delayed check
+     */
+    public function testDelayedCheck(): void
+    {
+        $client = Client::prepare('localhost', 9997);
+        $client->setPort(9998);
+        $this->assertStringEndsWith(self::$version, $client->getVersion());
+    }
+}

redisearch/tags/0.3.3/wp-redisearch.php

-                      r2455651
+                      r2525480
 /*
 Plugin Name: RediSearch
 Version: 0.3.2
+Version: 0.3.3
 Description: Replace Wordpress search by RediSearch.
 Author: Foad Yousefi
 …
 // Plugin version .
 if ( ! defined( 'WPRS_VERSION' ) ) {
     define( 'WPRS_VERSION', '0.3.2' );
+    define( 'WPRS_VERSION', '0.3.3' );
+}

redisearch/trunk/README.md

-                      r2455651
+                      r2525480
 ### Changelog
+##### 0.3.3
+* **Added**: Ability to connect via UNIX sockets
 ##### 0.3.2

redisearch/trunk/readme.txt

-                      r2455651
+                      r2525480
 Tags: search, redisearch, redis, fuzzy, aggregation, searching, autosuggest, suggest, advanced search, woocommerce
 Requires at least: 5.0
 Tested up to: 5.6
 Stable tag: 0.3.2
+Tested up to: 5.7
+Stable tag: 0.3.3
 Requires PHP: 7.2
 License: GPLv2 or later
 …
 == Changelog ==
+= 0.3.3 =
+* Added: Ability to connect via UNIX sockets
 = 0.3.2 =

redisearch/trunk/src/Admin/Admin.php

-                      r2455651
+                      r2525480
   public static function RedisServerConf() {
     Fields::add( 'header', null, __( 'Redis server configurations', 'wp-redisearch' ) );
+    Fields::add( 'text', 'wp_redisearch_server', __( 'Redis server', 'wp-redisearch' ), __( 'Redis server url, usually it is 127.0.0.1', 'wp-redisearch' ) );
+    Fields::add( 'select', 'wp_redisearch_connection_scheme', __( 'Server communication scheme', 'wp-redisearch' ), __( 'Choose Redis server communication scheme.', 'wp-redisearch'), array('tcp' => 'TCP', 'unix' => 'UNIX') );
+    Fields::add( 'text', 'wp_redisearch_server', __( 'Redis server/path', 'wp-redisearch' ), __( 'Redis server url, usually it is 127.0.0.1 and in case of using UNIX socket, the socket path.', 'wp-redisearch' ) );
     Fields::add( 'text', 'wp_redisearch_port', __( 'Redis port', 'wp-redisearch' ), __( 'Redis port number, by default it is 6379', 'wp-redisearch' ) );
     Fields::add( 'password', 'wp_redisearch_password', __( 'Redis server password', 'wp-redisearch' ), __( 'If your redis server is not password protected, leave this field blank', 'wp-redisearch' ) );

redisearch/trunk/src/RediSearch/Client.php

-                      r2452159
+                      r2525480
       Settings::RedisPort(),
       Settings::RedisPassword(),
+,
+      Settings::RedisScheme()
     );
+  }

redisearch/trunk/src/RedisRaw/PredisAdapter.php

-                      r2452159
+                      r2525480
   public $redis;
+  public function connect($hostname = '127.0.0.1', $port = 6379, $db = 0, $password = null): RedisRawClientInterface {
+    $this->redis = new Client([
+      'scheme' => 'tcp',
+      'host' => $hostname,
+      'port' => $port,
+      'database' => $db,
+      'password' => $password,
+    ]);
+  public function connect($hostname = '127.0.0.1', $port = 6379, $db = 0, $password = null, $scheme = 'tcp'): RedisRawClientInterface {
+    $clientArgs = array();
+    if ( $scheme === 'tcp' ) {
+      $clientArgs = array(
+      'scheme'    => 'tcp',
+      'host'      => $hostname,
+      'port'      => $port,
+      'database'  => $db,
+      'password'  => $password,
+      );
+    } else {
+      $clientArgs = array(
+        'scheme'    => 'unix',
+        'path'      => $host
+      );
+    }
+    $this->redis = new Client( $clientArgs );
     $this->redis->connect();
     return $this;

redisearch/trunk/src/Settings.php

-                      r2452159
+                      r2525480
     return isset( $redis_server ) && !empty( $redis_server ) ? $redis_server : '127.0.0.1';
+  }
+  /**
+  * Using UNIX socket for communicating with Redis server or not.
+  * @since    0.1.0
+  * @param
+  * @return bool    $unixServer
+  */
+  public static function RedisScheme() {
+    /**
+     * First we try to get the WP_REDIS_SCHEME option from wp-config.php
+     * @since 0.3.3
+     */
+    $redis_server = ( defined( 'WP_REDIS_SCHEME' ) ) ? WP_REDIS_SCHEME : get_option( 'wp_redisearch_connection_scheme' );
+    return get_option( 'wp_redisearch_connection_scheme' );
+  }

redisearch/trunk/vendor/foadyousefi/seven-fields/src/Fields/Fields.php

-                      r2013762
+                      r2525480
           update_option( $name, $value );
           break;
+        case 'select':
+          update_option( $name, $value );
+          break;
         case 'checkbox':
           $value = isset( $value ) ? true : false;

redisearch/trunk/vendor/foadyousefi/seven-fields/src/Fields/Select.php

r1949960	r2525480
39	39	self::$description = $description;
40	40	self::$options = $options;
	41	// Save value in as wp_option in database
	42	parent::save( self::$name, 'select' );
41	43	return $this->field_html();
42	44	}

redisearch/trunk/vendor/front/redisearch/src/RedisRaw/PredisAdapter.php

-                      r2452159
+                      r2525480
   public $redis;
+  public function connect($hostname = '127.0.0.1', $port = 6379, $db = 0, $password = null): RedisRawClientInterface {
+    $this->redis = new Client([
+      'scheme' => 'tcp',
+      'host' => $hostname,
+      'port' => $port,
+      'database' => $db,
+      'password' => $password,
+    ]);
+  public function connect($hostname = '127.0.0.1', $port = 6379, $db = 0, $password = null, $scheme = 'tcp'): RedisRawClientInterface {
+    $clientArgs = array(
+      'database'  => $db,
+      'password'  => $password
+    );
+    if ( $scheme === 'tcp' ) {
+      $clientArgs = array(
+        'scheme'    => 'tcp',
+        'port'      => $port,
+        'host'      => $hostname
+      );
+    } else if ( $scheme === 'unix' ) {
+      $clientArgs = array(
+        'scheme'    => 'unix',
+        'path'      => $host
+      );
+    }
+    $this->redis = new Client( $clientArgs );
     $this->redis->connect();
     return $this;

redisearch/trunk/vendor/front/redisearch/src/Setup.php

-                      r2452159
+                      r2525480
    * @return PredisAdapter
    */
   public static function connect( $server = '127.0.0.1', $port = 6379, $password = null, $database = 0 ) {
+  public static function connect( $server = '127.0.0.1', $port = 6379, $password = null, $database = 0, $scheme = 'tcp' ) {
     // Connect to server
     $client = ( new PredisAdapter() )->connect( $server, $port, $database, $password );
+    $client = ( new PredisAdapter() )->connect( $server, $port, $database, $password, $database, $scheme );
     return $client;
+  }

redisearch/trunk/vendor/vaites/php-apache-tika/src/Client.php

-                      r2002534
+                      r2525480
 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;
 /**
 …
+ *
  * @author  David Martínez <contacto@davidmartinez.net>
+ * @link    http://wiki.apache.org/tika/TikaJAXRS
+ * @link    https://tika.apache.org/1.10/formats.html
+ * @link    https://tika.apache.org/1.24/formats.html
  */
 abstract class Client
+{
+    /**
+     * List of supported Apache Tika versions
+    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 static $supportedVersions =
+    [
-        '1.7', '1.8', '1.9', '1.10', '1.11', '1.12', '1.13', '1.14', '1.15', '1.16', '1.17', '1.18', '1.19', '1.19.1'
-    ];
-    /**
-     * Response using callbacks
+     *
-     * @var string
-     */
-    protected $response = 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 \Closure
+     * @var callable|null
      */
     protected $callback = null;
     /**
+     * Enable or disable appending when using callback
+     *
+     * @var bool
+     */
+    protected $callbackAppend = true;
+    /**
      * Size of chunks for callback
+     *
 …
     /**
+     * Get a class instance
+     *
+     * @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 make($param1 = null, $param2 = null, $options = [])
+    {
+        if (preg_match('/\.jar$/', func_get_arg(0)))
+        {
+            return new CLIClient($param1, $param2);
+     * 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);
+        }
+            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
+     *
+     * @return  \Closure|null
+     */
+    public function getCallback()
+     */
+    public function getCallback(): ?Closure
+    {
         return $this->callback;
 …
      * Set the callback (callable or closure) for call on secuential read
+     *
+     * @param   mixed   $callback
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setCallback($callback)
+    {
+        if($callback instanceof Closure)
+        {
+     * @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_callable($callback))
+        {
+            $this->callback = function($chunk) use($callback)
+        elseif(is_string($callback))
+        {
+            $this->callbackAppend = (bool) $append;
+            $this->callback = function($chunk) use ($callback)
+            {
                 return call_user_func_array($callback, [$chunk]);
 …
     /**
      * Get the chunk size
+     *
+     * @return  int
+     */
+    public function getChunkSize()
+     */
+    public function getChunkSize(): int
+    {
         return $this->chunkSize;
 …
      * Set the chunk size for secuential read
+     *
+     * @param   int     $size
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setChunkSize($size)
+    {
+        if(static::MODE == 'cli' && is_numeric($size))
+        {
+            $this->chunkSize = (int)$size;
+        }
+        elseif(static::MODE == 'web')
+     * @throws \Exception
+     */
+    public function setChunkSize(int $size): self
+    {
+        if(static::MODE == 'cli')
+        {
+            $this->chunkSize = $size;
+        }
+        else
+        {
             throw new Exception('Chunk size is not supported on web mode');
+        }
-        else
+        {
-            throw new Exception("$size is not a valid chunk size");
+        }
         return $this;
 …
     /**
      * Get the remote download flag
+     *
+     * @return  bool
+     */
+    public function getDownloadRemote()
+     */
+    public function getDownloadRemote(): bool
+    {
         return $this->downloadRemote;
 …
     /**
      * Set the remote download flag
+     *
+     * @param   bool    $download
+     * @return  $this
+     */
+    public function setDownloadRemote($download)
+     */
+    public function setDownloadRemote(bool $download): self
+    {
         $this->downloadRemote = (bool) $download;
 …
      * Gets file metadata
+     *
+     * @param   string  $file
+     * @return  \Vaites\ApacheTika\Metadata\Metadata
+     * @throws  \Exception
+     */
+    public function getMetadata($file)
+    {
+        return $this->request('meta', $file);
+     * @throws \Exception
+     */
+    public function getMetadata(string $file): MetadataInterface
+    {
+        $response = $this->parseJsonResponse($this->request('meta', $file));
+        if($response instanceof stdClass == false)
+        {
+            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)
+        {
+            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)
+        {
+            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
+     *
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getLanguage($file)
+     * @throws \Exception
+     */
+    public function getLanguage(string $file): string
+    {
         return $this->request('lang', $file);
 …
      * Detect MIME type
+     *
+     * @param   string  $file
+     * @return  string
+     * @throws \Exception
+     */
+    public function getMIME($file)
+     * @throws \Exception
+     */
+    public function getMIME(string $file): string
+    {
         return $this->request('mime', $file);
 …
      * Extracts HTML
+     *
+     * @param   string  $file
+     * @param   mixed   $callback
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getHTML($file, $callback = null)
+     * @throws \Exception
+     */
+    public function getHTML(string $file, callable $callback = null, bool $append = true): string
+    {
         if(!is_null($callback))
+        {
             $this->setCallback($callback);
+            $this->setCallback($callback, $append);
+        }
 …
     /**
+     * Extracts XHTML
+     *
+     * @throws \Exception
+     */
+    public function getXHTML(string $file, callable $callback = null, bool $append = true): string
+    {
+        if(!is_null($callback))
+        {
+            $this->setCallback($callback, $append);
+        }
+        return $this->request('xhtml', $file);
+    }
+    /**
      * Extracts text
+     *
+     * @param   string  $file
+     * @param   mixed   $callback
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getText($file, $callback = null)
+     * @throws \Exception
+     */
+    public function getText(string $file, callable $callback = null, bool $append = true): string
+    {
         if(!is_null($callback))
+        {
             $this->setCallback($callback);
+            $this->setCallback($callback, $append);
+        }
 …
      * Extracts main text
+     *
+     * @param   string  $file
+     * @param   mixed   $callback
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getMainText($file, $callback = null)
+     * @throws \Exception
+     */
+    public function getMainText(string $file, callable $callback = null, bool $append = true): string
+    {
         if(!is_null($callback))
+        {
             $this->setCallback($callback);
+            $this->setCallback($callback, $append);
+        }
 …
     /**
-     * Returns the supported MIME types
+     *
-     * @return  string
-     * @throws  \Exception
-     */
-    public function getSupportedMIMETypes()
+    {
-        return $this->request('mime-types');
+    }
-    /**
-     * Returns the available detectors
+     *
-     * @return  string
-     * @throws  \Exception
-     */
-    public function getAvailableDetectors()
+    {
-        return $this->request('detectors');
+    }
-    /**
-     * Returns the available parsers
+     *
-     * @return  string
-     * @throws  \Exception
-     */
-    public function getAvailableParsers()
+    {
-        return $this->request('parsers');
+    }
-    /**
      * Returns current Tika version
+     *
+     * @return  string
+     * @throws  \Exception
+     */
+    public function getVersion()
+     * @throws \Exception
+     */
+    public function getVersion(): string
+    {
         return $this->request('version');
 …
      * Return the list of Apache Tika supported versions
+     *
+     * @return array
+     */
+    public static function getSupportedVersions()
+    {
+        return self::$supportedVersions;
+     * @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
+     *
+     * @param   string  $version
+     * @return  bool
+     */
+    public static function isVersionSupported($version)
+    {
+        return in_array($version, self::getSupportedVersions());
+     */
+    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
+     *
+     * @param   string  $type
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    public function checkRequest($type, $file)
+     * @throws \Exception
+     */
+    public function checkRequest(string $type, string $file = null): ?string
+    {
         // no checks for getters
 …
+        {
             //
+        }
+        // invalid local file
+        } // invalid local file
         elseif(!preg_match('/^http/', $file) && !file_exists($file))
+        {
             throw new Exception("File $file can't be opened");
+        }
+        // invalid remote file
+        } // 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
+        } // download remote file if required only for integrated downloader
         elseif(preg_match('/^http/', $file) && $this->downloadRemote)
+        {
 …
     /**
+     * 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
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    protected function downloadFile($file)
+     * @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');
 …
     /**
+     * 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.
+     *
+     * @param   string  $type
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    abstract public function request($type, $file);
+     * @throws \Exception
+     */
+    abstract public function request(string $type, string $file = null): string;
+}

redisearch/trunk/vendor/vaites/php-apache-tika/src/Clients/CLIClient.php

-                      r2002534
+                      r2525480
 use Vaites\ApacheTika\Client;
-use Vaites\ApacheTika\Metadata\Metadata;
 /**
 …
+ *
  * @author  David Martínez <contacto@davidmartinez.net>
+ * @link    http://wiki.apache.org/tika/TikaJAXRS
+ * @link    https://tika.apache.org/1.12/formats.html
+ * @link    https://tika.apache.org/1.23/gettingstarted.html#Using_Tika_as_a_command_line_utility
  */
 class CLIClient extends Client
+{
     const MODE = 'cli';
+    protected const MODE = 'cli';
     /**
 …
     /**
+     * Java arguments
+     *
+     * @var string
+     */
+    protected $javaArgs = null;
+    /**
      * Configure client
+     *
+     * @param   string  $path
+     * @param   string  $java
+     *
+     * @throws Exception
+     */
+    public function __construct($path = null, $java = null)
+    {
+     * @throws \Exception
+     */
+    public function __construct(string $path = null, string $java = null, bool $check = true)
+    {
+        parent::__construct();
         if($path)
+        {
 …
             $this->setJava($java);
+        }
+        if($check === true)
+        {
+            $this->check();
+        }
+    }
     /**
      * Get the path
+     *
+     * @return  null|string
+     */
+    public function getPath()
+     */
+    public function getPath(): ?string
+    {
         return $this->path;
 …
     /**
      * Set the path
+     *
+     * @param   string  $path
+     * @return  $this
+     */
+    public function setPath($path)
+     */
+    public function setPath($path): self
+    {
         $this->path = $path;
 …
     /**
      * Get the Java path
+     *
+     * @return  null|int
+     */
+    public function getJava()
+     */
+    public function getJava(): ?string
+    {
         return $this->java;
 …
     /**
      * Set the Java path
+     *
+     * @param   string    $java
+     * @return  $this
+     */
+    public function setJava($java)
+     */
+    public function setJava(string $java): self
+    {
         $this->java = $java;
 …
     /**
+     * Get the Java arguments
+     */
+    public function getJavaArgs(): ?string
+    {
+        return $this->javaArgs;
+    }
+    /**
+     * Set the Java arguments
+     *
+     * NOTE: to modify child process jvm args, prepend "J" to each argument (-JXmx4g)
+     */
+    public function setJavaArgs(string $args): self
+    {
+        $this->javaArgs = $args;
+        return $this;
+    }
+    /**
+     * Returns the supported MIME types
+     *
+     * NOTE: the data provided by the CLI must be parsed: mime type has no spaces, aliases go next prefixed with spaces
+     *
+     * @throws \Exception
+     */
+    public function getSupportedMIMETypes(): array
+    {
+        $mime = null;
+        $mimeTypes = [];
+        $response = preg_split("/\n/", $this->request('mime-types'));
+        foreach($response as $line)
+        {
+            if(preg_match('/^\w+/', $line))
+            {
+                $mime = trim($line);
+                $mimeTypes[$mime] = ['alias' => []];
+            }
+            else
+            {
+                [$key, $value] = preg_split('/:\s+/', trim($line));
+                if($key == 'alias')
+                {
+                    $mimeTypes[$mime]['alias'][] = $value;
+                }
+                else
+                {
+                    $mimeTypes[$mime][$key] = $value;
+                }
+            }
+        }
+        return $mimeTypes;
+    }
+    /**
+     * Returns the available detectors
+     *
+     * @throws \Exception
+     */
+    public function getAvailableDetectors(): array
+    {
+        $detectors = [];
+        $split = preg_split("/\n/", $this->request('detectors'));
+        $parent = null;
+        foreach($split as $line)
+        {
+            if(preg_match('/composite/i', $line))
+            {
+                $parent = trim(preg_replace('/\(.+\):/', '', $line));
+                $detectors[$parent] = ['children' => [], 'composite' => true, 'name' => $parent];
+            }
+            else
+            {
+                $child = trim($line);
+                $detectors[$parent]['children'][$child] = ['composite' => false, 'name' => $child];
+            }
+        }
+        return $detectors;
+    }
+    /**
+     * Returns the available parsers
+     *
+     * @throws \Exception
+     */
+    public function getAvailableParsers(): array
+    {
+        $parsers = [];
+        $split = preg_split("/\n/", $this->request('parsers'));
+        array_shift($split);
+        $parent = null;
+        foreach($split as $line)
+        {
+            if(preg_match('/composite/i', $line))
+            {
+                $parent = trim(preg_replace('/\(.+\):/', '', $line));
+                $parsers[$parent] = ['children' => [], 'composite' => true, 'name' => $parent, 'decorated' => false];
+            }
+            else
+            {
+                $child = trim($line);
+                $parsers[$parent]['children'][$child] = ['composite' => false, 'name' => $child, 'decorated' => false];
+            }
+        }
+        return $parsers;
+    }
+    /**
+     * Check Java binary, JAR path or server connection
+     *
+     * @throws \Exception
+     */
+    public function check(): void
+    {
+        if($this->isChecked() === false)
+        {
+            // Java command must not return an error
+            try
+            {
+                $this->exec(($this->java ?: 'java') . ' -version');
+            }
+            catch(Exception $exception)
+            {
+                throw new Exception('Java command not found');
+            }
+            // JAR path must exists
+            if(file_exists($this->path) === false)
+            {
+                throw new Exception('Apache Tika app JAR not found');
+            }
+            $this->setChecked(true);
+        }
+    }
+    /**
      * Configure and make a request and return its results
+     *
      * @param   string  $type
      * @param   string  $file
      * @return  string
      * @throws  \Exception
      */
     public function request($type, $file = null)
+    {
+     * @throws \Exception
+     */
+    public function request(string $type, string $file = null): string
+    {
+        // check if not checked
+        $this->check();
         // check if is cached
         if(isset($this->cache[sha1($file)][$type]))
+        {
             return $this->cache[sha1($file)][$type];
+        if($file !== null && $this->isCached($type, $file))
+        {
+            return $this->getCachedResponse($type, $file);
+        }
 …
         // check the request
         $file = parent::checkRequest($type, $file);
+        $file = $this->checkRequest($type, $file);
         // add last argument
 …
         // build command
         $jar = escapeshellarg($this->path);
         $command = ($this->java ?: 'java') . " -jar $jar " . implode(' ', $arguments);
+        $command = trim(($this->java ?: 'java') . " -jar $jar " . implode(' ', $arguments) . " {$this->javaArgs}");
         // run command
 …
         // metadata response
         if($type == 'meta')
+        if(in_array(preg_replace('/\/.+/', '', $type), ['meta', 'rmeta']))
+        {
             // fix for invalid? json returned only with images
             $response = str_replace(basename($file) . '"}{', '", ', $response);
+            // on Windows, response comes in another charset
+            if(defined('PHP_WINDOWS_VERSION_MAJOR'))
+            {
+                $response = utf8_encode($response);
+            }
+            $response = Metadata::make($response, $file);
+            // on Windows, response must be encoded to UTF8
+            $response = $this->platform == 'win' ? utf8_encode($response) : $response;
+        }
         // cache certain responses
         if(in_array($type, ['lang', 'meta']))
+        {
             $this->cache[sha1($file)][$type] = $response;
+        if($this->isCacheable($type))
+        {
+            $this->cacheResponse($type, $response, $file);
+        }
 …
      * Run the command and return its results
+     *
+     * @param   string  $command
+     * @return  null|string
+     * @throws  \Exception
+     */
+    public function exec($command)
+     * @throws \Exception
+     */
+    public function exec(string $command): ?string
+    {
         // run command
 …
+                }
+                $this->response .= $chunk;
+                if($this->callbackAppend === true)
+                {
+                    $this->response .= $chunk;
+                }
+            }
             fclose($pipes[1]);
 …
      * Get the arguments to run the command
+     *
-     * @param   string  $type
-     * @param   string  $file
-     * @return  array
      * @throws  Exception
      */
     protected function getArguments($type, $file = null)
+    {
         // parameters for command
+        $arguments = [];
+    protected function getArguments(string $type, string $file = null): array
+    {
+        $arguments = $this->encoding ? ["--encoding={$this->encoding}"] : [];
         switch($type)
+        {
 …
                 break;
+            case 'rmeta/ignore':
+                $arguments[] = '--metadata --jsonRecursive';
+                break;
+            case 'rmeta/html':
+                $arguments[] = '--html --jsonRecursive';
+                break;
+            case 'rmeta/text':
+                $arguments[] = '--text --jsonRecursive';
+                break;
+            case 'xhtml':
+                $arguments[] = '--xml';
+                break;
             default:
                 throw new Exception("Unknown type $type");
+                throw new Exception($file ? "Unknown type $type for $file" : "Unknown type $type");
+        }

redisearch/trunk/vendor/vaites/php-apache-tika/src/Clients/WebClient.php

-                      r2002534
+                      r2525480
 use Vaites\ApacheTika\Client;
-use Vaites\ApacheTika\Metadata\Metadata;
 /**
 …
+ *
  * @author  David Martínez <contacto@davidmartinez.net>
+ * @link    http://wiki.apache.org/tika/TikaJAXRS
+ * @link    https://tika.apache.org/1.12/formats.html
+ * @link    https://cwiki.apache.org/confluence/display/TIKA/TikaServer
  */
 class WebClient extends Client
+{
     const MODE = 'web';
+    protected const MODE = 'web';
     /**
 …
      * @var string
      */
     protected $host = '127.0.0.1';
+    protected $host = null;
     /**
 …
      * @var int
      */
     protected $port = 9998;
+    protected $port = null;
     /**
 …
     protected $options =
+    [
         CURLINFO_HEADER_OUT    => true,
         CURLOPT_HTTPHEADER     => [],
         CURLOPT_PUT            => true,
         CURLOPT_RETURNTRANSFER => true,
         CURLOPT_TIMEOUT        => 5,
+        CURLINFO_HEADER_OUT     => true,
+        CURLOPT_HTTPHEADER      => [],
+        CURLOPT_PUT             => true,
+        CURLOPT_RETURNTRANSFER  => true,
+        CURLOPT_TIMEOUT         => 5
     ];
 …
      * Configure class and test if server is running
+     *
+     * @param   string  $host
+     * @param   int     $port
+     * @param   array   $options
+     * @throws  \Exception
+     */
+    public function __construct($host = null, $port = null, $options = [])
+    {
+        if($host)
+     * @throws \Exception
+     */
+    public function __construct(string $host = null, int $port = null, array $options = [], bool $check = true)
+    {
+        parent::__construct();
+        if(is_string($host) && filter_var($host, FILTER_VALIDATE_URL))
+        {
+            $this->setUrl($host);
+        }
+        elseif($host)
+        {
             $this->setHost($host);
+        }
         if($port)
+        if(is_numeric($port))
+        {
             $this->setPort($port);
 …
         $this->setDownloadRemote(true);
+        $this->getVersion(); // exception if not running
+        if($check === true)
+        {
+            $this->check();
+        }
+    }
+    /**
+     * Get the base URL
+     */
+    public function getUrl(): string
+    {
+        return sprintf('http://%s:%d', $this->host, $this->port ?: 9998);
+    }
+    /**
+     * Set the host and port using an URL
+     */
+    public function setUrl(string $url): self
+    {
+        $url = parse_url($url);
+        $this->setHost($url['host']);
+        if(isset($url['port']))
+        {
+            $this->setPort($url['port']);
+        }
+        return $this;
+    }
     /**
      * Get the host
+     *
+     * @return  null|string
+     */
+    public function getHost()
+     */
+    public function getHost(): ?string
+    {
         return $this->host;
 …
     /**
      * Set the host
+     *
+     * @param   string  $host
+     * @return  $this
+     */
+    public function setHost($host)
+     */
+    public function setHost(string $host): self
+    {
         $this->host = $host;
 …
     /**
      * Get the port
+     *
+     * @return  null|int
+     */
+    public function getPort()
+     */
+    public function getPort(): ?int
+    {
         return $this->port;
 …
     /**
      * Set the port
+     *
+     * @param   int     $port
+     * @return  $this
+     */
+    public function setPort($port)
+     */
+    public function setPort(int $port): self
+    {
         $this->port = $port;
 …
     /**
      * Get the number of retries
+     *
+     * @return  int
+     */
+    public function getRetries()
+     */
+    public function getRetries(): int
+    {
         return $this->retries;
 …
     /**
      * Set the number of retries
+     *
+     * @param   int     $retries
+     * @return  $this
+     */
+    public function setRetries($retries)
+     */
+    public function setRetries(int $retries): self
+    {
         $this->retries = $retries;
 …
     /**
      * Get all the options
+     *
+     * @return  null|array
+     */
+    public function getOptions()
+     */
+    public function getOptions(): array
+    {
         return $this->options;
 …
      * Get an specified option
+     *
-     * @param   string  $key
      * @return  mixed
      */
     public function getOption($key)
+    {
         return isset($this->options[$key]) ? $this->options[$key] : null;
+    public function getOption(int $key)
+    {
+        return $this->options[$key] ?? null;
+    }
 …
      * Set a cURL option to be set with curl_setopt()
+     *
+     * @link    http://php.net/manual/en/curl.constants.php
+     * @link    http://php.net/manual/en/function.curl-setopt.php
+     * @param   string  $key
+     * @param   mixed   $value
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setOption($key, $value)
+     * @link http://php.net/manual/en/curl.constants.php
+     * @link http://php.net/manual/en/function.curl-setopt.php
+     * @throws \Exception
+     */
+    public function setOption(int $key, $value): self
+    {
         if(in_array($key, [CURLINFO_HEADER_OUT, CURLOPT_PUT, CURLOPT_RETURNTRANSFER]))
 …
      * Set the cURL options
+     *
+     * @param   array   $options
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setOptions($options)
+     * @throws \Exception
+     */
+    public function setOptions(array $options): self
+    {
         foreach($options as $key => $value)
 …
     /**
      * Get the timeout value for cURL
+     *
+     * @return  int
+     */
+    public function getTimeout()
+     */
+    public function getTimeout(): int
+    {
         return $this->getOption(CURLOPT_TIMEOUT);
 …
      * Set the timeout value for cURL
+     *
+     * @param   int     $value
+     * @return  $this
+     * @throws  \Exception
+     */
+    public function setTimeout($value)
+     * @throws \Exception
+     */
+    public function setTimeout(int $value): self
+    {
         $this->setOption(CURLOPT_TIMEOUT, (int) $value);
 …
     /**
+     * Returns the supported MIME types
+     *
+     * @throws \Exception
+     */
+    public function getSupportedMIMETypes(): array
+    {
+        $mimeTypes = json_decode($this->request('mime-types'), true);
+        ksort($mimeTypes);
+        return $mimeTypes;
+    }
+    /**
+     * Returns the available detectors
+     *
+     * @throws \Exception
+     */
+    public function getAvailableDetectors(): array
+    {
+        $detectors = [json_decode($this->request('detectors'), true)];
+        foreach($detectors as $index => $parent)
+        {
+            $detectors[$parent['name']] = $parent;
+            if(isset($parent['children']))
+            {
+                foreach($parent['children'] as $subindex => $child)
+                {
+                    $detectors[$parent['name']]['children'][$child['name']] = $child;
+                    unset($detectors[$parent['name']]['children'][$subindex]);
+                }
+            }
+            unset($detectors[$index]);
+        }
+        return $detectors;
+    }
+    /**
+     * Returns the available parsers
+     *
+     * @throws \Exception
+     */
+    public function getAvailableParsers(): array
+    {
+        $parsers = [json_decode($this->request('parsers'), true)];
+        foreach($parsers as $index => $parent)
+        {
+            $parsers[$parent['name']] = $parent;
+            if(isset($parent['children']))
+            {
+                foreach($parent['children'] as $subindex => $child)
+                {
+                    $parsers[$parent['name']]['children'][$child['name']] = $child;
+                    unset($parsers[$parent['name']]['children'][$subindex]);
+                }
+            }
+            unset($parsers[$index]);
+        }
+        return $parsers;
+    }
+    /**
+     * Check if server is running
+     *
+     * @throws \Exception
+     */
+    public function check(): void
+    {
+        if($this->isChecked() === false)
+        {
+            $this->setChecked(true);
+            // throws an exception if server is unreachable or can't connect
+            $this->request('version');
+        }
+    }
+    /**
      * Configure, make a request and return its results
+     *
+     * @param   string  $type
+     * @param   string  $file
+     * @return  string
+     * @throws  \Exception
+     */
+    public function request($type, $file = null)
+     * @throws \Exception
+     */
+    public function request(string $type, string $file = null): string
+    {
         static $retries = [];
+        // check if not checked
+        $this->check();
         // check if is cached
         if(isset($this->cache[sha1($file)][$type]))
+        {
             return $this->cache[sha1($file)][$type];
+        if($file !== null && $this->isCached($type, $file))
+        {
+            return $this->getCachedResponse($type, $file);
+        }
         elseif(!isset($retries[sha1($file)]))
 …
         // parameters for cURL request
         list($resource, $headers) = $this->getParameters($type, $file);
+        [$resource, $headers] = $this->getParameters($type, $file);
         // check the request
         $file = parent::checkRequest($type, $file);
+        $file = $this->checkRequest($type, $file);
         // cURL options
 …
         // cURL init and options
         $options[CURLOPT_URL] = "http://{$this->host}:{$this->port}" . "/$resource";
+        $options[CURLOPT_URL] = $this->getUrl() . "/$resource";
         // get the response and the HTTP status code
+        list($response, $status) = $this->exec($options);
+        [$response, $status] = $this->exec($options);
+        // reduce memory usage closing cURL resource
+        if(isset($options[CURLOPT_INFILE]) && is_resource($options[CURLOPT_INFILE]))
+        {
+            fclose($options[CURLOPT_INFILE]);
+        }
         // request completed successfully
         if($status == 200)
+        {
+            if($type == 'meta')
+            // cache certain responses
+            if($this->isCacheable($type))
+            {
                 $response = Metadata::make($response, $file);
+                $this->cacheResponse($type, $response, $file);
+            }
+            // cache certain responses
+            if(in_array($type, ['lang', 'meta']))
+            {
+                $this->cache[sha1($file)][$type] = $response;
+            }
+        }
+        // request completed successfully but result is empty
+        } // request completed successfully but result is empty
         elseif($status == 204)
+        {
             $response = null;
+        }
+        // retry on request failed with error 500
+        } // retry on request failed with error 500
         elseif($status == 500 && $retries[sha1($file)]--)
+        {
             $response = $this->request($type, $file);
+        }
+        // other status code is an error
+        } // other status code is an error
         else
+        {
             $this->error($status, $resource);
+            $this->error($status, $resource, $file);
+        }
 …
      * Make a request to Apache Tika Server
+     *
+     * @param   array   $options
+     * @return  array
+     * @throws  \Exception
+     */
+    protected function exec(array $options = [])
+     * @throws \Exception
+     */
+    protected function exec(array $options = []): array
+    {
         // cURL init and options
         $curl = curl_init();
         // we avoid curl_setopt_array($curl, $options) because extrange Windows behaviour (issue #8)
+        // we avoid curl_setopt_array($curl, $options) because strange Windows behaviour (issue #8)
         foreach($options as $option => $value)
+        {
 …
+        }
         // make the request
+        // make the request directly
         if(is_null($this->callback))
+        {
             $this->response = curl_exec($curl);
+        }
+            $this->response = curl_exec($curl) ?: '';
+        } // with a callback, the response is appended on each block inside the callback
         else
+        {
 …
      * Throws an exception for an error status code
+     *
+     * @codeCoverageIgnore
+     *
+     * @param   int       $status
+     * @param   string    $resource
+     * @throws  \Exception
+     */
+    protected function error($status, $resource)
+     * @throws \Exception
+     */
+    protected function error(int $status, string $resource, string $file = null): void
+    {
         switch($status)
 …
             //  method not allowed
             case 405:
                 throw new Exception('Method not allowed', 405);
+                $message = 'Method not allowed';
                 break;
             //  unsupported media type
             case 415:
                 throw new Exception('Unsupported media type', 415);
+                $message = 'Unsupported media type';
                 break;
             //  unprocessable entity
             case 422:
+                throw new Exception('Unprocessable document', 422);
+                $message = 'Unprocessable document';
+                // using remote files require Tika server to be launched with specific options
+                if($this->downloadRemote == false && preg_match('/^http/', $file))
+                {
+                    $message .= ' (is server launched using "-enableUnsecureFeatures -enableFileUrl" arguments?)';
+                }
                 break;
             // server error
             case 500:
                 throw new Exception('Error while processing document', 500);
+                $message = 'Error while processing document';
                 break;
             // unexpected
             default:
+                throw new Exception("Unexpected response for /$resource ($status)", 501);
+        }
+                $message = "Unexpected response for /$resource ($status)";
+                $status = 501;
+        }
+        throw new Exception($message, $status);
+    }
 …
      * Get the parameters to make the request
+     *
+     * @link    https://wiki.apache.org/tika/TikaJAXRS#Specifying_a_URL_Instead_of_Putting_Bytes
+     * @param   string  $type
+     * @param   string  file
+     * @return  array
+     * @throws  \Exception
+     */
+    protected function getParameters($type, $file = null)
+     * @link https://wiki.apache.org/tika/TikaJAXRS#Specifying_a_URL_Instead_of_Putting_Bytes
+     * @throws \Exception
+     */
+    protected function getParameters(string $type, string $file = null): array
+    {
         $headers = [];
+        $callback = null;
         if(!empty($file) && preg_match('/^http/', $file))
 …
                 break;
+            case 'detectors':
+            case 'parsers':
             case 'meta':
+                $resource = 'meta';
+            case 'mime-types':
+            case 'rmeta/html':
+            case 'rmeta/ignore':
+            case 'rmeta/text':
+                $resource = $type;
                 $headers[] = 'Accept: application/json';
+                $callback = function($response)
+                {
+                    return json_decode($response, true);
+                };
                 break;
 …
                 break;
-            case 'detectors':
-            case 'parsers':
-            case 'mime-types':
             case 'version':
                 $resource = $type;
                 break;
+            case 'xhtml':
+                throw new Exception("Tika Server does not support XHTML output");
+                break;
             default:
                 throw new Exception("Unknown type $type");
+        }
         return [$resource, $headers];
+        return [$resource, $headers, $callback];
+    }
 …
      * Get the cURL options
+     *
+     * @param   string  $type
+     * @param   string  file
+     * @return  array
+     * @throws  \Exception
+     */
+    protected function getCurlOptions($type, $file = null)
+     * @throws \Exception
+     */
+    protected function getCurlOptions(string $type, string $file = null): array
+    {
         // base options
 …
             $callback = $this->callback;
             $options[CURLOPT_WRITEFUNCTION] = function($handler, $data) use($callback)
+            $options[CURLOPT_WRITEFUNCTION] = function($handler, $data) use ($callback)
+            {
+                $this->response .= $data;
+                if($this->callbackAppend === true)
+                {
+                    $this->response .= $data;
+                }
                 $callback($data);
 …
+        {
             //
+        }
+        // local file options
+        } // local file options
         elseif($file && file_exists($file) && is_readable($file))
+        {
             $options[CURLOPT_INFILE] = fopen($file, 'r');
             $options[CURLOPT_INFILESIZE] = filesize($file);
+        }
+        // other options for specific requests
+        elseif(in_array($type,  ['detectors', 'mime-types', 'parsers', 'version']))
+        } // other options for specific requests
+        elseif(in_array($type, ['detectors', 'mime-types', 'parsers', 'version']))
+        {
             $options[CURLOPT_PUT] = false;
+        }
+        // file not accesible
+        } // file not accesible
         else
+        {

redisearch/trunk/vendor/vaites/php-apache-tika/tests/BaseTest.php

-                      r2002534
+                      r2525480
 namespace Vaites\ApacheTika\Tests;
+use PHPUnit_Framework_TestCase;
+use Exception;
+use PHPUnit\Framework\TestCase;
 /**
  * Common test functionality
  */
 abstract class BaseTest extends PHPUnit_Framework_TestCase
+abstract class BaseTest extends TestCase
+{
     /**
 …
     /**
      * Get env variables
+     *
+     * @param null      $name
+     * @param array     $data
+     * @param string    $dataName
+     */
+    public function __construct($name = null, array $data = array(), $dataName = '')
+     *
+     * @throws \Exception
+     */
+    public function __construct(string $name = null, array $data = array(), $dataName = '')
+    {
         self::$version = getenv('APACHE_TIKA_VERSION');
         self::$binaries = getenv('APACHE_TIKA_BINARIES');
+        if(empty(self::$version))
+        {
+            throw new Exception('APACHE_TIKA_VERSION environment variable not defined');
+        }
         parent::__construct($name, $data, $dataName);
+    }
 …
      * Version test
      */
     public function testVersion()
+    public function testVersion(): void
+    {
         $this->assertEquals('Apache Tika ' . self::$version, self::$client->getVersion());
 …
      * Metadata test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @param   string $class
+     * @throws  \Exception
+     */
+    public function testMetadata($file, $class = 'Metadata')
+     * @dataProvider documentProvider
+     */
+    public function testMetadata(string $file, string $class = 'Metadata'): void
+    {
+        $this->assertInstanceOf("\\Vaites\\ApacheTika\\Metadata\\$class", self::$client->getMetadata($file));
+    }
+    /**
+     * Metadata test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadata(string $file, string $class = 'DocumentMetadata'): void
+    {
+        $this->testMetadata($file, $class);
+    }
+    /**
+     * Metadata title test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataTitle(string $file): void
+    {
+        $this->assertEquals('Lorem ipsum dolor sit amet', self::$client->getMetadata($file)->title);
+    }
+    /**
+     * Metadata author test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataAuthor(string $file): void
+    {
+        $this->assertEquals('David Martínez', self::$client->getMetadata($file)->author);
+    }
+    /**
+     * Metadata dates test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataCreated(string $file): void
+    {
+        $this->assertInstanceOf('DateTime', self::$client->getMetadata($file)->created);
+    }
+    /**
+     * Metadata dates test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataUpdated(string $file): void
+    {
+        $this->assertInstanceOf('DateTime', self::$client->getMetadata($file)->updated);
+    }
+    /**
+     * Metadata keywords test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMetadataKeywords(string $file): void
+    {
+        $this->assertContains('ipsum', self::$client->getMetadata($file)->keywords);
+    }
+    /**
+     * Recursive text metadata test
+     *
+     * @dataProvider recursiveProvider
+     */
+    public function testTextRecursiveMetadata(string $file): void
+    {
+        $nested = 'sample8.zip/sample1.doc';
+        $metadata = self::$client->getRecursiveMetadata($file, 'text');
+        $this->assertStringContainsString('Zenonis est, inquam, hoc Stoici', $metadata[$nested]->content ?? 'ERROR');
+    }
+    /**
+     * Recursive HTML metadata test
+     *
+     * @dataProvider recursiveProvider
+     */
+    public function testHtmlRecursiveMetadata(string $file): void
+    {
+        $nested = 'sample8.zip/sample1.doc';
+        $metadata = self::$client->getRecursiveMetadata($file, 'html');
+        $this->assertStringContainsString('Zenonis est, inquam, hoc Stoici', $metadata[$nested]->content ?? 'ERROR');
+    }
+    /**
+     * Recursive ignore metadata test
+     *
+     * @dataProvider ocrProvider
+     */
+    public function testIgnoreRecursiveMetadata(string $file): void
+    {
+        $metadata = self::$client->getRecursiveMetadata($file, 'ignore');
+        $this->assertNull(array_shift($metadata)->content);
+    }
+    /**
+     * Language test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentLanguage(string $file): void
+    {
+        $this->assertRegExp('/^[a-z]{2}$/', self::$client->getLanguage($file));
+    }
+    /**
+     * MIME test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMIME(string $file): void
+    {
+        $this->assertNotEmpty(self::$client->getMIME($file));
+    }
+    /**
+     * HTML test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentHTML(string $file): void
+    {
+        $this->assertStringContainsString('Zenonis est, inquam, hoc Stoici', self::$client->getHTML($file));
+    }
+    /**
+     * Text test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentText(string $file): void
+    {
+        $this->assertStringContainsString('Zenonis est, inquam, hoc Stoici', self::$client->getText($file));
+    }
+    /**
+     * Main text test
+     *
+     * @dataProvider documentProvider
+     */
+    public function testDocumentMainText(string $file): void
+    {
+        $this->assertStringContainsString('Lorem ipsum dolor sit amet', self::$client->getMainText($file));
+    }
+    /**
+     * Metadata test
+     *
+     * @dataProvider imageProvider
+     */
+    public function testImageMetadata(string $file, string $class = 'ImageMetadata'): void
+    {
+        $this->testMetadata($file, $class);
+    }
+    /**
+     * Metadata width test
+     *
+     * @dataProvider imageProvider
+     */
+    public function testImageMetadataWidth(string $file): void
+    {
+        $meta = self::$client->getMetadata($file);
+        $this->assertEquals(1600, $meta->width, basename($file));
+    }
+    /**
+     * Metadata height test
+     *
+     * @dataProvider imageProvider
+     */
+    public function testImageMetadataHeight(string $file): void
+    {
+        $meta = self::$client->getMetadata($file);
+        $this->assertEquals(900, $meta->height, basename($file));
+    }
+    /**
+     * OCR test
+     *
+     * @dataProvider ocrProvider
+     */
+    public function testImageOCR(string $file): void
+    {
+        $text = self::$client->getText($file);
+        $this->assertRegExp('/voluptate/i', $text);
+    }
+    /**
+     * Text callback test
+     *
+     * @dataProvider callbackProvider
+     */
+    public function testTextCallback(string $file): void
+    {
+        BaseTest::$shared = 0;
+        self::$client->getText($file, [$this, 'callableCallback']);
+        $this->assertGreaterThan(1, BaseTest::$shared);
+    }
+    /**
+     * Text callback test
+     *
+     * @dataProvider callbackProvider
+     */
+    public function testTextCallbackWithoutAppend(string $file): void
+    {
+        BaseTest::$shared = 0;
+        $response = self::$client->getText($file, [$this, 'callableCallback'], false);
+        $this->assertEmpty($response);
+    }
+    /**
+     * Main text callback test
+     *
+     * @dataProvider callbackProvider
+     */
+    public function testMainTextCallback(string $file): void
+    {
+        BaseTest::$shared = 0;
+        self::$client->getMainText($file, function()
+        {
+            BaseTest::$shared++;
+        });
+        $this->assertGreaterThan(1, BaseTest::$shared);
+    }
+    /**
+     * Main text callback test
+     *
+     * @dataProvider callbackProvider
+     */
+    public function testHtmlCallback(string $file): void
+    {
+        BaseTest::$shared = 0;
+        self::$client->getHtml($file, function()
+        {
+            BaseTest::$shared++;
+        });
+        $this->assertGreaterThan(1, BaseTest::$shared);
+    }
+    /**
+     * Remote file test with integrated download
+     *
+     * @dataProvider remoteProvider
+     */
+    public function testRemoteDocumentText(string $file): void
+    {
+        $this->assertStringContainsString('Rationis enim perfectio est virtus', self::$client->getText($file));
+    }
+    /**
+     * Remote file test with internal downloader
+     *
+     * @dataProvider remoteProvider
+     */
+    public function testDirectRemoteDocumentText(string $file): void
+    {
         $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertInstanceOf("\\Vaites\\ApacheTika\\Metadata\\$class", self::$client->getMetadata($file));
+        }
+    }
+    /**
+     * Metadata test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @param   string $class
+     * @throws  \Exception
+     */
+    public function testDocumentMetadata($file, $class = 'DocumentMetadata')
+        $client->setDownloadRemote(false);
+        $this->assertStringContainsString('Rationis enim perfectio est virtus', $client->getText($file));
+    }
+    /**
+     * Encoding tests
+     *
+     * @dataProvider encodingProvider
+     */
+    public function testEncodingDocumentText(string $file): void
+    {
         $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->testMetadata($file, $class);
+        }
+    }
+    /**
+     * Metadata title test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataTitle($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertEquals('Lorem ipsum dolor sit amet', self::$client->getMetadata($file)->title);
+        }
+    }
+    /**
+     * Metadata author test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataAuthor($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertEquals('David Martínez', self::$client->getMetadata($file)->author);
+        }
+    }
+    /**
+     * Metadata dates test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataCreated($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertInstanceOf('DateTime', self::$client->getMetadata($file)->created);
+        }
+    }
+    /**
+     * Metadata dates test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataUpdated($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertInstanceOf('DateTime', self::$client->getMetadata($file)->updated);
+        }
+    }
+    /**
+     * Metadata keywords test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMetadataKeywords($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertContains('ipsum', self::$client->getMetadata($file)->keywords);
+        }
+    }
+    /**
+     * Language test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentLanguage($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') < 0)
+        {
+            $this->markTestSkipped('Apache Tika ' . self::$version . ' lacks REST language identification');
+        }
+        else
+        {
+            $this->assertRegExp('/^[a-z]{2}$/', self::$client->getLanguage($file));
+        }
+    }
+    /**
+     * MIME test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMIME($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertNotEmpty(self::$client->getMIME($file));
+        }
+    }
+    /**
+     * HTML test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentHTML($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertContains('Zenonis est, inquam, hoc Stoici', self::$client->getHTML($file));
+        }
+    }
+    /**
+     * Text test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentText($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertContains('Zenonis est, inquam, hoc Stoici', self::$client->getText($file));
+        }
+    }
+    /**
+     * Main text test
+     *
+     * @dataProvider    documentProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDocumentMainText($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.15') < 0)
+        {
+            $this->markTestSkipped('Apache Tika ' . self::$version . ' lacks main content extraction');
+        }
+        else
+        {
+            $this->assertContains('Lorem ipsum dolor sit amet', self::$client->getMainText($file));
+        }
+    }
+    /**
+     * Metadata test
+     *
+     * @dataProvider    imageProvider
+     *
+     * @param   string $file
+     * @param   string $class
+     * @throws  \Exception
+     */
+    public function testImageMetadata($file, $class = 'ImageMetadata')
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.14') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.14 throws "Expected \';\', got \',\'> when parsing some images');
+        }
+        else
+        {
+            $this->testMetadata($file, $class);
+        }
+    }
+    /**
+     * Metadata width test
+     *
+     * @dataProvider    imageProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testImageMetadataWidth($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.14') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.14 throws "Expected \';\', got \',\'> when parsing some images');
+        }
+        else
+        {
+            $meta = self::$client->getMetadata($file);
+            $this->assertEquals(1600, $meta->width, basename($file));
+        }
+    }
+    /**
+     * Metadata height test
+     *
+     * @dataProvider    imageProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testImageMetadataHeight($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.14') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.14 throws "Expected \';\', got \',\'> when parsing some images');
+        }
+        else
+        {
+            $meta = self::$client->getMetadata($file);
+            $this->assertEquals(900, $meta->height, basename($file));
+        }
+    }
+    /**
+     * OCR test
+     *
+     * @dataProvider    ocrProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testImageOCR($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.14') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.14 throws "Expected \';\', got \',\'> when parsing some images');
+        }
+        else
+        {
+            $text = self::$client->getText($file);
+            $this->assertRegExp('/voluptate/i', $text);
+        }
+    }
+    /**
+     * Text callback test
+     *
+     * @dataProvider    callbackProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testTextCallback($file)
+    {
+        $client =& self::$client;
+    if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            BaseTest::$shared = 0;
+            self::$client->getText($file, [$this, 'callableCallback']);
+            $this->assertGreaterThan(1, BaseTest::$shared);
+        }
+    }
+    /**
+     * Main text callback test
+     *
+     * @dataProvider    callbackProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testMainTextCallback($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.15') < 0)
+        {
+            $this->markTestSkipped('Apache Tika ' . self::$version . ' lacks main content extraction');
+        }
+        else
+        {
+            BaseTest::$shared = 0;
+            self::$client->getMainText($file, function ($chunk) {
+                BaseTest::$shared++;
+            });
+            $this->assertGreaterThan(1, BaseTest::$shared);
+        }
+    }
+    /**
+     * Main text callback test
+     *
+     * @dataProvider    callbackProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testHtmlCallback($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            BaseTest::$shared = 0;
+            self::$client->getHtml($file, function($chunk)
+            {
+                BaseTest::$shared++;
+            });
+            $this->assertGreaterThan(1, BaseTest::$shared);
+        }
+    }
+    /**
+     * Remote file test with integrated download
+     *
+     * @dataProvider    remoteProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testRemoteDocumentText($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        else
+        {
+            $this->assertContains('This is a small demonstration .pdf file', $client->getText($file));
+        }
+    }
+    /**
+     * Remote file test with internal downloader
+     *
+     * @dataProvider    remoteProvider
+     *
+     * @param   string $file
+     * @throws  \Exception
+     */
+    public function testDirectRemoteDocumentText($file)
+    {
+        $client =& self::$client;
+        if($client::MODE == 'web' && version_compare(self::$version, '1.9') == 0)
+        {
+            $this->markTestSkipped('Apache Tika 1.9 throws random "Error while processing document" errors');
+        }
+        elseif($client::MODE == 'web' && version_compare(self::$version, '1.15') < 0)
+        {
+            $this->markTestSkipped('Apache Tika between 1.10 and 1.14 doesn\'t supports unsecure features');
+        }
+        else
+        {
+            $client->setDownloadRemote(false);
+            $this->assertContains('This is a small demonstration .pdf file', $client->getText($file));
+        }
+        $client->setEncoding('UTF-8');
+        $this->assertThat($client->getText($file), $this->logicalAnd
+        (
+            $this->stringContains('L’espéranto'),
+            $this->stringContains('世界語'),
+            $this->stringContains('Эспера́нто')
+        ));
+    }
     /**
      * Test available detectors
+     *
      * @throws  \Exception
      */
     public function testAvailableDetectors()
+    {
         $this->assertContains('org.apache.tika.mime.MimeTypes', self::$client->getAvailableDetectors());
+     */
+    public function testAvailableDetectors(): void
+    {
+        $detectors = self::$client->getAvailableDetectors();
+        $this->assertArrayHasKey('org.apache.tika.detect.DefaultDetector', $detectors);
+    }
     /**
      * Test available parsers
+     *
      * @throws  \Exception
      */
     public function testAvailableParsers()
+    {
         $this->assertContains('org.apache.tika.parser.DefaultParser', self::$client->getAvailableParsers());
+     */
+    public function testAvailableParsers(): void
+    {
+        $parsers = self::$client->getAvailableParsers();
+        $this->assertArrayHasKey('org.apache.tika.parser.DefaultParser', $parsers);
+    }
     /**
      * Test supported MIME types
+     *
+     * @throws  \Exception
+     */
+    public function testSupportedMIMETypes()
+    {
+        $this->assertContains('application/x-pdf', self::$client->getSupportedMIMETypes());
+     */
+    public function testSupportedMIMETypes(): void
+    {
+        $this->assertArrayHasKey('application/pdf', self::$client->getSupportedMIMETypes());
+    }
+    /**
+     * Test supported MIME types
+     */
+    public function testIsMIMETypeSupported(): void
+    {
+        $this->assertTrue(self::$client->isMIMETypeSupported('application/pdf'));
+    }
     /**
      * Static method to test callback
+     *
+     * @param   string  $chunk
+     */
+    public static function callableCallback($chunk)
+     */
+    public static function callableCallback(): void
+    {
         BaseTest::$shared++;
 …
     /**
      * Document file provider
+     *
+     * @return  array
+     */
+    public function documentProvider()
+     */
+    public function documentProvider(): array
+    {
         return $this->samples('sample1');
 …
     /**
      * Image file provider
+     *
+     * @return array
+     */
+    public function imageProvider()
+     */
+    public function imageProvider(): array
+    {
         return $this->samples('sample2');
 …
     /**
      * File provider for OCR testing
+     *
+     * @return array
+     */
+    public function ocrProvider()
+     */
+    public function ocrProvider(): array
+    {
         return $this->samples('sample3');
 …
     /**
      * File provider for callback testing
+     *
+     * @return array
+     */
+    public function callbackProvider()
+     */
+    public function callbackProvider(): array
+    {
         return $this->samples('sample5');
 …
     /**
      * File provider for remote testing
+     *
+     * @return array
+     */
+    public function remoteProvider()
+     */
+    public function remoteProvider(): array
+    {
         return
+        [
+            [
                 'http://www.africau.edu/images/default/sample.pdf'
+                'https://raw.githubusercontent.com/vaites/php-apache-tika/master/samples/sample6.pdf'
+            ]
         ];
 …
     /**
+     * File provider for encoding testing
+     */
+    public function encodingProvider(): array
+    {
+        return $this->samples('sample7');
+    }
+    /**
+     * File provider for recursive testing
+     */
+    public function recursiveProvider(): array
+    {
+        return $this->samples('sample8');
+    }
+    /**
      * File provider using "samples" folder
+     *
+     * @param   string $sample
+     * @return  array
+     */
+    protected function samples($sample)
+     */
+    protected function samples(string $sample): array
+    {
         $samples = [];

redisearch/trunk/vendor/vaites/php-apache-tika/tests/CLITest.php

-                      r2002534
+                      r2525480
      * Create shared instances of clients
      */
     public static function setUpBeforeClass()
+    public static function setUpBeforeClass(): void
+    {
         self::$client = Client::make(self::getPathForVersion(self::$version));
 …
     /**
+     * XHTML test
+     *
+     * @dataProvider encodingProvider
+     */
+    public function testDocumentHTML(string $file): void
+    {
+        $this->assertStringStartsWith('<?xml version="1.0"', self::$client->getXHTML($file));
+    }
+    /**
      * Set path test
      */
     public function testSetPath()
+    public function testSetPath(): void
+    {
         $client = Client::make(self::getPathForVersion('1.0'));
+        $path = self::getPathForVersion(self::$version);
+        $this->assertEquals(self::getPathForVersion('1.0'), $client->getPath());
+        $client = Client::make($path);
+        $this->assertEquals($path, $client->getPath());
+    }
 …
      * Set Java test
      */
     public function testSetPort()
+    public function testSetBinary(): void
+    {
         $client = Client::make(self::getPathForVersion('1.0'), '/opt/jdk/bin/java');
+        $path = self::getPathForVersion(self::$version);
+        $this->assertEquals('/opt/jdk/bin/java', $client->getJava());
+        $client = Client::make($path, 'java');
+        $this->assertEquals('java', $client->getJava());
+    }
+    /**
+     * Set Java test
+     */
+    public function testSetArguments(): void
+    {
+        $path = self::getPathForVersion(self::$version);
+        $client = Client::make($path);
+        $client->setJavaArgs('-JXmx4g');
+        $this->assertEquals('-JXmx4g', $client->getJavaArgs());
+    }
+    /**
+     * Test delayed check
+     */
+    public function testDelayedCheck(): void
+    {
+        $path = self::getPathForVersion(self::$version);
+        $client = Client::prepare('/nonexistent/path/to/apache-tika.jar');
+        $client->setPath($path);
+        $this->assertStringEndsWith(self::$version, $client->getVersion());
+    }
     /**
      * Get the full path of Tika app for a specified version
+     *
-     * @param   string  $version
-     * @return  string
      */
     private static function getPathForVersion($version)
+    private static function getPathForVersion(string $version): string
+    {
         return self::$binaries . "/tika-app-{$version}.jar";

redisearch/trunk/vendor/vaites/php-apache-tika/tests/CommonTest.php

-                      r2002534
+                      r2525480
 <?php namespace Vaites\ApacheTika\Tests;
 use PHPUnit_Framework_TestCase;
+use PHPUnit\Framework\TestCase;
 use Vaites\ApacheTika\Client;
 …
  * Common test functionality
  */
 class CommonTest extends PHPUnit_Framework_TestCase
+class CommonTest extends TestCase
+{
     /**
 …
     /**
      * Get env variables
+     *
-     * @param null      $name
-     * @param array     $data
-     * @param string    $dataName
-     * @throws \Exception
      */
     public function __construct($name = null, array $data = array(), $dataName = '')
+    public function __construct(string $name = null, array $data = array(), $dataName = '')
+    {
         self::$version = getenv('APACHE_TIKA_VERSION');
 …
      * Set chunk size test
      */
     public function testSetChunkSize()
+    public function testSetChunkSize(): void
+    {
         self::$client->setChunkSize(42);
 …
     /**
+     * Set download remote
+     */
+    public function testDownloadRemote(): void
+    {
+        self::$client->setDownloadRemote(true);
+        $this->assertTrue(self::$client->getDownloadRemote());
+    }
+    /**
      * Set callback (closure) test
      */
     public function testSetClosureCallback()
+    public function testSetClosureCallback(): void
+    {
         self::$client->setCallback(function($chunk)
 …
      * Set callback (callable) test
      */
     public function testSetCallableCallback()
+    public function testSetCallableCallback(): void
+    {
         self::$client->setCallback('trim');
 …
      * Get supported versions test
      */
     public function testGetSupportedVersions()
+    public function testGetSupportedVersions(): void
+    {
         $this->assertTrue(in_array('1.10', Client::getSupportedVersions()));
+        $this->assertTrue(in_array(self::$version, self::$client->getSupportedVersions()));
+    }
 …
      * Is version supported vtest
      */
     public function testIsVersionSupported()
+    public function testIsVersionSupported(): void
+    {
         $this->assertTrue(Client::isVersionSupported('1.10'));
+        $this->assertTrue(self::$client->isVersionSupported(self::$version));
+    }
+}

redisearch/trunk/vendor/vaites/php-apache-tika/tests/ErrorTest.php

-                      r2002534
+                      r2525480
 use Exception;
+use PHPUnit_Framework_TestCase;
+use PHPUnit\Framework\TestCase;
 use Vaites\ApacheTika\Client;
 …
  * Error tests
  */
 class ErrorTest extends PHPUnit_Framework_TestCase
+class ErrorTest extends TestCase
+{
     /**
 …
     /**
      * Get env variables
+     *
+     * @param null      $name
+     * @param array     $data
+     * @param string    $dataName
+     */
+    public function __construct($name = null, array $data = array(), $dataName = '')
+     */
+    public function __construct(string $name = null, array $data = array(), $dataName = '')
+    {
         self::$version = getenv('APACHE_TIKA_VERSION');
 …
      * Test wrong command line mode path
      */
     public function testAppPath()
+    {
         try
+        {
             $client = Client::make('/nonexistent/path/to/apache-tika.jar');
+    public function testAppPath(): void
+    {
+        try
+        {
+            $client = Client::prepare('/nonexistent/path/to/apache-tika.jar');
             $client->getVersion();
+        }
         catch(Exception $exception)
+        {
             $this->assertContains('Unexpected exit value', $exception->getMessage());
+            $this->assertStringContainsString('Apache Tika app JAR not found', $exception->getMessage());
+        }
+    }
 …
      * Test unexpected exit value for command line mode
      */
     public function testAppExitValue()
+    public function testAppExitValue(): void
+    {
         $path = self::getPathForVersion(self::$version);
 …
             rename($path . '.bak', $path);
             $this->assertContains('Unexpected exit value', $exception->getMessage());
+            $this->assertStringContainsString('Unexpected exit value', $exception->getMessage());
+        }
+    }
 …
      * Test invalid Java binary path for command line mode
      */
     public function testAppJavaBinary()
+    public function testJavaBinary(): void
+    {
         $path = self::getPathForVersion(self::$version);
 …
         catch(Exception $exception)
+        {
             $this->assertContains('Unexpected exit value', $exception->getMessage());
+            $this->assertStringContainsString('Java command not found', $exception->getMessage());
+        }
+    }
 …
      * Test wrong server
      */
+    public function testServerConnection()
+    {
+        try
+        {
+            Client::make('localhost', 9997);
+            $this->fail();
+        }
+        catch(Exception $exception)
+        {
+            $this->assertEquals(7, $exception->getCode());
+    public function testServerConnection(): void
+    {
+        try
+        {
+            $client = Client::prepare('localhost', 9997);
+            $client->getVersion();
+            $this->fail();
+        }
+        catch(Exception $exception)
+        {
+            $this->assertThat($exception->getCode(), $this->logicalOr
+            (
+                $this->equalTo(CURLE_COULDNT_CONNECT),
+                $this->equalTo(CURLE_OPERATION_TIMEDOUT)
+            ));
+        }
+    }
 …
      * Test wrong request options
      */
     public function testRequestOptions()
+    {
         try
+        {
             $client = Client::make('localhost', 9998, [CURLOPT_PROXY => 'localhost']);
+    public function testRequestOptions(): void
+    {
+        try
+        {
+            $client = Client::make('localhost', 9998);
             $client->request('bad');
 …
         catch(Exception $exception)
+        {
             $this->assertEquals(7, $exception->getCode());
+            $this->assertStringContainsString('Unknown type bad', $exception->getMessage());
+        }
+    }
 …
      * Test invalidrequest options
      */
     public function testRequestRestrictedOptions()
+    {
         try
+        {
             $client = Client::make('localhost', 9998, [CURLOPT_PUT => false]);
+    public function testRequestRestrictedOptions(): void
+    {
+        try
+        {
+            Client::make('localhost', 9998, [CURLOPT_PUT => false]);
+        }
         catch(Exception $exception)
 …
     /**
+     * Test wrong recursive metadata type
+     */
+    public function testRequestMetadataType(): void
+    {
+        try
+        {
+            $client = Client::make('localhost', 9998);
+            $client->getRecursiveMetadata(dirname(__DIR__) . '/samples/sample3.png', 'bad');
+            $this->fail();
+        }
+        catch(Exception $exception)
+        {
+            $this->assertStringContainsString('Unknown recursive type', $exception->getMessage());
+        }
+    }
+    /**
      * Test unsupported media type
+     */
+    public function testUnsupportedMedia()
+     *
+     * NOTE: return value was changed in version 1.23
+     *
+     * @link    https://github.com/apache/tika/blob/master/CHANGES.txt
+     */
+    public function testUnsupportedMedia(): void
+    {
         try
 …
         catch(Exception $exception)
+        {
+            $this->assertEquals(415, $exception->getCode());
+        }
+    }
+    /**
+     * Test invalid callback
+     */
+    public function testInvalidCallback()
+    {
+        try
+        {
+            $client = Client::make(self::$binaries . '/tika-app-' . self::$version . '.jar');
+            $client->setCallback('unknown_function');
+        }
+        catch(Exception $exception)
+        {
+            $this->assertContains('Invalid callback', $exception->getMessage());
+            if(version_compare(self::$version, '1.23') < 0)
+            {
+                $this->assertEquals(415, $exception->getCode());
+            }
+            else
+            {
+                $this->assertEquals(0, $exception->getCode());
+            }
+        }
+    }
+    /**
+     * Test unknown recursive metadata type
+     */
+    public function testUnknownRecursiveMetadataType(): void
+    {
+        try
+        {
+            $client = Client::make('localhost', 9998);
+            $client->getRecursiveMetadata('example.doc', 'error');
+            $this->fail();
+        }
+        catch(Exception $exception)
+        {
+            $this->assertStringContainsString('Unknown recursive type', $exception->getMessage());
+        }
+    }
 …
      * Test invalid chunk size
      */
+    public function testInvalidChunkSize()
+    {
+        try
+        {
+            $client = Client::make(self::$binaries . '/tika-app-' . self::$version . '.jar');
+            $client->setChunkSize('string');
+        }
+        catch(Exception $exception)
+        {
+            $this->assertContains('is not a valid chunk size', $exception->getMessage());
+        }
+    }
+    /**
+     * Test invalid chunk size
+     */
+    public function testUnsupportedChunkSize()
+    public function testUnsupportedChunkSize(): void
+    {
         try
 …
         catch(Exception $exception)
+        {
+            $this->assertContains('Chunk size is not supported', $exception->getMessage());
+        }
+    }
+    /**
+     * Test invalid metadata
+     */
+    public function testInvalidMetadata()
+    {
+        try
+        {
+            $metadata = Metadata::make('InvalidJsonString', './samples/sample1.doc');
+        }
+        catch(Exception $exception)
+        {
+            $this->assertEquals(JSON_ERROR_SYNTAX, $exception->getCode());
+        }
+    }
+    /**
+     * Test empty metadata
+     */
+    public function testEmptyMetadata()
+    {
+        try
+        {
+            $metadata = Metadata::make('', './samples/sample1.doc');
+        }
+        catch(Exception $exception)
+        {
+            $this->assertContains('Empty response', $exception->getMessage());
+            $this->assertStringContainsString('Chunk size is not supported', $exception->getMessage());
+        }
+    }
 …
+     *
      * @dataProvider    parameterProvider
+     *
+     * @param   array   $parameters
+     */
+    public function testRequestType($parameters)
+     */
+    public function testRequestType(array $parameters): void
+    {
         try
 …
         catch(Exception $exception)
+        {
             $this->assertContains('Unknown type bad', $exception->getMessage());
+            $this->assertStringContainsString('Unknown type bad', $exception->getMessage());
+        }
+    }
 …
+     *
      * @dataProvider    parameterProvider
+     *
+     * @param   array   $parameters
+     */
+    public function testLocalFile($parameters)
+     */
+    public function testLocalFile(array $parameters): void
+    {
         try
 …
+     *
      * @dataProvider    parameterProvider
+     *
+     * @param   array   $parameters
+     */
+    public function testRemoteFile($parameters)
+     */
+    public function testRemoteFile(array $parameters): void
+    {
         try
 …
     /**
      * Client parameters provider
+     *
+     * @return array
+     */
+    public function parameterProvider()
+     */
+    public function parameterProvider(): array
+    {
         return
 …
     /**
      * Get the full path of Tika app for a specified version
+     *
+     * @param   string  $version
+     * @return  string
+     */
+    private static function getPathForVersion($version)
+     */
+    private static function getPathForVersion(string $version): string
+    {
         return self::$binaries . "/tika-app-{$version}.jar";

redisearch/trunk/vendor/vaites/php-apache-tika/tests/WebTest.php

-                      r2002534
+                      r2525480
      * Start Tika server and create shared instance of clients
      */
     public static function setUpBeforeClass()
+    public static function setUpBeforeClass(): void
+    {
         self::$client = Client::make('localhost', 9998, [CURLOPT_TIMEOUT => 30]);
 …
      * cURL multiple options test
      */
     public function testCurlOptions()
+    public function testCurlOptions(): void
+    {
         $client = Client::make('localhost', 9998, [CURLOPT_TIMEOUT => 3]);
 …
      * cURL single option test
      */
     public function testCurlSingleOption()
+    public function testCurlSingleOption(): void
+    {
         $client = Client::make('localhost', 9998)->setOption(CURLOPT_TIMEOUT, 3);
 …
      * cURL timeout option test
      */
     public function testCurlTimeoutOption()
+    public function testCurlTimeoutOption(): void
+    {
         $client = Client::make('localhost', 9998)->setTimeout(3);
 …
      * cURL headers test
      */
     public function testCurlHeaders()
+    public function testCurlHeaders(): void
+    {
         $header = 'Content-Type: image/jpeg';
 …
      * Set host test
      */
     public function testSetHost()
+    public function testSetHost(): void
+    {
         $client = Client::make('localhost', 9998);
 …
      * Set port test
      */
     public function testSetPort()
+    public function testSetPort(): void
+    {
         $client = Client::make('localhost', 9998);
 …
     /**
+     * Set url host test
+     */
+    public function testSetUrlHost(): void
+    {
+        $client = Client::make('http://localhost:9998');
+        $this->assertEquals('localhost', $client->getHost());
+    }
+    /**
+     * Set url port test
+     */
+    public function testSetUrlPort(): void
+    {
+        $client = Client::make('http://localhost:9998');
+        $this->assertEquals(9998, $client->getPort());
+    }
+    /**
      * Set retries test
      */
     public function testRetriesPort()
+    public function testSetRetries(): void
+    {
         $client = Client::make('localhost', 9998);
 …
         $this->assertEquals(5, $client->getRetries());
+    }
+    /**
+     * Test delayed check
+     */
+    public function testDelayedCheck(): void
+    {
+        $client = Client::prepare('localhost', 9997);
+        $client->setPort(9998);
+        $this->assertStringEndsWith(self::$version, $client->getVersion());
+    }
+}

redisearch/trunk/wp-redisearch.php

-                      r2455651
+                      r2525480
 /*
 Plugin Name: RediSearch
 Version: 0.3.2
+Version: 0.3.3
 Description: Replace Wordpress search by RediSearch.
 Author: Foad Yousefi
 …
 // Plugin version .
 if ( ! defined( 'WPRS_VERSION' ) ) {
     define( 'WPRS_VERSION', '0.3.2' );
+    define( 'WPRS_VERSION', '0.3.3' );
+}

Context Navigation

Legend:

Download in other formats: