gravityview / GravityView

vendor/brianhenryie/strauss/src/ChangeEnumerator.php

Indentation +155 added lines, -155 removed lines

@@ -13,128 +13,128 @@ 
 class ChangeEnumerator
 {
 
-    protected string $namespacePrefix;
-    protected string $classmapPrefix;
-    /**
-     *
-     * @var string[]
-     */
-    protected array $excludePackagesFromPrefixing = array();
-    protected array $excludeNamespacesFromPrefixing = array();
-
-    protected array $excludeFilePatternsFromPrefixing = array();
-
-    protected array $namespaceReplacementPatterns = array();
-
-    /** @var string[] */
-    protected array $discoveredNamespaces = [];
-
-    /** @var string[] */
-    protected array $discoveredClasses = [];
-
-
-    /**
-     * ChangeEnumerator constructor.
-     * @param \BrianHenryIE\Strauss\Composer\Extra\StraussConfig $config
-     */
-    public function __construct(StraussConfig $config)
-    {
-        $this->namespacePrefix = $config->getNamespacePrefix();
-        $this->classmapPrefix = $config->getClassmapPrefix();
-
-        $this->excludePackagesFromPrefixing = $config->getExcludePackagesFromPrefixing();
-        $this->excludeNamespacesFromPrefixing = $config->getExcludeNamespacesFromPrefixing();
-        $this->excludeFilePatternsFromPrefixing = $config->getExcludeFilePatternsFromPrefixing();
-
-        $this->namespaceReplacementPatterns = $config->getNamespaceReplacementPatterns();
-    }
-
-    /**
-     * TODO: Order by longest string first. (or instead, record classnames with their namespaces)
-     *
-     * @return string[]
-     */
-    public function getDiscoveredNamespaceReplacements(): array
-    {
-        $discoveredNamespaceReplacements = $this->discoveredNamespaces;
-
-        uksort($discoveredNamespaceReplacements, function ($a, $b) {
-            return strlen($b) <=> strlen($a);
-        });
-
-        return $discoveredNamespaceReplacements;
-    }
-
-    /**
-     * @return string[]
-     */
-    public function getDiscoveredClasses(): array
-    {
-        return array_keys($this->discoveredClasses);
-    }
-
-
-    /**
-     * @param string $dir
-     * @param array<string, ComposerPackage> $relativeFilepaths
-     */
-    public function findInFiles($dir, $relativeFilepaths)
-    {
-
-        foreach ($relativeFilepaths as $relativeFilepath => $package) {
-            foreach ($this->excludePackagesFromPrefixing as $excludePackagesName) {
-                if ($package->getName() === $excludePackagesName) {
-                    continue 2;
-                }
-            }
-
-            foreach ($this->excludeFilePatternsFromPrefixing as $excludeFilePattern) {
-                if (1 === preg_match($excludeFilePattern, $relativeFilepath)) {
-                    continue 2;
-                }
-            }
-
-
-            $filepath = $dir . $relativeFilepath;
-
-            // TODO: use flysystem
-            // $contents = $this->filesystem->read($targetFile);
-
-            $contents = file_get_contents($filepath);
-
-            $this->find($contents);
-        }
-    }
-
-
-    /**
-     * TODO: Don't use preg_replace_callback!
-     *
-     * @param string $contents
-     *
-     * @return string $contents
-     */
-    public function find(string $contents): string
-    {
-
-        // If the entire file is under one namespace, all we want is the namespace.
-        $singleNamespacePattern = '/
+	protected string $namespacePrefix;
+	protected string $classmapPrefix;
+	/**
+	 *
+	 * @var string[]
+	 */
+	protected array $excludePackagesFromPrefixing = array();
+	protected array $excludeNamespacesFromPrefixing = array();
+
+	protected array $excludeFilePatternsFromPrefixing = array();
+
+	protected array $namespaceReplacementPatterns = array();
+
+	/** @var string[] */
+	protected array $discoveredNamespaces = [];
+
+	/** @var string[] */
+	protected array $discoveredClasses = [];
+
+
+	/**
+	 * ChangeEnumerator constructor.
+	 * @param \BrianHenryIE\Strauss\Composer\Extra\StraussConfig $config
+	 */
+	public function __construct(StraussConfig $config)
+	{
+		$this->namespacePrefix = $config->getNamespacePrefix();
+		$this->classmapPrefix = $config->getClassmapPrefix();
+
+		$this->excludePackagesFromPrefixing = $config->getExcludePackagesFromPrefixing();
+		$this->excludeNamespacesFromPrefixing = $config->getExcludeNamespacesFromPrefixing();
+		$this->excludeFilePatternsFromPrefixing = $config->getExcludeFilePatternsFromPrefixing();
+
+		$this->namespaceReplacementPatterns = $config->getNamespaceReplacementPatterns();
+	}
+
+	/**
+	 * TODO: Order by longest string first. (or instead, record classnames with their namespaces)
+	 *
+	 * @return string[]
+	 */
+	public function getDiscoveredNamespaceReplacements(): array
+	{
+		$discoveredNamespaceReplacements = $this->discoveredNamespaces;
+
+		uksort($discoveredNamespaceReplacements, function ($a, $b) {
+			return strlen($b) <=> strlen($a);
+		});
+
+		return $discoveredNamespaceReplacements;
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getDiscoveredClasses(): array
+	{
+		return array_keys($this->discoveredClasses);
+	}
+
+
+	/**
+	 * @param string $dir
+	 * @param array<string, ComposerPackage> $relativeFilepaths
+	 */
+	public function findInFiles($dir, $relativeFilepaths)
+	{
+
+		foreach ($relativeFilepaths as $relativeFilepath => $package) {
+			foreach ($this->excludePackagesFromPrefixing as $excludePackagesName) {
+				if ($package->getName() === $excludePackagesName) {
+					continue 2;
+				}
+			}
+
+			foreach ($this->excludeFilePatternsFromPrefixing as $excludeFilePattern) {
+				if (1 === preg_match($excludeFilePattern, $relativeFilepath)) {
+					continue 2;
+				}
+			}
+
+
+			$filepath = $dir . $relativeFilepath;
+
+			// TODO: use flysystem
+			// $contents = $this->filesystem->read($targetFile);
+
+			$contents = file_get_contents($filepath);
+
+			$this->find($contents);
+		}
+	}
+
+
+	/**
+	 * TODO: Don't use preg_replace_callback!
+	 *
+	 * @param string $contents
+	 *
+	 * @return string $contents
+	 */
+	public function find(string $contents): string
+	{
+
+		// If the entire file is under one namespace, all we want is the namespace.
+		$singleNamespacePattern = '/
             namespace\s+([0-9A-Za-z_\x7f-\xff\\\\]+)[\s\S]*;    # A single namespace in the file.... should return
         /x';
-        if (1 === preg_match($singleNamespacePattern, $contents, $matches)) {
-            $this->addDiscoveredNamespaceChange($matches[1]);
-            return $contents;
-        }
+		if (1 === preg_match($singleNamespacePattern, $contents, $matches)) {
+			$this->addDiscoveredNamespaceChange($matches[1]);
+			return $contents;
+		}
 
 
-        // TODO traits
+		// TODO traits
 
-        // TODO: Is the ";" in this still correct since it's being taken care of in the regex just above?
-        // Looks like with the preceeding regex, it will never match.
+		// TODO: Is the ";" in this still correct since it's being taken care of in the regex just above?
+		// Looks like with the preceeding regex, it will never match.
 
 
-        return preg_replace_callback(
-            '
+		return preg_replace_callback(
+			'
 			~											# Start the pattern
 				namespace\s+([a-zA-Z0-9_\x7f-\xff\\\\]+)[;{\s\n]{1}[\s\S]*?(?=namespace|$) 
 														# Look for a preceeding namespace declaration, 
@@ -152,44 +152,44 @@ 
 				(?:{|extends|implements|\n|$)			# Class declaration can be followed by {, extends, implements 
 														# or a new line
 			~x', //                                     # x: ignore whitespace in regex.
-            function ($matches) {
-
-                // If we're inside a namespace other than the global namespace:
-                if (1 === preg_match('/^namespace\s+[a-zA-Z0-9_\x7f-\xff\\\\]+[;{\s\n]{1}.*/', $matches[0])) {
-                    $this->addDiscoveredNamespaceChange($matches[1]);
-                    return $matches[0];
-                }
-
-                if (count($matches) < 3) {
-                    return $matches[0];
-                }
-
-                // TODO: Why is this [2] and not [1] (which seems to be always empty).
-                $this->discoveredClasses[$matches[2]] = $matches[2];
-                return $matches[0];
-            },
-            $contents
-        );
-    }
-
-    protected function addDiscoveredNamespaceChange(string $namespace)
-    {
-
-        foreach ($this->excludeNamespacesFromPrefixing as $excludeNamespace) {
-            if (0 === strpos($namespace, $excludeNamespace)) {
-                return;
-            }
-        }
-
-        foreach ($this->namespaceReplacementPatterns as $namespaceReplacementPattern => $replacement) {
-            $prefixed = preg_replace($namespaceReplacementPattern, $replacement, $namespace);
-
-            if ($prefixed !== $namespace) {
-                $this->discoveredNamespaces[$namespace] = $prefixed;
-                return;
-            }
-        }
-
-        $this->discoveredNamespaces[$namespace] = $this->namespacePrefix . '\\'. $namespace;
-    }
+			function ($matches) {
+
+				// If we're inside a namespace other than the global namespace:
+				if (1 === preg_match('/^namespace\s+[a-zA-Z0-9_\x7f-\xff\\\\]+[;{\s\n]{1}.*/', $matches[0])) {
+					$this->addDiscoveredNamespaceChange($matches[1]);
+					return $matches[0];
+				}
+
+				if (count($matches) < 3) {
+					return $matches[0];
+				}
+
+				// TODO: Why is this [2] and not [1] (which seems to be always empty).
+				$this->discoveredClasses[$matches[2]] = $matches[2];
+				return $matches[0];
+			},
+			$contents
+		);
+	}
+
+	protected function addDiscoveredNamespaceChange(string $namespace)
+	{
+
+		foreach ($this->excludeNamespacesFromPrefixing as $excludeNamespace) {
+			if (0 === strpos($namespace, $excludeNamespace)) {
+				return;
+			}
+		}
+
+		foreach ($this->namespaceReplacementPatterns as $namespaceReplacementPattern => $replacement) {
+			$prefixed = preg_replace($namespaceReplacementPattern, $replacement, $namespace);
+
+			if ($prefixed !== $namespace) {
+				$this->discoveredNamespaces[$namespace] = $prefixed;
+				return;
+			}
+		}
+
+		$this->discoveredNamespaces[$namespace] = $this->namespacePrefix . '\\'. $namespace;
+	}
 }

vendor/brianhenryie/strauss/src/Console/Commands/Compose.php

Indentation +200 added lines, -200 removed lines

@@ -19,259 +19,259 @@
 
 class Compose extends Command
 {
-    /** @var string */
-    protected string $workingDir;
+	/** @var string */
+	protected string $workingDir;
 
-    /** @var StraussConfig */
-    protected StraussConfig $config;
+	/** @var StraussConfig */
+	protected StraussConfig $config;
 
-    protected ProjectComposerPackage $projectComposerPackage;
+	protected ProjectComposerPackage $projectComposerPackage;
 
-    /** @var Copier */
-    protected Copier $copier;
+	/** @var Copier */
+	protected Copier $copier;
 
-    /** @var Prefixer */
-    protected Prefixer $replacer;
-    /**
-     * @var ChangeEnumerator
-     */
-    protected ChangeEnumerator $changeEnumerator;
+	/** @var Prefixer */
+	protected Prefixer $replacer;
+	/**
+	 * @var ChangeEnumerator
+	 */
+	protected ChangeEnumerator $changeEnumerator;
 
 
-    /**
-     * @return void
-     */
-    protected function configure()
-    {
-        $this->setName('compose');
-        $this->setDescription("Copy composer's `require` and prefix their namespace and classnames.");
-        $this->setHelp('');
-    }
+	/**
+	 * @return void
+	 */
+	protected function configure()
+	{
+		$this->setName('compose');
+		$this->setDescription("Copy composer's `require` and prefix their namespace and classnames.");
+		$this->setHelp('');
+	}
 
-    /**
-     * @see Command::execute()
-     *
-     * @param InputInterface $input
-     * @param OutputInterface $output
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output): int
-    {
-        $workingDir = getcwd() . DIRECTORY_SEPARATOR;
-        $this->workingDir = $workingDir;
+	/**
+	 * @see Command::execute()
+	 *
+	 * @param InputInterface $input
+	 * @param OutputInterface $output
+	 * @return int
+	 */
+	protected function execute(InputInterface $input, OutputInterface $output): int
+	{
+		$workingDir = getcwd() . DIRECTORY_SEPARATOR;
+		$this->workingDir = $workingDir;
 
-        try {
-            $this->loadProjectComposerPackage();
+		try {
+			$this->loadProjectComposerPackage();
 
-            $this->buildDependencyList();
+			$this->buildDependencyList();
 
-            $this->enumerateFiles();
+			$this->enumerateFiles();
 
-            $this->copyFiles();
+			$this->copyFiles();
 
-            $this->determineChanges();
+			$this->determineChanges();
 
-            $this->performReplacements();
+			$this->performReplacements();
 
-            $this->addLicenses();
-
-            $this->generateAutoloader();
+			$this->addLicenses();
+
+			$this->generateAutoloader();
 
-            $this->cleanUp();
-        } catch (Exception $e) {
-            $output->write($e->getMessage());
-            return 1;
-        }
+			$this->cleanUp();
+		} catch (Exception $e) {
+			$output->write($e->getMessage());
+			return 1;
+		}
 
-        // What should this be?!
-        return 0;
-    }
+		// What should this be?!
+		return 0;
+	}
 
 
-    /**
-     * 1. Load the composer.json.
-     *
-     * @throws Exception
-     */
-    protected function loadProjectComposerPackage()
-    {
+	/**
+	 * 1. Load the composer.json.
+	 *
+	 * @throws Exception
+	 */
+	protected function loadProjectComposerPackage()
+	{
 
-        $this->projectComposerPackage = new ProjectComposerPackage($this->workingDir . 'composer.json');
+		$this->projectComposerPackage = new ProjectComposerPackage($this->workingDir . 'composer.json');
 
-        $config = $this->projectComposerPackage->getStraussConfig();
+		$config = $this->projectComposerPackage->getStraussConfig();
 
-        $this->config = $config;
-    }
+		$this->config = $config;
+	}
 
 
-    /** @var ComposerPackage[] */
-    protected array $flatDependencyTree = [];
+	/** @var ComposerPackage[] */
+	protected array $flatDependencyTree = [];
 
-    /**
-     * 2. Built flat list of packages and dependencies.
-     *
-     * 2.1 Initiate getting dependencies for the project composer.json.
-     *
-     * @see Compose::flatDependencyTree
-     */
-    protected function buildDependencyList()
-    {
+	/**
+	 * 2. Built flat list of packages and dependencies.
+	 *
+	 * 2.1 Initiate getting dependencies for the project composer.json.
+	 *
+	 * @see Compose::flatDependencyTree
+	 */
+	protected function buildDependencyList()
+	{
 
-        $requiredPackageNames = $this->config->getPackages();
+		$requiredPackageNames = $this->config->getPackages();
 
-        // Unset PHP, ext-*.
-        $removePhpExt = function ($element) {
-            return !( 0 === strpos($element, 'ext') || 'php' === $element );
-        };
+		// Unset PHP, ext-*.
+		$removePhpExt = function ($element) {
+			return !( 0 === strpos($element, 'ext') || 'php' === $element );
+		};
 
-        $requiredPackageNames = array_filter($requiredPackageNames, $removePhpExt);
+		$requiredPackageNames = array_filter($requiredPackageNames, $removePhpExt);
 
-        foreach ($requiredPackageNames as $requiredPackageName) {
-            $packageDir = $this->workingDir . 'vendor' .DIRECTORY_SEPARATOR
-                . $requiredPackageName . DIRECTORY_SEPARATOR;
+		foreach ($requiredPackageNames as $requiredPackageName) {
+			$packageDir = $this->workingDir . 'vendor' .DIRECTORY_SEPARATOR
+				. $requiredPackageName . DIRECTORY_SEPARATOR;
 
-            $overrideAutoload = isset($this->config->getOverrideAutoload()[$requiredPackageName])
-                ? $this->config->getOverrideAutoload()[$requiredPackageName]
-                : null;
+			$overrideAutoload = isset($this->config->getOverrideAutoload()[$requiredPackageName])
+				? $this->config->getOverrideAutoload()[$requiredPackageName]
+				: null;
 
-            $requiredComposerPackage = new ComposerPackage($packageDir, $overrideAutoload);
-            $this->flatDependencyTree[$requiredComposerPackage->getName()] = $requiredComposerPackage;
-            $this->getAllDependencies($requiredComposerPackage);
-        }
-    }
-
-    /**
-     * 2.2 Recursive function to get dependencies.
-     *
-     * @param ComposerPackage $requiredDependency
-     */
-    protected function getAllDependencies(ComposerPackage $requiredDependency): void
-    {
-        $excludedPackagesNames = $this->config->getExcludePackagesFromPrefixing();
+			$requiredComposerPackage = new ComposerPackage($packageDir, $overrideAutoload);
+			$this->flatDependencyTree[$requiredComposerPackage->getName()] = $requiredComposerPackage;
+			$this->getAllDependencies($requiredComposerPackage);
+		}
+	}
+
+	/**
+	 * 2.2 Recursive function to get dependencies.
+	 *
+	 * @param ComposerPackage $requiredDependency
+	 */
+	protected function getAllDependencies(ComposerPackage $requiredDependency): void
+	{
+		$excludedPackagesNames = $this->config->getExcludePackagesFromPrefixing();
 
-        // Unset PHP, ext-*.
-        $removePhpExt = function ($element) {
-            return !( 0 === strpos($element, 'ext') || 'php' === $element );
-        };
+		// Unset PHP, ext-*.
+		$removePhpExt = function ($element) {
+			return !( 0 === strpos($element, 'ext') || 'php' === $element );
+		};
 
-        $required = array_filter($requiredDependency->getRequiresNames(), $removePhpExt);
+		$required = array_filter($requiredDependency->getRequiresNames(), $removePhpExt);
 
-        foreach ($required as $dependencyName) {
-            if (in_array($dependencyName, $excludedPackagesNames)) {
-                continue;
-            }
+		foreach ($required as $dependencyName) {
+			if (in_array($dependencyName, $excludedPackagesNames)) {
+				continue;
+			}
 
-            $overrideAutoload = isset($this->config->getOverrideAutoload()[$dependencyName])
-                ? $this->config->getOverrideAutoload()[$dependencyName]
-                : null;
+			$overrideAutoload = isset($this->config->getOverrideAutoload()[$dependencyName])
+				? $this->config->getOverrideAutoload()[$dependencyName]
+				: null;
 
-            $dependencyComposerPackage = new ComposerPackage(
-                $this->workingDir . 'vendor' . DIRECTORY_SEPARATOR
-                . $dependencyName . DIRECTORY_SEPARATOR . 'composer.json',
-                $overrideAutoload
-            );
+			$dependencyComposerPackage = new ComposerPackage(
+				$this->workingDir . 'vendor' . DIRECTORY_SEPARATOR
+				. $dependencyName . DIRECTORY_SEPARATOR . 'composer.json',
+				$overrideAutoload
+			);
 
-            $this->flatDependencyTree[$dependencyName] = $dependencyComposerPackage;
-            $this->getAllDependencies($dependencyComposerPackage);
-        }
-    }
-
-    protected FileEnumerator $fileEnumerator;
-
-    protected function enumerateFiles()
-    {
-
-        $this->fileEnumerator = new FileEnumerator(
-            $this->flatDependencyTree,
-            $this->workingDir,
-            $this->config
-        );
+			$this->flatDependencyTree[$dependencyName] = $dependencyComposerPackage;
+			$this->getAllDependencies($dependencyComposerPackage);
+		}
+	}
+
+	protected FileEnumerator $fileEnumerator;
+
+	protected function enumerateFiles()
+	{
+
+		$this->fileEnumerator = new FileEnumerator(
+			$this->flatDependencyTree,
+			$this->workingDir,
+			$this->config
+		);
 
-        $this->fileEnumerator->compileFileList();
-    }
-
-    // 3. Copy autoloaded files for each
-    protected function copyFiles()
-    {
+		$this->fileEnumerator->compileFileList();
+	}
+
+	// 3. Copy autoloaded files for each
+	protected function copyFiles()
+	{
 
-        $this->copier = new Copier(
-            $this->fileEnumerator->getAllFilesAndDependencyList(),
-            $this->workingDir,
-            $this->config->getTargetDirectory()
-        );
-
-        $this->copier->prepareTarget();
-
-        $this->copier->copy();
-    }
-
-    // 4. Determine namespace and classname changes
-    protected function determineChanges()
-    {
-
-        $this->changeEnumerator = new ChangeEnumerator($this->config);
-
-        $relativeTargetDir = $this->config->getTargetDirectory();
-        $phpFiles = $this->fileEnumerator->getPhpFilesAndDependencyList();
-        $this->changeEnumerator->findInFiles($relativeTargetDir, $phpFiles);
-    }
-
-    // 5. Update namespaces and class names.
-    // Replace references to updated namespaces and classnames throughout the dependencies.
-    protected function performReplacements()
-    {
-        $this->replacer = new Prefixer($this->config, $this->workingDir);
-
-        $namespaces = $this->changeEnumerator->getDiscoveredNamespaceReplacements();
-        $classes = $this->changeEnumerator->getDiscoveredClasses();
+		$this->copier = new Copier(
+			$this->fileEnumerator->getAllFilesAndDependencyList(),
+			$this->workingDir,
+			$this->config->getTargetDirectory()
+		);
+
+		$this->copier->prepareTarget();
+
+		$this->copier->copy();
+	}
+
+	// 4. Determine namespace and classname changes
+	protected function determineChanges()
+	{
+
+		$this->changeEnumerator = new ChangeEnumerator($this->config);
+
+		$relativeTargetDir = $this->config->getTargetDirectory();
+		$phpFiles = $this->fileEnumerator->getPhpFilesAndDependencyList();
+		$this->changeEnumerator->findInFiles($relativeTargetDir, $phpFiles);
+	}
+
+	// 5. Update namespaces and class names.
+	// Replace references to updated namespaces and classnames throughout the dependencies.
+	protected function performReplacements()
+	{
+		$this->replacer = new Prefixer($this->config, $this->workingDir);
+
+		$namespaces = $this->changeEnumerator->getDiscoveredNamespaceReplacements();
+		$classes = $this->changeEnumerator->getDiscoveredClasses();
         
-        $phpFiles = $this->fileEnumerator->getPhpFilesAndDependencyList();
+		$phpFiles = $this->fileEnumerator->getPhpFilesAndDependencyList();
 
-        $this->replacer->replaceInFiles($namespaces, $classes, $phpFiles);
-    }
+		$this->replacer->replaceInFiles($namespaces, $classes, $phpFiles);
+	}
 
-    protected function addLicenses(): void
-    {
+	protected function addLicenses(): void
+	{
 
-        $author = $this->projectComposerPackage->getAuthor();
+		$author = $this->projectComposerPackage->getAuthor();
 
-        $dependencies = $this->flatDependencyTree;
+		$dependencies = $this->flatDependencyTree;
 
-        $licenser = new Licenser($this->config, $this->workingDir, $dependencies, $author);
+		$licenser = new Licenser($this->config, $this->workingDir, $dependencies, $author);
 
-        $licenser->copyLicenses();
+		$licenser->copyLicenses();
 
-        $modifiedFiles = $this->replacer->getModifiedFiles();
-        $licenser->addInformationToUpdatedFiles($modifiedFiles);
-    }
+		$modifiedFiles = $this->replacer->getModifiedFiles();
+		$licenser->addInformationToUpdatedFiles($modifiedFiles);
+	}
 
-    /**
-     * 6. Generate autoloader.
-     */
-    protected function generateAutoloader()
-    {
+	/**
+	 * 6. Generate autoloader.
+	 */
+	protected function generateAutoloader()
+	{
 
-        $files = $this->fileEnumerator->getFilesAutoloaders();
+		$files = $this->fileEnumerator->getFilesAutoloaders();
 
-        $classmap = new Autoload($this->config, $this->workingDir, $files);
+		$classmap = new Autoload($this->config, $this->workingDir, $files);
 
-        $classmap->generate();
-    }
+		$classmap->generate();
+	}
 
 
-    /**
-     * 7.
-     * Delete source files if desired.
-     * Delete empty directories in destination.
-     */
-    protected function cleanUp()
-    {
+	/**
+	 * 7.
+	 * Delete source files if desired.
+	 * Delete empty directories in destination.
+	 */
+	protected function cleanUp()
+	{
 
-        $cleanup = new Cleanup($this->config, $this->workingDir);
+		$cleanup = new Cleanup($this->config, $this->workingDir);
 
-        $sourceFiles = array_keys($this->fileEnumerator->getAllFilesAndDependencyList());
+		$sourceFiles = array_keys($this->fileEnumerator->getAllFilesAndDependencyList());
 
-        // This will check the config to check should it delete or not.
-        $cleanup->cleanup($sourceFiles);
-    }
+		// This will check the config to check should it delete or not.
+		$cleanup->cleanup($sourceFiles);
+	}
 }

vendor/brianhenryie/strauss/src/Console/Application.php

Indentation +10 added lines, -10 removed lines

@@ -7,16 +7,16 @@
 
 class Application extends BaseApplication
 {
-    /**
-     * @param string $version
-     */
-    public function __construct(string $version)
-    {
-        parent::__construct('strauss', $version);
+	/**
+	 * @param string $version
+	 */
+	public function __construct(string $version)
+	{
+		parent::__construct('strauss', $version);
 
-        $composeCommand = new Compose();
-        $this->add($composeCommand);
+		$composeCommand = new Compose();
+		$this->add($composeCommand);
 
-        $this->setDefaultCommand('compose');
-    }
+		$this->setDefaultCommand('compose');
+	}
 }

vendor/paragonie/random_compat/lib/random_bytes_dev_urandom.php

Indentation +148 added lines, -148 removed lines

@@ -27,164 +27,164 @@
  */
 
 if (!defined('RANDOM_COMPAT_READ_BUFFER')) {
-    define('RANDOM_COMPAT_READ_BUFFER', 8);
+	define('RANDOM_COMPAT_READ_BUFFER', 8);
 }
 
 if (!is_callable('random_bytes')) {
-    /**
-     * Unless open_basedir is enabled, use /dev/urandom for
-     * random numbers in accordance with best practices
-     *
-     * Why we use /dev/urandom and not /dev/random
-     * @ref https://www.2uo.de/myths-about-urandom
-     * @ref http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers
-     *
-     * @param int $bytes
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    function random_bytes($bytes)
-    {
-        /** @var resource $fp */
-        static $fp = null;
+	/**
+	 * Unless open_basedir is enabled, use /dev/urandom for
+	 * random numbers in accordance with best practices
+	 *
+	 * Why we use /dev/urandom and not /dev/random
+	 * @ref https://www.2uo.de/myths-about-urandom
+	 * @ref http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers
+	 *
+	 * @param int $bytes
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	function random_bytes($bytes)
+	{
+		/** @var resource $fp */
+		static $fp = null;
 
-        /**
-         * This block should only be run once
-         */
-        if (empty($fp)) {
-            /**
-             * We don't want to ever read C:\dev\random, only /dev/urandom on
-             * Unix-like operating systems. While we guard against this
-             * condition in random.php, it doesn't hurt to be defensive in depth
-             * here.
-             *
-             * To that end, we only try to open /dev/urandom if we're on a Unix-
-             * like operating system (which means the directory separator is set
-             * to "/" not "\".
-             */
-            if (DIRECTORY_SEPARATOR === '/') {
-                if (!is_readable('/dev/urandom')) {
-                    throw new Exception(
-                        'Environment misconfiguration: ' .
-                        '/dev/urandom cannot be read.'
-                    );
-                }
-                /**
-                 * We use /dev/urandom if it is a char device.
-                 * We never fall back to /dev/random
-                 */
-                /** @var resource|bool $fp */
-                $fp = fopen('/dev/urandom', 'rb');
-                if (is_resource($fp)) {
-                    /** @var array<string, int> $st */
-                    $st = fstat($fp);
-                    if (($st['mode'] & 0170000) !== 020000) {
-                        fclose($fp);
-                        $fp = false;
-                    }
-                }
-            }
+		/**
+		 * This block should only be run once
+		 */
+		if (empty($fp)) {
+			/**
+			 * We don't want to ever read C:\dev\random, only /dev/urandom on
+			 * Unix-like operating systems. While we guard against this
+			 * condition in random.php, it doesn't hurt to be defensive in depth
+			 * here.
+			 *
+			 * To that end, we only try to open /dev/urandom if we're on a Unix-
+			 * like operating system (which means the directory separator is set
+			 * to "/" not "\".
+			 */
+			if (DIRECTORY_SEPARATOR === '/') {
+				if (!is_readable('/dev/urandom')) {
+					throw new Exception(
+						'Environment misconfiguration: ' .
+						'/dev/urandom cannot be read.'
+					);
+				}
+				/**
+				 * We use /dev/urandom if it is a char device.
+				 * We never fall back to /dev/random
+				 */
+				/** @var resource|bool $fp */
+				$fp = fopen('/dev/urandom', 'rb');
+				if (is_resource($fp)) {
+					/** @var array<string, int> $st */
+					$st = fstat($fp);
+					if (($st['mode'] & 0170000) !== 020000) {
+						fclose($fp);
+						$fp = false;
+					}
+				}
+			}
 
-            if (is_resource($fp)) {
-                /**
-                 * stream_set_read_buffer() does not exist in HHVM
-                 *
-                 * If we don't set the stream's read buffer to 0, PHP will
-                 * internally buffer 8192 bytes, which can waste entropy
-                 *
-                 * stream_set_read_buffer returns 0 on success
-                 */
-                if (is_callable('stream_set_read_buffer')) {
-                    stream_set_read_buffer($fp, RANDOM_COMPAT_READ_BUFFER);
-                }
-                if (is_callable('stream_set_chunk_size')) {
-                    stream_set_chunk_size($fp, RANDOM_COMPAT_READ_BUFFER);
-                }
-            }
-        }
+			if (is_resource($fp)) {
+				/**
+				 * stream_set_read_buffer() does not exist in HHVM
+				 *
+				 * If we don't set the stream's read buffer to 0, PHP will
+				 * internally buffer 8192 bytes, which can waste entropy
+				 *
+				 * stream_set_read_buffer returns 0 on success
+				 */
+				if (is_callable('stream_set_read_buffer')) {
+					stream_set_read_buffer($fp, RANDOM_COMPAT_READ_BUFFER);
+				}
+				if (is_callable('stream_set_chunk_size')) {
+					stream_set_chunk_size($fp, RANDOM_COMPAT_READ_BUFFER);
+				}
+			}
+		}
 
-        try {
-            /** @var int $bytes */
-            $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_bytes(): $bytes must be an integer'
-            );
-        }
+		try {
+			/** @var int $bytes */
+			$bytes = RandomCompat_intval($bytes);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_bytes(): $bytes must be an integer'
+			);
+		}
 
-        if ($bytes < 1) {
-            throw new Error(
-                'Length must be greater than 0'
-            );
-        }
+		if ($bytes < 1) {
+			throw new Error(
+				'Length must be greater than 0'
+			);
+		}
 
-        /**
-         * This if() block only runs if we managed to open a file handle
-         *
-         * It does not belong in an else {} block, because the above
-         * if (empty($fp)) line is logic that should only be run once per
-         * page load.
-         */
-        if (is_resource($fp)) {
-            /**
-             * @var int
-             */
-            $remaining = $bytes;
+		/**
+		 * This if() block only runs if we managed to open a file handle
+		 *
+		 * It does not belong in an else {} block, because the above
+		 * if (empty($fp)) line is logic that should only be run once per
+		 * page load.
+		 */
+		if (is_resource($fp)) {
+			/**
+			 * @var int
+			 */
+			$remaining = $bytes;
 
-            /**
-             * @var string|bool
-             */
-            $buf = '';
+			/**
+			 * @var string|bool
+			 */
+			$buf = '';
 
-            /**
-             * We use fread() in a loop to protect against partial reads
-             */
-            do {
-                /**
-                 * @var string|bool
-                 */
-                $read = fread($fp, $remaining);
-                if (!is_string($read)) {
-                    /**
-                     * We cannot safely read from the file. Exit the
-                     * do-while loop and trigger the exception condition
-                     *
-                     * @var string|bool
-                     */
-                    $buf = false;
-                    break;
-                }
-                /**
-                 * Decrease the number of bytes returned from remaining
-                 */
-                $remaining -= RandomCompat_strlen($read);
-                /**
-                 * @var string $buf
-                 */
-                $buf .= $read;
-            } while ($remaining > 0);
+			/**
+			 * We use fread() in a loop to protect against partial reads
+			 */
+			do {
+				/**
+				 * @var string|bool
+				 */
+				$read = fread($fp, $remaining);
+				if (!is_string($read)) {
+					/**
+					 * We cannot safely read from the file. Exit the
+					 * do-while loop and trigger the exception condition
+					 *
+					 * @var string|bool
+					 */
+					$buf = false;
+					break;
+				}
+				/**
+				 * Decrease the number of bytes returned from remaining
+				 */
+				$remaining -= RandomCompat_strlen($read);
+				/**
+				 * @var string $buf
+				 */
+				$buf .= $read;
+			} while ($remaining > 0);
 
-            /**
-             * Is our result valid?
-             * @var string|bool $buf
-             */
-            if (is_string($buf)) {
-                if (RandomCompat_strlen($buf) === $bytes) {
-                    /**
-                     * Return our random entropy buffer here:
-                     */
-                    return $buf;
-                }
-            }
-        }
+			/**
+			 * Is our result valid?
+			 * @var string|bool $buf
+			 */
+			if (is_string($buf)) {
+				if (RandomCompat_strlen($buf) === $bytes) {
+					/**
+					 * Return our random entropy buffer here:
+					 */
+					return $buf;
+				}
+			}
+		}
 
-        /**
-         * If we reach here, PHP has failed us.
-         */
-        throw new Exception(
-            'Error reading from source device'
-        );
-    }
+		/**
+		 * If we reach here, PHP has failed us.
+		 */
+		throw new Exception(
+			'Error reading from source device'
+		);
+	}
 }

vendor/paragonie/random_compat/lib/random_int.php

Indentation +200 added lines, -200 removed lines

@@ -1,204 +1,204 @@
 <?php
 
 if (!is_callable('random_int')) {
-    /**
-     * Random_* Compatibility Library
-     * for using the new PHP 7 random_* API in PHP 5 projects
-     *
-     * The MIT License (MIT)
-     *
-     * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
-     *
-     * Permission is hereby granted, free of charge, to any person obtaining a copy
-     * of this software and associated documentation files (the "Software"), to deal
-     * in the Software without restriction, including without limitation the rights
-     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-     * copies of the Software, and to permit persons to whom the Software is
-     * furnished to do so, subject to the following conditions:
-     *
-     * The above copyright notice and this permission notice shall be included in
-     * all copies or substantial portions of the Software.
-     *
-     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-     * SOFTWARE.
-     */
-
-    /**
-     * Fetch a random integer between $min and $max inclusive
-     *
-     * @param int $min
-     * @param int $max
-     *
-     * @throws Exception
-     *
-     * @return int
-     */
-    function random_int($min, $max)
-    {
-        /**
-         * Type and input logic checks
-         *
-         * If you pass it a float in the range (~PHP_INT_MAX, PHP_INT_MAX)
-         * (non-inclusive), it will sanely cast it to an int. If you it's equal to
-         * ~PHP_INT_MAX or PHP_INT_MAX, we let it fail as not an integer. Floats
-         * lose precision, so the <= and => operators might accidentally let a float
-         * through.
-         */
-
-        try {
-            /** @var int $min */
-            $min = RandomCompat_intval($min);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_int(): $min must be an integer'
-            );
-        }
-
-        try {
-            /** @var int $max */
-            $max = RandomCompat_intval($max);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_int(): $max must be an integer'
-            );
-        }
-
-        /**
-         * Now that we've verified our weak typing system has given us an integer,
-         * let's validate the logic then we can move forward with generating random
-         * integers along a given range.
-         */
-        if ($min > $max) {
-            throw new Error(
-                'Minimum value must be less than or equal to the maximum value'
-            );
-        }
-
-        if ($max === $min) {
-            return (int) $min;
-        }
-
-        /**
-         * Initialize variables to 0
-         *
-         * We want to store:
-         * $bytes => the number of random bytes we need
-         * $mask => an integer bitmask (for use with the &) operator
-         *          so we can minimize the number of discards
-         */
-        $attempts = $bits = $bytes = $mask = $valueShift = 0;
-        /** @var int $attempts */
-        /** @var int $bits */
-        /** @var int $bytes */
-        /** @var int $mask */
-        /** @var int $valueShift */
-
-        /**
-         * At this point, $range is a positive number greater than 0. It might
-         * overflow, however, if $max - $min > PHP_INT_MAX. PHP will cast it to
-         * a float and we will lose some precision.
-         *
-         * @var int|float $range
-         */
-        $range = $max - $min;
-
-        /**
-         * Test for integer overflow:
-         */
-        if (!is_int($range)) {
-
-            /**
-             * Still safely calculate wider ranges.
-             * Provided by @CodesInChaos, @oittaa
-             *
-             * @ref https://gist.github.com/CodesInChaos/03f9ea0b58e8b2b8d435
-             *
-             * We use ~0 as a mask in this case because it generates all 1s
-             *
-             * @ref https://eval.in/400356 (32-bit)
-             * @ref http://3v4l.org/XX9r5  (64-bit)
-             */
-            $bytes = PHP_INT_SIZE;
-            /** @var int $mask */
-            $mask = ~0;
-
-        } else {
-
-            /**
-             * $bits is effectively ceil(log($range, 2)) without dealing with
-             * type juggling
-             */
-            while ($range > 0) {
-                if ($bits % 8 === 0) {
-                    ++$bytes;
-                }
-                ++$bits;
-                $range >>= 1;
-                /** @var int $mask */
-                $mask = $mask << 1 | 1;
-            }
-            $valueShift = $min;
-        }
-
-        /** @var int $val */
-        $val = 0;
-        /**
-         * Now that we have our parameters set up, let's begin generating
-         * random integers until one falls between $min and $max
-         */
-        /** @psalm-suppress RedundantCondition */
-        do {
-            /**
-             * The rejection probability is at most 0.5, so this corresponds
-             * to a failure probability of 2^-128 for a working RNG
-             */
-            if ($attempts > 128) {
-                throw new Exception(
-                    'random_int: RNG is broken - too many rejections'
-                );
-            }
-
-            /**
-             * Let's grab the necessary number of random bytes
-             */
-            $randomByteString = random_bytes($bytes);
-
-            /**
-             * Let's turn $randomByteString into an integer
-             *
-             * This uses bitwise operators (<< and |) to build an integer
-             * out of the values extracted from ord()
-             *
-             * Example: [9F] | [6D] | [32] | [0C] =>
-             *   159 + 27904 + 3276800 + 201326592 =>
-             *   204631455
-             */
-            $val &= 0;
-            for ($i = 0; $i < $bytes; ++$i) {
-                $val |= ord($randomByteString[$i]) << ($i * 8);
-            }
-            /** @var int $val */
-
-            /**
-             * Apply mask
-             */
-            $val &= $mask;
-            $val += $valueShift;
-
-            ++$attempts;
-            /**
-             * If $val overflows to a floating point number,
-             * ... or is larger than $max,
-             * ... or smaller than $min,
-             * then try again.
-             */
-        } while (!is_int($val) || $val > $max || $val < $min);
-
-        return (int) $val;
-    }
+	/**
+	 * Random_* Compatibility Library
+	 * for using the new PHP 7 random_* API in PHP 5 projects
+	 *
+	 * The MIT License (MIT)
+	 *
+	 * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+	 *
+	 * Permission is hereby granted, free of charge, to any person obtaining a copy
+	 * of this software and associated documentation files (the "Software"), to deal
+	 * in the Software without restriction, including without limitation the rights
+	 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	 * copies of the Software, and to permit persons to whom the Software is
+	 * furnished to do so, subject to the following conditions:
+	 *
+	 * The above copyright notice and this permission notice shall be included in
+	 * all copies or substantial portions of the Software.
+	 *
+	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+	 * SOFTWARE.
+	 */
+
+	/**
+	 * Fetch a random integer between $min and $max inclusive
+	 *
+	 * @param int $min
+	 * @param int $max
+	 *
+	 * @throws Exception
+	 *
+	 * @return int
+	 */
+	function random_int($min, $max)
+	{
+		/**
+		 * Type and input logic checks
+		 *
+		 * If you pass it a float in the range (~PHP_INT_MAX, PHP_INT_MAX)
+		 * (non-inclusive), it will sanely cast it to an int. If you it's equal to
+		 * ~PHP_INT_MAX or PHP_INT_MAX, we let it fail as not an integer. Floats
+		 * lose precision, so the <= and => operators might accidentally let a float
+		 * through.
+		 */
+
+		try {
+			/** @var int $min */
+			$min = RandomCompat_intval($min);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_int(): $min must be an integer'
+			);
+		}
+
+		try {
+			/** @var int $max */
+			$max = RandomCompat_intval($max);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_int(): $max must be an integer'
+			);
+		}
+
+		/**
+		 * Now that we've verified our weak typing system has given us an integer,
+		 * let's validate the logic then we can move forward with generating random
+		 * integers along a given range.
+		 */
+		if ($min > $max) {
+			throw new Error(
+				'Minimum value must be less than or equal to the maximum value'
+			);
+		}
+
+		if ($max === $min) {
+			return (int) $min;
+		}
+
+		/**
+		 * Initialize variables to 0
+		 *
+		 * We want to store:
+		 * $bytes => the number of random bytes we need
+		 * $mask => an integer bitmask (for use with the &) operator
+		 *          so we can minimize the number of discards
+		 */
+		$attempts = $bits = $bytes = $mask = $valueShift = 0;
+		/** @var int $attempts */
+		/** @var int $bits */
+		/** @var int $bytes */
+		/** @var int $mask */
+		/** @var int $valueShift */
+
+		/**
+		 * At this point, $range is a positive number greater than 0. It might
+		 * overflow, however, if $max - $min > PHP_INT_MAX. PHP will cast it to
+		 * a float and we will lose some precision.
+		 *
+		 * @var int|float $range
+		 */
+		$range = $max - $min;
+
+		/**
+		 * Test for integer overflow:
+		 */
+		if (!is_int($range)) {
+
+			/**
+			 * Still safely calculate wider ranges.
+			 * Provided by @CodesInChaos, @oittaa
+			 *
+			 * @ref https://gist.github.com/CodesInChaos/03f9ea0b58e8b2b8d435
+			 *
+			 * We use ~0 as a mask in this case because it generates all 1s
+			 *
+			 * @ref https://eval.in/400356 (32-bit)
+			 * @ref http://3v4l.org/XX9r5  (64-bit)
+			 */
+			$bytes = PHP_INT_SIZE;
+			/** @var int $mask */
+			$mask = ~0;
+
+		} else {
+
+			/**
+			 * $bits is effectively ceil(log($range, 2)) without dealing with
+			 * type juggling
+			 */
+			while ($range > 0) {
+				if ($bits % 8 === 0) {
+					++$bytes;
+				}
+				++$bits;
+				$range >>= 1;
+				/** @var int $mask */
+				$mask = $mask << 1 | 1;
+			}
+			$valueShift = $min;
+		}
+
+		/** @var int $val */
+		$val = 0;
+		/**
+		 * Now that we have our parameters set up, let's begin generating
+		 * random integers until one falls between $min and $max
+		 */
+		/** @psalm-suppress RedundantCondition */
+		do {
+			/**
+			 * The rejection probability is at most 0.5, so this corresponds
+			 * to a failure probability of 2^-128 for a working RNG
+			 */
+			if ($attempts > 128) {
+				throw new Exception(
+					'random_int: RNG is broken - too many rejections'
+				);
+			}
+
+			/**
+			 * Let's grab the necessary number of random bytes
+			 */
+			$randomByteString = random_bytes($bytes);
+
+			/**
+			 * Let's turn $randomByteString into an integer
+			 *
+			 * This uses bitwise operators (<< and |) to build an integer
+			 * out of the values extracted from ord()
+			 *
+			 * Example: [9F] | [6D] | [32] | [0C] =>
+			 *   159 + 27904 + 3276800 + 201326592 =>
+			 *   204631455
+			 */
+			$val &= 0;
+			for ($i = 0; $i < $bytes; ++$i) {
+				$val |= ord($randomByteString[$i]) << ($i * 8);
+			}
+			/** @var int $val */
+
+			/**
+			 * Apply mask
+			 */
+			$val &= $mask;
+			$val += $valueShift;
+
+			++$attempts;
+			/**
+			 * If $val overflows to a floating point number,
+			 * ... or is larger than $max,
+			 * ... or smaller than $min,
+			 * then try again.
+			 */
+		} while (!is_int($val) || $val > $max || $val < $min);
+
+		return (int) $val;
+	}
 }

vendor/paragonie/random_compat/lib/random_bytes_libsodium_legacy.php

Indentation +58 added lines, -58 removed lines

@@ -27,67 +27,67 @@
  */
 
 if (!is_callable('random_bytes')) {
-    /**
-     * If the libsodium PHP extension is loaded, we'll use it above any other
-     * solution.
-     *
-     * libsodium-php project:
-     * @ref https://github.com/jedisct1/libsodium-php
-     *
-     * @param int $bytes
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    function random_bytes($bytes)
-    {
-        try {
-            /** @var int $bytes */
-            $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_bytes(): $bytes must be an integer'
-            );
-        }
+	/**
+	 * If the libsodium PHP extension is loaded, we'll use it above any other
+	 * solution.
+	 *
+	 * libsodium-php project:
+	 * @ref https://github.com/jedisct1/libsodium-php
+	 *
+	 * @param int $bytes
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	function random_bytes($bytes)
+	{
+		try {
+			/** @var int $bytes */
+			$bytes = RandomCompat_intval($bytes);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_bytes(): $bytes must be an integer'
+			);
+		}
 
-        if ($bytes < 1) {
-            throw new Error(
-                'Length must be greater than 0'
-            );
-        }
+		if ($bytes < 1) {
+			throw new Error(
+				'Length must be greater than 0'
+			);
+		}
 
-        /**
-         * @var string
-         */
-        $buf = '';
+		/**
+		 * @var string
+		 */
+		$buf = '';
 
-        /**
-         * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
-         * generated in one invocation.
-         */
-        if ($bytes > 2147483647) {
-            for ($i = 0; $i < $bytes; $i += 1073741824) {
-                $n = ($bytes - $i) > 1073741824
-                    ? 1073741824
-                    : $bytes - $i;
-                $buf .= Sodium::randombytes_buf((int) $n);
-            }
-        } else {
-            $buf .= Sodium::randombytes_buf((int) $bytes);
-        }
+		/**
+		 * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
+		 * generated in one invocation.
+		 */
+		if ($bytes > 2147483647) {
+			for ($i = 0; $i < $bytes; $i += 1073741824) {
+				$n = ($bytes - $i) > 1073741824
+					? 1073741824
+					: $bytes - $i;
+				$buf .= Sodium::randombytes_buf((int) $n);
+			}
+		} else {
+			$buf .= Sodium::randombytes_buf((int) $bytes);
+		}
 
-        if (is_string($buf)) {
-            if (RandomCompat_strlen($buf) === $bytes) {
-                return $buf;
-            }
-        }
+		if (is_string($buf)) {
+			if (RandomCompat_strlen($buf) === $bytes) {
+				return $buf;
+			}
+		}
 
-        /**
-         * If we reach here, PHP has failed us.
-         */
-        throw new Exception(
-            'Could not gather sufficient random data'
-        );
-    }
+		/**
+		 * If we reach here, PHP has failed us.
+		 */
+		throw new Exception(
+			'Could not gather sufficient random data'
+		);
+	}
 }

vendor/paragonie/random_compat/lib/cast_to_int.php

Indentation +44 added lines, -44 removed lines

@@ -28,50 +28,50 @@
 
 if (!is_callable('RandomCompat_intval')) {
 
-    /**
-     * Cast to an integer if we can, safely.
-     *
-     * If you pass it a float in the range (~PHP_INT_MAX, PHP_INT_MAX)
-     * (non-inclusive), it will sanely cast it to an int. If you it's equal to
-     * ~PHP_INT_MAX or PHP_INT_MAX, we let it fail as not an integer. Floats 
-     * lose precision, so the <= and => operators might accidentally let a float
-     * through.
-     *
-     * @param int|float $number    The number we want to convert to an int
-     * @param bool      $fail_open Set to true to not throw an exception
-     *
-     * @return float|int
-     * @psalm-suppress InvalidReturnType
-     *
-     * @throws TypeError
-     */
-    function RandomCompat_intval($number, $fail_open = false)
-    {
-        if (is_int($number) || is_float($number)) {
-            $number += 0;
-        } elseif (is_numeric($number)) {
-            /** @psalm-suppress InvalidOperand */
-            $number += 0;
-        }
-        /** @var int|float $number */
+	/**
+	 * Cast to an integer if we can, safely.
+	 *
+	 * If you pass it a float in the range (~PHP_INT_MAX, PHP_INT_MAX)
+	 * (non-inclusive), it will sanely cast it to an int. If you it's equal to
+	 * ~PHP_INT_MAX or PHP_INT_MAX, we let it fail as not an integer. Floats 
+	 * lose precision, so the <= and => operators might accidentally let a float
+	 * through.
+	 *
+	 * @param int|float $number    The number we want to convert to an int
+	 * @param bool      $fail_open Set to true to not throw an exception
+	 *
+	 * @return float|int
+	 * @psalm-suppress InvalidReturnType
+	 *
+	 * @throws TypeError
+	 */
+	function RandomCompat_intval($number, $fail_open = false)
+	{
+		if (is_int($number) || is_float($number)) {
+			$number += 0;
+		} elseif (is_numeric($number)) {
+			/** @psalm-suppress InvalidOperand */
+			$number += 0;
+		}
+		/** @var int|float $number */
 
-        if (
-            is_float($number)
-                &&
-            $number > ~PHP_INT_MAX
-                &&
-            $number < PHP_INT_MAX
-        ) {
-            $number = (int) $number;
-        }
+		if (
+			is_float($number)
+				&&
+			$number > ~PHP_INT_MAX
+				&&
+			$number < PHP_INT_MAX
+		) {
+			$number = (int) $number;
+		}
 
-        if (is_int($number)) {
-            return (int) $number;
-        } elseif (!$fail_open) {
-            throw new TypeError(
-                'Expected an integer.'
-            );
-        }
-        return $number;
-    }
+		if (is_int($number)) {
+			return (int) $number;
+		} elseif (!$fail_open) {
+			throw new TypeError(
+				'Expected an integer.'
+			);
+		}
+		return $number;
+	}
 }

vendor/paragonie/random_compat/lib/random_bytes_mcrypt.php

Indentation +46 added lines, -46 removed lines

@@ -27,53 +27,53 @@
  */
 
 if (!is_callable('random_bytes')) {
-    /**
-     * Powered by ext/mcrypt (and thankfully NOT libmcrypt)
-     *
-     * @ref https://bugs.php.net/bug.php?id=55169
-     * @ref https://github.com/php/php-src/blob/c568ffe5171d942161fc8dda066bce844bdef676/ext/mcrypt/mcrypt.c#L1321-L1386
-     *
-     * @param int $bytes
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    function random_bytes($bytes)
-    {
-        try {
-            /** @var int $bytes */
-            $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_bytes(): $bytes must be an integer'
-            );
-        }
+	/**
+	 * Powered by ext/mcrypt (and thankfully NOT libmcrypt)
+	 *
+	 * @ref https://bugs.php.net/bug.php?id=55169
+	 * @ref https://github.com/php/php-src/blob/c568ffe5171d942161fc8dda066bce844bdef676/ext/mcrypt/mcrypt.c#L1321-L1386
+	 *
+	 * @param int $bytes
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	function random_bytes($bytes)
+	{
+		try {
+			/** @var int $bytes */
+			$bytes = RandomCompat_intval($bytes);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_bytes(): $bytes must be an integer'
+			);
+		}
 
-        if ($bytes < 1) {
-            throw new Error(
-                'Length must be greater than 0'
-            );
-        }
+		if ($bytes < 1) {
+			throw new Error(
+				'Length must be greater than 0'
+			);
+		}
 
-        /** @var string|bool $buf */
-        $buf = @mcrypt_create_iv((int) $bytes, (int) MCRYPT_DEV_URANDOM);
-        if (
-            is_string($buf)
-                &&
-            RandomCompat_strlen($buf) === $bytes
-        ) {
-            /**
-             * Return our random entropy buffer here:
-             */
-            return $buf;
-        }
+		/** @var string|bool $buf */
+		$buf = @mcrypt_create_iv((int) $bytes, (int) MCRYPT_DEV_URANDOM);
+		if (
+			is_string($buf)
+				&&
+			RandomCompat_strlen($buf) === $bytes
+		) {
+			/**
+			 * Return our random entropy buffer here:
+			 */
+			return $buf;
+		}
 
-        /**
-         * If we reach here, PHP has failed us.
-         */
-        throw new Exception(
-            'Could not gather sufficient random data'
-        );
-    }
+		/**
+		 * If we reach here, PHP has failed us.
+		 */
+		throw new Exception(
+			'Could not gather sufficient random data'
+		);
+	}
 }

vendor/paragonie/random_compat/lib/random_bytes_libsodium.php

Indentation +57 added lines, -57 removed lines

@@ -27,65 +27,65 @@
  */
 
 if (!is_callable('random_bytes')) {
-    /**
-     * If the libsodium PHP extension is loaded, we'll use it above any other
-     * solution.
-     *
-     * libsodium-php project:
-     * @ref https://github.com/jedisct1/libsodium-php
-     *
-     * @param int $bytes
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    function random_bytes($bytes)
-    {
-        try {
-            /** @var int $bytes */
-            $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_bytes(): $bytes must be an integer'
-            );
-        }
+	/**
+	 * If the libsodium PHP extension is loaded, we'll use it above any other
+	 * solution.
+	 *
+	 * libsodium-php project:
+	 * @ref https://github.com/jedisct1/libsodium-php
+	 *
+	 * @param int $bytes
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	function random_bytes($bytes)
+	{
+		try {
+			/** @var int $bytes */
+			$bytes = RandomCompat_intval($bytes);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_bytes(): $bytes must be an integer'
+			);
+		}
 
-        if ($bytes < 1) {
-            throw new Error(
-                'Length must be greater than 0'
-            );
-        }
+		if ($bytes < 1) {
+			throw new Error(
+				'Length must be greater than 0'
+			);
+		}
 
-        /**
-         * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
-         * generated in one invocation.
-         */
-        /** @var string|bool $buf */
-        if ($bytes > 2147483647) {
-            $buf = '';
-            for ($i = 0; $i < $bytes; $i += 1073741824) {
-                $n = ($bytes - $i) > 1073741824
-                    ? 1073741824
-                    : $bytes - $i;
-                $buf .= \Sodium\randombytes_buf($n);
-            }
-        } else {
-            /** @var string|bool $buf */
-            $buf = \Sodium\randombytes_buf($bytes);
-        }
+		/**
+		 * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
+		 * generated in one invocation.
+		 */
+		/** @var string|bool $buf */
+		if ($bytes > 2147483647) {
+			$buf = '';
+			for ($i = 0; $i < $bytes; $i += 1073741824) {
+				$n = ($bytes - $i) > 1073741824
+					? 1073741824
+					: $bytes - $i;
+				$buf .= \Sodium\randombytes_buf($n);
+			}
+		} else {
+			/** @var string|bool $buf */
+			$buf = \Sodium\randombytes_buf($bytes);
+		}
 
-        if (is_string($buf)) {
-            if (RandomCompat_strlen($buf) === $bytes) {
-                return $buf;
-            }
-        }
+		if (is_string($buf)) {
+			if (RandomCompat_strlen($buf) === $bytes) {
+				return $buf;
+			}
+		}
 
-        /**
-         * If we reach here, PHP has failed us.
-         */
-        throw new Exception(
-            'Could not gather sufficient random data'
-        );
-    }
+		/**
+		 * If we reach here, PHP has failed us.
+		 */
+		throw new Exception(
+			'Could not gather sufficient random data'
+		);
+	}
 }