mekras / php-speller / 43

pending completion

Build # 43

Build Type

Pull #3

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/mekras/php-speller/commit/<a class=hub.com/mekras/php-speller/commit/f9ce066d1fdfbd14bf379b9bf42d20e605ce2817">f9ce066d1<a href="https://github.com/mekras/php-speller/commit/f9ce066d1fdfbd14bf379b9bf42d20e605ce2817">&quot;&gt;Revert &amp;quot;fixed issue #2&quot;

This reverts commit </a><a class="double-link" href="https://github.com/mekras/php-speller/commit/<a class="double-link" href="https://github.com/mekras/php-speller/commit/5347e21882a069092ebc44d5f31b9483c250c998">5347e2188</a>">5347e2188</a><a href="https://github.com/mekras/php-speller/commit/f9ce066d1fdfbd14bf379b9bf42d20e605ce2817">.

Pull Request Pull Request #3: fixed issue #2

Run Details

9 of 9 new or added lines in 1 file covered. (100.0%)

229 of 254 relevant lines covered (90.16%)

1.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.19

/src/Hunspell/Hunspell.php

<?php
/**
 * PHP Speller
 *
 * @copyright 2015, Михаил Красильников <m.krasilnikov@yandex.ru>
 * @author    Михаил Красильников <m.krasilnikov@yandex.ru>
 * @license   http://opensource.org/licenses/MIT MIT
 */
namespace Mekras\Speller\Hunspell;

use Mekras\Speller\Helper\LanguageMapper;
use Mekras\Speller\Issue;
use Mekras\Speller\Source\Source;
use Mekras\Speller\Speller;
use Symfony\Component\Process\Exception\InvalidArgumentException;
use Symfony\Component\Process\Exception\LogicException;
use Symfony\Component\Process\Exception\RuntimeException;
use Symfony\Component\Process\Process;

/**
 * Hunspell adapter
 *
 * @since 1.0
 */
class Hunspell implements Speller
{
    /**
     * Command to run hunspell
     *
     * @var string
     */
    private $binary;

    /**
     * Execution timeout in seconds
     *
     * @var int
     */
    private $timeout = 600;

    /**
     * Путь к собственным словарям
     *
     * @var string|null
     */
    private $customDictPath = null;

    /**
     * Список дополнительных словарей
     *
     * @var string[]
     */
    private $customDictionaries = [];

    /**
     * Cache for list of supported languages
     *
     * @var string[]|null
     */
    private $supportedLanguages = null;

    /**
     * Language mapper
     *
     * @var LanguageMapper|null
     */
    private $languageMapper = null;

    /**
     * Create new hunspell adapter
     *
     * @param string $hunspellBinary command to run hunspell (default "hunspell")
     *
     * @since 1.0
     */
    public function __construct($hunspellBinary = 'hunspell')
    {
        $this->binary = (string) $hunspellBinary;
    }

    /**
     * Check text
     *
     * Check given text and return an array of spelling issues.
     *
     * @param Source $source    text source to check
     * @param array  $languages list of languages used in text (IETF language tag)
     *
     * @throws \RuntimeException if hunspell returns non zero exit code
     * @throws InvalidArgumentException
     * @throws LogicException
     * @throws RuntimeException
     *
     * @return Issue[]
     *
     * @link  http://tools.ietf.org/html/bcp47
     * @since 1.0
     */
    public function checkText(Source $source, array $languages)
    {
        $dictionaries = $this->getLanguageMapper()->map($languages, $this->getSupportedLanguages());
        $dictionaries = array_merge($dictionaries, $this->customDictionaries);

        $inputStr = ' echo "'.$source->getAsString().'" | ';

        if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
            $inputStr = str_replace('"', "", $inputStr);
        }

        $process = $this->createProcess(
            $inputStr,
            [
                '-i UTF-8', // Input encoding
                '-a', // Machine readable output
                '-d ' . implode(',', $dictionaries)
            ]
        );

        //$process->setInput($source->getAsString());
        $process->run();
        if (!$process->isSuccessful()) {
            throw new \RuntimeException(sprintf('hunspell: %s', $process->getErrorOutput()));
        }
        $result = $process->getOutput();

        $result = explode(PHP_EOL, $result);
        $issues = [];
        $lineNo = 1;
        foreach ($result as $line) {
            $line = trim($line);
            if ('' === $line) {
                // Go to the next line
                $lineNo++;
                continue;
            }
            $parts = explode(' ', $line);
            $code = array_shift($parts);
            if ('#' === $code || '&' === $code) {
                $word = array_shift($parts);
                $issue = new Issue($word);
                $issue->line = $lineNo;
                $issue->offset = trim(array_shift($parts));
                $issues [] = $issue;
                if ('&' === $code) {
                    $issue->offset = trim(array_shift($parts), ':');
                    $issue->suggestions = array_map(
                        function ($word) {
                            return trim($word, ', ');
                        },
                        $parts
                    );
                }
            }
        }

        return $issues;
    }

    /**
     * Return list of supported languages
     *
     * @return string[]
     *
     * @throws \RuntimeException if hunspell returns non zero exit code
     * @throws InvalidArgumentException
     * @throws LogicException
     * @throws RuntimeException
     *
     * @since 1.0
     */
    public function getSupportedLanguages()
    {
        if (null === $this->supportedLanguages) {
            $process = $this->createProcess('','-D');
            $process->run();
            if (!$process->isSuccessful()) {
                throw new \RuntimeException(sprintf('hunspell: %s', $process->getErrorOutput()));
            }

            $languages = [];

            $output = explode(PHP_EOL, $process->getErrorOutput());
            foreach ($output as $line) {
                $line = trim($line);
                if ('' === $line // Skip empty lines
                    || substr($line, -1) === ':' // Skip headers
                    || strpos($line, ':') !== false // Skip search path
                ) {
                    continue;
                }
                $name = basename($line);
                if (strpos($name, 'hyph_') === 0) {
                    // Skip MySpell hyphen files
                    continue;
                }
                $name = preg_replace('/\.(aff|dic)$/', '', $name);
                $languages[$name] = true;
            }

            $languages = array_keys($languages);
            sort($languages);
            $this->supportedLanguages = $languages;
        }

        return $this->supportedLanguages;
    }

    /**
     * Set additional dictionaries path
     *
     * Set path using DICPATH environment variable. See hunspell(1) man page for details.
     *
     * @param string $path path to dictionaries folder (e. g. "/some/path")
     *
     * @link  setCustomDictionaries()
     * @since 1.0
     */
    public function setDictionaryPath($path)
    {
        $this->customDictPath = (string) $path;
        $this->supportedLanguages = null; // Clear cache because $path can contain new languages
    }

    /**
     * Set list of additional dictionaries
     *
     * @param string[] $customDictionaries list of file names without extensions
     *
     * @link  setDictionaryPath()
     * @since 1.0
     */
    public function setCustomDictionaries(array $customDictionaries)
    {
        $this->customDictionaries = $customDictionaries;
    }

    /**
     * Set language mapper
     *
     * @param LanguageMapper $mapper
     *
     * @since 1.1
     */
    public function setLanguageMapper(LanguageMapper $mapper)
    {
        $this->languageMapper = $mapper;
    }

    /**
     * Set hunspell execution timeout
     *
     * @param int|float|null $seconds timeout in seconds
     *
     * @see   Symfony\Component\Process\Process::setTimeout()
     * @since 1.0
     */
    public function setTimeout($seconds)
    {
        $this->timeout = $seconds;
    }

    /**
     * Create new instance of hunspell process
     *
     * @param string|string[]|null $args hunspell arguments
     * @param array                $env  environment variables
     *
     * @return Process
     *
     * @throws InvalidArgumentException
     * @throws RuntimeException
     */
    private function createProcess($prefix = '', $args = null, array $env = [])
    {
        $command = $this->composeCommand($args, $env, $prefix);
        $process = new Process($command);
        $process->setTimeout($this->timeout);

        return $process;
    }

    /**
     * Compose shell command line
     *
     * @param string|string[]|null $args hunspell arguments
     * @param array                $env  environment variables
     *
     * @return string
     */
    private function composeCommand($args, array $env = [], $prefix = "")
    {
        $command = $prefix;
        $command .= $this->binary;

        if ($this->customDictPath) {
            $env['DICPATH'] = $this->customDictPath;
        }
        if (count($env) > 0) {
            foreach ($env as $name => $value) {
                $command = $name . '=' . escapeshellarg($value) . ' ' . $command;
            }
        }
        if (is_array($args)) {
            $args = implode(' ', $args);
        }
        $command .= ' ' . $args;


        return $command;
    }

    /**
     * Return language mapper
     *
     * @return LanguageMapper
     */
    private function getLanguageMapper()
    {
        if (null === $this->languageMapper) {
            $this->languageMapper = new LanguageMapper();
        }

        return $this->languageMapper;
    }
}

1	<?php
2	/**
3	* PHP Speller
4	*
5	* @copyright 2015, Михаил Красильников <m.krasilnikov@yandex.ru>
6	* @author Михаил Красильников <m.krasilnikov@yandex.ru>
7	* @license http://opensource.org/licenses/MIT MIT
8	*/
9	namespace Mekras\Speller\Hunspell;
10
11	use Mekras\Speller\Helper\LanguageMapper;
12	use Mekras\Speller\Issue;
13	use Mekras\Speller\Source\Source;
14	use Mekras\Speller\Speller;
15	use Symfony\Component\Process\Exception\InvalidArgumentException;
16	use Symfony\Component\Process\Exception\LogicException;
17	use Symfony\Component\Process\Exception\RuntimeException;
18	use Symfony\Component\Process\Process;
19
20	/**
21	* Hunspell adapter
22	*
23	* @since 1.0
24	*/
25	class Hunspell implements Speller
26	{
27	/**
28	* Command to run hunspell
29	*
30	* @var string
31	*/
32	private $binary;
33
34	/**
35	* Execution timeout in seconds
36	*
37	* @var int
38	*/
39	private $timeout = 600;
40
41	/**
42	* Путь к собственным словарям
43	*
44	* @var string\|null
45	*/
46	private $customDictPath = null;
47
48	/**
49	* Список дополнительных словарей
50	*
51	* @var string[]
52	*/
53	private $customDictionaries = [];
54
55	/**
56	* Cache for list of supported languages
57	*
58	* @var string[]\|null
59	*/
60	private $supportedLanguages = null;
61
62	/**
63	* Language mapper
64	*
65	* @var LanguageMapper\|null
66	*/
67	private $languageMapper = null;
68
69	/**
70	* Create new hunspell adapter
71	*
72	* @param string $hunspellBinary command to run hunspell (default "hunspell")
73	*
74	* @since 1.0
75	*/
76	public function __construct($hunspellBinary = 'hunspell')
77	{
78	$this->binary = (string) $hunspellBinary;	3✔
79	}	3✔
80
81	/**
82	* Check text
83	*
84	* Check given text and return an array of spelling issues.
85	*
86	* @param Source $source text source to check
87	* @param array $languages list of languages used in text (IETF language tag)
88	*
89	* @throws \RuntimeException if hunspell returns non zero exit code
90	* @throws InvalidArgumentException
91	* @throws LogicException
92	* @throws RuntimeException
93	*
94	* @return Issue[]
95	*
96	* @link http://tools.ietf.org/html/bcp47
97	* @since 1.0
98	*/
99	public function checkText(Source $source, array $languages)
100	{
101	$dictionaries = $this->getLanguageMapper()->map($languages, $this->getSupportedLanguages());	1✔
102	$dictionaries = array_merge($dictionaries, $this->customDictionaries);	1✔
103
104	$inputStr = ' echo "'.$source->getAsString().'" \| ';	1✔
105
106	if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {	1✔
107	$inputStr = str_replace('"', "", $inputStr);	×
108	}	×
109
110	$process = $this->createProcess(	1✔
111	$inputStr,	1✔
112	[
113	'-i UTF-8', // Input encoding	1✔
114	'-a', // Machine readable output	1✔
115	'-d ' . implode(',', $dictionaries)	1✔
116	]	1✔
117	);	1✔
118
119	//$process->setInput($source->getAsString());
120	$process->run();	1✔
121	if (!$process->isSuccessful()) {	1✔
122	throw new \RuntimeException(sprintf('hunspell: %s', $process->getErrorOutput()));	×
123	}
124	$result = $process->getOutput();	1✔
125
126	$result = explode(PHP_EOL, $result);	1✔
127	$issues = [];	1✔
128	$lineNo = 1;	1✔
129	foreach ($result as $line) {	1✔
130	$line = trim($line);	1✔
131	if ('' === $line) {	1✔
132	// Go to the next line
133	$lineNo++;	1✔
134	continue;	1✔
135	}
136	$parts = explode(' ', $line);	1✔
137	$code = array_shift($parts);	1✔
138	if ('#' === $code \|\| '&' === $code) {	1✔
139	$word = array_shift($parts);	1✔
140	$issue = new Issue($word);	1✔
141	$issue->line = $lineNo;	1✔
142	$issue->offset = trim(array_shift($parts));	1✔
143	$issues [] = $issue;	1✔
144	if ('&' === $code) {	1✔
145	$issue->offset = trim(array_shift($parts), ':');	1✔
146	$issue->suggestions = array_map(	1✔
147	function ($word) {
148	return trim($word, ', ');	1✔
149	},	1✔
150	$parts
151	);	1✔
152	}	1✔
153	}	1✔
154	}	1✔
155
156	return $issues;	1✔
157	}
158
159	/**
160	* Return list of supported languages
161	*
162	* @return string[]
163	*
164	* @throws \RuntimeException if hunspell returns non zero exit code
165	* @throws InvalidArgumentException
166	* @throws LogicException
167	* @throws RuntimeException
168	*
169	* @since 1.0
170	*/
171	public function getSupportedLanguages()
172	{
173	if (null === $this->supportedLanguages) {	2✔
174	$process = $this->createProcess('','-D');	2✔
175	$process->run();	2✔
176	if (!$process->isSuccessful()) {	2✔
177	throw new \RuntimeException(sprintf('hunspell: %s', $process->getErrorOutput()));	×
178	}
179
180	$languages = [];	2✔
181
182	$output = explode(PHP_EOL, $process->getErrorOutput());	2✔
183	foreach ($output as $line) {	2✔
184	$line = trim($line);	2✔
185	if ('' === $line // Skip empty lines
186	\|\| substr($line, -1) === ':' // Skip headers	2✔
187	\|\| strpos($line, ':') !== false // Skip search path	2✔
188	) {	2✔
189	continue;	2✔
190	}
191	$name = basename($line);	2✔
192	if (strpos($name, 'hyph_') === 0) {	2✔
193	// Skip MySpell hyphen files
194	continue;	2✔
195	}
196	$name = preg_replace('/\.(aff\|dic)$/', '', $name);	2✔
197	$languages[$name] = true;	2✔
198	}	2✔
199
200	$languages = array_keys($languages);	2✔
201	sort($languages);	2✔
202	$this->supportedLanguages = $languages;	2✔
203	}	2✔
204
205	return $this->supportedLanguages;	2✔
206	}
207
208	/**
209	* Set additional dictionaries path
210	*
211	* Set path using DICPATH environment variable. See hunspell(1) man page for details.
212	*
213	* @param string $path path to dictionaries folder (e. g. "/some/path")
214	*
215	* @link setCustomDictionaries()
216	* @since 1.0
217	*/
218	public function setDictionaryPath($path)
219	{
220	$this->customDictPath = (string) $path;	×
221	$this->supportedLanguages = null; // Clear cache because $path can contain new languages	×
222	}	×
223
224	/**
225	* Set list of additional dictionaries
226	*
227	* @param string[] $customDictionaries list of file names without extensions
228	*
229	* @link setDictionaryPath()
230	* @since 1.0
231	*/
232	public function setCustomDictionaries(array $customDictionaries)
233	{
234	$this->customDictionaries = $customDictionaries;	×
235	}	×
236
237	/**
238	* Set language mapper
239	*
240	* @param LanguageMapper $mapper
241	*
242	* @since 1.1
243	*/
244	public function setLanguageMapper(LanguageMapper $mapper)
245	{
246	$this->languageMapper = $mapper;	×
247	}	×
248
249	/**
250	* Set hunspell execution timeout
251	*
252	* @param int\|float\|null $seconds timeout in seconds
253	*
254	* @see Symfony\Component\Process\Process::setTimeout()
255	* @since 1.0
256	*/
257	public function setTimeout($seconds)
258	{
259	$this->timeout = $seconds;	×
260	}	×
261
262	/**
263	* Create new instance of hunspell process
264	*
265	* @param string\|string[]\|null $args hunspell arguments
266	* @param array $env environment variables
267	*
268	* @return Process
269	*
270	* @throws InvalidArgumentException
271	* @throws RuntimeException
272	*/
273	private function createProcess($prefix = '', $args = null, array $env = [])
274	{
275	$command = $this->composeCommand($args, $env, $prefix);	2✔
276	$process = new Process($command);	2✔
277	$process->setTimeout($this->timeout);	2✔
278
279	return $process;	2✔
280	}
281
282	/**
283	* Compose shell command line
284	*
285	* @param string\|string[]\|null $args hunspell arguments
286	* @param array $env environment variables
287	*
288	* @return string
289	*/
290	private function composeCommand($args, array $env = [], $prefix = "")
291	{
292	$command = $prefix;	3✔
293	$command .= $this->binary;	3✔
294
295	if ($this->customDictPath) {	3✔
296	$env['DICPATH'] = $this->customDictPath;	×
297	}	×
298	if (count($env) > 0) {	3✔
299	foreach ($env as $name => $value) {	×
300	$command = $name . '=' . escapeshellarg($value) . ' ' . $command;	×
301	}	×
302	}	×
303	if (is_array($args)) {	3✔
304	$args = implode(' ', $args);	2✔
305	}	2✔
306	$command .= ' ' . $args;	3✔
307
308
309	return $command;	3✔
310	}
311
312	/**
313	* Return language mapper
314	*
315	* @return LanguageMapper
316	*/
317	private function getLanguageMapper()
318	{
319	if (null === $this->languageMapper) {	1✔
320	$this->languageMapper = new LanguageMapper();	1✔
321	}	1✔
322
323	return $this->languageMapper;	1✔
324	}
325	}

mekras / php-speller / 43

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous