nochso / omni

src/Exec.php

Doc Comments +1 added lines, -1 removed lines

@@ -82,7 +82,7 @@
 	/**
 	 * getLastCommand returns the string last used by a previous call to `run()`.
 	 *
-	 * @return string|null
+	 * @return string
 	 */
 	public function getLastCommand() {
 		return $this->lastCommand;

Indentation +160 added lines, -160 removed lines

@@ -14,174 +14,174 @@
  * @see \nochso\Omni\OS::hasBinary Check if the binary/command is available before you run it.
  */
 class Exec {
-	/**
-	 * @var string[]
-	 */
-	private $prefixes;
-	/**
-	 * @var string[]
-	 */
-	private $output;
-	/**
-	 * @var int
-	 */
-	private $status;
-	/**
-	 * @var string
-	 */
-	private $lastCommand;
+    /**
+     * @var string[]
+     */
+    private $prefixes;
+    /**
+     * @var string[]
+     */
+    private $output;
+    /**
+     * @var int
+     */
+    private $status;
+    /**
+     * @var string
+     */
+    private $lastCommand;
 
-	/**
-	 * Create a new callable `Exec` object.
-	 *
-	 * @param string[] $prefixes,... Optional arguments will always be added to the beginning of the command.
-	 *
-	 * @return \nochso\Omni\Exec
-	 */
-	public static function create(...$prefixes) {
-		$exec = new self();
-		$exec->prefixes = $prefixes;
-		return $exec;
-	}
+    /**
+     * Create a new callable `Exec` object.
+     *
+     * @param string[] $prefixes,... Optional arguments will always be added to the beginning of the command.
+     *
+     * @return \nochso\Omni\Exec
+     */
+    public static function create(...$prefixes) {
+        $exec = new self();
+        $exec->prefixes = $prefixes;
+        return $exec;
+    }
 
-	/**
-	 * Run a command with auto-escaped arguments.
-	 *
-	 * @param string[] $arguments,... Optional arguments will be added after the prefixes.
-	 *
-	 * @return $this
-	 */
-	public function run(...$arguments) {
-		$this->lastCommand = $this->getCommand(...$arguments);
-		exec($this->lastCommand, $output, $status);
-		$this->output = $output;
-		$this->status = $status;
-		return $this;
-	}
+    /**
+     * Run a command with auto-escaped arguments.
+     *
+     * @param string[] $arguments,... Optional arguments will be added after the prefixes.
+     *
+     * @return $this
+     */
+    public function run(...$arguments) {
+        $this->lastCommand = $this->getCommand(...$arguments);
+        exec($this->lastCommand, $output, $status);
+        $this->output = $output;
+        $this->status = $status;
+        return $this;
+    }
 
-	/**
-	 * getCommand returns the string to be used by `\exec()`.
-	 *
-	 * @param string[] $arguments,...
-	 *
-	 * @return string
-	 */
-	public function getCommand(...$arguments) {
-		$command = [];
-		$allArguments = array_merge($this->prefixes, $arguments);
-		if (count($allArguments) === 0) {
-			$allArguments[] = '';
-		}
-		foreach ($allArguments as $argument) {
-			$command[] = $this->escapeArgument($argument);
-		}
-		$commandString = implode(' ', $command);
-		return $commandString;
-	}
+    /**
+     * getCommand returns the string to be used by `\exec()`.
+     *
+     * @param string[] $arguments,...
+     *
+     * @return string
+     */
+    public function getCommand(...$arguments) {
+        $command = [];
+        $allArguments = array_merge($this->prefixes, $arguments);
+        if (count($allArguments) === 0) {
+            $allArguments[] = '';
+        }
+        foreach ($allArguments as $argument) {
+            $command[] = $this->escapeArgument($argument);
+        }
+        $commandString = implode(' ', $command);
+        return $commandString;
+    }
 
-	/**
-	 * getLastCommand returns the string last used by a previous call to `run()`.
-	 *
-	 * @return string|null
-	 */
-	public function getLastCommand() {
-		return $this->lastCommand;
-	}
+    /**
+     * getLastCommand returns the string last used by a previous call to `run()`.
+     *
+     * @return string|null
+     */
+    public function getLastCommand() {
+        return $this->lastCommand;
+    }
 
-	/**
-	 * getOutput of last execution.
-	 *
-	 * @return string[]
-	 */
-	public function getOutput() {
-		return $this->output;
-	}
+    /**
+     * getOutput of last execution.
+     *
+     * @return string[]
+     */
+    public function getOutput() {
+        return $this->output;
+    }
 
-	/**
-	 * getStatus code of last execution.
-	 *
-	 * @return int
-	 */
-	public function getStatus() {
-		return $this->status;
-	}
+    /**
+     * getStatus code of last execution.
+     *
+     * @return int
+     */
+    public function getStatus() {
+        return $this->status;
+    }
 
-	/**
-	 * __invoke allows using this object as a callable by calling `run()`.
-	 *
-	 * e.g. `$runner('argument');`
-	 *
-	 * @param array $arguments,...
-	 *
-	 * @return \nochso\Omni\Exec
-	 */
-	public function __invoke(...$arguments) {
-		return $this->run(...$arguments);
-	}
+    /**
+     * __invoke allows using this object as a callable by calling `run()`.
+     *
+     * e.g. `$runner('argument');`
+     *
+     * @param array $arguments,...
+     *
+     * @return \nochso\Omni\Exec
+     */
+    public function __invoke(...$arguments) {
+        return $this->run(...$arguments);
+    }
 
-	/**
-	 * @param string $argument
-	 *
-	 * @return string
-	 */
-	private function escapeArgument($argument) {
-		// Always escape an empty argument so it doesn't get lost.
-		if ($argument === '') {
-			return escapeshellarg($argument);
-		}
-		if (!OS::isWindows()) {
-			return $this->escapeLinuxArgument($argument);
-		}
-		return $this->escapeWindowsArgument($argument);
-	}
+    /**
+     * @param string $argument
+     *
+     * @return string
+     */
+    private function escapeArgument($argument) {
+        // Always escape an empty argument so it doesn't get lost.
+        if ($argument === '') {
+            return escapeshellarg($argument);
+        }
+        if (!OS::isWindows()) {
+            return $this->escapeLinuxArgument($argument);
+        }
+        return $this->escapeWindowsArgument($argument);
+    }
 
-	/**
-	 * @param string $argument
-	 *
-	 * @return string
-	 */
-	private function escapeLinuxArgument($argument) {
-		$escapedArgument = escapeshellarg($argument);
-		// Is escaping really needed?
-		if ($argument !== '--' && mb_substr($escapedArgument, 1, -1) === $argument && preg_match('/^[a-z0-9-]+$/i', $argument) === 1) {
-			return $argument;
-		}
-		return $escapedArgument;
-	}
+    /**
+     * @param string $argument
+     *
+     * @return string
+     */
+    private function escapeLinuxArgument($argument) {
+        $escapedArgument = escapeshellarg($argument);
+        // Is escaping really needed?
+        if ($argument !== '--' && mb_substr($escapedArgument, 1, -1) === $argument && preg_match('/^[a-z0-9-]+$/i', $argument) === 1) {
+            return $argument;
+        }
+        return $escapedArgument;
+    }
 
-	/**
-	 * @param string $argument
-	 *
-	 * @return string
-	 *
-	 * @link https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
-	 */
-	private function escapeWindowsArgument($argument) {
-		// Check if there's anything to escape
-		if (strpbrk($argument, " \t\n\v\"\\") === false) {
-			return $argument;
-		}
-		$escapedArgument = '"';
-		$strlen = mb_strlen($argument);
-		for ($i = 0; $i < $strlen; $i++) {
-			$backslashes = 0;
-			while ($i < $strlen && mb_substr($argument, $i, 1) === '\\') {
-				$i++;
-				$backslashes++;
-			}
-			if ($i === $strlen) {
-				// Escape all backslashes, but let the terminating double quote be interpreted as a meta character
-				$escapedArgument .= str_repeat('\\', $backslashes * 2);
-			} elseif (mb_substr($argument, $i, 1) === '"') {
-				// Escape all backslashes and the following quotation mark
-				$escapedArgument .= str_repeat('\\', $backslashes * 2 + 1);
-				$escapedArgument .= '"';
-			} else {
-				$escapedArgument .= str_repeat('\\', $backslashes);
-				$escapedArgument .= mb_substr($argument, $i, 1);
-			}
-		}
-		$escapedArgument .= '"';
-		return $escapedArgument;
-	}
+    /**
+     * @param string $argument
+     *
+     * @return string
+     *
+     * @link https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
+     */
+    private function escapeWindowsArgument($argument) {
+        // Check if there's anything to escape
+        if (strpbrk($argument, " \t\n\v\"\\") === false) {
+            return $argument;
+        }
+        $escapedArgument = '"';
+        $strlen = mb_strlen($argument);
+        for ($i = 0; $i < $strlen; $i++) {
+            $backslashes = 0;
+            while ($i < $strlen && mb_substr($argument, $i, 1) === '\\') {
+                $i++;
+                $backslashes++;
+            }
+            if ($i === $strlen) {
+                // Escape all backslashes, but let the terminating double quote be interpreted as a meta character
+                $escapedArgument .= str_repeat('\\', $backslashes * 2);
+            } elseif (mb_substr($argument, $i, 1) === '"') {
+                // Escape all backslashes and the following quotation mark
+                $escapedArgument .= str_repeat('\\', $backslashes * 2 + 1);
+                $escapedArgument .= '"';
+            } else {
+                $escapedArgument .= str_repeat('\\', $backslashes);
+                $escapedArgument .= mb_substr($argument, $i, 1);
+            }
+        }
+        $escapedArgument .= '"';
+        return $escapedArgument;
+    }
 }

src/VcsVersionInfo.php

Indentation +111 added lines, -111 removed lines

@@ -26,122 +26,122 @@
  * as it uses different constructor parameters.
  */
 final class VcsVersionInfo {
-	/**
-	 * @var \nochso\Omni\VersionInfo
-	 */
-	private $version;
-	/**
-	 * @var string
-	 */
-	private $repositoryRoot;
+    /**
+     * @var \nochso\Omni\VersionInfo
+     */
+    private $version;
+    /**
+     * @var string
+     */
+    private $repositoryRoot;
 
-	/**
-	 * @param string $name            Package or application name.
-	 * @param string $fallBackVersion Optional version to fall back on if no repository info was found.
-	 * @param string $repositoryRoot  Path the VCS repository root (e.g. folder that contains ".git", ".hg", etc.)
-	 * @param string $infoFormat      Optional format to use for `getInfo`. Defaults to `VersionInfo::INFO_FORMAT_DEFAULT`
-	 *
-	 * @throws \RuntimeException When no fallback was given and tag could not be extracted from a VCS repo.
-	 */
-	public function __construct(
-		$name,
-		$fallBackVersion = null,
-		$repositoryRoot = '.',
-		$infoFormat = \nochso\Omni\VersionInfo::INFO_FORMAT_SHORT
-	) {
-		$this->repositoryRoot = $repositoryRoot;
-		$tag = $this->extractTag();
-		if ($tag === null) {
-			$tag = $fallBackVersion;
-		}
-		if ($tag === null) {
-			throw new \RuntimeException(
-				'Unable to detect version from VCS repository and no fallback version was specified.'
-			);
-		}
-		$this->version = new VersionInfo($name, $tag, $infoFormat);
-	}
+    /**
+     * @param string $name            Package or application name.
+     * @param string $fallBackVersion Optional version to fall back on if no repository info was found.
+     * @param string $repositoryRoot  Path the VCS repository root (e.g. folder that contains ".git", ".hg", etc.)
+     * @param string $infoFormat      Optional format to use for `getInfo`. Defaults to `VersionInfo::INFO_FORMAT_DEFAULT`
+     *
+     * @throws \RuntimeException When no fallback was given and tag could not be extracted from a VCS repo.
+     */
+    public function __construct(
+        $name,
+        $fallBackVersion = null,
+        $repositoryRoot = '.',
+        $infoFormat = \nochso\Omni\VersionInfo::INFO_FORMAT_SHORT
+    ) {
+        $this->repositoryRoot = $repositoryRoot;
+        $tag = $this->extractTag();
+        if ($tag === null) {
+            $tag = $fallBackVersion;
+        }
+        if ($tag === null) {
+            throw new \RuntimeException(
+                'Unable to detect version from VCS repository and no fallback version was specified.'
+            );
+        }
+        $this->version = new VersionInfo($name, $tag, $infoFormat);
+    }
 
-	/**
-	 * @return string
-	 */
-	public function getInfo() {
-		return $this->version->getInfo();
-	}
+    /**
+     * @return string
+     */
+    public function getInfo() {
+        return $this->version->getInfo();
+    }
 
-	/**
-	 * @return string
-	 */
-	public function getVersion() {
-		return $this->version->getVersion();
-	}
+    /**
+     * @return string
+     */
+    public function getVersion() {
+        return $this->version->getVersion();
+    }
 
-	/**
-	 * @return string
-	 */
-	public function getName() {
-		return $this->version->getName();
-	}
+    /**
+     * @return string
+     */
+    public function getName() {
+        return $this->version->getName();
+    }
 
-	private function extractTag() {
-		$tag = $this->readGit();
-		if ($tag === null) {
-			$tag = $this->readMercurial();
-		}
-		return $tag;
-	}
+    private function extractTag() {
+        $tag = $this->readGit();
+        if ($tag === null) {
+            $tag = $this->readMercurial();
+        }
+        return $tag;
+    }
 
-	/**
-	 * @return null|string
-	 */
-	private function readGit() {
-		$gitDir = Path::combine($this->repositoryRoot, '.git');
-		if (!is_dir($gitDir) || !OS::hasBinary('git')) {
-			return null;
-		}
-		$git = Exec::create('git', '--git-dir=' . $gitDir, '--work-tree=' . $this->repositoryRoot);
-		$git->run('describe', '--tags', '--always', '--dirty');
-		return Dot::get($git->getOutput(), 0);
-	}
+    /**
+     * @return null|string
+     */
+    private function readGit() {
+        $gitDir = Path::combine($this->repositoryRoot, '.git');
+        if (!is_dir($gitDir) || !OS::hasBinary('git')) {
+            return null;
+        }
+        $git = Exec::create('git', '--git-dir=' . $gitDir, '--work-tree=' . $this->repositoryRoot);
+        $git->run('describe', '--tags', '--always', '--dirty');
+        return Dot::get($git->getOutput(), 0);
+    }
 
-	/**
-	 * @return null|string
-	 */
-	private function readMercurial() {
-		$hgDir = Path::combine($this->repositoryRoot, '.hg');
-		if (!is_dir($hgDir) || !OS::hasBinary('hg')) {
-			return null;
-		}
-		$hg = Exec::create('hg', '--repository', $this->repositoryRoot);
-		// Removes everything but the tag if distance is zero.
-		$hg->run(
-			'log',
-			'-r',
-			'.',
-			'--template',
-			'{latesttag}{sub(\'^-0-m.*\', \'\', \'-{latesttagdistance}-m{node|short}\')}'
-		);
-		$tag = Dot::get($hg->getOutput(), 0);
-		// Actual null if no lines were returned or `hg log` returned actual "null".
-		// Either way, need to fall back to the revision id.
-		if ($tag === null || $tag === 'null' || Strings::startsWith($tag, 'null-')) {
-			$hg->run('id', '-i');
-			$tag = Dot::get($hg->getOutput(), 0);
-			// Remove 'dirty' plus from revision id
-			$tag = rtrim($tag, '+');
-		}
-		$summary = $hg->run('summary')->getOutput();
-		$isDirty = 0 === count(
-			array_filter(
-				$summary,
-				function ($line) {
-					return preg_match('/^commit: .*\(clean\)$/', $line) === 1;
-				}
-			)
-		);
-		if ($isDirty) {
-			$tag .= '-dirty';
-		}
-		return $tag;
-	}
+    /**
+     * @return null|string
+     */
+    private function readMercurial() {
+        $hgDir = Path::combine($this->repositoryRoot, '.hg');
+        if (!is_dir($hgDir) || !OS::hasBinary('hg')) {
+            return null;
+        }
+        $hg = Exec::create('hg', '--repository', $this->repositoryRoot);
+        // Removes everything but the tag if distance is zero.
+        $hg->run(
+            'log',
+            '-r',
+            '.',
+            '--template',
+            '{latesttag}{sub(\'^-0-m.*\', \'\', \'-{latesttagdistance}-m{node|short}\')}'
+        );
+        $tag = Dot::get($hg->getOutput(), 0);
+        // Actual null if no lines were returned or `hg log` returned actual "null".
+        // Either way, need to fall back to the revision id.
+        if ($tag === null || $tag === 'null' || Strings::startsWith($tag, 'null-')) {
+            $hg->run('id', '-i');
+            $tag = Dot::get($hg->getOutput(), 0);
+            // Remove 'dirty' plus from revision id
+            $tag = rtrim($tag, '+');
+        }
+        $summary = $hg->run('summary')->getOutput();
+        $isDirty = 0 === count(
+            array_filter(
+                $summary,
+                function ($line) {
+                    return preg_match('/^commit: .*\(clean\)$/', $line) === 1;
+                }
+            )
+        );
+        if ($isDirty) {
+            $tag .= '-dirty';
+        }
+        return $tag;
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -99,7 +99,7 @@
 		if (!is_dir($gitDir) || !OS::hasBinary('git')) {
 			return null;
 		}
-		$git = Exec::create('git', '--git-dir=' . $gitDir, '--work-tree=' . $this->repositoryRoot);
+		$git = Exec::create('git', '--git-dir='.$gitDir, '--work-tree='.$this->repositoryRoot);
 		$git->run('describe', '--tags', '--always', '--dirty');
 		return Dot::get($git->getOutput(), 0);
 	}

src/Type.php

Indentation +29 added lines, -29 removed lines

@@ -10,34 +10,34 @@
  * - easier debugging
  */
 final class Type {
-	/**
-	 * Summarize the type of any variable.
-	 *
-	 * @param mixed $value
-	 *
-	 * @return string Result of `get_class` for objects or `gettype` for anything else.
-	 *
-	 * @see gettype
-	 * @see get_class
-	 */
-	public static function summarize($value) {
-		if (!is_object($value)) {
-			return gettype($value);
-		}
-		return get_class($value);
-	}
+    /**
+     * Summarize the type of any variable.
+     *
+     * @param mixed $value
+     *
+     * @return string Result of `get_class` for objects or `gettype` for anything else.
+     *
+     * @see gettype
+     * @see get_class
+     */
+    public static function summarize($value) {
+        if (!is_object($value)) {
+            return gettype($value);
+        }
+        return get_class($value);
+    }
 
-	/**
-	 * getClassName returns the class name without namespaces.
-	 *
-	 * @param object|string $object Object instance of a fully qualified name.
-	 *
-	 * @return string
-	 */
-	public static function getClassName($object) {
-		if (is_object($object)) {
-			$object = get_class($object);
-		}
-		return ltrim(substr($object, strrpos($object, '\\')), '\\');
-	}
+    /**
+     * getClassName returns the class name without namespaces.
+     *
+     * @param object|string $object Object instance of a fully qualified name.
+     *
+     * @return string
+     */
+    public static function getClassName($object) {
+        if (is_object($object)) {
+            $object = get_class($object);
+        }
+        return ltrim(substr($object, strrpos($object, '\\')), '\\');
+    }
 }

src/PhpCsFixer/PrettyPSR.php

Indentation +79 added lines, -79 removed lines

@@ -24,85 +24,85 @@
  * ```
  */
 class PrettyPSR extends Config {
-	/**
-	 * @param string|array $dirs
-	 *
-	 * @return static
-	 */
-	public static function createIn($dirs) {
-		$config = new static();
-		$config->finder(DefaultFinder::createIn($dirs));
-		return $config;
-	}
+    /**
+     * @param string|array $dirs
+     *
+     * @return static
+     */
+    public static function createIn($dirs) {
+        $config = new static();
+        $config->finder(DefaultFinder::createIn($dirs));
+        return $config;
+    }
 
-	/**
-	 * @param string $name
-	 * @param string $description
-	 */
-	public function __construct($name = self::class, $description = '') {
-		parent::__construct($name, $description);
-		$this->level = FixerInterface::PSR2_LEVEL;
-		$this->fixers = $this->getDefaultFixers();
-		$this->setUsingCache(true);
-	}
+    /**
+     * @param string $name
+     * @param string $description
+     */
+    public function __construct($name = self::class, $description = '') {
+        parent::__construct($name, $description);
+        $this->level = FixerInterface::PSR2_LEVEL;
+        $this->fixers = $this->getDefaultFixers();
+        $this->setUsingCache(true);
+    }
 
-	/**
-	 * @return string[]
-	 */
-	public function getDefaultFixers() {
-		return [
-			'-psr0',
-			'-return',
-			'-concat_without_spaces',
-			'-empty_return',
-			'extra_empty_lines',
-			'concat_with_spaces',
-			'array_element_no_space_before_comma',
-			'array_element_white_space_after_comma',
-			'double_arrow_multiline_whitespaces',
-			'duplicate_semicolon',
-			'function_typehint_space',
-			'include',
-			'list_commas',
-			'multiline_array_trailing_comma',
-			'namespace_no_leading_whitespace',
-			'newline_after_open_tag',
-			'new_with_braces',
-			'no_blank_lines_after_class_opening',
-			'no_blank_lines_before_namespace',
-			'no_empty_lines_after_phpdocs',
-			'object_operator',
-			'operators_spaces',
-			'spaces_cast',
-			'ordered_use',
-			'phpdoc_indent',
-			'phpdoc_inline_tag',
-			'phpdoc_no_access',
-			'phpdoc_no_package',
-			'phpdoc_order',
-			'phpdoc_params',
-			'phpdoc_scalar',
-			'phpdoc_separation',
-			'phpdoc_short_description',
-			'phpdoc_to_comment',
-			'phpdoc_trim',
-			'phpdoc_types',
-			'phpdoc_type_to_var',
-			'print_to_echo',
-			'remove_lines_between_uses',
-			'self_accessor',
-			'short_array_syntax',
-			'single_array_no_trailing_comma',
-			'single_quote',
-			'spaces_before_semicolon',
-			'ternary_spaces',
-			'trim_array_spaces',
-			'unalign_double_arrow',
-			'unalign_equals',
-			'unary_operators_spaces',
-			'unneeded_control_parentheses',
-			'unused_use',
-			'whitespacy_lines',
-		];
-	}
+    /**
+     * @return string[]
+     */
+    public function getDefaultFixers() {
+        return [
+            '-psr0',
+            '-return',
+            '-concat_without_spaces',
+            '-empty_return',
+            'extra_empty_lines',
+            'concat_with_spaces',
+            'array_element_no_space_before_comma',
+            'array_element_white_space_after_comma',
+            'double_arrow_multiline_whitespaces',
+            'duplicate_semicolon',
+            'function_typehint_space',
+            'include',
+            'list_commas',
+            'multiline_array_trailing_comma',
+            'namespace_no_leading_whitespace',
+            'newline_after_open_tag',
+            'new_with_braces',
+            'no_blank_lines_after_class_opening',
+            'no_blank_lines_before_namespace',
+            'no_empty_lines_after_phpdocs',
+            'object_operator',
+            'operators_spaces',
+            'spaces_cast',
+            'ordered_use',
+            'phpdoc_indent',
+            'phpdoc_inline_tag',
+            'phpdoc_no_access',
+            'phpdoc_no_package',
+            'phpdoc_order',
+            'phpdoc_params',
+            'phpdoc_scalar',
+            'phpdoc_separation',
+            'phpdoc_short_description',
+            'phpdoc_to_comment',
+            'phpdoc_trim',
+            'phpdoc_types',
+            'phpdoc_type_to_var',
+            'print_to_echo',
+            'remove_lines_between_uses',
+            'self_accessor',
+            'short_array_syntax',
+            'single_array_no_trailing_comma',
+            'single_quote',
+            'spaces_before_semicolon',
+            'ternary_spaces',
+            'trim_array_spaces',
+            'unalign_double_arrow',
+            'unalign_equals',
+            'unary_operators_spaces',
+            'unneeded_control_parentheses',
+            'unused_use',
+            'whitespacy_lines',
+        ];
+    }
 }

src/PhpCsFixer/DefaultFinder.php

Indentation +65 added lines, -65 removed lines

@@ -8,74 +8,74 @@
  * DefaultFinder respects ignore files for Git, Mercurial and Darcs.
  */
 class DefaultFinder extends Finder {
-	/**
-	 * @param array|string $dirs
-	 *
-	 * @return \nochso\Omni\PhpCsFixer\DefaultFinder
-	 */
-	public static function createIn($dirs) {
-		$finder = new self();
-		if (!is_array($dirs)) {
-			$dirs = [$dirs];
-		}
-		$finder->in($dirs);
-		$excludes = [];
-		foreach ($finder->getVcsIgnoreFiles($dirs) as $ignore) {
-			$excludes = array_merge($excludes, $finder->readExcludeLines($ignore));
-		}
-		$finder->exclude($excludes);
-		return $finder;
-	}
+    /**
+     * @param array|string $dirs
+     *
+     * @return \nochso\Omni\PhpCsFixer\DefaultFinder
+     */
+    public static function createIn($dirs) {
+        $finder = new self();
+        if (!is_array($dirs)) {
+            $dirs = [$dirs];
+        }
+        $finder->in($dirs);
+        $excludes = [];
+        foreach ($finder->getVcsIgnoreFiles($dirs) as $ignore) {
+            $excludes = array_merge($excludes, $finder->readExcludeLines($ignore));
+        }
+        $finder->exclude($excludes);
+        return $finder;
+    }
 
-	public function __construct() {
-		parent::__construct();
-		foreach ($this->getNames() as $name) {
-			$this->name($name);
-		}
-		$this->files()->ignoreDotFiles(true)->ignoreVCS(true);
-	}
+    public function __construct() {
+        parent::__construct();
+        foreach ($this->getNames() as $name) {
+            $this->name($name);
+        }
+        $this->files()->ignoreDotFiles(true)->ignoreVCS(true);
+    }
 
-	/**
-	 * @return array
-	 */
-	protected function getNames() {
-		return ['*.php', '*.twig', '#.*.ya?ml#i', '*.xml'];
-	}
+    /**
+     * @return array
+     */
+    protected function getNames() {
+        return ['*.php', '*.twig', '#.*.ya?ml#i', '*.xml'];
+    }
 
-	/**
-	 * @param array $dirs
-	 *
-	 * @return array
-	 */
-	protected function getVcsIgnoreFiles(array $dirs) {
-		$files = ['.gitignore', '.hgignore', '_darcs/prefs/boring'];
-		$filepaths = [];
-		foreach ($dirs as $dir) {
-			foreach ($files as $file) {
-				$filepaths[] = Path::combine($dir, $file);
-			}
-		}
-		return $filepaths;
-	}
+    /**
+     * @param array $dirs
+     *
+     * @return array
+     */
+    protected function getVcsIgnoreFiles(array $dirs) {
+        $files = ['.gitignore', '.hgignore', '_darcs/prefs/boring'];
+        $filepaths = [];
+        foreach ($dirs as $dir) {
+            foreach ($files as $file) {
+                $filepaths[] = Path::combine($dir, $file);
+            }
+        }
+        return $filepaths;
+    }
 
-	/**
-	 * @param $ignoreFile
-	 *
-	 * @return array
-	 */
-	private function readExcludeLines($ignoreFile) {
-		if (!file_exists($ignoreFile)) {
-			return [];
-		}
-		$lines = file($ignoreFile);
-		if ($lines === false) {
-			// Not sure how to test, so ignore it instead of inlining it above
-			return [];
-			// @codeCoverageIgnore
+    /**
+     * @param $ignoreFile
+     *
+     * @return array
+     */
+    private function readExcludeLines($ignoreFile) {
+        if (!file_exists($ignoreFile)) {
+            return [];
+        }
+        $lines = file($ignoreFile);
+        if ($lines === false) {
+            // Not sure how to test, so ignore it instead of inlining it above
+            return [];
+            // @codeCoverageIgnore
 
-		}
-		return array_map(function ($line) {
-				return rtrim($line, "\r\n\\/");
-			}, $lines);
-	}
+        }
+        return array_map(function ($line) {
+                return rtrim($line, "\r\n\\/");
+            }, $lines);
+    }
 }

src/Dot.php

Indentation +161 added lines, -161 removed lines

@@ -5,174 +5,174 @@
  * Dot allows easy access to multi-dimensional arrays using dot notation.
  */
 final class Dot {
-	/**
-	 * Get the value of the element at the given dot key path.
-	 *
-	 * @param array      $array   Multi-dimensional array to access.
-	 * @param string     $path    Dot-notation key path. e.g. `parent.child`
-	 * @param null|mixed $default Default value to return
-	 *
-	 * @return mixed
-	 */
-	public static function get(array $array, $path, $default = null) {
-		$getter = function ($arrayCarry, $key) use ($default) {
-			if (!is_array($arrayCarry) || !isset($arrayCarry[$key])) {
-				return $default;
-			}
-			return $arrayCarry[$key];
-		};
-		$keys = self::extractKeys($path);
-		return array_reduce($keys, $getter, $array);
-	}
+    /**
+     * Get the value of the element at the given dot key path.
+     *
+     * @param array      $array   Multi-dimensional array to access.
+     * @param string     $path    Dot-notation key path. e.g. `parent.child`
+     * @param null|mixed $default Default value to return
+     *
+     * @return mixed
+     */
+    public static function get(array $array, $path, $default = null) {
+        $getter = function ($arrayCarry, $key) use ($default) {
+            if (!is_array($arrayCarry) || !isset($arrayCarry[$key])) {
+                return $default;
+            }
+            return $arrayCarry[$key];
+        };
+        $keys = self::extractKeys($path);
+        return array_reduce($keys, $getter, $array);
+    }
 
-	/**
-	 * Has returns true if an element exists at the given dot key path.
-	 *
-	 * @param array  $array Multi-dimensionsal array to search.
-	 * @param string $path  Dot-notation key path to search.
-	 *
-	 * @return bool
-	 */
-	public static function has(array $array, $path) {
-		$unique = new \stdClass();
-		$value = self::get($array, $path, $unique);
-		return $value !== $unique;
-	}
+    /**
+     * Has returns true if an element exists at the given dot key path.
+     *
+     * @param array  $array Multi-dimensionsal array to search.
+     * @param string $path  Dot-notation key path to search.
+     *
+     * @return bool
+     */
+    public static function has(array $array, $path) {
+        $unique = new \stdClass();
+        $value = self::get($array, $path, $unique);
+        return $value !== $unique;
+    }
 
-	/**
-	 * Set a value at a certain path by creating missing elements and overwriting non-array values.
-	 *
-	 * If any of the visited elements is not an array, it will be replaced with an array.
-	 *
-	 * This will overwrite existing non-array values.
-	 *
-	 * @param array  $array
-	 * @param string $path
-	 * @param mixed  $value
-	 */
-	public static function set(array &$array, $path, $value) {
-		self::setHelper($array, $path, $value, false);
-	}
+    /**
+     * Set a value at a certain path by creating missing elements and overwriting non-array values.
+     *
+     * If any of the visited elements is not an array, it will be replaced with an array.
+     *
+     * This will overwrite existing non-array values.
+     *
+     * @param array  $array
+     * @param string $path
+     * @param mixed  $value
+     */
+    public static function set(array &$array, $path, $value) {
+        self::setHelper($array, $path, $value, false);
+    }
 
-	/**
-	 * trySet sets a value at a certain path, expecting arrays or missing elements along the way.
-	 *
-	 * If any of the visited elements is not an array, a \RuntimeException is thrown.
-	 *
-	 * Use this if you want to avoid overwriting existing non-array values.
-	 *
-	 * @param array  $array
-	 * @param string $path
-	 * @param mixed  $value
-	 *
-	 * @throws \RuntimeException
-	 */
-	public static function trySet(array &$array, $path, $value) {
-		self::setHelper($array, $path, $value, true);
-	}
+    /**
+     * trySet sets a value at a certain path, expecting arrays or missing elements along the way.
+     *
+     * If any of the visited elements is not an array, a \RuntimeException is thrown.
+     *
+     * Use this if you want to avoid overwriting existing non-array values.
+     *
+     * @param array  $array
+     * @param string $path
+     * @param mixed  $value
+     *
+     * @throws \RuntimeException
+     */
+    public static function trySet(array &$array, $path, $value) {
+        self::setHelper($array, $path, $value, true);
+    }
 
-	/**
-	 * Remove an element if it exists.
-	 *
-	 * @param array  $array
-	 * @param string $path
-	 */
-	public static function remove(array &$array, $path) {
-		$keys = self::extractKeys($path);
-		$keysWithoutLast = array_slice($keys, 0, -1);
-		$keyCount = count($keysWithoutLast);
-		$lastKey = $keys[$keyCount];
-		$node =& $array;
-		// Abort when key is missing earlier than expected
-		for ($i = 0; $i < $keyCount && is_array($node) && isset($node[$keys[$i]]); ++$i) {
-			$node =& $node[$keys[$i]];
-		}
-		if ($i < $keyCount) {
-			return;
-		}
-		if (is_array($node) && isset($node[$lastKey])) {
-			unset($node[$lastKey]);
-		}
-	}
+    /**
+     * Remove an element if it exists.
+     *
+     * @param array  $array
+     * @param string $path
+     */
+    public static function remove(array &$array, $path) {
+        $keys = self::extractKeys($path);
+        $keysWithoutLast = array_slice($keys, 0, -1);
+        $keyCount = count($keysWithoutLast);
+        $lastKey = $keys[$keyCount];
+        $node =& $array;
+        // Abort when key is missing earlier than expected
+        for ($i = 0; $i < $keyCount && is_array($node) && isset($node[$keys[$i]]); ++$i) {
+            $node =& $node[$keys[$i]];
+        }
+        if ($i < $keyCount) {
+            return;
+        }
+        if (is_array($node) && isset($node[$lastKey])) {
+            unset($node[$lastKey]);
+        }
+    }
 
-	/**
-	 * Flatten the array into a single dimension array with dot paths as keys.
-	 *
-	 * @param array       $array
-	 * @param null|string $parent
-	 *
-	 * @return array
-	 */
-	public static function flatten(array $array, $parent = null) {
-		$flat = [];
-		foreach ($array as $key => $value) {
-			$keypath = self::escapeKey($key);
-			if ($parent !== null) {
-				$keypath = $parent . '.' . $keypath;
-			}
-			if (is_array($value)) {
-				$flat = array_merge(self::flatten($value, $keypath), $flat);
-			} else {
-				$flat[$keypath] = $value;
-			}
-		}
-		return $flat;
-	}
+    /**
+     * Flatten the array into a single dimension array with dot paths as keys.
+     *
+     * @param array       $array
+     * @param null|string $parent
+     *
+     * @return array
+     */
+    public static function flatten(array $array, $parent = null) {
+        $flat = [];
+        foreach ($array as $key => $value) {
+            $keypath = self::escapeKey($key);
+            if ($parent !== null) {
+                $keypath = $parent . '.' . $keypath;
+            }
+            if (is_array($value)) {
+                $flat = array_merge(self::flatten($value, $keypath), $flat);
+            } else {
+                $flat[$keypath] = $value;
+            }
+        }
+        return $flat;
+    }
 
-	/**
-	 * escapeKey escapes an individual part of a key.
-	 *
-	 * @param string $key
-	 *
-	 * @return string
-	 */
-	private static function escapeKey($key) {
-		$re = '/([\\.\\\\])/';
-		$subst = '\\\$1';
-		return preg_replace($re, $subst, $key);
-	}
+    /**
+     * escapeKey escapes an individual part of a key.
+     *
+     * @param string $key
+     *
+     * @return string
+     */
+    private static function escapeKey($key) {
+        $re = '/([\\.\\\\])/';
+        $subst = '\\\$1';
+        return preg_replace($re, $subst, $key);
+    }
 
-	/**
-	 * @param string $path
-	 *
-	 * @return array
-	 */
-	private static function extractKeys($path) {
-		$keys = [];
-		if (!preg_match_all('/(?:\\\\.|[^\\.\\\\]++)+/', $path, $matches)) {
-			return [$path];
-		}
-		foreach ($matches[0] as $match) {
-			$keys[] = str_replace(['\.', '\\\\'], ['.', '\\'], $match);
-		}
-		return $keys;
-	}
+    /**
+     * @param string $path
+     *
+     * @return array
+     */
+    private static function extractKeys($path) {
+        $keys = [];
+        if (!preg_match_all('/(?:\\\\.|[^\\.\\\\]++)+/', $path, $matches)) {
+            return [$path];
+        }
+        foreach ($matches[0] as $match) {
+            $keys[] = str_replace(['\.', '\\\\'], ['.', '\\'], $match);
+        }
+        return $keys;
+    }
 
-	private static function setHelper(array &$array, $path, $value, $strict = true) {
-		$keys = self::extractKeys($path);
-		$lastKey = $keys[count($keys) - 1];
-		$keysWithoutLast = array_slice($keys, 0, -1);
-		$node =& $array;
-		foreach ($keysWithoutLast as $key) {
-			self::prepareNode($node, $key, $path, $strict);
-			$node =& $node[$key];
-		}
-		$node[$lastKey] = $value;
-	}
+    private static function setHelper(array &$array, $path, $value, $strict = true) {
+        $keys = self::extractKeys($path);
+        $lastKey = $keys[count($keys) - 1];
+        $keysWithoutLast = array_slice($keys, 0, -1);
+        $node =& $array;
+        foreach ($keysWithoutLast as $key) {
+            self::prepareNode($node, $key, $path, $strict);
+            $node =& $node[$key];
+        }
+        $node[$lastKey] = $value;
+    }
 
-	private static function prepareNode(array &$node, $key, $path, $strict) {
-		if (!isset($node[$key]) || !$strict && !is_array($node[$key])) {
-			$node[$key] = [];
-		}
-		if ($strict && !is_array($node[$key])) {
-			throw new \RuntimeException(
-				sprintf(
-					"Can not set value at path '%s' because the element at key '%s' is not an array. Found value of type '%s' instead.",
-					$path,
-					$key,
-					gettype($node[$key])
-				)
-			);
-		}
-	}
+    private static function prepareNode(array &$node, $key, $path, $strict) {
+        if (!isset($node[$key]) || !$strict && !is_array($node[$key])) {
+            $node[$key] = [];
+        }
+        if ($strict && !is_array($node[$key])) {
+            throw new \RuntimeException(
+                sprintf(
+                    "Can not set value at path '%s' because the element at key '%s' is not an array. Found value of type '%s' instead.",
+                    $path,
+                    $key,
+                    gettype($node[$key])
+                )
+            );
+        }
+    }
 }

Spacing +5 added lines, -5 removed lines

@@ -82,10 +82,10 @@ 
 		$keysWithoutLast = array_slice($keys, 0, -1);
 		$keyCount = count($keysWithoutLast);
 		$lastKey = $keys[$keyCount];
-		$node =& $array;
+		$node = & $array;
 		// Abort when key is missing earlier than expected
 		for ($i = 0; $i < $keyCount && is_array($node) && isset($node[$keys[$i]]); ++$i) {
-			$node =& $node[$keys[$i]];
+			$node = & $node[$keys[$i]];
 		}
 		if ($i < $keyCount) {
 			return;
@@ -108,7 +108,7 @@ 
 		foreach ($array as $key => $value) {
 			$keypath = self::escapeKey($key);
 			if ($parent !== null) {
-				$keypath = $parent . '.' . $keypath;
+				$keypath = $parent.'.'.$keypath;
 			}
 			if (is_array($value)) {
 				$flat = array_merge(self::flatten($value, $keypath), $flat);
@@ -152,10 +152,10 @@ 
 		$keys = self::extractKeys($path);
 		$lastKey = $keys[count($keys) - 1];
 		$keysWithoutLast = array_slice($keys, 0, -1);
-		$node =& $array;
+		$node = & $array;
 		foreach ($keysWithoutLast as $key) {
 			self::prepareNode($node, $key, $path, $strict);
-			$node =& $node[$key];
+			$node = & $node[$key];
 		}
 		$node[$lastKey] = $value;
 	}

src/DotArray.php

Indentation +146 added lines, -146 removed lines

@@ -28,163 +28,163 @@
  * @see \nochso\Omni\Dot
  */
 class DotArray implements \ArrayAccess, \IteratorAggregate{
-	private $data;
+    private $data;
 
-	/**
-	 * @param array $array Any (nested) array.
-	 */
-	public function __construct(array $array = []) {
-		$this->data = $array;
-	}
+    /**
+     * @param array $array Any (nested) array.
+     */
+    public function __construct(array $array = []) {
+        $this->data = $array;
+    }
 
-	/**
-	 * getArray returns the complete array.
-	 *
-	 * @return array
-	 */
-	public function getArray() {
-		return $this->data;
-	}
+    /**
+     * getArray returns the complete array.
+     *
+     * @return array
+     */
+    public function getArray() {
+        return $this->data;
+    }
 
-	/**
-	 * Get the value of the element at the given dot key path.
-	 *
-	 * @param string     $path    Dot-notation key path. e.g. `parent.child`
-	 * @param null|mixed $default Default value to return
-	 *
-	 * @return mixed
-	 */
-	public function get($path, $default = null) {
-		return Dot::get($this->data, $path, $default);
-	}
+    /**
+     * Get the value of the element at the given dot key path.
+     *
+     * @param string     $path    Dot-notation key path. e.g. `parent.child`
+     * @param null|mixed $default Default value to return
+     *
+     * @return mixed
+     */
+    public function get($path, $default = null) {
+        return Dot::get($this->data, $path, $default);
+    }
 
-	/**
-	 * Has returns true if an element exists at the given dot key path.
-	 *
-	 * @param string $path Dot-notation key path to search.
-	 *
-	 * @return bool
-	 */
-	public function has($path) {
-		return Dot::has($this->data, $path);
-	}
+    /**
+     * Has returns true if an element exists at the given dot key path.
+     *
+     * @param string $path Dot-notation key path to search.
+     *
+     * @return bool
+     */
+    public function has($path) {
+        return Dot::has($this->data, $path);
+    }
 
-	/**
-	 * Set a value at a certain path by creating missing elements and overwriting non-array values.
-	 *
-	 * If any of the visited elements is not an array, it will be replaced with an array.
-	 *
-	 * This will overwrite existing non-array values.
-	 *
-	 * @param string $path
-	 * @param mixed  $value
-	 */
-	public function set($path, $value) {
-		Dot::set($this->data, $path, $value);
-	}
+    /**
+     * Set a value at a certain path by creating missing elements and overwriting non-array values.
+     *
+     * If any of the visited elements is not an array, it will be replaced with an array.
+     *
+     * This will overwrite existing non-array values.
+     *
+     * @param string $path
+     * @param mixed  $value
+     */
+    public function set($path, $value) {
+        Dot::set($this->data, $path, $value);
+    }
 
-	/**
-	 * trySet sets a value at a certain path, expecting arrays or missing elements along the way.
-	 *
-	 * If any of the visited elements is not an array, a \RuntimeException is thrown.
-	 *
-	 * Use this if you want to avoid overwriting existing non-array values.
-	 *
-	 * @param string $path
-	 * @param mixed  $value
-	 *
-	 * @throws \RuntimeException
-	 */
-	public function trySet($path, $value) {
-		Dot::trySet($this->data, $path, $value);
-	}
+    /**
+     * trySet sets a value at a certain path, expecting arrays or missing elements along the way.
+     *
+     * If any of the visited elements is not an array, a \RuntimeException is thrown.
+     *
+     * Use this if you want to avoid overwriting existing non-array values.
+     *
+     * @param string $path
+     * @param mixed  $value
+     *
+     * @throws \RuntimeException
+     */
+    public function trySet($path, $value) {
+        Dot::trySet($this->data, $path, $value);
+    }
 
-	/**
-	 * Remove an element if it exists.
-	 *
-	 * @param string $path
-	 */
-	public function remove($path) {
-		Dot::remove($this->data, $path);
-	}
+    /**
+     * Remove an element if it exists.
+     *
+     * @param string $path
+     */
+    public function remove($path) {
+        Dot::remove($this->data, $path);
+    }
 
-	/**
-	 * Flatten the array into a single dimension array with escaped dot paths as keys.
-	 *
-	 * Dots within specific keys are escaped.
-	 *
-	 * @return array
-	 */
-	public function flatten() {
-		return Dot::flatten($this->data);
-	}
+    /**
+     * Flatten the array into a single dimension array with escaped dot paths as keys.
+     *
+     * Dots within specific keys are escaped.
+     *
+     * @return array
+     */
+    public function flatten() {
+        return Dot::flatten($this->data);
+    }
 
-	/**
-	 * getIterator allows you to iterate over a flattened array using `foreach`.
-	 *
-	 * Keys are escaped and thus safe to use.
-	 *
-	 * @link  http://php.net/manual/en/iteratoraggregate.getiterator.php
-	 *
-	 * @return \Traversable An instance of an object implementing <b>Iterator</b> or <b>Traversable</b>
-	 */
-	public function getIterator() {
-		return new \ArrayIterator($this->flatten());
-	}
+    /**
+     * getIterator allows you to iterate over a flattened array using `foreach`.
+     *
+     * Keys are escaped and thus safe to use.
+     *
+     * @link  http://php.net/manual/en/iteratoraggregate.getiterator.php
+     *
+     * @return \Traversable An instance of an object implementing <b>Iterator</b> or <b>Traversable</b>
+     */
+    public function getIterator() {
+        return new \ArrayIterator($this->flatten());
+    }
 
-	/**
-	 * offsetExists allows using `isset($da['a.b'])`.
-	 *
-	 * @link  http://php.net/manual/en/arrayaccess.offsetexists.php
-	 *
-	 * @param mixed $offset An offset to check for.
-	 *
-	 * @return bool true on success or false on failure.
-	 */
-	public function offsetExists($offset) {
-		return $this->has($offset);
-	}
+    /**
+     * offsetExists allows using `isset($da['a.b'])`.
+     *
+     * @link  http://php.net/manual/en/arrayaccess.offsetexists.php
+     *
+     * @param mixed $offset An offset to check for.
+     *
+     * @return bool true on success or false on failure.
+     */
+    public function offsetExists($offset) {
+        return $this->has($offset);
+    }
 
-	/**
-	 * offsetGet allows array access, e.g. `$da['a.b']`.
-	 *
-	 * @link  http://php.net/manual/en/arrayaccess.offsetget.php
-	 *
-	 * @param mixed $offset The offset to retrieve.
-	 *
-	 * @return mixed Can return all value types.
-	 */
-	public function offsetGet($offset) {
-		return $this->get($offset);
-	}
+    /**
+     * offsetGet allows array access, e.g. `$da['a.b']`.
+     *
+     * @link  http://php.net/manual/en/arrayaccess.offsetget.php
+     *
+     * @param mixed $offset The offset to retrieve.
+     *
+     * @return mixed Can return all value types.
+     */
+    public function offsetGet($offset) {
+        return $this->get($offset);
+    }
 
-	/**
-	 * offsetSet allows writing to arrays `$da['a.b'] = 'foo'`.
-	 *
-	 * @link  http://php.net/manual/en/arrayaccess.offsetset.php
-	 *
-	 * @param mixed $offset The offset to assign the value to.
-	 * @param mixed $value  The value to set.
-	 *
-	 * @return void
-	 */
-	public function offsetSet($offset, $value) {
-		if ($offset === null) {
-			throw new \InvalidArgumentException(sprintf('Appending to %s is not supported.', self::class));
-		}
-		$this->set($offset, $value);
-	}
+    /**
+     * offsetSet allows writing to arrays `$da['a.b'] = 'foo'`.
+     *
+     * @link  http://php.net/manual/en/arrayaccess.offsetset.php
+     *
+     * @param mixed $offset The offset to assign the value to.
+     * @param mixed $value  The value to set.
+     *
+     * @return void
+     */
+    public function offsetSet($offset, $value) {
+        if ($offset === null) {
+            throw new \InvalidArgumentException(sprintf('Appending to %s is not supported.', self::class));
+        }
+        $this->set($offset, $value);
+    }
 
-	/**
-	 * offsetUnset allows using `unset($da['a.b'])`.
-	 *
-	 * @link  http://php.net/manual/en/arrayaccess.offsetunset.php
-	 *
-	 * @param mixed $offset The offset to unset.
-	 *
-	 * @return void
-	 */
-	public function offsetUnset($offset) {
-		$this->remove($offset);
-	}
+    /**
+     * offsetUnset allows using `unset($da['a.b'])`.
+     *
+     * @link  http://php.net/manual/en/arrayaccess.offsetunset.php
+     *
+     * @param mixed $offset The offset to unset.
+     *
+     * @return void
+     */
+    public function offsetUnset($offset) {
+        $this->remove($offset);
+    }
 }

src/Strings.php

Indentation +226 added lines, -226 removed lines

@@ -7,241 +7,241 @@
  * `mb_*` methods are used where sensible, so make sure to pass UTF-8 strings.
  */
 final class Strings {
-	private static $controlCharMap = [
-		"\n" => '\n',
-		"\r" => '\r',
-		"\t" => '\t',
-		"\v" => '\v',
-		"\e" => '\e',
-		"\f" => '\f',
-	];
+    private static $controlCharMap = [
+        "\n" => '\n',
+        "\r" => '\r',
+        "\t" => '\t',
+        "\v" => '\v',
+        "\e" => '\e',
+        "\f" => '\f',
+    ];
 
-	const CONTROL_CHAR_PATTERN = '/[\x00-\x1F\x7F]/';
+    const CONTROL_CHAR_PATTERN = '/[\x00-\x1F\x7F]/';
 
-	/**
-	 * startsWith returns true if the input begins with a prefix.
-	 *
-	 * @param string $input
-	 * @param string $prefix
-	 *
-	 * @return bool
-	 */
-	public static function startsWith($input, $prefix) {
-		return substr($input, 0, strlen($prefix)) === $prefix;
-	}
+    /**
+     * startsWith returns true if the input begins with a prefix.
+     *
+     * @param string $input
+     * @param string $prefix
+     *
+     * @return bool
+     */
+    public static function startsWith($input, $prefix) {
+        return substr($input, 0, strlen($prefix)) === $prefix;
+    }
 
-	/**
-	 * endsWith returns true if the input ends with a suffix.
-	 *
-	 * @param string $input
-	 * @param string $suffix
-	 *
-	 * @return bool
-	 */
-	public static function endsWith($input, $suffix) {
-		return strlen($suffix) === 0 || substr($input, -strlen($suffix)) === $suffix;
-	}
+    /**
+     * endsWith returns true if the input ends with a suffix.
+     *
+     * @param string $input
+     * @param string $suffix
+     *
+     * @return bool
+     */
+    public static function endsWith($input, $suffix) {
+        return strlen($suffix) === 0 || substr($input, -strlen($suffix)) === $suffix;
+    }
 
-	/**
-	 * getMostFrequentNeedle by counting occurences of each needle in haystack.
-	 *
-	 * @param string $haystack Haystack to be searched in.
-	 * @param array  $needles  Needles to be counted.
-	 *
-	 * @return string|null The most occuring needle. If counts are tied, the first tied needle is returned. If no
-	 *                     needles were found, `null` is returned.
-	 */
-	public static function getMostFrequentNeedle($haystack, array $needles) {
-		$maxCount = 0;
-		$maxNeedle = null;
-		foreach ($needles as $needle) {
-			$newCount = mb_substr_count($haystack, $needle);
-			if ($newCount > $maxCount) {
-				$maxCount = $newCount;
-				$maxNeedle = $needle;
-			}
-		}
-		return $maxNeedle;
-	}
+    /**
+     * getMostFrequentNeedle by counting occurences of each needle in haystack.
+     *
+     * @param string $haystack Haystack to be searched in.
+     * @param array  $needles  Needles to be counted.
+     *
+     * @return string|null The most occuring needle. If counts are tied, the first tied needle is returned. If no
+     *                     needles were found, `null` is returned.
+     */
+    public static function getMostFrequentNeedle($haystack, array $needles) {
+        $maxCount = 0;
+        $maxNeedle = null;
+        foreach ($needles as $needle) {
+            $newCount = mb_substr_count($haystack, $needle);
+            if ($newCount > $maxCount) {
+                $maxCount = $newCount;
+                $maxNeedle = $needle;
+            }
+        }
+        return $maxNeedle;
+    }
 
-	/**
-	 * escapeControlChars by replacing line feeds, tabs, etc. to their escaped representation.
-	 *
-	 * e.g. an actual line feed will return '\n'
-	 *
-	 * @param string $input
-	 *
-	 * @return string
-	 */
-	public static function escapeControlChars($input) {
-		$escaper = function ($chars) {
-			$char = $chars[0];
-			if (isset(self::$controlCharMap[$char])) {
-				return self::$controlCharMap[$char];
-			}
-			return sprintf('\x%02X', ord($char));
-		};
-		$output = str_replace('\\', '\\\\', $input);
-		return preg_replace_callback(self::CONTROL_CHAR_PATTERN, $escaper, $output);
-	}
+    /**
+     * escapeControlChars by replacing line feeds, tabs, etc. to their escaped representation.
+     *
+     * e.g. an actual line feed will return '\n'
+     *
+     * @param string $input
+     *
+     * @return string
+     */
+    public static function escapeControlChars($input) {
+        $escaper = function ($chars) {
+            $char = $chars[0];
+            if (isset(self::$controlCharMap[$char])) {
+                return self::$controlCharMap[$char];
+            }
+            return sprintf('\x%02X', ord($char));
+        };
+        $output = str_replace('\\', '\\\\', $input);
+        return preg_replace_callback(self::CONTROL_CHAR_PATTERN, $escaper, $output);
+    }
 
-	/**
-	 * padMultibyte strings to a certain length with another string.
-	 *
-	 * @param string $input       The input string to be padded.
-	 * @param int    $padLength   If the pad is length smaller than the input length, no padding takes place.
-	 * @param string $padding     Optional, defaults to a space character. Can be more than one character. The padding
-	 *                            may be truncated if the required number of padding characters can't be evenly
-	 *                            divided.
-	 * @param int    $paddingType Optional, defaults to STR_PAD_RIGHT. Must be one of STR_PAD_LEFT, STR_PAD_RIGHT or
-	 *                            STR_PAD_BOTH.
-	 *
-	 * @return string The padded string.
-	 */
-	public static function padMultibyte($input, $padLength, $padding = ' ', $paddingType = STR_PAD_RIGHT) {
-		if ($paddingType !== STR_PAD_LEFT && $paddingType !== STR_PAD_RIGHT && $paddingType !== STR_PAD_BOTH) {
-			throw new \InvalidArgumentException('Padding type must be one of STR_PAD_LEFT, STR_PAD_RIGHT or STR_PAD_BOTH.');
-		}
-		$paddingLength = mb_strlen($padding);
-		if ($paddingLength === 0) {
-			throw new \InvalidArgumentException('Padding string must not be empty.');
-		}
-		$inputLength = mb_strlen($input);
-		if ($inputLength > $padLength) {
-			return $input;
-		}
-		$freeLength = $padLength - $inputLength;
-		if ($paddingType === STR_PAD_BOTH) {
-			// Original str_pad prefers trailing padding
-			$leftPadLength = $padLength - ceil($freeLength / 2);
-			// Reuse the below left/right implementation
-			return self::padMultibyte(
-				self::padMultibyte($input, $leftPadLength, $padding, STR_PAD_LEFT),
-				$padLength,
-				$padding,
-				STR_PAD_RIGHT
-			);
-		}
-		$foo = str_repeat($padding, $freeLength / $paddingLength);
-		$partialPadLength = $freeLength % $paddingLength;
-		if ($partialPadLength > 0) {
-			$foo .= mb_substr($padding, 0, $partialPadLength);
-		}
-		if ($paddingType === STR_PAD_LEFT) {
-			return $foo . $input;
-		}
-		return $input . $foo;
-	}
+    /**
+     * padMultibyte strings to a certain length with another string.
+     *
+     * @param string $input       The input string to be padded.
+     * @param int    $padLength   If the pad is length smaller than the input length, no padding takes place.
+     * @param string $padding     Optional, defaults to a space character. Can be more than one character. The padding
+     *                            may be truncated if the required number of padding characters can't be evenly
+     *                            divided.
+     * @param int    $paddingType Optional, defaults to STR_PAD_RIGHT. Must be one of STR_PAD_LEFT, STR_PAD_RIGHT or
+     *                            STR_PAD_BOTH.
+     *
+     * @return string The padded string.
+     */
+    public static function padMultibyte($input, $padLength, $padding = ' ', $paddingType = STR_PAD_RIGHT) {
+        if ($paddingType !== STR_PAD_LEFT && $paddingType !== STR_PAD_RIGHT && $paddingType !== STR_PAD_BOTH) {
+            throw new \InvalidArgumentException('Padding type must be one of STR_PAD_LEFT, STR_PAD_RIGHT or STR_PAD_BOTH.');
+        }
+        $paddingLength = mb_strlen($padding);
+        if ($paddingLength === 0) {
+            throw new \InvalidArgumentException('Padding string must not be empty.');
+        }
+        $inputLength = mb_strlen($input);
+        if ($inputLength > $padLength) {
+            return $input;
+        }
+        $freeLength = $padLength - $inputLength;
+        if ($paddingType === STR_PAD_BOTH) {
+            // Original str_pad prefers trailing padding
+            $leftPadLength = $padLength - ceil($freeLength / 2);
+            // Reuse the below left/right implementation
+            return self::padMultibyte(
+                self::padMultibyte($input, $leftPadLength, $padding, STR_PAD_LEFT),
+                $padLength,
+                $padding,
+                STR_PAD_RIGHT
+            );
+        }
+        $foo = str_repeat($padding, $freeLength / $paddingLength);
+        $partialPadLength = $freeLength % $paddingLength;
+        if ($partialPadLength > 0) {
+            $foo .= mb_substr($padding, 0, $partialPadLength);
+        }
+        if ($paddingType === STR_PAD_LEFT) {
+            return $foo . $input;
+        }
+        return $input . $foo;
+    }
 
-	/**
-	 * getCommonPrefix of two strings.
-	 *
-	 * @param string $first
-	 * @param string $second
-	 *
-	 * @return string All common characters from the beginning of both strings.
-	 */
-	public static function getCommonPrefix($first, $second) {
-		if ($first === $second) {
-			return $first;
-		}
-		$length = min(mb_strlen($first), mb_strlen($second));
-		for ($i = 0; $i < $length; $i++) {
-			if ($first[$i] !== $second[$i]) {
-				return mb_substr($first, 0, $i);
-			}
-		}
-		return mb_substr($first, 0, $length);
-	}
+    /**
+     * getCommonPrefix of two strings.
+     *
+     * @param string $first
+     * @param string $second
+     *
+     * @return string All common characters from the beginning of both strings.
+     */
+    public static function getCommonPrefix($first, $second) {
+        if ($first === $second) {
+            return $first;
+        }
+        $length = min(mb_strlen($first), mb_strlen($second));
+        for ($i = 0; $i < $length; $i++) {
+            if ($first[$i] !== $second[$i]) {
+                return mb_substr($first, 0, $i);
+            }
+        }
+        return mb_substr($first, 0, $length);
+    }
 
-	/**
-	 * getCommonSuffix of two strings.
-	 *
-	 * @param string $first
-	 * @param string $second
-	 *
-	 * @return string All common characters from the end of both strings.
-	 */
-	public static function getCommonSuffix($first, $second) {
-		$reversedCommon = self::getCommonPrefix(self::reverse($first), self::reverse($second));
-		return self::reverse($reversedCommon);
-	}
+    /**
+     * getCommonSuffix of two strings.
+     *
+     * @param string $first
+     * @param string $second
+     *
+     * @return string All common characters from the end of both strings.
+     */
+    public static function getCommonSuffix($first, $second) {
+        $reversedCommon = self::getCommonPrefix(self::reverse($first), self::reverse($second));
+        return self::reverse($reversedCommon);
+    }
 
-	/**
-	 * Reverse a string.
-	 *
-	 * @param string $input
-	 *
-	 * @return string The reversed string.
-	 */
-	public static function reverse($input) {
-		$length = mb_strlen($input);
-		$reversed = '';
-		for ($i = $length - 1; $i !== -1; --$i) {
-			$reversed .= mb_substr($input, $i, 1);
-		}
-		return $reversed;
-	}
+    /**
+     * Reverse a string.
+     *
+     * @param string $input
+     *
+     * @return string The reversed string.
+     */
+    public static function reverse($input) {
+        $length = mb_strlen($input);
+        $reversed = '';
+        for ($i = $length - 1; $i !== -1; --$i) {
+            $reversed .= mb_substr($input, $i, 1);
+        }
+        return $reversed;
+    }
 
-	/**
-	 * groupByCommonPrefix returns an array with a common key and a list of differing suffixes.
-	 *
-	 * e.g. passing an array `['sameHERE', 'sameTHERE']` would return
-	 * ```
-	 * 'same' => [
-	 *    'HERE',
-	 *    'THERE',
-	 * ]
-	 * ```
-	 *
-	 * This can be used to group several file paths by a common base.
-	 *
-	 * @param string[] $strings
-	 *
-	 * @return string[][]
-	 */
-	public static function groupByCommonPrefix($strings) {
-		sort($strings);
-		$common = null;
-		foreach ($strings as $folder) {
-			if ($common === null) {
-				$common = $folder;
-			} else {
-				$common = self::getCommonPrefix($common, $folder);
-			}
-		}
-		$trimmedFolders = [];
-		$commonLength = mb_strlen($common);
-		foreach ($strings as $folder) {
-			$trimmedFolders[$common][] = mb_substr($folder, $commonLength);
-		}
-		return $trimmedFolders;
-	}
+    /**
+     * groupByCommonPrefix returns an array with a common key and a list of differing suffixes.
+     *
+     * e.g. passing an array `['sameHERE', 'sameTHERE']` would return
+     * ```
+     * 'same' => [
+     *    'HERE',
+     *    'THERE',
+     * ]
+     * ```
+     *
+     * This can be used to group several file paths by a common base.
+     *
+     * @param string[] $strings
+     *
+     * @return string[][]
+     */
+    public static function groupByCommonPrefix($strings) {
+        sort($strings);
+        $common = null;
+        foreach ($strings as $folder) {
+            if ($common === null) {
+                $common = $folder;
+            } else {
+                $common = self::getCommonPrefix($common, $folder);
+            }
+        }
+        $trimmedFolders = [];
+        $commonLength = mb_strlen($common);
+        foreach ($strings as $folder) {
+            $trimmedFolders[$common][] = mb_substr($folder, $commonLength);
+        }
+        return $trimmedFolders;
+    }
 
-	/**
-	 * groupByCommonSuffix returns an array with a common key and a list of differing suffixes.
-	 *
-	 * e.g. passing an array `['sameHERE', 'sameTHERE']` would return
-	 * ```
-	 * 'HERE' => [
-	 *    'same',
-	 *    'sameT',
-	 * ]
-	 * ```
-	 *
-	 * @param string[] $strings
-	 *
-	 * @return string[][]
-	 */
-	public static function groupByCommonSuffix($strings) {
-		foreach ($strings as $key => $string) {
-			$strings[$key] = self::reverse($string);
-		}
-		$reversedGroups = self::groupByCommonPrefix($strings);
-		$groups = [];
-		foreach ($reversedGroups as $revKey => $revStrings) {
-			$groups[self::reverse($revKey)] = array_map([self::class, 'reverse'], $revStrings);
-		}
-		return $groups;
-	}
+    /**
+     * groupByCommonSuffix returns an array with a common key and a list of differing suffixes.
+     *
+     * e.g. passing an array `['sameHERE', 'sameTHERE']` would return
+     * ```
+     * 'HERE' => [
+     *    'same',
+     *    'sameT',
+     * ]
+     * ```
+     *
+     * @param string[] $strings
+     *
+     * @return string[][]
+     */
+    public static function groupByCommonSuffix($strings) {
+        foreach ($strings as $key => $string) {
+            $strings[$key] = self::reverse($string);
+        }
+        $reversedGroups = self::groupByCommonPrefix($strings);
+        $groups = [];
+        foreach ($reversedGroups as $revKey => $revStrings) {
+            $groups[self::reverse($revKey)] = array_map([self::class, 'reverse'], $revStrings);
+        }
+        return $groups;
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -128,9 +128,9 @@
 			$foo .= mb_substr($padding, 0, $partialPadLength);
 		}
 		if ($paddingType === STR_PAD_LEFT) {
-			return $foo . $input;
+			return $foo.$input;
 		}
-		return $input . $foo;
+		return $input.$foo;
 	}
 
 	/**

src/Multiline.php

Indentation +141 added lines, -141 removed lines

@@ -5,154 +5,154 @@
  * Multiline string class for working with lines of text.
  */
 final class Multiline extends ArrayCollection {
-	/**
-	 * @var \nochso\Omni\EOL
-	 */
-	private $eol;
+    /**
+     * @var \nochso\Omni\EOL
+     */
+    private $eol;
 
-	/**
-	 * Create a new Multiline object from a string.
-	 *
-	 * First the input string is split into lines by the detected end-of-line
-	 * character. Afterwards any extra EOL chars will be trimmed.
-	 *
-	 * @see \nochso\Omni\EOL
-	 *
-	 * @param string $input      A string to split into a Multiline object
-	 * @param string $defaultEol Default end-of-line type to split the input by. This is a fallback in case it could
-	 *                           not be detected from the input string. Optional, defaults to `EOL::EOL_LF` i.e. "\n".
-	 *                           See the `EOL::EOL_*` class constants.
-	 *
-	 * @return \nochso\Omni\Multiline
-	 */
-	public static function create($input, $defaultEol = \nochso\Omni\EOL::EOL_LF) {
-		$eol = EOL::detectDefault($input, $defaultEol);
-		$lines = explode($eol, $input);
-		$multiline = new self($lines);
-		// Remove left-over line feeds
-		$multiline->apply(function ($line) {
-				return trim($line, "\r\n");
-			});
-		$multiline->setEol($eol);
-		return $multiline;
-	}
+    /**
+     * Create a new Multiline object from a string.
+     *
+     * First the input string is split into lines by the detected end-of-line
+     * character. Afterwards any extra EOL chars will be trimmed.
+     *
+     * @see \nochso\Omni\EOL
+     *
+     * @param string $input      A string to split into a Multiline object
+     * @param string $defaultEol Default end-of-line type to split the input by. This is a fallback in case it could
+     *                           not be detected from the input string. Optional, defaults to `EOL::EOL_LF` i.e. "\n".
+     *                           See the `EOL::EOL_*` class constants.
+     *
+     * @return \nochso\Omni\Multiline
+     */
+    public static function create($input, $defaultEol = \nochso\Omni\EOL::EOL_LF) {
+        $eol = EOL::detectDefault($input, $defaultEol);
+        $lines = explode($eol, $input);
+        $multiline = new self($lines);
+        // Remove left-over line feeds
+        $multiline->apply(function ($line) {
+                return trim($line, "\r\n");
+            });
+        $multiline->setEol($eol);
+        return $multiline;
+    }
 
-	/**
-	 * __toString returns a single string using the current EOL style.
-	 *
-	 * @return string
-	 */
-	public function __toString() {
-		return implode((string) $this->eol, $this->list);
-	}
+    /**
+     * __toString returns a single string using the current EOL style.
+     *
+     * @return string
+     */
+    public function __toString() {
+        return implode((string) $this->eol, $this->list);
+    }
 
-	/**
-	 * Get EOL style ending.
-	 *
-	 * @return \nochso\Omni\EOL
-	 */
-	public function getEol() {
-		return $this->eol;
-	}
+    /**
+     * Get EOL style ending.
+     *
+     * @return \nochso\Omni\EOL
+     */
+    public function getEol() {
+        return $this->eol;
+    }
 
-	/**
-	 * getMaxLength of all lines.
-	 *
-	 * @return int
-	 */
-	public function getMaxLength() {
-		$length = 0;
-		foreach ($this->list as $line) {
-			$length = max($length, mb_strlen($line));
-		}
-		return $length;
-	}
+    /**
+     * getMaxLength of all lines.
+     *
+     * @return int
+     */
+    public function getMaxLength() {
+        $length = 0;
+        foreach ($this->list as $line) {
+            $length = max($length, mb_strlen($line));
+        }
+        return $length;
+    }
 
-	/**
-	 * Set EOL used by this Multiline string.
-	 *
-	 * @param \nochso\Omni\EOL|string $eol Either an `EOL` object or a string ("\r\n" or "\n")
-	 *
-	 * @return $this
-	 */
-	public function setEol($eol) {
-		if (!$eol instanceof EOL) {
-			$eol = new EOL($eol);
-		}
-		$this->eol = $eol;
-		return $this;
-	}
+    /**
+     * Set EOL used by this Multiline string.
+     *
+     * @param \nochso\Omni\EOL|string $eol Either an `EOL` object or a string ("\r\n" or "\n")
+     *
+     * @return $this
+     */
+    public function setEol($eol) {
+        if (!$eol instanceof EOL) {
+            $eol = new EOL($eol);
+        }
+        $this->eol = $eol;
+        return $this;
+    }
 
-	/**
-	 * Append text to a certain line.
-	 *
-	 * @param string   $text
-	 * @param null|int $index Optional, defaults to the last line. Other
-	 *
-	 * @return $this
-	 */
-	public function append($text, $index = null) {
-		if ($index === null) {
-			$index = count($this) - 1;
-		}
-		$this->list[$index] .= $text;
-		return $this;
-	}
+    /**
+     * Append text to a certain line.
+     *
+     * @param string   $text
+     * @param null|int $index Optional, defaults to the last line. Other
+     *
+     * @return $this
+     */
+    public function append($text, $index = null) {
+        if ($index === null) {
+            $index = count($this) - 1;
+        }
+        $this->list[$index] .= $text;
+        return $this;
+    }
 
-	/**
-	 * Prefix all lines with a string.
-	 *
-	 * @param string $prefix The prefix to add to the start of the string.
-	 *
-	 * @return string
-	 */
-	public function prefix($prefix) {
-		$prefixer = function ($line) use ($prefix) {
-			return $prefix . $line;
-		};
-		return $this->apply($prefixer);
-	}
+    /**
+     * Prefix all lines with a string.
+     *
+     * @param string $prefix The prefix to add to the start of the string.
+     *
+     * @return string
+     */
+    public function prefix($prefix) {
+        $prefixer = function ($line) use ($prefix) {
+            return $prefix . $line;
+        };
+        return $this->apply($prefixer);
+    }
 
-	/**
-	 * Pad all lines to the same length using `str_pad`.
-	 *
-	 * @param int    $length      If length is larger than the maximum line length, all lines will be padded up to the
-	 *                            given length. If length is null, the maximum of all line lengths is used. Optional,
-	 *                            defaults to null.
-	 * @param string $padding     Optional, defaults to a space character. Can be more than one character. The padding
-	 *                            may be truncated if the required number of padding characters can't be evenly
-	 *                            divided.
-	 * @param int    $paddingType Optional argument pad_type can be STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH.
-	 *                            Defaults to STR_PAD_RIGHT.
-	 *
-	 * @return string
-	 */
-	public function pad($length = null, $padding = ' ', $paddingType = STR_PAD_RIGHT) {
-		if ($length === null) {
-			$length = $this->getMaxLength();
-		}
-		$padder = function ($line) use ($length, $padding, $paddingType) {
-			return Strings::padMultibyte($line, $length, $padding, $paddingType);
-		};
-		return $this->apply($padder);
-	}
+    /**
+     * Pad all lines to the same length using `str_pad`.
+     *
+     * @param int    $length      If length is larger than the maximum line length, all lines will be padded up to the
+     *                            given length. If length is null, the maximum of all line lengths is used. Optional,
+     *                            defaults to null.
+     * @param string $padding     Optional, defaults to a space character. Can be more than one character. The padding
+     *                            may be truncated if the required number of padding characters can't be evenly
+     *                            divided.
+     * @param int    $paddingType Optional argument pad_type can be STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH.
+     *                            Defaults to STR_PAD_RIGHT.
+     *
+     * @return string
+     */
+    public function pad($length = null, $padding = ' ', $paddingType = STR_PAD_RIGHT) {
+        if ($length === null) {
+            $length = $this->getMaxLength();
+        }
+        $padder = function ($line) use ($length, $padding, $paddingType) {
+            return Strings::padMultibyte($line, $length, $padding, $paddingType);
+        };
+        return $this->apply($padder);
+    }
 
-	/**
-	 * getLineIndexByCharacterPosition returns the line index containing a certain position.
-	 *
-	 * @param int $characterPosition Position of a character as if Multiline was a raw string.
-	 *
-	 * @return int|null The array index of the line containing the character position.
-	 */
-	public function getLineIndexByCharacterPosition($characterPosition) {
-		$position = 0;
-		foreach ($this->list as $key => $line) {
-			$length = mb_strlen($line . $this->getEol());
-			if ($characterPosition >= $position && $characterPosition <= $position + $length) {
-				return $key;
-			}
-			$position += $length;
-		}
-		return null;
-	}
+    /**
+     * getLineIndexByCharacterPosition returns the line index containing a certain position.
+     *
+     * @param int $characterPosition Position of a character as if Multiline was a raw string.
+     *
+     * @return int|null The array index of the line containing the character position.
+     */
+    public function getLineIndexByCharacterPosition($characterPosition) {
+        $position = 0;
+        foreach ($this->list as $key => $line) {
+            $length = mb_strlen($line . $this->getEol());
+            if ($characterPosition >= $position && $characterPosition <= $position + $length) {
+                return $key;
+            }
+            $position += $length;
+        }
+        return null;
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -43,7 +43,7 @@ 
 	 * @return string
 	 */
 	public function __toString() {
-		return implode((string) $this->eol, $this->list);
+		return implode((string)$this->eol, $this->list);
 	}
 
 	/**
@@ -108,7 +108,7 @@ 
 	 */
 	public function prefix($prefix) {
 		$prefixer = function ($line) use ($prefix) {
-			return $prefix . $line;
+			return $prefix.$line;
 		};
 		return $this->apply($prefixer);
 	}
@@ -147,7 +147,7 @@ 
 	public function getLineIndexByCharacterPosition($characterPosition) {
 		$position = 0;
 		foreach ($this->list as $key => $line) {
-			$length = mb_strlen($line . $this->getEol());
+			$length = mb_strlen($line.$this->getEol());
 			if ($characterPosition >= $position && $characterPosition <= $position + $length) {
 				return $key;
 			}