s9e / RegexpBuilder

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

src/Passes/Recurse.php

Indentation +37 added lines, -37 removed lines

@@ -14,45 +14,45 @@
 */
 class Recurse extends AbstractPass
 {
-	/**
-	* @var Runner
-	*/
-	protected $runner;
+    /**
+     * @var Runner
+     */
+    protected $runner;
 
-	/**
-	* @param Runner $runner
-	*/
-	public function __construct(Runner $runner)
-	{
-		$this->runner = $runner;
-	}
+    /**
+     * @param Runner $runner
+     */
+    public function __construct(Runner $runner)
+    {
+        $this->runner = $runner;
+    }
 
-	/**
-	* {@inheritdoc}
-	*/
-	protected function runPass(array $strings)
-	{
-		return array_map([$this, 'recurseString'], $strings);
-	}
+    /**
+     * {@inheritdoc}
+     */
+    protected function runPass(array $strings)
+    {
+        return array_map([$this, 'recurseString'], $strings);
+    }
 
-	/**
-	* Recurse into given string and run all passes on each element
-	*
-	* @param  array $string
-	* @return array
-	*/
-	protected function recurseString(array $string)
-	{
-		$isOptional = $this->isOptional;
-		foreach ($string as $k => $element)
-		{
-			if (is_array($element))
-			{
-				$string[$k] = $this->runner->run($element);
-			}
-		}
-		$this->isOptional = $isOptional;
+    /**
+     * Recurse into given string and run all passes on each element
+     *
+     * @param  array $string
+     * @return array
+     */
+    protected function recurseString(array $string)
+    {
+        $isOptional = $this->isOptional;
+        foreach ($string as $k => $element)
+        {
+            if (is_array($element))
+            {
+                $string[$k] = $this->runner->run($element);
+            }
+        }
+        $this->isOptional = $isOptional;
 
-		return $string;
-	}
+        return $string;
+    }
 }
\ No newline at end of file

src/Passes/MergeSuffix.php

Indentation +61 added lines, -61 removed lines

@@ -12,72 +12,72 @@
 */
 class MergeSuffix extends AbstractPass
 {
-	/**
-	* {@inheritdoc}
-	*/
-	protected function canRun(array $strings)
-	{
-		return (count($strings) > 1 && $this->hasMatchingSuffix($strings));
-	}
+    /**
+     * {@inheritdoc}
+     */
+    protected function canRun(array $strings)
+    {
+        return (count($strings) > 1 && $this->hasMatchingSuffix($strings));
+    }
 
-	/**
-	* {@inheritdoc}
-	*/
-	protected function runPass(array $strings)
-	{
-		$newString = [];
-		while ($this->hasMatchingSuffix($strings))
-		{
-			array_unshift($newString, end($strings[0]));
-			$strings = $this->pop($strings);
-		}
-		array_unshift($newString, $strings);
+    /**
+     * {@inheritdoc}
+     */
+    protected function runPass(array $strings)
+    {
+        $newString = [];
+        while ($this->hasMatchingSuffix($strings))
+        {
+            array_unshift($newString, end($strings[0]));
+            $strings = $this->pop($strings);
+        }
+        array_unshift($newString, $strings);
 
-		return [$newString];
-	}
+        return [$newString];
+    }
 
-	/**
-	* Test whether all given strings have the same last element
-	*
-	* @param  array[] $strings
-	* @return bool
-	*/
-	protected function hasMatchingSuffix(array $strings)
-	{
-		$suffix = end($strings[1]);
-		foreach ($strings as $string)
-		{
-			if (end($string) !== $suffix)
-			{
-				return false;
-			}
-		}
+    /**
+     * Test whether all given strings have the same last element
+     *
+     * @param  array[] $strings
+     * @return bool
+     */
+    protected function hasMatchingSuffix(array $strings)
+    {
+        $suffix = end($strings[1]);
+        foreach ($strings as $string)
+        {
+            if (end($string) !== $suffix)
+            {
+                return false;
+            }
+        }
 
-		return ($suffix !== false);
-	}
+        return ($suffix !== false);
+    }
 
-	/**
-	* Remove the last element of every string
-	*
-	* @param  array[] $strings Original strings
-	* @return array[]          Processed strings
-	*/
-	protected function pop(array $strings)
-	{
-		$cnt = count($strings);
-		$i   = $cnt;
-		while (--$i >= 0)
-		{
-			array_pop($strings[$i]);
-		}
+    /**
+     * Remove the last element of every string
+     *
+     * @param  array[] $strings Original strings
+     * @return array[]          Processed strings
+     */
+    protected function pop(array $strings)
+    {
+        $cnt = count($strings);
+        $i   = $cnt;
+        while (--$i >= 0)
+        {
+            array_pop($strings[$i]);
+        }
 
-		// Remove empty elements then prepend one back at the start of the array if applicable
-		$strings = array_filter($strings);
-		if (count($strings) < $cnt)
-		{
-			array_unshift($strings, []);
-		}
+        // Remove empty elements then prepend one back at the start of the array if applicable
+        $strings = array_filter($strings);
+        if (count($strings) < $cnt)
+        {
+            array_unshift($strings, []);
+        }
 
-		return $strings;
-	}
+        return $strings;
+    }
 }
\ No newline at end of file

src/Passes/GroupSingleCharacters.php

Indentation +33 added lines, -33 removed lines

@@ -12,40 +12,40 @@
 */
 class GroupSingleCharacters extends AbstractPass
 {
-	/**
-	* {@inheritdoc}
-	*/
-	protected function runPass(array $strings)
-	{
-		$singles = $this->getSingleCharStrings($strings);
-		$cnt     = count($singles);
-		if ($cnt > 1 && $cnt < count($strings))
-		{
-			// Remove the singles from the input, then prepend them as a new string
-			$strings = array_diff_key($strings, $singles);
-			array_unshift($strings, [array_values($singles)]);
-		}
+    /**
+     * {@inheritdoc}
+     */
+    protected function runPass(array $strings)
+    {
+        $singles = $this->getSingleCharStrings($strings);
+        $cnt     = count($singles);
+        if ($cnt > 1 && $cnt < count($strings))
+        {
+            // Remove the singles from the input, then prepend them as a new string
+            $strings = array_diff_key($strings, $singles);
+            array_unshift($strings, [array_values($singles)]);
+        }
 
-		return $strings;
-	}
+        return $strings;
+    }
 
-	/**
-	* Return an array of every single-char string in given list of strings
-	*
-	* @param  array[] $strings
-	* @return array[]
-	*/
-	protected function getSingleCharStrings(array $strings)
-	{
-		$singles = [];
-		foreach ($strings as $k => $string)
-		{
-			if (count($string) === 1 && !is_array($string[0]))
-			{
-				$singles[$k] = $string;
-			}
-		}
+    /**
+     * Return an array of every single-char string in given list of strings
+     *
+     * @param  array[] $strings
+     * @return array[]
+     */
+    protected function getSingleCharStrings(array $strings)
+    {
+        $singles = [];
+        foreach ($strings as $k => $string)
+        {
+            if (count($string) === 1 && !is_array($string[0]))
+            {
+                $singles[$k] = $string;
+            }
+        }
 
-		return $singles;
-	}
+        return $singles;
+    }
 }
\ No newline at end of file

src/Passes/MergePrefix.php

Indentation +80 added lines, -80 removed lines

@@ -12,93 +12,93 @@
 */
 class MergePrefix extends AbstractPass
 {
-	/**
-	* {@inheritdoc}
-	*/
-	protected function runPass(array $strings)
-	{
-		$newStrings = [];
-		foreach ($this->getStringsByPrefix($strings) as $prefix => $strings)
-		{
-			$newStrings[] = (isset($strings[1])) ? $this->mergeStrings($strings) : $strings[0];
-		}
+    /**
+     * {@inheritdoc}
+     */
+    protected function runPass(array $strings)
+    {
+        $newStrings = [];
+        foreach ($this->getStringsByPrefix($strings) as $prefix => $strings)
+        {
+            $newStrings[] = (isset($strings[1])) ? $this->mergeStrings($strings) : $strings[0];
+        }
 
-		return $newStrings;
-	}
+        return $newStrings;
+    }
 
-	/**
-	* Get the number of leading elements common to all given strings
-	*
-	* @param  array[] $strings
-	* @return integer
-	*/
-	protected function getPrefixLength(array $strings)
-	{
-		$len = 1;
-		$cnt = count($strings[0]);
-		while ($len < $cnt && $this->stringsMatch($strings, $len))
-		{
-			++$len;
-		}
+    /**
+     * Get the number of leading elements common to all given strings
+     *
+     * @param  array[] $strings
+     * @return integer
+     */
+    protected function getPrefixLength(array $strings)
+    {
+        $len = 1;
+        $cnt = count($strings[0]);
+        while ($len < $cnt && $this->stringsMatch($strings, $len))
+        {
+            ++$len;
+        }
 
-		return $len;
-	}
+        return $len;
+    }
 
-	/**
-	* Return given strings grouped by their first element
-	*
-	* NOTE: assumes that this pass is run before the first element of any string could be replaced
-	*
-	* @param  array[] $strings
-	* @return array[]
-	*/
-	protected function getStringsByPrefix(array $strings)
-	{
-		$byPrefix = [];
-		foreach ($strings as $string)
-		{
-			$byPrefix[$string[0]][] = $string;
-		}
+    /**
+     * Return given strings grouped by their first element
+     *
+     * NOTE: assumes that this pass is run before the first element of any string could be replaced
+     *
+     * @param  array[] $strings
+     * @return array[]
+     */
+    protected function getStringsByPrefix(array $strings)
+    {
+        $byPrefix = [];
+        foreach ($strings as $string)
+        {
+            $byPrefix[$string[0]][] = $string;
+        }
 
-		return $byPrefix;
-	}
+        return $byPrefix;
+    }
 
-	/**
-	* Merge given strings into a new single string
-	*
-	* @param  array[] $strings
-	* @return array
-	*/
-	protected function mergeStrings(array $strings)
-	{
-		$len       = $this->getPrefixLength($strings);
-		$newString = array_slice($strings[0], 0, $len);
-		foreach ($strings as $string)
-		{
-			$newString[$len][] = array_slice($string, $len);
-		}
+    /**
+     * Merge given strings into a new single string
+     *
+     * @param  array[] $strings
+     * @return array
+     */
+    protected function mergeStrings(array $strings)
+    {
+        $len       = $this->getPrefixLength($strings);
+        $newString = array_slice($strings[0], 0, $len);
+        foreach ($strings as $string)
+        {
+            $newString[$len][] = array_slice($string, $len);
+        }
 
-		return $newString;
-	}
+        return $newString;
+    }
 
-	/**
-	* Test whether all given strings' elements match at given position
-	*
-	* @param  array[] $strings
-	* @param  integer $pos
-	* @return bool
-	*/
-	protected function stringsMatch(array $strings, $pos)
-	{
-		$value = $strings[0][$pos];
-		foreach ($strings as $string)
-		{
-			if (!isset($string[$pos]) || $string[$pos] !== $value)
-			{
-				return false;
-			}
-		}
+    /**
+     * Test whether all given strings' elements match at given position
+     *
+     * @param  array[] $strings
+     * @param  integer $pos
+     * @return bool
+     */
+    protected function stringsMatch(array $strings, $pos)
+    {
+        $value = $strings[0][$pos];
+        foreach ($strings as $string)
+        {
+            if (!isset($string[$pos]) || $string[$pos] !== $value)
+            {
+                return false;
+            }
+        }
 
-		return true;
-	}
+        return true;
+    }
 }
\ No newline at end of file