s9e / RegexpBuilder

src/Output/PHP.php

Indentation +9 added lines, -9 removed lines

@@ -9,14 +9,14 @@
 
 class PHP extends PrintableAscii
 {
-	/** {@inheritdoc} */
-	protected $maxValue = 0x10FFFF;
+    /** {@inheritdoc} */
+    protected $maxValue = 0x10FFFF;
 
-	/**
-	* {@inheritdoc}
-	*/
-	protected function escapeUnicode($cp)
-	{
-		return sprintf('\\x{%04X}', $cp);
-	}
+    /**
+     * {@inheritdoc}
+     */
+    protected function escapeUnicode($cp)
+    {
+        return sprintf('\\x{%04X}', $cp);
+    }
 }
\ No newline at end of file

src/Output/BaseImplementation.php

Indentation +26 added lines, -26 removed lines

@@ -11,34 +11,34 @@
 
 abstract class BaseImplementation implements OutputInterface
 {
-	/**
-	* @var integer
-	*/
-	protected $maxValue = 0;
+    /**
+     * @var integer
+     */
+    protected $maxValue = 0;
 
-	/**
-	* @var integer
-	*/
-	protected $minValue = 0;
+    /**
+     * @var integer
+     */
+    protected $minValue = 0;
 
-	/**
-	* {@inheritdoc}
-	*/
-	public function output($value)
-	{
-		if ($value < $this->minValue || $value > $this->maxValue)
-		{
-			throw new InvalidArgumentException('Value ' . $value . ' is out of bounds (' . $this->minValue . '..' . $this->maxValue . ')');
-		}
+    /**
+     * {@inheritdoc}
+     */
+    public function output($value)
+    {
+        if ($value < $this->minValue || $value > $this->maxValue)
+        {
+            throw new InvalidArgumentException('Value ' . $value . ' is out of bounds (' . $this->minValue . '..' . $this->maxValue . ')');
+        }
 
-		return $this->outputValidValue($value);
-	}
+        return $this->outputValidValue($value);
+    }
 
-	/**
-	* Serialize a valid value into a character
-	*
-	* @param  integer $value
-	* @return string
-	*/
-	abstract protected function outputValidValue($value);
+    /**
+     * Serialize a valid value into a character
+     *
+     * @param  integer $value
+     * @return string
+     */
+    abstract protected function outputValidValue($value);
 }
\ No newline at end of file

src/Input/Utf8.php

Indentation +44 added lines, -44 removed lines

@@ -11,52 +11,52 @@
 
 class Utf8 implements InputInterface
 {
-	/**
-	* {@inheritdoc}
-	*/
-	public function split($string)
-	{
-		if (preg_match_all('(.)us', $string, $matches) === false)
-		{
-			throw new InvalidArgumentException('Invalid UTF-8 string');
-		}
+    /**
+     * {@inheritdoc}
+     */
+    public function split($string)
+    {
+        if (preg_match_all('(.)us', $string, $matches) === false)
+        {
+            throw new InvalidArgumentException('Invalid UTF-8 string');
+        }
 
-		return $this->charsToCodepoints($matches[0]);
-	}
+        return $this->charsToCodepoints($matches[0]);
+    }
 
-	/**
-	* Convert a list of UTF-8 characters to a list of Unicode codepoint
-	*
-	* @param  string[]  $chars
-	* @return integer[]
-	*/
-	protected function charsToCodepoints(array $chars)
-	{
-		return array_map([$this, 'cp'], $chars);
-	}
+    /**
+     * Convert a list of UTF-8 characters to a list of Unicode codepoint
+     *
+     * @param  string[]  $chars
+     * @return integer[]
+     */
+    protected function charsToCodepoints(array $chars)
+    {
+        return array_map([$this, 'cp'], $chars);
+    }
 
-	/**
-	* Compute and return the Unicode codepoint for given UTF-8 char
-	*
-	* @param  string  $char UTF-8 char
-	* @return integer
-	*/
-	protected function cp($char)
-	{
-		$cp = ord($char[0]);
-		if ($cp >= 0xF0)
-		{
-			$cp = ($cp << 18) + (ord($char[1]) << 12) + (ord($char[2]) << 6) + ord($char[3]) - 0x3C82080;
-		}
-		elseif ($cp >= 0xE0)
-		{
-			$cp = ($cp << 12) + (ord($char[1]) << 6) + ord($char[2]) - 0xE2080;
-		}
-		elseif ($cp >= 0xC0)
-		{
-			$cp = ($cp << 6) + ord($char[1]) - 0x3080;
-		}
+    /**
+     * Compute and return the Unicode codepoint for given UTF-8 char
+     *
+     * @param  string  $char UTF-8 char
+     * @return integer
+     */
+    protected function cp($char)
+    {
+        $cp = ord($char[0]);
+        if ($cp >= 0xF0)
+        {
+            $cp = ($cp << 18) + (ord($char[1]) << 12) + (ord($char[2]) << 6) + ord($char[3]) - 0x3C82080;
+        }
+        elseif ($cp >= 0xE0)
+        {
+            $cp = ($cp << 12) + (ord($char[1]) << 6) + ord($char[2]) - 0xE2080;
+        }
+        elseif ($cp >= 0xC0)
+        {
+            $cp = ($cp << 6) + ord($char[1]) - 0x3080;
+        }
 
-		return $cp;
-	}
+        return $cp;
+    }
 }
\ No newline at end of file

src/Builder.php

Indentation +141 added lines, -141 removed lines

@@ -18,145 +18,145 @@
 
 class Builder
 {
-	/**
-	* @var InputInterface
-	*/
-	protected $input;
-
-	/**
-	* @var Runner
-	*/
-	protected $runner;
-
-	/**
-	* @var Serializer
-	*/
-	protected $serializer;
-
-	/**
-	* @param array $config
-	*/
-	public function __construct(array $config = [])
-	{
-		$config += [
-			'delimiter' => '/',
-			'input'     => 'Bytes',
-			'output'    => 'Bytes'
-		];
-
-		$this->setInput($config['input']);
-		$this->setSerializer($config['output'], $config['delimiter']);
-		$this->setRunner();
-	}
-
-	/**
-	* Build and return a regular expression that matches all of the given strings
-	*
-	* @param  string[] $strings Literal strings to be matched
-	* @return string            Regular expression (without delimiters)
-	*/
-	public function build(array $strings)
-	{
-		$strings = array_unique($strings);
-		if ($this->isEmpty($strings))
-		{
-			return '';
-		}
-
-		$strings = $this->splitStrings($strings);
-		usort($strings, __CLASS__ . '::compareStrings');
-		$strings = $this->runner->run($strings);
-
-		return $this->serializer->serializeStrings($strings);
-	}
-
-	/**
-	* Compare two split strings
-	*
-	* Will sort strings in ascending order
-	*
-	* @param  integer[] $a
-	* @param  integer[] $b
-	* @return integer
-	*/
-	protected function compareStrings(array $a, array $b)
-	{
-		$i   = -1;
-		$cnt = min(count($a), count($b));
-		while (++$i < $cnt)
-		{
-			if ($a[$i] !== $b[$i])
-			{
-				return $a[$i] - $b[$i];
-			}
-		}
-
-		return count($a) - count($b);
-	}
-
-	/**
-	* Test whether the list of strings is empty
-	*
-	* @param  string[] $strings
-	* @return bool
-	*/
-	protected function isEmpty(array $strings)
-	{
-		return (empty($strings) || $strings === ['']);
-	}
-
-	/**
-	* Set the InputInterface instance in $this->input
-	*
-	* @param  string $inputType
-	* @return void
-	*/
-	protected function setInput($inputType)
-	{
-		$className   = __NAMESPACE__ . '\\Input\\' . $inputType;
-		$this->input = new $className;
-	}
-
-	/**
-	* Set the Runner instance $in this->runner
-	*
-	* @return void
-	*/
-	protected function setRunner()
-	{
-		$this->runner = new Runner;
-		$this->runner->addPass(new MergePrefix);
-		$this->runner->addPass(new GroupSingleCharacters);
-		$this->runner->addPass(new Recurse($this->runner));
-		$this->runner->addPass(new PromoteSingleStrings);
-		$this->runner->addPass(new MergeSuffix);
-		$this->runner->addPass(new CoalesceSingleCharacterPrefix);
-	}
-
-	/**
-	* Set the Serializer instance in $this->serializer
-	*
-	* @param  string $outputType
-	* @param  string $delimiter
-	* @return void
-	*/
-	protected function setSerializer($outputType, $delimiter)
-	{
-		$className = __NAMESPACE__ . '\\Output\\' . $outputType;
-		$output    = new $className;
-		$escaper   = new Escaper($delimiter);
-
-		$this->serializer = new Serializer($output, $escaper);
-	}
-
-	/**
-	* Split all given strings by character
-	*
-	* @param  string[] $strings List of strings
-	* @return array[]           List of arrays
-	*/
-	protected function splitStrings(array $strings)
-	{
-		return array_map([$this->input, 'split'], $strings);
-	}
+    /**
+     * @var InputInterface
+     */
+    protected $input;
+
+    /**
+     * @var Runner
+     */
+    protected $runner;
+
+    /**
+     * @var Serializer
+     */
+    protected $serializer;
+
+    /**
+     * @param array $config
+     */
+    public function __construct(array $config = [])
+    {
+        $config += [
+            'delimiter' => '/',
+            'input'     => 'Bytes',
+            'output'    => 'Bytes'
+        ];
+
+        $this->setInput($config['input']);
+        $this->setSerializer($config['output'], $config['delimiter']);
+        $this->setRunner();
+    }
+
+    /**
+     * Build and return a regular expression that matches all of the given strings
+     *
+     * @param  string[] $strings Literal strings to be matched
+     * @return string            Regular expression (without delimiters)
+     */
+    public function build(array $strings)
+    {
+        $strings = array_unique($strings);
+        if ($this->isEmpty($strings))
+        {
+            return '';
+        }
+
+        $strings = $this->splitStrings($strings);
+        usort($strings, __CLASS__ . '::compareStrings');
+        $strings = $this->runner->run($strings);
+
+        return $this->serializer->serializeStrings($strings);
+    }
+
+    /**
+     * Compare two split strings
+     *
+     * Will sort strings in ascending order
+     *
+     * @param  integer[] $a
+     * @param  integer[] $b
+     * @return integer
+     */
+    protected function compareStrings(array $a, array $b)
+    {
+        $i   = -1;
+        $cnt = min(count($a), count($b));
+        while (++$i < $cnt)
+        {
+            if ($a[$i] !== $b[$i])
+            {
+                return $a[$i] - $b[$i];
+            }
+        }
+
+        return count($a) - count($b);
+    }
+
+    /**
+     * Test whether the list of strings is empty
+     *
+     * @param  string[] $strings
+     * @return bool
+     */
+    protected function isEmpty(array $strings)
+    {
+        return (empty($strings) || $strings === ['']);
+    }
+
+    /**
+     * Set the InputInterface instance in $this->input
+     *
+     * @param  string $inputType
+     * @return void
+     */
+    protected function setInput($inputType)
+    {
+        $className   = __NAMESPACE__ . '\\Input\\' . $inputType;
+        $this->input = new $className;
+    }
+
+    /**
+     * Set the Runner instance $in this->runner
+     *
+     * @return void
+     */
+    protected function setRunner()
+    {
+        $this->runner = new Runner;
+        $this->runner->addPass(new MergePrefix);
+        $this->runner->addPass(new GroupSingleCharacters);
+        $this->runner->addPass(new Recurse($this->runner));
+        $this->runner->addPass(new PromoteSingleStrings);
+        $this->runner->addPass(new MergeSuffix);
+        $this->runner->addPass(new CoalesceSingleCharacterPrefix);
+    }
+
+    /**
+     * Set the Serializer instance in $this->serializer
+     *
+     * @param  string $outputType
+     * @param  string $delimiter
+     * @return void
+     */
+    protected function setSerializer($outputType, $delimiter)
+    {
+        $className = __NAMESPACE__ . '\\Output\\' . $outputType;
+        $output    = new $className;
+        $escaper   = new Escaper($delimiter);
+
+        $this->serializer = new Serializer($output, $escaper);
+    }
+
+    /**
+     * Split all given strings by character
+     *
+     * @param  string[] $strings List of strings
+     * @return array[]           List of arrays
+     */
+    protected function splitStrings(array $strings)
+    {
+        return array_map([$this->input, 'split'], $strings);
+    }
 }
\ No newline at end of file

src/Serializer.php

Indentation +198 added lines, -198 removed lines

@@ -11,202 +11,202 @@
 
 class Serializer
 {
-	/**
-	* @var Escaper
-	*/
-	protected $escaper;
-
-	/**
-	* @var OutputInterface
-	*/
-	protected $output;
-
-	/**
-	* @param OutputInterface $output
-	* @param Escaper         $escaper
-	*/
-	public function __construct(OutputInterface $output, Escaper $escaper)
-	{
-		$this->escaper = $escaper;
-		$this->output  = $output;
-	}
-
-	/**
-	* Serialize given strings into a regular expression
-	*
-	* @param  array[] $strings
-	* @return string
-	*/
-	public function serializeStrings(array $strings)
-	{
-		$info = $this->analyzeStrings($strings);
-		$alternations = $this->buildAlternations($info);
-		$expr = implode('|', $alternations);
-
-		if (count($alternations) > 1 || $this->isOneOptionalString($info))
-		{
-			$expr = '(?:' . $expr . ')';
-		}
-
-		return $expr . $info['quantifier'];
-	}
-
-	/**
-	* Analyze given strings to determine how to serialize them
-	*
-	* The returned array may contains any of the following elements:
-	*
-	*  - (string) quantifier Either '' or '?'
-	*  - (array)  chars      List of values from single-char strings
-	*  - (array)  strings    List of multi-char strings
-	*
-	* @param  array[] $strings
-	* @return array
-	*/
-	protected function analyzeStrings(array $strings)
-	{
-		$info = ['quantifier' => ''];
-		if ($strings[0] === [])
-		{
-			$info['quantifier'] = '?';
-			unset($strings[0]);
-		}
-
-		$chars = $this->getChars($strings);
-		if (count($chars) > 1)
-		{
-			$info['chars'] = array_values($chars);
-			$strings = array_diff_key($strings, $chars);
-		}
-
-		$info['strings'] = array_values($strings);
-
-		return $info;
-	}
-
-	/**
-	* Build the list of alternations based on given info
-	*
-	* @param  array    $info
-	* @return string[]
-	*/
-	protected function buildAlternations(array $info)
-	{
-		$alternations = [];
-		if (!empty($info['chars']))
-		{
-			$alternations[] = $this->serializeCharacterClass($info['chars']);
-		}
-		foreach ($info['strings'] as $string)
-		{
-			$alternations[] = $this->serializeString($string);
-		}
-
-		return $alternations;
-	}
-
-	/**
-	* Return the portion of strings that are composed of a single character
-	*
-	* @param  array[]
-	* @return array   String key => codepoint
-	*/
-	protected function getChars(array $strings)
-	{
-		$chars = [];
-		foreach ($strings as $k => $string)
-		{
-			if (count($string) === 1 && !is_array($string[0]))
-			{
-				$chars[$k] = $string[0];
-			}
-		}
-
-		return $chars;
-	}
-
-	/**
-	* Get the list of ranges that cover all given values
-	*
-	* @param  integer[] $values Ordered list of values
-	* @return array[]           List of ranges in the form [start, end]
-	*/
-	protected function getRanges(array $values)
-	{
-		$i      = 0;
-		$cnt    = count($values);
-		$start  = $values[0];
-		$end    = $start;
-		$ranges = [];
-		while (++$i < $cnt)
-		{
-			if ($values[$i] === $end + 1)
-			{
-				++$end;
-			}
-			else
-			{
-				$ranges[] = [$start, $end];
-				$start = $end = $values[$i];
-			}
-		}
-		$ranges[] = [$start, $end];
-
-		return $ranges;
-	}
-
-	/**
-	* Test whether a string is optional and has more than one character
-	*
-	* @param  array $info
-	* @return bool
-	*/
-	protected function isOneOptionalString(array $info)
-	{
-		// Test whether the first string has a quantifier and more than one element
-		return (!empty($info['quantifier']) && isset($info['strings'][0][1]));
-	}
-
-	/**
-	* Serialize a given list of values into a character class
-	*
-	* @param  integer[] $values
-	* @return string
-	*/
-	protected function serializeCharacterClass(array $values)
-	{
-		$expr = '[';
-		foreach ($this->getRanges($values) as list($start, $end))
-		{
-			$expr .= $this->escaper->escapeCharacterClass($this->output->output($start));
-			if ($end > $start)
-			{
-				if ($end > $start + 1)
-				{
-					$expr .= '-';
-				}
-				$expr .= $this->escaper->escapeCharacterClass($this->output->output($end));
-			}
-		}
-		$expr .= ']';
-
-		return $expr;
-	}
-
-	/**
-	* Serialize a given string into a regular expression
-	*
-	* @param  array  $string
-	* @return string
-	*/
-	protected function serializeString(array $string)
-	{
-		$expr = '';
-		foreach ($string as $element)
-		{
-			$expr .= (is_array($element)) ? $this->serializeStrings($element) : $this->escaper->escapeLiteral($this->output->output($element));
-		}
-
-		return $expr;
-	}
+    /**
+     * @var Escaper
+     */
+    protected $escaper;
+
+    /**
+     * @var OutputInterface
+     */
+    protected $output;
+
+    /**
+     * @param OutputInterface $output
+     * @param Escaper         $escaper
+     */
+    public function __construct(OutputInterface $output, Escaper $escaper)
+    {
+        $this->escaper = $escaper;
+        $this->output  = $output;
+    }
+
+    /**
+     * Serialize given strings into a regular expression
+     *
+     * @param  array[] $strings
+     * @return string
+     */
+    public function serializeStrings(array $strings)
+    {
+        $info = $this->analyzeStrings($strings);
+        $alternations = $this->buildAlternations($info);
+        $expr = implode('|', $alternations);
+
+        if (count($alternations) > 1 || $this->isOneOptionalString($info))
+        {
+            $expr = '(?:' . $expr . ')';
+        }
+
+        return $expr . $info['quantifier'];
+    }
+
+    /**
+     * Analyze given strings to determine how to serialize them
+     *
+     * The returned array may contains any of the following elements:
+     *
+     *  - (string) quantifier Either '' or '?'
+     *  - (array)  chars      List of values from single-char strings
+     *  - (array)  strings    List of multi-char strings
+     *
+     * @param  array[] $strings
+     * @return array
+     */
+    protected function analyzeStrings(array $strings)
+    {
+        $info = ['quantifier' => ''];
+        if ($strings[0] === [])
+        {
+            $info['quantifier'] = '?';
+            unset($strings[0]);
+        }
+
+        $chars = $this->getChars($strings);
+        if (count($chars) > 1)
+        {
+            $info['chars'] = array_values($chars);
+            $strings = array_diff_key($strings, $chars);
+        }
+
+        $info['strings'] = array_values($strings);
+
+        return $info;
+    }
+
+    /**
+     * Build the list of alternations based on given info
+     *
+     * @param  array    $info
+     * @return string[]
+     */
+    protected function buildAlternations(array $info)
+    {
+        $alternations = [];
+        if (!empty($info['chars']))
+        {
+            $alternations[] = $this->serializeCharacterClass($info['chars']);
+        }
+        foreach ($info['strings'] as $string)
+        {
+            $alternations[] = $this->serializeString($string);
+        }
+
+        return $alternations;
+    }
+
+    /**
+     * Return the portion of strings that are composed of a single character
+     *
+     * @param  array[]
+     * @return array   String key => codepoint
+     */
+    protected function getChars(array $strings)
+    {
+        $chars = [];
+        foreach ($strings as $k => $string)
+        {
+            if (count($string) === 1 && !is_array($string[0]))
+            {
+                $chars[$k] = $string[0];
+            }
+        }
+
+        return $chars;
+    }
+
+    /**
+     * Get the list of ranges that cover all given values
+     *
+     * @param  integer[] $values Ordered list of values
+     * @return array[]           List of ranges in the form [start, end]
+     */
+    protected function getRanges(array $values)
+    {
+        $i      = 0;
+        $cnt    = count($values);
+        $start  = $values[0];
+        $end    = $start;
+        $ranges = [];
+        while (++$i < $cnt)
+        {
+            if ($values[$i] === $end + 1)
+            {
+                ++$end;
+            }
+            else
+            {
+                $ranges[] = [$start, $end];
+                $start = $end = $values[$i];
+            }
+        }
+        $ranges[] = [$start, $end];
+
+        return $ranges;
+    }
+
+    /**
+     * Test whether a string is optional and has more than one character
+     *
+     * @param  array $info
+     * @return bool
+     */
+    protected function isOneOptionalString(array $info)
+    {
+        // Test whether the first string has a quantifier and more than one element
+        return (!empty($info['quantifier']) && isset($info['strings'][0][1]));
+    }
+
+    /**
+     * Serialize a given list of values into a character class
+     *
+     * @param  integer[] $values
+     * @return string
+     */
+    protected function serializeCharacterClass(array $values)
+    {
+        $expr = '[';
+        foreach ($this->getRanges($values) as list($start, $end))
+        {
+            $expr .= $this->escaper->escapeCharacterClass($this->output->output($start));
+            if ($end > $start)
+            {
+                if ($end > $start + 1)
+                {
+                    $expr .= '-';
+                }
+                $expr .= $this->escaper->escapeCharacterClass($this->output->output($end));
+            }
+        }
+        $expr .= ']';
+
+        return $expr;
+    }
+
+    /**
+     * Serialize a given string into a regular expression
+     *
+     * @param  array  $string
+     * @return string
+     */
+    protected function serializeString(array $string)
+    {
+        $expr = '';
+        foreach ($string as $element)
+        {
+            $expr .= (is_array($element)) ? $this->serializeStrings($element) : $this->escaper->escapeLiteral($this->output->output($element));
+        }
+
+        return $expr;
+    }
 }
\ No newline at end of file

src/Output/JavaScript.php

Indentation +9 added lines, -9 removed lines

@@ -9,14 +9,14 @@
 
 class JavaScript extends PrintableAscii
 {
-	/** {@inheritdoc} */
-	protected $maxValue = 0x10FFFF;
+    /** {@inheritdoc} */
+    protected $maxValue = 0x10FFFF;
 
-	/**
-	* {@inheritdoc}
-	*/
-	protected function escapeUnicode($cp)
-	{
-		return sprintf(($cp > 0xFFFF) ? '\\u{%X}' : '\\u%04X', $cp);
-	}
+    /**
+     * {@inheritdoc}
+     */
+    protected function escapeUnicode($cp)
+    {
+        return sprintf(($cp > 0xFFFF) ? '\\u{%X}' : '\\u%04X', $cp);
+    }
 }
\ No newline at end of file

src/Passes/PromoteSingleStrings.php

Indentation +29 added lines, -29 removed lines

@@ -13,35 +13,35 @@
 */
 class PromoteSingleStrings extends AbstractPass
 {
-	/**
-	* {@inheritdoc}
-	*/
-	protected function runPass(array $strings)
-	{
-		return array_map([$this, 'promoteSingleStrings'], $strings);
-	}
+    /**
+     * {@inheritdoc}
+     */
+    protected function runPass(array $strings)
+    {
+        return array_map([$this, 'promoteSingleStrings'], $strings);
+    }
 
-	/**
-	* Promote single strings found inside given string
-	*
-	* @param  array $string Original string
-	* @return array         Modified string
-	*/
-	protected function promoteSingleStrings(array $string)
-	{
-		$newString = [];
-		foreach ($string as $element)
-		{
-			if (is_array($element) && count($element) === 1)
-			{
-				$newString = array_merge($newString, $element[0]);
-			}
-			else
-			{
-				$newString[] = $element;
-			}
-		}
+    /**
+     * Promote single strings found inside given string
+     *
+     * @param  array $string Original string
+     * @return array         Modified string
+     */
+    protected function promoteSingleStrings(array $string)
+    {
+        $newString = [];
+        foreach ($string as $element)
+        {
+            if (is_array($element) && count($element) === 1)
+            {
+                $newString = array_merge($newString, $element[0]);
+            }
+            else
+            {
+                $newString[] = $element;
+            }
+        }
 
-		return $newString;
-	}
+        return $newString;
+    }
 }
\ No newline at end of file

src/Passes/AbstractPass.php

Indentation +63 added lines, -63 removed lines

@@ -9,75 +9,75 @@
 
 abstract class AbstractPass implements PassInterface
 {
-	/**
-	* @var bool Whether the current set of strings is optional
-	*/
-	protected $isOptional;
+    /**
+     * @var bool Whether the current set of strings is optional
+     */
+    protected $isOptional;
 
-	/**
-	* {@inheritdoc}
-	*/
-	public function run(array $strings)
-	{
-		$strings = $this->beforeRun($strings);
-		if ($this->canRun($strings))
-		{
-			$strings = $this->runPass($strings);
-		}
-		$strings = $this->afterRun($strings);
+    /**
+     * {@inheritdoc}
+     */
+    public function run(array $strings)
+    {
+        $strings = $this->beforeRun($strings);
+        if ($this->canRun($strings))
+        {
+            $strings = $this->runPass($strings);
+        }
+        $strings = $this->afterRun($strings);
 
-		return $strings;
-	}
+        return $strings;
+    }
 
-	/**
-	* Process the list of strings after the pass is run
-	*
-	* @param  array[] $strings
-	* @return array[]
-	*/
-	protected function afterRun(array $strings)
-	{
-		if ($this->isOptional && $strings[0] !== [])
-		{
-			array_unshift($strings, []);
-		}
+    /**
+     * Process the list of strings after the pass is run
+     *
+     * @param  array[] $strings
+     * @return array[]
+     */
+    protected function afterRun(array $strings)
+    {
+        if ($this->isOptional && $strings[0] !== [])
+        {
+            array_unshift($strings, []);
+        }
 
-		return $strings;
-	}
+        return $strings;
+    }
 
-	/**
-	* Prepare the list of strings before the pass is run
-	*
-	* @param  array[] $strings
-	* @return array[]
-	*/
-	protected function beforeRun(array $strings)
-	{
-		$this->isOptional = (isset($strings[0]) && $strings[0] === []);
-		if ($this->isOptional)
-		{
-			array_shift($strings);
-		}
+    /**
+     * Prepare the list of strings before the pass is run
+     *
+     * @param  array[] $strings
+     * @return array[]
+     */
+    protected function beforeRun(array $strings)
+    {
+        $this->isOptional = (isset($strings[0]) && $strings[0] === []);
+        if ($this->isOptional)
+        {
+            array_shift($strings);
+        }
 
-		return $strings;
-	}
+        return $strings;
+    }
 
-	/**
-	* Test whether this pass can be run on a given list of strings
-	*
-	* @param  array[] $strings
-	* @return bool
-	*/
-	protected function canRun(array $strings)
-	{
-		return true;
-	}
+    /**
+     * Test whether this pass can be run on a given list of strings
+     *
+     * @param  array[] $strings
+     * @return bool
+     */
+    protected function canRun(array $strings)
+    {
+        return true;
+    }
 
-	/**
-	* Run this pass on a list of strings
-	*
-	* @param  array[] $strings
-	* @return array[]
-	*/
-	abstract protected function runPass(array $strings);
+    /**
+     * Run this pass on a list of strings
+     *
+     * @param  array[] $strings
+     * @return array[]
+     */
+    abstract protected function runPass(array $strings);
 }
\ No newline at end of file

src/Passes/CoalesceSingleCharacterPrefix.php

Indentation +58 added lines, -58 removed lines

@@ -12,67 +12,67 @@
 */
 class CoalesceSingleCharacterPrefix extends AbstractPass
 {
-	/**
-	* {@inheritdoc}
-	*/
-	protected function runPass(array $strings)
-	{
-		$newStrings = [];
-		foreach ($this->getEligibleKeys($strings) as $keys)
-		{
-			// Create a new string to hold the merged strings and replace the first element with
-			// an empty character class
-			$newString    = $strings[$keys[0]];
-			$newString[0] = [];
-			foreach ($keys as $key)
-			{
-				$newString[0][] = [$strings[$key][0]];
-				unset($strings[$key]);
-			}
-			$newStrings[] = $newString;
-		}
+    /**
+     * {@inheritdoc}
+     */
+    protected function runPass(array $strings)
+    {
+        $newStrings = [];
+        foreach ($this->getEligibleKeys($strings) as $keys)
+        {
+            // Create a new string to hold the merged strings and replace the first element with
+            // an empty character class
+            $newString    = $strings[$keys[0]];
+            $newString[0] = [];
+            foreach ($keys as $key)
+            {
+                $newString[0][] = [$strings[$key][0]];
+                unset($strings[$key]);
+            }
+            $newStrings[] = $newString;
+        }
 
-		return array_merge($newStrings, $strings);
-	}
+        return array_merge($newStrings, $strings);
+    }
 
-	/**
-	* Filter the list of eligible keys and keep those that have at least two matches
-	*
-	* @param  array[] $eligibleKeys List of lists of keys
-	* @return array[]
-	*/
-	protected function filterEligibleKeys(array $eligibleKeys)
-	{
-		$filteredKeys = [];
-		foreach ($eligibleKeys as $k => $keys)
-		{
-			if (count($keys) > 1)
-			{
-				$filteredKeys[] = $keys;
-			}
-		}
+    /**
+     * Filter the list of eligible keys and keep those that have at least two matches
+     *
+     * @param  array[] $eligibleKeys List of lists of keys
+     * @return array[]
+     */
+    protected function filterEligibleKeys(array $eligibleKeys)
+    {
+        $filteredKeys = [];
+        foreach ($eligibleKeys as $k => $keys)
+        {
+            if (count($keys) > 1)
+            {
+                $filteredKeys[] = $keys;
+            }
+        }
 
-		return $filteredKeys;
-	}
+        return $filteredKeys;
+    }
 
-	/**
-	* Get a list of keys of strings eligible to be merged together, grouped by suffix
-	*
-	* @param  array[] $strings
-	* @return array[]
-	*/
-	protected function getEligibleKeys(array $strings)
-	{
-		$eligibleKeys = [];
-		foreach ($strings as $k => $string)
-		{
-			if (!is_array($string[0]) && isset($string[1]))
-			{
-				$suffix = serialize(array_slice($string, 1));
-				$eligibleKeys[$suffix][] = $k;
-			}
-		}
+    /**
+     * Get a list of keys of strings eligible to be merged together, grouped by suffix
+     *
+     * @param  array[] $strings
+     * @return array[]
+     */
+    protected function getEligibleKeys(array $strings)
+    {
+        $eligibleKeys = [];
+        foreach ($strings as $k => $string)
+        {
+            if (!is_array($string[0]) && isset($string[1]))
+            {
+                $suffix = serialize(array_slice($string, 1));
+                $eligibleKeys[$suffix][] = $k;
+            }
+        }
 
-		return $this->filterEligibleKeys($eligibleKeys);
-	}
+        return $this->filterEligibleKeys($eligibleKeys);
+    }
 }
\ No newline at end of file