YoutubeDl::download() - Code Metrics - Inspection of "Decouple custom YoutubeDl implementation from our..." - gnutix/videos-downloader - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6d49a3...a20a92 )

by Dorian

created 2018-02-11 01:46 UTC

YoutubeDl::download() C

↳ Parent: Project

Complexity

Conditions	12
Paths	10

Size

Total Lines	52
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	52
rs	5.9842
c	0
b	0
f	0
cc	12
eloc	31
nc	10
nop	1

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace App\YoutubeDl;

use Symfony\Component\OptionsResolver\Options;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Process\ExecutableFinder;
use Symfony\Component\Process\Process;
use YoutubeDl\Entity\Video;
use YoutubeDl\Exception\AccountTerminatedException;
use YoutubeDl\Exception\CopyrightException;
use YoutubeDl\Exception\ExecutableNotFoundException;
use YoutubeDl\Exception\NotFoundException;
use YoutubeDl\Exception\PrivateVideoException;
use YoutubeDl\Exception\UrlNotSupportedException;
use YoutubeDl\Exception\YoutubeDlException;

class YoutubeDl
{
    const PROGRESS_PATTERN = '#\[download\]\s+(?<percentage>\d+(?:\.\d+)?%)\s+of\s+(?<size>\d+(?:\.\d+)?(?:K|M|G)iB)(?:\s+at\s+(?<speed>\d+(?:\.\d+)?(?:K|M|G)iB/s))?(?:\s+ETA\s+(?<eta>[\d]{2}:[\d]{2}))?#i';

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

    /**
     * @var string
     */
    protected $binPath;

    /**
     * @var string
     */
    protected $pythonPath;

    /**
     * @var string
     */
    protected $downloadPath;

    /**
     * @var callable
     */
    protected $debug;

    /**
     * @var int
     */
    protected $timeout = 0;

    /**
     * @var array
     */
    protected $allowedAudioFormats = ['best', 'aac', 'vorbis', 'mp3', 'm4a', 'opus', 'wav'];

    /**
     * @var callable
     */
    private $progress;

    private static $blacklist = [
        '#soundcloud.com/.+/sets.+#',
    ];

    public function __construct(array $options = [])
    {
        $resolver = new OptionsResolver();
        $this->configureOptions($resolver);

        $this->options = $resolver->resolve($options);
    }

    public function setBinPath(string $binPath)
    {
        $this->binPath = $binPath;
    }

    public function setPythonPath(string $pythonPath)
    {
        $this->pythonPath = $pythonPath;
    }

    /**
     * @param string $downloadPath Download path without trailing slash
     */
    public function setDownloadPath(string $downloadPath)
    {
        $this->downloadPath = $downloadPath;
    }

    public function debug(callable $debug)
    {
        $this->debug = $debug;
    }

    public function setTimeout(int $timeout)
    {
        $this->timeout = $timeout;
    }

    public function onProgress(callable $onProgress)
    {
        $this->progress = $onProgress;
    }

    public function download(string $url): Video
    {
        if (!$this->downloadPath) {
            throw new \RuntimeException('No download path was set.');
        }

        if (!$this->isUrlSupported($url)) {
            throw new UrlNotSupportedException(sprintf('Provided url "%s" is not supported.', $url));
        }

        $arguments = [
            $url,
            '--no-playlist',
            '--ignore-config',
            '--write-info-json',
        ];

        foreach ($this->options as $option => $value) {
            if ('add-header' === $option) {
                foreach ($value as $header) {
                    $arguments[] = sprintf('--%s=%s', $option, $header);
                }
            } elseif (is_bool($value)) {
                $arguments[] = sprintf('--%s', $option);
            } else {
                $arguments[] = sprintf('--%s=%s', $option, $value);
            }
        }

        $process = $this->createProcess($arguments);

        try {
            $process->mustRun(function ($type, $buffer) {
                $debug = $this->debug;
                $progress = $this->progress;

                if (is_callable($debug)) {
                    $debug($type, $buffer);
                }

                if (is_callable($progress) && Process::OUT === $type && preg_match(self::PROGRESS_PATTERN, $buffer, $matches)) {
                    unset($matches[0], $matches[1], $matches[2], $matches[3], $matches[4]);

                    $progress($matches);
                }
            });
        } catch (\Exception $e) {
            throw $this->handleException($e);
        }

        return $this->processDownload($process);
    }

    public function getExtractorsList(): array
    {
        $process = $this->createProcess(['--list-extractors']);
        $process->mustRun(is_callable($this->debug) ? $this->debug : null);

        return array_filter(explode("\n", $process->getOutput()));
    }

    private function jsonDecode($data): array
    {
        $decoded = json_decode($data, true);

        if (JSON_ERROR_NONE !== json_last_error()) {
            throw new YoutubeDlException(sprintf('Response can\'t be decoded: %s.', $data));
        }

        return $decoded;
    }

    private function processDownload(Process $process): Video
    {
        if (!preg_match('/Writing video description metadata as JSON to:\s(.+)/', $process->getOutput(), $m)) {
            throw new YoutubeDlException('Failed to detect metadata file.');
        }

        $metadataFile = $this->downloadPath.'/'.$m[1];

        $videoData = $this->jsonDecode(trim(file_get_contents($metadataFile)));

        @unlink($metadataFile);

        if (!isset($this->options['skip-download']) || false === $this->options['skip-download']) {
            if (isset($this->options['extract-audio']) && true === $this->options['extract-audio']) {
                $videoData['_filename'] = $this->findFile($videoData['_filename'], implode('|', $this->allowedAudioFormats));
            } elseif (preg_match('/merged into mkv/', $process->getErrorOutput())) {
                $videoData['_filename'] = $this->findFile($videoData['_filename'], 'mkv');
            }

            $videoData['file'] = new \SplFileInfo($this->downloadPath.'/'.$videoData['_filename']);
        } else {
            $videoData['file'] = null;
        }

        return new Video($videoData);
    }

    private function handleException(\Exception $e): \Exception
    {
        $message = $e->getMessage();

        if (preg_match('/please sign in to view this video|video is protected by a password/i', $message)) {
            return new PrivateVideoException();
        } elseif (preg_match('/copyright infringement/i', $message)) {
            return new CopyrightException();
        } elseif (preg_match('/this video does not exist|404/i', $message)) {
            return new NotFoundException();
        } elseif (preg_match('/account associated with this video has been terminated/', $message)) {
            return new AccountTerminatedException();
        }

        return $e;
    }

    private function createProcess(array $arguments = []): Process
    {
        $binPath = $this->binPath ?: (new ExecutableFinder())->find('youtube-dl');

        if (null === $binPath) {
            throw new ExecutableNotFoundException('"youtube-dl" executable was not found. Did you forgot to add it to environment variables? Or set it via $yt->setBinPath(\'/usr/bin/youtube-dl\').');
        }

        array_unshift($arguments, $binPath);

        if ($this->pythonPath) {
            array_unshift($arguments, $this->pythonPath);
        }

        $process = new Process($arguments);
        $process->setTimeout($this->timeout);

        if ($this->downloadPath) {
            $process->setWorkingDirectory($this->downloadPath);
        }

        return $process;
    }

    private function findFile(string $fileName, string $extension)
    {
        $dirName = pathinfo($fileName, PATHINFO_DIRNAME);
        $path = $this->downloadPath.(('.' === $dirName) ? '' : DIRECTORY_SEPARATOR.$dirName);

        $iterator = new \RegexIterator(new \DirectoryIterator($path), sprintf('/%s\.%s$/ui', preg_quote(pathinfo($fileName, PATHINFO_FILENAME), '/'), '('.$extension.')'), \RegexIterator::GET_MATCH);

        $iterator->rewind();

        return (('.' === $dirName) ? '' : $dirName.DIRECTORY_SEPARATOR).$iterator->current()[0];
    }

    private function configureOptions(OptionsResolver $resolver)
    {
        $options = [
            // General options
            'ignore-errors' => 'bool',
            'abort-on-error' => 'bool',
            'default-search' => 'string',
            'force-generic-extractor' => 'bool',
            // Network options
            'proxy' => 'string',
            'socket-timeout' => 'int',
            'source-address' => 'string',
            'force-ipv4' => 'bool',
            'force-ipv6' => 'bool',
            // Video selection options
            'match-title' => 'string',
            'reject-title' => 'string',
            'max-downloads' => 'int',
            'min-filesize' => 'string',
            'max-filesize' => 'string',
            'date' => 'string',
            'datebefore' => 'string',
            'dateafter' => 'string',
            'min-views' => 'int',
            'max-views' => 'int',
            'match-filter' => 'string',
            'download-archive' => 'string',
            'include-ads' => 'bool',
            // Download Options
            'rate-limit' => 'string',
            'retries' => 'int|string',
            'buffer-size' => 'string',
            'no-resize-buffer' => 'bool',
            'xattr-set-filesize' => 'bool',
            'hls-prefer-native' => 'bool',
            'external-downloader' => 'string',
            'external-downloader-args' => 'string',
            // Filesystem Options
            'batch-file' => 'string',
            'output' => 'string',
            'autonumber-size' => 'int',
            'restrict-filenames' => 'bool',
            'no-overwrites' => 'bool',
            'continue' => 'bool',
            'no-continue' => 'bool',
            'no-part' => 'bool',
            'no-mtime' => 'bool',
            'write-description' => 'bool',
            'write-annotations' => 'bool',
            'cookies' => 'string',
            'cache-dir' => 'string',
            'no-cache-dir' => 'bool',
            'rm-cache-dir' => 'bool',
            'id' => 'bool',
            // Thumbnail images
            'write-thumbnail' => 'bool',
            'write-all-thumbnails' => 'bool',
            // Verbosity / Simulation Options
            'quiet' => 'bool',
            'no-warnings' => 'bool',
            'simulate' => 'bool',
            'skip-download' => 'bool',
            'call-home' => 'bool',
            'no-call-home' => 'bool',
            // Workarounds
            'encoding' => 'string',
            'no-check-certificate' => 'bool',
            'prefer-insecure' => 'bool',
            'user-agent' => 'string',
            'referer' => 'string',
            'add-header' => 'array',
            'bidi-workaround' => 'bool',
            'sleep-interval' => 'int',
            // Video Format Options
            'format' => 'string',
            'prefer-free-formats' => 'bool',
            'max-quality' => 'string',
            'youtube-skip-dash-manifest' => 'bool',
            'merge-output-format' => 'string',
            // Subtitle Options
            'write-sub' => 'bool',
            'write-auto-sub' => 'bool',
            'all-subs' => 'bool',
            'sub-format' => 'string',
            'sub-lang' => 'string',
            // Authentication Options
            'username' => 'string',
            'password' => 'string',
            'twofactor' => 'string',
            'netrc' => 'bool',
            'video-password' => 'string',
            // Post-processing Options
            'extract-audio' => 'bool',
            'audio-format' => 'string',
            'audio-quality' => 'int',
            'recode-video' => 'string',
            'keep-video' => 'bool',
            'no-post-overwrites' => 'bool',
            'embed-subs' => 'bool',
            'embed-thumbnail' => 'bool',
            'add-metadata' => 'bool',
            'metadata-from-title' => 'string',
            'xattrs' => 'bool',
            'fixup' => 'string',
            'prefer-avconv' => 'bool',
            'prefer-ffmpeg' => 'bool',
            'ffmpeg-location' => 'string',
            'exec' => 'string',
            'convert-subtitles' => 'string',
        ];

        $resolver->setDefined(array_keys($options));

        foreach ($options as $option => $types) {
            $resolver->setAllowedTypes($option, explode('|', $types));
        }

        $resolver->setAllowedValues('retries', function ($value) {
            if (is_string($value) && 'infinite' != $value) {
                return false;
            }

            return true;
        });

        $resolver->setAllowedValues('external-downloader', ['aria2c', 'avconv', 'axel', 'curl', 'ffmpeg', 'httpie', 'wget']);

        $resolver->setAllowedValues('audio-format', $this->allowedAudioFormats);

        $resolver->setAllowedValues('ffmpeg-location', function ($value) {
            if (!is_file($value) && !is_dir($value)) {
                return false;
            }

            return true;
        });

        $resolver->setNormalizer('add-header', function (Options $options, $value) {
            foreach ($value as $k => $v) {
                if (false === strpos($v, ':')) {
                    unset($value[$k]);
                }
            }

            return $value;
        });
    }

    private function isUrlSupported(string $url): bool
    {
        foreach (self::$blacklist as $pattern) {
            if (preg_match($pattern, $url)) {
                return false;
            }
        }

        return true;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace App\YoutubeDl;
6
7			use Symfony\Component\OptionsResolver\Options;
8			use Symfony\Component\OptionsResolver\OptionsResolver;
9			use Symfony\Component\Process\ExecutableFinder;
10			use Symfony\Component\Process\Process;
11			use YoutubeDl\Entity\Video;
12			use YoutubeDl\Exception\AccountTerminatedException;
13			use YoutubeDl\Exception\CopyrightException;
14			use YoutubeDl\Exception\ExecutableNotFoundException;
15			use YoutubeDl\Exception\NotFoundException;
16			use YoutubeDl\Exception\PrivateVideoException;
17			use YoutubeDl\Exception\UrlNotSupportedException;
18			use YoutubeDl\Exception\YoutubeDlException;
19
20			class YoutubeDl
21			{
22			const PROGRESS_PATTERN = '#\[download\]\s+(?<percentage>\d+(?:\.\d+)?%)\s+of\s+(?<size>\d+(?:\.\d+)?(?:K\|M\|G)iB)(?:\s+at\s+(?<speed>\d+(?:\.\d+)?(?:K\|M\|G)iB/s))?(?:\s+ETA\s+(?<eta>[\d]{2}:[\d]{2}))?#i';
23
24			/**
25			* @var array
26			*/
27			protected $options = [];
28
29			/**
30			* @var string
31			*/
32			protected $binPath;
33
34			/**
35			* @var string
36			*/
37			protected $pythonPath;
38
39			/**
40			* @var string
41			*/
42			protected $downloadPath;
43
44			/**
45			* @var callable
46			*/
47			protected $debug;
48
49			/**
50			* @var int
51			*/
52			protected $timeout = 0;
53
54			/**
55			* @var array
56			*/
57			protected $allowedAudioFormats = ['best', 'aac', 'vorbis', 'mp3', 'm4a', 'opus', 'wav'];
58
59			/**
60			* @var callable
61			*/
62			private $progress;
63
64			private static $blacklist = [
65			'#soundcloud.com/.+/sets.+#',
66			];
67
68			public function __construct(array $options = [])
69			{
70			$resolver = new OptionsResolver();
71			$this->configureOptions($resolver);
72
73			$this->options = $resolver->resolve($options);
74			}
75
76			public function setBinPath(string $binPath)
77			{
78			$this->binPath = $binPath;
79			}
80
81			public function setPythonPath(string $pythonPath)
82			{
83			$this->pythonPath = $pythonPath;
84			}
85
86			/**
87			* @param string $downloadPath Download path without trailing slash
88			*/
89			public function setDownloadPath(string $downloadPath)
90			{
91			$this->downloadPath = $downloadPath;
92			}
93
94			public function debug(callable $debug)
95			{
96			$this->debug = $debug;
97			}
98
99			public function setTimeout(int $timeout)
100			{
101			$this->timeout = $timeout;
102			}
103
104			public function onProgress(callable $onProgress)
105			{
106			$this->progress = $onProgress;
107			}
108
109			public function download(string $url): Video
110			{
111			if (!$this->downloadPath) {
112			throw new \RuntimeException('No download path was set.');
113			}
114
115			if (!$this->isUrlSupported($url)) {
116			throw new UrlNotSupportedException(sprintf('Provided url "%s" is not supported.', $url));
117			}
118
119			$arguments = [
120			$url,
121			'--no-playlist',
122			'--ignore-config',
123			'--write-info-json',
124			];
125
126			foreach ($this->options as $option => $value) {
127			if ('add-header' === $option) {
128			foreach ($value as $header) {
129			$arguments[] = sprintf('--%s=%s', $option, $header);
130			}
131			} elseif (is_bool($value)) {
132			$arguments[] = sprintf('--%s', $option);
133			} else {
134			$arguments[] = sprintf('--%s=%s', $option, $value);
135			}
136			}
137
138			$process = $this->createProcess($arguments);
139
140			try {
141			$process->mustRun(function ($type, $buffer) {
142			$debug = $this->debug;
143			$progress = $this->progress;
144
145			if (is_callable($debug)) {
146			$debug($type, $buffer);
147			}
148
149			if (is_callable($progress) && Process::OUT === $type && preg_match(self::PROGRESS_PATTERN, $buffer, $matches)) {
150			unset($matches[0], $matches[1], $matches[2], $matches[3], $matches[4]);
151
152			$progress($matches);
153			}
154			});
155			} catch (\Exception $e) {
156			throw $this->handleException($e);
157			}
158
159			return $this->processDownload($process);
160			}
161
162			public function getExtractorsList(): array
163			{
164			$process = $this->createProcess(['--list-extractors']);
165			$process->mustRun(is_callable($this->debug) ? $this->debug : null);
166
167			return array_filter(explode("\n", $process->getOutput()));
168			}
169
170			private function jsonDecode($data): array
171			{
172			$decoded = json_decode($data, true);
173
174			if (JSON_ERROR_NONE !== json_last_error()) {
175			throw new YoutubeDlException(sprintf('Response can\'t be decoded: %s.', $data));
176			}
177
178			return $decoded;
179			}
180
181			private function processDownload(Process $process): Video
182			{
183			if (!preg_match('/Writing video description metadata as JSON to:\s(.+)/', $process->getOutput(), $m)) {
184			throw new YoutubeDlException('Failed to detect metadata file.');
185			}
186
187			$metadataFile = $this->downloadPath.'/'.$m[1];
188
189			$videoData = $this->jsonDecode(trim(file_get_contents($metadataFile)));
190
191			@unlink($metadataFile);
192
193			if (!isset($this->options['skip-download']) \|\| false === $this->options['skip-download']) {
194			if (isset($this->options['extract-audio']) && true === $this->options['extract-audio']) {
195			$videoData['_filename'] = $this->findFile($videoData['_filename'], implode('\|', $this->allowedAudioFormats));
196			} elseif (preg_match('/merged into mkv/', $process->getErrorOutput())) {
197			$videoData['_filename'] = $this->findFile($videoData['_filename'], 'mkv');
198			}
199
200			$videoData['file'] = new \SplFileInfo($this->downloadPath.'/'.$videoData['_filename']);
201			} else {
202			$videoData['file'] = null;
203			}
204
205			return new Video($videoData);
206			}
207
208			private function handleException(\Exception $e): \Exception
209			{
210			$message = $e->getMessage();
211
212			if (preg_match('/please sign in to view this video\|video is protected by a password/i', $message)) {
213			return new PrivateVideoException();
214			} elseif (preg_match('/copyright infringement/i', $message)) {
215			return new CopyrightException();
216			} elseif (preg_match('/this video does not exist\|404/i', $message)) {
217			return new NotFoundException();
218			} elseif (preg_match('/account associated with this video has been terminated/', $message)) {
219			return new AccountTerminatedException();
220			}
221
222			return $e;
223			}
224
225			private function createProcess(array $arguments = []): Process
226			{
227			$binPath = $this->binPath ?: (new ExecutableFinder())->find('youtube-dl');
228
229			if (null === $binPath) {
230			throw new ExecutableNotFoundException('"youtube-dl" executable was not found. Did you forgot to add it to environment variables? Or set it via $yt->setBinPath(\'/usr/bin/youtube-dl\').');
231			}
232
233			array_unshift($arguments, $binPath);
234
235			if ($this->pythonPath) {
236			array_unshift($arguments, $this->pythonPath);
237			}
238
239			$process = new Process($arguments);
240			$process->setTimeout($this->timeout);
241
242			if ($this->downloadPath) {
243			$process->setWorkingDirectory($this->downloadPath);
244			}
245
246			return $process;
247			}
248
249			private function findFile(string $fileName, string $extension)
250			{
251			$dirName = pathinfo($fileName, PATHINFO_DIRNAME);
252			$path = $this->downloadPath.(('.' === $dirName) ? '' : DIRECTORY_SEPARATOR.$dirName);
253
254			$iterator = new \RegexIterator(new \DirectoryIterator($path), sprintf('/%s\.%s$/ui', preg_quote(pathinfo($fileName, PATHINFO_FILENAME), '/'), '('.$extension.')'), \RegexIterator::GET_MATCH);
255
256			$iterator->rewind();
257
258			return (('.' === $dirName) ? '' : $dirName.DIRECTORY_SEPARATOR).$iterator->current()[0];
259			}
260
261			private function configureOptions(OptionsResolver $resolver)
262			{
263			$options = [
264			// General options
265			'ignore-errors' => 'bool',
266			'abort-on-error' => 'bool',
267			'default-search' => 'string',
268			'force-generic-extractor' => 'bool',
269			// Network options
270			'proxy' => 'string',
271			'socket-timeout' => 'int',
272			'source-address' => 'string',
273			'force-ipv4' => 'bool',
274			'force-ipv6' => 'bool',
275			// Video selection options
276			'match-title' => 'string',
277			'reject-title' => 'string',
278			'max-downloads' => 'int',
279			'min-filesize' => 'string',
280			'max-filesize' => 'string',
281			'date' => 'string',
282			'datebefore' => 'string',
283			'dateafter' => 'string',
284			'min-views' => 'int',
285			'max-views' => 'int',
286			'match-filter' => 'string',
287			'download-archive' => 'string',
288			'include-ads' => 'bool',
289			// Download Options
290			'rate-limit' => 'string',
291			'retries' => 'int\|string',
292			'buffer-size' => 'string',
293			'no-resize-buffer' => 'bool',
294			'xattr-set-filesize' => 'bool',
295			'hls-prefer-native' => 'bool',
296			'external-downloader' => 'string',
297			'external-downloader-args' => 'string',
298			// Filesystem Options
299			'batch-file' => 'string',
300			'output' => 'string',
301			'autonumber-size' => 'int',
302			'restrict-filenames' => 'bool',
303			'no-overwrites' => 'bool',
304			'continue' => 'bool',
305			'no-continue' => 'bool',
306			'no-part' => 'bool',
307			'no-mtime' => 'bool',
308			'write-description' => 'bool',
309			'write-annotations' => 'bool',
310			'cookies' => 'string',
311			'cache-dir' => 'string',
312			'no-cache-dir' => 'bool',
313			'rm-cache-dir' => 'bool',
314			'id' => 'bool',
315			// Thumbnail images
316			'write-thumbnail' => 'bool',
317			'write-all-thumbnails' => 'bool',
318			// Verbosity / Simulation Options
319			'quiet' => 'bool',
320			'no-warnings' => 'bool',
321			'simulate' => 'bool',
322			'skip-download' => 'bool',
323			'call-home' => 'bool',
324			'no-call-home' => 'bool',
325			// Workarounds
326			'encoding' => 'string',
327			'no-check-certificate' => 'bool',
328			'prefer-insecure' => 'bool',
329			'user-agent' => 'string',
330			'referer' => 'string',
331			'add-header' => 'array',
332			'bidi-workaround' => 'bool',
333			'sleep-interval' => 'int',
334			// Video Format Options
335			'format' => 'string',
336			'prefer-free-formats' => 'bool',
337			'max-quality' => 'string',
338			'youtube-skip-dash-manifest' => 'bool',
339			'merge-output-format' => 'string',
340			// Subtitle Options
341			'write-sub' => 'bool',
342			'write-auto-sub' => 'bool',
343			'all-subs' => 'bool',
344			'sub-format' => 'string',
345			'sub-lang' => 'string',
346			// Authentication Options
347			'username' => 'string',
348			'password' => 'string',
349			'twofactor' => 'string',
350			'netrc' => 'bool',
351			'video-password' => 'string',
352			// Post-processing Options
353			'extract-audio' => 'bool',
354			'audio-format' => 'string',
355			'audio-quality' => 'int',
356			'recode-video' => 'string',
357			'keep-video' => 'bool',
358			'no-post-overwrites' => 'bool',
359			'embed-subs' => 'bool',
360			'embed-thumbnail' => 'bool',
361			'add-metadata' => 'bool',
362			'metadata-from-title' => 'string',
363			'xattrs' => 'bool',
364			'fixup' => 'string',
365			'prefer-avconv' => 'bool',
366			'prefer-ffmpeg' => 'bool',
367			'ffmpeg-location' => 'string',
368			'exec' => 'string',
369			'convert-subtitles' => 'string',
370			];
371
372			$resolver->setDefined(array_keys($options));
373
374			foreach ($options as $option => $types) {
375			$resolver->setAllowedTypes($option, explode('\|', $types));
376			}
377
378			$resolver->setAllowedValues('retries', function ($value) {
379			if (is_string($value) && 'infinite' != $value) {
380			return false;
381			}
382
383			return true;
384			});
385
386			$resolver->setAllowedValues('external-downloader', ['aria2c', 'avconv', 'axel', 'curl', 'ffmpeg', 'httpie', 'wget']);
387
388			$resolver->setAllowedValues('audio-format', $this->allowedAudioFormats);
389
390			$resolver->setAllowedValues('ffmpeg-location', function ($value) {
391			if (!is_file($value) && !is_dir($value)) {
392			return false;
393			}
394
395			return true;
396			});
397
398			$resolver->setNormalizer('add-header', function (Options $options, $value) {
399			foreach ($value as $k => $v) {
400			if (false === strpos($v, ':')) {
401			unset($value[$k]);
402			}
403			}
404
405			return $value;
406			});
407			}
408
409			private function isUrlSupported(string $url): bool
410			{
411			foreach (self::$blacklist as $pattern) {
412			if (preg_match($pattern, $url)) {
413			return false;
414			}
415			}
416
417			return true;
418			}
419			}
420

gnutix / videos-downloader

Push — master ( 6d49a3...a20a92 )

YoutubeDl::download() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like