ladybirdweb / agorainvoicing

vendor/phpdocumentor/reflection-docblock/src/phpDocumentor/Reflection/DocBlock.php

Doc Comments -1 removed lines

@@ -271,7 +271,6 @@
      * Sets the text portion (short and long description combined) of the doc
      * block.
      *
-     * @param string $docblock The new text portion of the doc block.
      * 
      * @return $this This doc block.
      */

Spacing +2 added lines, -2 removed lines

@@ -225,14 +225,14 @@
             if ('@' !== $tags[0]) {
                 throw new \LogicException(
                     'A tag block started with text instead of an actual tag,'
-                    . ' this makes the tag block invalid: ' . $tags
+                    . ' this makes the tag block invalid: '.$tags
                 );
             }
             foreach (explode("\n", $tags) as $tag_line) {
                 if (isset($tag_line[0]) && ($tag_line[0] === '@')) {
                     $result[] = $tag_line;
                 } else {
-                    $result[count($result) - 1] .= "\n" . $tag_line;
+                    $result[count($result) - 1] .= "\n".$tag_line;
                 }
             }
 

vendor/phpdocumentor/reflection-docblock/src/phpDocumentor/Reflection/DocBlock/Location.php

Doc Comments +1 added lines, -1 removed lines

@@ -44,7 +44,7 @@
 
     /**
      * 
-     * @param type $lineNumber
+     * @param integer $lineNumber
      * @return $this
      */
     public function setLineNumber($lineNumber)

Spacing +2 added lines, -2 removed lines

@@ -49,7 +49,7 @@ 
      */
     public function setLineNumber($lineNumber)
     {
-        $this->lineNumber = (int)$lineNumber;
+        $this->lineNumber = (int) $lineNumber;
 
         return $this;
     }
@@ -69,7 +69,7 @@ 
      */
     public function setColumnNumber($columnNumber)
     {
-        $this->columnNumber = (int)$columnNumber;
+        $this->columnNumber = (int) $columnNumber;
 
         return $this;
     }

vendor/phpdocumentor/reflection-docblock/src/phpDocumentor/Reflection/DocBlock/Serializer.php

Doc Comments +2 added lines, -2 removed lines

@@ -61,7 +61,7 @@ 
     /**
      * Sets the string to indent comments with.
      * 
-     * @param string $indentationString The string to indent comments with.
+     * @param string $indentString The string to indent comments with.
      * 
      * @return $this This serializer object.
      */
@@ -161,7 +161,7 @@ 
     /**
      * Generate a DocBlock comment.
      *
-     * @param DocBlock The DocBlock to serialize.
+     * @param DocBlock  DocBlock to serialize.
      * 
      * @return string The serialized doc block.
      */

Spacing +5 added lines, -5 removed lines

@@ -67,7 +67,7 @@ 
      */
     public function setIndentationString($indentString)
     {
-        $this->indentString = (string)$indentString;
+        $this->indentString = (string) $indentString;
         return $this;
     }
 
@@ -90,7 +90,7 @@ 
      */
     public function setIndent($indent)
     {
-        $this->indent = (int)$indent;
+        $this->indent = (int) $indent;
         return $this;
     }
 
@@ -116,7 +116,7 @@ 
      */
     public function setIsFirstLineIndented($indentFirstLine)
     {
-        $this->isFirstLineIndented = (bool)$indentFirstLine;
+        $this->isFirstLineIndented = (bool) $indentFirstLine;
         return $this;
     }
 
@@ -143,7 +143,7 @@ 
      */
     public function setLineLength($lineLength)
     {
-        $this->lineLength = null === $lineLength ? null : (int)$lineLength;
+        $this->lineLength = null === $lineLength ? null : (int) $lineLength;
         return $this;
     }
 
@@ -191,7 +191,7 @@ 
             $comment .= "{$indent} * {$tagText}\n";
         }
 
-        $comment .= $indent . ' */';
+        $comment .= $indent.' */';
 
         return $comment;
     }

vendor/phpdocumentor/reflection-docblock/src/phpDocumentor/Reflection/DocBlock/Type/Collection.php

Doc Comments -1 removed lines

@@ -56,7 +56,6 @@
      *
      * @param string[] $types    Array containing a list of types to add to this
      *     container.
-     * @param Context  $location The current invoking location.
      */
     public function __construct(
         array $types = array(),

Spacing +2 added lines, -2 removed lines

@@ -152,7 +152,7 @@ 
         }
 
         if ($this->isTypeAnArray($type)) {
-            return $this->expand(substr($type, 0, -2)) . self::OPERATOR_ARRAY;
+            return $this->expand(substr($type, 0, -2)).self::OPERATOR_ARRAY;
         }
 
         if ($this->isRelativeType($type) && !$this->isTypeAKeyword($type)) {
@@ -166,7 +166,7 @@ 
                 if ('' !== $namespace) {
                     $namespace .= self::OPERATOR_NAMESPACE;
                 }
-                return self::OPERATOR_NAMESPACE . $namespace . $type;
+                return self::OPERATOR_NAMESPACE.$namespace.$type;
             }
 
             $type_parts[0] = $namespace_aliases[$type_parts[0]];

vendor/phpdocumentor/reflection-docblock/tests/phpDocumentor/Reflection/DocBlock/Tag/ExampleTagTest.php

Doc Comments +1 added lines, -1 removed lines

@@ -31,7 +31,7 @@
      * @param string $exContent
      * @param string $exStartingLine
      * @param string $exLineCount
-     * @param string $exFilepath
+     * @param string $exFilePath
      *
      * @covers \phpDocumentor\Reflection\DocBlock\Tag\ExampleTag
      * @dataProvider provideDataForConstuctor

vendor/phpspec/php-diff/lib/Diff/SequenceMatcher.php

Doc Comments +3 added lines, -3 removed lines

@@ -607,7 +607,7 @@ 
 	 * The ratio is calculated as (2 * number of matches) / total number of
 	 * elements in both sequences.
 	 *
-	 * @return float The calculated ratio.
+	 * @return integer The calculated ratio.
 	 */
 	public function Ratio()
 	{
@@ -668,7 +668,7 @@ 
 	 * Return an upper bound ratio really quickly for the similarity of the strings.
 	 * This is quicker to compute than Ratio() and quickRatio().
 	 *
-	 * @return float The calculated ratio.
+	 * @return integer The calculated ratio.
 	 */
 	private function realquickRatio()
 	{
@@ -684,7 +684,7 @@ 
 	 *
 	 * @param int $matches The number of matches in the two strings.
 	 * @param int $length The length of the two strings.
-	 * @return float The calculated ratio.
+	 * @return integer The calculated ratio.
 	 */
 	private function calculateRatio($matches, $length=0)
 	{

Spacing +72 added lines, -72 removed lines

@@ -85,7 +85,7 @@ 
 	 * @param string|array $junkCallback Either an array or string that references a callback function (if there is one) to determine 'junk' characters.
 	 * @param array $options
 	 */
-	public function __construct($a, $b, $junkCallback=null, $options)
+	public function __construct($a, $b, $junkCallback = null, $options)
 	{
 		$this->a = null;
 		$this->b = null;
@@ -124,14 +124,14 @@ 
 	 */
 	public function setSeq1($a)
 	{
-		if(!is_array($a)) {
+		if (!is_array($a)) {
 			$a = str_split($a);
 		}
-		if($a == $this->a) {
+		if ($a == $this->a) {
 			return;
 		}
 
-		$this->a= $a;
+		$this->a = $a;
 		$this->matchingBlocks = null;
 		$this->opCodes = null;
 	}
@@ -144,10 +144,10 @@ 
 	 */
 	public function setSeq2($b)
 	{
-		if(!is_array($b)) {
+		if (!is_array($b)) {
 			$b = str_split($b);
 		}
-		if($b == $this->b) {
+		if ($b == $this->b) {
 			return;
 		}
 
@@ -164,14 +164,14 @@ 
 	 */
 	private function chainB()
 	{
-		$length = count ($this->b);
+		$length = count($this->b);
 		$this->b2j = array();
 		$popularDict = array();
 
-		for($i = 0; $i < $length; ++$i) {
+		for ($i = 0; $i < $length; ++$i) {
 			$char = $this->b[$i];
-			if(isset($this->b2j[$char])) {
-				if($length >= 200 && count($this->b2j[$char]) * 100 > $length) {
+			if (isset($this->b2j[$char])) {
+				if ($length >= 200 && count($this->b2j[$char]) * 100 > $length) {
 					$popularDict[$char] = 1;
 					unset($this->b2j[$char]);
 				}
@@ -187,21 +187,21 @@ 
 		}
 
 		// Remove leftovers
-		foreach(array_keys($popularDict) as $char) {
+		foreach (array_keys($popularDict) as $char) {
 			unset($this->b2j[$char]);
 		}
 
 		$this->junkDict = array();
-		if(is_callable($this->junkCallback)) {
-			foreach(array_keys($popularDict) as $char) {
-				if(call_user_func($this->junkCallback, $char)) {
+		if (is_callable($this->junkCallback)) {
+			foreach (array_keys($popularDict) as $char) {
+				if (call_user_func($this->junkCallback, $char)) {
 					$this->junkDict[$char] = 1;
 					unset($popularDict[$char]);
 				}
 			}
 
-			foreach(array_keys($this->b2j) as $char) {
-				if(call_user_func($this->junkCallback, $char)) {
+			foreach (array_keys($this->b2j) as $char) {
+				if (call_user_func($this->junkCallback, $char)) {
 					$this->junkDict[$char] = 1;
 					unset($this->b2j[$char]);
 				}
@@ -217,7 +217,7 @@ 
 	 */
 	private function isBJunk($b)
 	{
-		if(isset($this->juncDict[$b])) {
+		if (isset($this->juncDict[$b])) {
 			return true;
 		}
 
@@ -255,20 +255,20 @@ 
 		$j2Len = array();
 		$nothing = array();
 
-		for($i = $alo; $i < $ahi; ++$i) {
+		for ($i = $alo; $i < $ahi; ++$i) {
 			$newJ2Len = array();
 			$jDict = $this->arrayGetDefault($this->b2j, $a[$i], $nothing);
-			foreach($jDict as $jKey => $j) {
-				if($j < $blo) {
+			foreach ($jDict as $jKey => $j) {
+				if ($j < $blo) {
 					continue;
 				}
-				else if($j >= $bhi) {
+				else if ($j >= $bhi) {
 					break;
 				}
 
-				$k = $this->arrayGetDefault($j2Len, $j -1, 0) + 1;
+				$k = $this->arrayGetDefault($j2Len, $j - 1, 0) + 1;
 				$newJ2Len[$j] = $k;
-				if($k > $bestSize) {
+				if ($k > $bestSize) {
 					$bestI = $i - $k + 1;
 					$bestJ = $j - $k + 1;
 					$bestSize = $k;
@@ -278,26 +278,26 @@ 
 			$j2Len = $newJ2Len;
 		}
 
-		while($bestI > $alo && $bestJ > $blo && !$this->isBJunk($b[$bestJ - 1]) &&
+		while ($bestI > $alo && $bestJ > $blo && !$this->isBJunk($b[$bestJ - 1]) &&
 			!$this->linesAreDifferent($bestI - 1, $bestJ - 1)) {
 				--$bestI;
 				--$bestJ;
 				++$bestSize;
 		}
 
-		while($bestI + $bestSize < $ahi && ($bestJ + $bestSize) < $bhi &&
+		while ($bestI + $bestSize < $ahi && ($bestJ + $bestSize) < $bhi &&
 			!$this->isBJunk($b[$bestJ + $bestSize]) && !$this->linesAreDifferent($bestI + $bestSize, $bestJ + $bestSize)) {
 				++$bestSize;
 		}
 
-		while($bestI > $alo && $bestJ > $blo && $this->isBJunk($b[$bestJ - 1]) &&
+		while ($bestI > $alo && $bestJ > $blo && $this->isBJunk($b[$bestJ - 1]) &&
 			!$this->isLineDifferent($bestI - 1, $bestJ - 1)) {
 				--$bestI;
 				--$bestJ;
 				++$bestSize;
 		}
 
-		while($bestI + $bestSize < $ahi && $bestJ + $bestSize < $bhi &&
+		while ($bestI + $bestSize < $ahi && $bestJ + $bestSize < $bhi &&
 			$this->isBJunk($b[$bestJ + $bestSize]) && !$this->linesAreDifferent($bestI + $bestSize, $bestJ + $bestSize)) {
 					++$bestSize;
 		}
@@ -321,18 +321,18 @@ 
 		$lineA = $this->a[$aIndex];
 		$lineB = $this->b[$bIndex];
 
-		if($this->options['ignoreWhitespace']) {
+		if ($this->options['ignoreWhitespace']) {
 			$replace = array("\t", ' ');
 			$lineA = str_replace($replace, '', $lineA);
 			$lineB = str_replace($replace, '', $lineB);
 		}
 
-		if($this->options['ignoreCase']) {
+		if ($this->options['ignoreCase']) {
 			$lineA = strtolower($lineA);
 			$lineB = strtolower($lineB);
 		}
 
-		if($lineA != $lineB) {
+		if ($lineA != $lineB) {
 			return true;
 		}
 
@@ -351,7 +351,7 @@ 
 	 */
 	public function getMatchingBlocks()
 	{
-		if(!empty($this->matchingBlocks)) {
+		if (!empty($this->matchingBlocks)) {
 			return $this->matchingBlocks;
 		}
 
@@ -368,13 +368,13 @@ 
 		);
 
 		$matchingBlocks = array();
-		while(!empty($queue)) {
+		while (!empty($queue)) {
 			list($alo, $ahi, $blo, $bhi) = array_pop($queue);
 			$x = $this->findLongestMatch($alo, $ahi, $blo, $bhi);
 			list($i, $j, $k) = $x;
-			if($k) {
+			if ($k) {
 				$matchingBlocks[] = $x;
-				if($alo < $i && $blo < $j) {
+				if ($alo < $i && $blo < $j) {
 					$queue[] = array(
 						$alo,
 						$i,
@@ -383,7 +383,7 @@ 
 					);
 				}
 
-				if($i + $k < $ahi && $j + $k < $bhi) {
+				if ($i + $k < $ahi && $j + $k < $bhi) {
 					$queue[] = array(
 						$i + $k,
 						$ahi,
@@ -400,13 +400,13 @@ 
 		$j1 = 0;
 		$k1 = 0;
 		$nonAdjacent = array();
-		foreach($matchingBlocks as $block) {
+		foreach ($matchingBlocks as $block) {
 			list($i2, $j2, $k2) = $block;
-			if($i1 + $k1 == $i2 && $j1 + $k1 == $j2) {
+			if ($i1 + $k1 == $i2 && $j1 + $k1 == $j2) {
 				$k1 += $k2;
 			}
 			else {
-				if($k1) {
+				if ($k1) {
 					$nonAdjacent[] = array(
 						$i1,
 						$j1,
@@ -420,7 +420,7 @@ 
 			}
 		}
 
-		if($k1) {
+		if ($k1) {
 			$nonAdjacent[] = array(
 				$i1,
 				$j1,
@@ -462,7 +462,7 @@ 
 	 */
 	public function getOpCodes()
 	{
-		if(!empty($this->opCodes)) {
+		if (!empty($this->opCodes)) {
 			return $this->opCodes;
 		}
 
@@ -471,20 +471,20 @@ 
 		$this->opCodes = array();
 
 		$blocks = $this->getMatchingBlocks();
-		foreach($blocks as $block) {
+		foreach ($blocks as $block) {
 			list($ai, $bj, $size) = $block;
 			$tag = '';
-			if($i < $ai && $j < $bj) {
+			if ($i < $ai && $j < $bj) {
 				$tag = 'replace';
 			}
-			else if($i < $ai) {
+			else if ($i < $ai) {
 				$tag = 'delete';
 			}
-			else if($j < $bj) {
+			else if ($j < $bj) {
 				$tag = 'insert';
 			}
 
-			if($tag) {
+			if ($tag) {
 				$this->opCodes[] = array(
 					$tag,
 					$i,
@@ -497,7 +497,7 @@ 
 			$i = $ai + $size;
 			$j = $bj + $size;
 
-			if($size) {
+			if ($size) {
 				$this->opCodes[] = array(
 					'equal',
 					$ai,
@@ -524,10 +524,10 @@ 
 	 * @param int $context The number of lines of context to provide around the groups.
 	 * @return array Nested array of all of the grouped opcodes.
 	 */
-	public function getGroupedOpcodes($context=3)
+	public function getGroupedOpcodes($context = 3)
 	{
 		$opCodes = $this->getOpCodes();
-		if(empty($opCodes)) {
+		if (empty($opCodes)) {
 			$opCodes = array(
 				array(
 					'equal',
@@ -539,7 +539,7 @@ 
 			);
 		}
 
-		if($opCodes[0][0] == 'equal') {
+		if ($opCodes[0][0] == 'equal') {
 			$opCodes[0] = array(
 				$opCodes[0][0],
 				max($opCodes[0][1], $opCodes[0][2] - $context),
@@ -550,7 +550,7 @@ 
 		}
 
 		$lastItem = count($opCodes) - 1;
-		if($opCodes[$lastItem][0] == 'equal') {
+		if ($opCodes[$lastItem][0] == 'equal') {
 			list($tag, $i1, $i2, $j1, $j2) = $opCodes[$lastItem];
 			$opCodes[$lastItem] = array(
 				$tag,
@@ -564,9 +564,9 @@ 
 		$maxRange = $context * 2;
 		$groups = array();
 		$group = array();
-		foreach($opCodes as $code) {
+		foreach ($opCodes as $code) {
 			list($tag, $i1, $i2, $j1, $j2) = $code;
-			if($tag == 'equal' && $i2 - $i1 > $maxRange) {
+			if ($tag == 'equal' && $i2 - $i1 > $maxRange) {
 				$group[] = array(
 					$tag,
 					$i1,
@@ -588,7 +588,7 @@ 
 			);
 		}
 
-		if(!empty($group) && !(count($group) == 1 && $group[0][0] == 'equal')) {
+		if (!empty($group) && !(count($group) == 1 && $group[0][0] == 'equal')) {
 			$groups[] = $group;
 		}
 
@@ -612,7 +612,7 @@ 
 	public function Ratio()
 	{
 		$matches = array_reduce($this->getMatchingBlocks(), array($this, 'ratioReduce'), 0);
-		return $this->calculateRatio($matches, count ($this->a) + count ($this->b));
+		return $this->calculateRatio($matches, count($this->a) + count($this->b));
 	}
 
 	/**
@@ -635,10 +635,10 @@ 
 	 */
 	private function quickRatio()
 	{
-		if($this->fullBCount === null) {
+		if ($this->fullBCount === null) {
 			$this->fullBCount = array();
-			$bLength = count ($this->b);
-			for($i = 0; $i < $bLength; ++$i) {
+			$bLength = count($this->b);
+			for ($i = 0; $i < $bLength; ++$i) {
 				$char = $this->b[$i];
 				$this->fullBCount[$char] = $this->arrayGetDefault($this->fullBCount, $char, 0) + 1;
 			}
@@ -646,22 +646,22 @@ 
 
 		$avail = array();
 		$matches = 0;
-		$aLength = count ($this->a);
-		for($i = 0; $i < $aLength; ++$i) {
+		$aLength = count($this->a);
+		for ($i = 0; $i < $aLength; ++$i) {
 			$char = $this->a[$i];
-			if(isset($avail[$char])) {
+			if (isset($avail[$char])) {
 				$numb = $avail[$char];
 			}
 			else {
 				$numb = $this->arrayGetDefault($this->fullBCount, $char, 0);
 			}
 			$avail[$char] = $numb - 1;
-			if($numb > 0) {
+			if ($numb > 0) {
 				++$matches;
 			}
 		}
 
-		$this->calculateRatio($matches, count ($this->a) + count ($this->b));
+		$this->calculateRatio($matches, count($this->a) + count($this->b));
 	}
 
 	/**
@@ -672,8 +672,8 @@ 
 	 */
 	private function realquickRatio()
 	{
-		$aLength = count ($this->a);
-		$bLength = count ($this->b);
+		$aLength = count($this->a);
+		$bLength = count($this->b);
 
 		return $this->calculateRatio(min($aLength, $bLength), $aLength + $bLength);
 	}
@@ -686,9 +686,9 @@ 
 	 * @param int $length The length of the two strings.
 	 * @return float The calculated ratio.
 	 */
-	private function calculateRatio($matches, $length=0)
+	private function calculateRatio($matches, $length = 0)
 	{
-		if($length) {
+		if ($length) {
 			return 2 * ($matches / $length);
 		}
 		else {
@@ -708,7 +708,7 @@ 
 	 */
 	private function arrayGetDefault($array, $key, $default)
 	{
-		if(isset($array[$key])) {
+		if (isset($array[$key])) {
 			return $array[$key];
 		}
 		else {
@@ -726,19 +726,19 @@ 
 	private function tupleSort($a, $b)
 	{
 		$max = max(count($a), count($b));
-		for($i = 0; $i < $max; ++$i) {
-			if($a[$i] < $b[$i]) {
+		for ($i = 0; $i < $max; ++$i) {
+			if ($a[$i] < $b[$i]) {
 				return -1;
 			}
-			else if($a[$i] > $b[$i]) {
+			else if ($a[$i] > $b[$i]) {
 				return 1;
 			}
 		}
 
-		if(count($a) == count($b)) {
+		if (count($a) == count($b)) {
 			return 0;
 		}
-		else if(count($a) < count($b)) {
+		else if (count($a) < count($b)) {
 			return -1;
 		}
 		else {

Braces +12 added lines, -24 removed lines

@@ -174,12 +174,10 @@ 
 				if($length >= 200 && count($this->b2j[$char]) * 100 > $length) {
 					$popularDict[$char] = 1;
 					unset($this->b2j[$char]);
-				}
-				else {
+				} else {
 					$this->b2j[$char][] = $i;
 				}
-			}
-			else {
+			} else {
 				$this->b2j[$char] = array(
 					$i
 				);
@@ -261,8 +259,7 @@ 
 			foreach($jDict as $jKey => $j) {
 				if($j < $blo) {
 					continue;
-				}
-				else if($j >= $bhi) {
+				} else if($j >= $bhi) {
 					break;
 				}
 
@@ -404,8 +401,7 @@ 
 			list($i2, $j2, $k2) = $block;
 			if($i1 + $k1 == $i2 && $j1 + $k1 == $j2) {
 				$k1 += $k2;
-			}
-			else {
+			} else {
 				if($k1) {
 					$nonAdjacent[] = array(
 						$i1,
@@ -476,11 +472,9 @@ 
 			$tag = '';
 			if($i < $ai && $j < $bj) {
 				$tag = 'replace';
-			}
-			else if($i < $ai) {
+			} else if($i < $ai) {
 				$tag = 'delete';
-			}
-			else if($j < $bj) {
+			} else if($j < $bj) {
 				$tag = 'insert';
 			}
 
@@ -651,8 +645,7 @@ 
 			$char = $this->a[$i];
 			if(isset($avail[$char])) {
 				$numb = $avail[$char];
-			}
-			else {
+			} else {
 				$numb = $this->arrayGetDefault($this->fullBCount, $char, 0);
 			}
 			$avail[$char] = $numb - 1;
@@ -690,8 +683,7 @@ 
 	{
 		if($length) {
 			return 2 * ($matches / $length);
-		}
-		else {
+		} else {
 			return 1;
 		}
 	}
@@ -710,8 +702,7 @@ 
 	{
 		if(isset($array[$key])) {
 			return $array[$key];
-		}
-		else {
+		} else {
 			return $default;
 		}
 	}
@@ -729,19 +720,16 @@ 
 		for($i = 0; $i < $max; ++$i) {
 			if($a[$i] < $b[$i]) {
 				return -1;
-			}
-			else if($a[$i] > $b[$i]) {
+			} else if($a[$i] > $b[$i]) {
 				return 1;
 			}
 		}
 
 		if(count($a) == count($b)) {
 			return 0;
-		}
-		else if(count($a) < count($b)) {
+		} else if(count($a) < count($b)) {
 			return -1;
-		}
-		else {
+		} else {
 			return 1;
 		}
 	}

Indentation +703 added lines, -703 removed lines

@@ -42,707 +42,707 @@
 
 class Diff_SequenceMatcher
 {
-	/**
-	 * @var string|array Either a string or an array containing a callback function to determine if a line is "junk" or not.
-	 */
-	private $junkCallback = null;
-
-	/**
-	 * @var array The first sequence to compare against.
-	 */
-	private $a = null;
-
-	/**
-	 * @var array The second sequence.
-	 */
-	private $b = null;
-
-	/**
-	 * @var array Array of characters that are considered junk from the second sequence. Characters are the array key.
-	 */
-	private $junkDict = array();
-
-	/**
-	 * @var array Array of indices that do not contain junk elements.
-	 */
-	private $b2j = array();
-
-	private $options = array();
-
-	private $defaultOptions = array(
-		'ignoreNewLines' => false,
-		'ignoreWhitespace' => false,
-		'ignoreCase' => false
-	);
-
-	/**
-	 * The constructor. With the sequences being passed, they'll be set for the
-	 * sequence matcher and it will perform a basic cleanup & calculate junk
-	 * elements.
-	 *
-	 * @param string|array $a A string or array containing the lines to compare against.
-	 * @param string|array $b A string or array containing the lines to compare.
-	 * @param string|array $junkCallback Either an array or string that references a callback function (if there is one) to determine 'junk' characters.
-	 * @param array $options
-	 */
-	public function __construct($a, $b, $junkCallback=null, $options)
-	{
-		$this->a = null;
-		$this->b = null;
-		$this->junkCallback = $junkCallback;
-		$this->setOptions($options);
-		$this->setSequences($a, $b);
-	}
-
-	/**
-	 * Set new options
-	 *
-	 * @param array $options
-	 */
-	public function setOptions($options)
-	{
-		$this->options = array_merge($this->defaultOptions, $options);
-	}
-
-	/**
-	 * Set the first and second sequences to use with the sequence matcher.
-	 *
-	 * @param string|array $a A string or array containing the lines to compare against.
-	 * @param string|array $b A string or array containing the lines to compare.
-	 */
-	public function setSequences($a, $b)
-	{
-		$this->setSeq1($a);
-		$this->setSeq2($b);
-	}
-
-	/**
-	 * Set the first sequence ($a) and reset any internal caches to indicate that
-	 * when calling the calculation methods, we need to recalculate them.
-	 *
-	 * @param string|array $a The sequence to set as the first sequence.
-	 */
-	public function setSeq1($a)
-	{
-		if(!is_array($a)) {
-			$a = str_split($a);
-		}
-		if($a == $this->a) {
-			return;
-		}
-
-		$this->a= $a;
-		$this->matchingBlocks = null;
-		$this->opCodes = null;
-	}
-
-	/**
-	 * Set the second sequence ($b) and reset any internal caches to indicate that
-	 * when calling the calculation methods, we need to recalculate them.
-	 *
-	 * @param string|array $b The sequence to set as the second sequence.
-	 */
-	public function setSeq2($b)
-	{
-		if(!is_array($b)) {
-			$b = str_split($b);
-		}
-		if($b == $this->b) {
-			return;
-		}
-
-		$this->b = $b;
-		$this->matchingBlocks = null;
-		$this->opCodes = null;
-		$this->fullBCount = null;
-		$this->chainB();
-	}
-
-	/**
-	 * Generate the internal arrays containing the list of junk and non-junk
-	 * characters for the second ($b) sequence.
-	 */
-	private function chainB()
-	{
-		$length = count ($this->b);
-		$this->b2j = array();
-		$popularDict = array();
-
-		for($i = 0; $i < $length; ++$i) {
-			$char = $this->b[$i];
-			if(isset($this->b2j[$char])) {
-				if($length >= 200 && count($this->b2j[$char]) * 100 > $length) {
-					$popularDict[$char] = 1;
-					unset($this->b2j[$char]);
-				}
-				else {
-					$this->b2j[$char][] = $i;
-				}
-			}
-			else {
-				$this->b2j[$char] = array(
-					$i
-				);
-			}
-		}
-
-		// Remove leftovers
-		foreach(array_keys($popularDict) as $char) {
-			unset($this->b2j[$char]);
-		}
-
-		$this->junkDict = array();
-		if(is_callable($this->junkCallback)) {
-			foreach(array_keys($popularDict) as $char) {
-				if(call_user_func($this->junkCallback, $char)) {
-					$this->junkDict[$char] = 1;
-					unset($popularDict[$char]);
-				}
-			}
-
-			foreach(array_keys($this->b2j) as $char) {
-				if(call_user_func($this->junkCallback, $char)) {
-					$this->junkDict[$char] = 1;
-					unset($this->b2j[$char]);
-				}
-			}
-		}
-	}
-
-	/**
-	 * Checks if a particular character is in the junk dictionary
-	 * for the list of junk characters.
-	 * @param $b
-	 * @return boolean True if the character is considered junk. False if not.
-	 */
-	private function isBJunk($b)
-	{
-		if(isset($this->juncDict[$b])) {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * Find the longest matching block in the two sequences, as defined by the
-	 * lower and upper constraints for each sequence. (for the first sequence,
-	 * $alo - $ahi and for the second sequence, $blo - $bhi)
-	 *
-	 * Essentially, of all of the maximal matching blocks, return the one that
-	 * startest earliest in $a, and all of those maximal matching blocks that
-	 * start earliest in $a, return the one that starts earliest in $b.
-	 *
-	 * If the junk callback is defined, do the above but with the restriction
-	 * that the junk element appears in the block. Extend it as far as possible
-	 * by matching only junk elements in both $a and $b.
-	 *
-	 * @param int $alo The lower constraint for the first sequence.
-	 * @param int $ahi The upper constraint for the first sequence.
-	 * @param int $blo The lower constraint for the second sequence.
-	 * @param int $bhi The upper constraint for the second sequence.
-	 * @return array Array containing the longest match that includes the starting position in $a, start in $b and the length/size.
-	 */
-	public function findLongestMatch($alo, $ahi, $blo, $bhi)
-	{
-		$a = $this->a;
-		$b = $this->b;
-
-		$bestI = $alo;
-		$bestJ = $blo;
-		$bestSize = 0;
-
-		$j2Len = array();
-		$nothing = array();
-
-		for($i = $alo; $i < $ahi; ++$i) {
-			$newJ2Len = array();
-			$jDict = $this->arrayGetDefault($this->b2j, $a[$i], $nothing);
-			foreach($jDict as $jKey => $j) {
-				if($j < $blo) {
-					continue;
-				}
-				else if($j >= $bhi) {
-					break;
-				}
-
-				$k = $this->arrayGetDefault($j2Len, $j -1, 0) + 1;
-				$newJ2Len[$j] = $k;
-				if($k > $bestSize) {
-					$bestI = $i - $k + 1;
-					$bestJ = $j - $k + 1;
-					$bestSize = $k;
-				}
-			}
-
-			$j2Len = $newJ2Len;
-		}
-
-		while($bestI > $alo && $bestJ > $blo && !$this->isBJunk($b[$bestJ - 1]) &&
-			!$this->linesAreDifferent($bestI - 1, $bestJ - 1)) {
-				--$bestI;
-				--$bestJ;
-				++$bestSize;
-		}
-
-		while($bestI + $bestSize < $ahi && ($bestJ + $bestSize) < $bhi &&
-			!$this->isBJunk($b[$bestJ + $bestSize]) && !$this->linesAreDifferent($bestI + $bestSize, $bestJ + $bestSize)) {
-				++$bestSize;
-		}
-
-		while($bestI > $alo && $bestJ > $blo && $this->isBJunk($b[$bestJ - 1]) &&
-			!$this->isLineDifferent($bestI - 1, $bestJ - 1)) {
-				--$bestI;
-				--$bestJ;
-				++$bestSize;
-		}
-
-		while($bestI + $bestSize < $ahi && $bestJ + $bestSize < $bhi &&
-			$this->isBJunk($b[$bestJ + $bestSize]) && !$this->linesAreDifferent($bestI + $bestSize, $bestJ + $bestSize)) {
-					++$bestSize;
-		}
-
-		return array(
-			$bestI,
-			$bestJ,
-			$bestSize
-		);
-	}
-
-	/**
-	 * Check if the two lines at the given indexes are different or not.
-	 *
-	 * @param int $aIndex Line number to check against in a.
-	 * @param int $bIndex Line number to check against in b.
-	 * @return boolean True if the lines are different and false if not.
-	 */
-	public function linesAreDifferent($aIndex, $bIndex)
-	{
-		$lineA = $this->a[$aIndex];
-		$lineB = $this->b[$bIndex];
-
-		if($this->options['ignoreWhitespace']) {
-			$replace = array("\t", ' ');
-			$lineA = str_replace($replace, '', $lineA);
-			$lineB = str_replace($replace, '', $lineB);
-		}
-
-		if($this->options['ignoreCase']) {
-			$lineA = strtolower($lineA);
-			$lineB = strtolower($lineB);
-		}
-
-		if($lineA != $lineB) {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * Return a nested set of arrays for all of the matching sub-sequences
-	 * in the strings $a and $b.
-	 *
-	 * Each block contains the lower constraint of the block in $a, the lower
-	 * constraint of the block in $b and finally the number of lines that the
-	 * block continues for.
-	 *
-	 * @return array Nested array of the matching blocks, as described by the function.
-	 */
-	public function getMatchingBlocks()
-	{
-		if(!empty($this->matchingBlocks)) {
-			return $this->matchingBlocks;
-		}
-
-		$aLength = count($this->a);
-		$bLength = count($this->b);
-
-		$queue = array(
-			array(
-				0,
-				$aLength,
-				0,
-				$bLength
-			)
-		);
-
-		$matchingBlocks = array();
-		while(!empty($queue)) {
-			list($alo, $ahi, $blo, $bhi) = array_pop($queue);
-			$x = $this->findLongestMatch($alo, $ahi, $blo, $bhi);
-			list($i, $j, $k) = $x;
-			if($k) {
-				$matchingBlocks[] = $x;
-				if($alo < $i && $blo < $j) {
-					$queue[] = array(
-						$alo,
-						$i,
-						$blo,
-						$j
-					);
-				}
-
-				if($i + $k < $ahi && $j + $k < $bhi) {
-					$queue[] = array(
-						$i + $k,
-						$ahi,
-						$j + $k,
-						$bhi
-					);
-				}
-			}
-		}
-
-		usort($matchingBlocks, array($this, 'tupleSort'));
-
-		$i1 = 0;
-		$j1 = 0;
-		$k1 = 0;
-		$nonAdjacent = array();
-		foreach($matchingBlocks as $block) {
-			list($i2, $j2, $k2) = $block;
-			if($i1 + $k1 == $i2 && $j1 + $k1 == $j2) {
-				$k1 += $k2;
-			}
-			else {
-				if($k1) {
-					$nonAdjacent[] = array(
-						$i1,
-						$j1,
-						$k1
-					);
-				}
-
-				$i1 = $i2;
-				$j1 = $j2;
-				$k1 = $k2;
-			}
-		}
-
-		if($k1) {
-			$nonAdjacent[] = array(
-				$i1,
-				$j1,
-				$k1
-			);
-		}
-
-		$nonAdjacent[] = array(
-			$aLength,
-			$bLength,
-			0
-		);
-
-		$this->matchingBlocks = $nonAdjacent;
-		return $this->matchingBlocks;
-	}
-
-	/**
-	 * Return a list of all of the opcodes for the differences between the
-	 * two strings.
-	 *
-	 * The nested array returned contains an array describing the opcode
-	 * which includes:
-	 * 0 - The type of tag (as described below) for the opcode.
-	 * 1 - The beginning line in the first sequence.
-	 * 2 - The end line in the first sequence.
-	 * 3 - The beginning line in the second sequence.
-	 * 4 - The end line in the second sequence.
-	 *
-	 * The different types of tags include:
-	 * replace - The string from $i1 to $i2 in $a should be replaced by
-	 *           the string in $b from $j1 to $j2.
-	 * delete -  The string in $a from $i1 to $j2 should be deleted.
-	 * insert -  The string in $b from $j1 to $j2 should be inserted at
-	 *           $i1 in $a.
-	 * equal  -  The two strings with the specified ranges are equal.
-	 *
-	 * @return array Array of the opcodes describing the differences between the strings.
-	 */
-	public function getOpCodes()
-	{
-		if(!empty($this->opCodes)) {
-			return $this->opCodes;
-		}
-
-		$i = 0;
-		$j = 0;
-		$this->opCodes = array();
-
-		$blocks = $this->getMatchingBlocks();
-		foreach($blocks as $block) {
-			list($ai, $bj, $size) = $block;
-			$tag = '';
-			if($i < $ai && $j < $bj) {
-				$tag = 'replace';
-			}
-			else if($i < $ai) {
-				$tag = 'delete';
-			}
-			else if($j < $bj) {
-				$tag = 'insert';
-			}
-
-			if($tag) {
-				$this->opCodes[] = array(
-					$tag,
-					$i,
-					$ai,
-					$j,
-					$bj
-				);
-			}
-
-			$i = $ai + $size;
-			$j = $bj + $size;
-
-			if($size) {
-				$this->opCodes[] = array(
-					'equal',
-					$ai,
-					$i,
-					$bj,
-					$j
-				);
-			}
-		}
-		return $this->opCodes;
-	}
-
-	/**
-	 * Return a series of nested arrays containing different groups of generated
-	 * opcodes for the differences between the strings with up to $context lines
-	 * of surrounding content.
-	 *
-	 * Essentially what happens here is any big equal blocks of strings are stripped
-	 * out, the smaller subsets of changes are then arranged in to their groups.
-	 * This means that the sequence matcher and diffs do not need to include the full
-	 * content of the different files but can still provide context as to where the
-	 * changes are.
-	 *
-	 * @param int $context The number of lines of context to provide around the groups.
-	 * @return array Nested array of all of the grouped opcodes.
-	 */
-	public function getGroupedOpcodes($context=3)
-	{
-		$opCodes = $this->getOpCodes();
-		if(empty($opCodes)) {
-			$opCodes = array(
-				array(
-					'equal',
-					0,
-					1,
-					0,
-					1
-				)
-			);
-		}
-
-		if($opCodes[0][0] == 'equal') {
-			$opCodes[0] = array(
-				$opCodes[0][0],
-				max($opCodes[0][1], $opCodes[0][2] - $context),
-				$opCodes[0][2],
-				max($opCodes[0][3], $opCodes[0][4] - $context),
-				$opCodes[0][4]
-			);
-		}
-
-		$lastItem = count($opCodes) - 1;
-		if($opCodes[$lastItem][0] == 'equal') {
-			list($tag, $i1, $i2, $j1, $j2) = $opCodes[$lastItem];
-			$opCodes[$lastItem] = array(
-				$tag,
-				$i1,
-				min($i2, $i1 + $context),
-				$j1,
-				min($j2, $j1 + $context)
-			);
-		}
-
-		$maxRange = $context * 2;
-		$groups = array();
-		$group = array();
-		foreach($opCodes as $code) {
-			list($tag, $i1, $i2, $j1, $j2) = $code;
-			if($tag == 'equal' && $i2 - $i1 > $maxRange) {
-				$group[] = array(
-					$tag,
-					$i1,
-					min($i2, $i1 + $context),
-					$j1,
-					min($j2, $j1 + $context)
-				);
-				$groups[] = $group;
-				$group = array();
-				$i1 = max($i1, $i2 - $context);
-				$j1 = max($j1, $j2 - $context);
-			}
-			$group[] = array(
-				$tag,
-				$i1,
-				$i2,
-				$j1,
-				$j2
-			);
-		}
-
-		if(!empty($group) && !(count($group) == 1 && $group[0][0] == 'equal')) {
-			$groups[] = $group;
-		}
-
-		return $groups;
-	}
-
-	/**
-	 * Return a measure of the similarity between the two sequences.
-	 * This will be a float value between 0 and 1.
-	 *
-	 * Out of all of the ratio calculation functions, this is the most
-	 * expensive to call if getMatchingBlocks or getOpCodes is yet to be
-	 * called. The other calculation methods (quickRatio and realquickRatio)
-	 * can be used to perform quicker calculations but may be less accurate.
-	 *
-	 * The ratio is calculated as (2 * number of matches) / total number of
-	 * elements in both sequences.
-	 *
-	 * @return float The calculated ratio.
-	 */
-	public function Ratio()
-	{
-		$matches = array_reduce($this->getMatchingBlocks(), array($this, 'ratioReduce'), 0);
-		return $this->calculateRatio($matches, count ($this->a) + count ($this->b));
-	}
-
-	/**
-	 * Helper function to calculate the number of matches for Ratio().
-	 *
-	 * @param int $sum The running total for the number of matches.
-	 * @param array $triple Array containing the matching block triple to add to the running total.
-	 * @return int The new running total for the number of matches.
-	 */
-	private function ratioReduce($sum, $triple)
-	{
-		return $sum + ($triple[count($triple) - 1]);
-	}
-
-	/**
-	 * Quickly return an upper bound ratio for the similarity of the strings.
-	 * This is quicker to compute than Ratio().
-	 *
-	 * @return float The calculated ratio.
-	 */
-	private function quickRatio()
-	{
-		if($this->fullBCount === null) {
-			$this->fullBCount = array();
-			$bLength = count ($this->b);
-			for($i = 0; $i < $bLength; ++$i) {
-				$char = $this->b[$i];
-				$this->fullBCount[$char] = $this->arrayGetDefault($this->fullBCount, $char, 0) + 1;
-			}
-		}
-
-		$avail = array();
-		$matches = 0;
-		$aLength = count ($this->a);
-		for($i = 0; $i < $aLength; ++$i) {
-			$char = $this->a[$i];
-			if(isset($avail[$char])) {
-				$numb = $avail[$char];
-			}
-			else {
-				$numb = $this->arrayGetDefault($this->fullBCount, $char, 0);
-			}
-			$avail[$char] = $numb - 1;
-			if($numb > 0) {
-				++$matches;
-			}
-		}
-
-		$this->calculateRatio($matches, count ($this->a) + count ($this->b));
-	}
-
-	/**
-	 * Return an upper bound ratio really quickly for the similarity of the strings.
-	 * This is quicker to compute than Ratio() and quickRatio().
-	 *
-	 * @return float The calculated ratio.
-	 */
-	private function realquickRatio()
-	{
-		$aLength = count ($this->a);
-		$bLength = count ($this->b);
-
-		return $this->calculateRatio(min($aLength, $bLength), $aLength + $bLength);
-	}
-
-	/**
-	 * Helper function for calculating the ratio to measure similarity for the strings.
-	 * The ratio is defined as being 2 * (number of matches / total length)
-	 *
-	 * @param int $matches The number of matches in the two strings.
-	 * @param int $length The length of the two strings.
-	 * @return float The calculated ratio.
-	 */
-	private function calculateRatio($matches, $length=0)
-	{
-		if($length) {
-			return 2 * ($matches / $length);
-		}
-		else {
-			return 1;
-		}
-	}
-
-	/**
-	 * Helper function that provides the ability to return the value for a key
-	 * in an array of it exists, or if it doesn't then return a default value.
-	 * Essentially cleaner than doing a series of if(isset()) {} else {} calls.
-	 *
-	 * @param array $array The array to search.
-	 * @param string $key The key to check that exists.
-	 * @param mixed $default The value to return as the default value if the key doesn't exist.
-	 * @return mixed The value from the array if the key exists or otherwise the default.
-	 */
-	private function arrayGetDefault($array, $key, $default)
-	{
-		if(isset($array[$key])) {
-			return $array[$key];
-		}
-		else {
-			return $default;
-		}
-	}
-
-	/**
-	 * Sort an array by the nested arrays it contains. Helper function for getMatchingBlocks
-	 *
-	 * @param array $a First array to compare.
-	 * @param array $b Second array to compare.
-	 * @return int -1, 0 or 1, as expected by the usort function.
-	 */
-	private function tupleSort($a, $b)
-	{
-		$max = max(count($a), count($b));
-		for($i = 0; $i < $max; ++$i) {
-			if($a[$i] < $b[$i]) {
-				return -1;
-			}
-			else if($a[$i] > $b[$i]) {
-				return 1;
-			}
-		}
-
-		if(count($a) == count($b)) {
-			return 0;
-		}
-		else if(count($a) < count($b)) {
-			return -1;
-		}
-		else {
-			return 1;
-		}
-	}
+    /**
+     * @var string|array Either a string or an array containing a callback function to determine if a line is "junk" or not.
+     */
+    private $junkCallback = null;
+
+    /**
+     * @var array The first sequence to compare against.
+     */
+    private $a = null;
+
+    /**
+     * @var array The second sequence.
+     */
+    private $b = null;
+
+    /**
+     * @var array Array of characters that are considered junk from the second sequence. Characters are the array key.
+     */
+    private $junkDict = array();
+
+    /**
+     * @var array Array of indices that do not contain junk elements.
+     */
+    private $b2j = array();
+
+    private $options = array();
+
+    private $defaultOptions = array(
+        'ignoreNewLines' => false,
+        'ignoreWhitespace' => false,
+        'ignoreCase' => false
+    );
+
+    /**
+     * The constructor. With the sequences being passed, they'll be set for the
+     * sequence matcher and it will perform a basic cleanup & calculate junk
+     * elements.
+     *
+     * @param string|array $a A string or array containing the lines to compare against.
+     * @param string|array $b A string or array containing the lines to compare.
+     * @param string|array $junkCallback Either an array or string that references a callback function (if there is one) to determine 'junk' characters.
+     * @param array $options
+     */
+    public function __construct($a, $b, $junkCallback=null, $options)
+    {
+        $this->a = null;
+        $this->b = null;
+        $this->junkCallback = $junkCallback;
+        $this->setOptions($options);
+        $this->setSequences($a, $b);
+    }
+
+    /**
+     * Set new options
+     *
+     * @param array $options
+     */
+    public function setOptions($options)
+    {
+        $this->options = array_merge($this->defaultOptions, $options);
+    }
+
+    /**
+     * Set the first and second sequences to use with the sequence matcher.
+     *
+     * @param string|array $a A string or array containing the lines to compare against.
+     * @param string|array $b A string or array containing the lines to compare.
+     */
+    public function setSequences($a, $b)
+    {
+        $this->setSeq1($a);
+        $this->setSeq2($b);
+    }
+
+    /**
+     * Set the first sequence ($a) and reset any internal caches to indicate that
+     * when calling the calculation methods, we need to recalculate them.
+     *
+     * @param string|array $a The sequence to set as the first sequence.
+     */
+    public function setSeq1($a)
+    {
+        if(!is_array($a)) {
+            $a = str_split($a);
+        }
+        if($a == $this->a) {
+            return;
+        }
+
+        $this->a= $a;
+        $this->matchingBlocks = null;
+        $this->opCodes = null;
+    }
+
+    /**
+     * Set the second sequence ($b) and reset any internal caches to indicate that
+     * when calling the calculation methods, we need to recalculate them.
+     *
+     * @param string|array $b The sequence to set as the second sequence.
+     */
+    public function setSeq2($b)
+    {
+        if(!is_array($b)) {
+            $b = str_split($b);
+        }
+        if($b == $this->b) {
+            return;
+        }
+
+        $this->b = $b;
+        $this->matchingBlocks = null;
+        $this->opCodes = null;
+        $this->fullBCount = null;
+        $this->chainB();
+    }
+
+    /**
+     * Generate the internal arrays containing the list of junk and non-junk
+     * characters for the second ($b) sequence.
+     */
+    private function chainB()
+    {
+        $length = count ($this->b);
+        $this->b2j = array();
+        $popularDict = array();
+
+        for($i = 0; $i < $length; ++$i) {
+            $char = $this->b[$i];
+            if(isset($this->b2j[$char])) {
+                if($length >= 200 && count($this->b2j[$char]) * 100 > $length) {
+                    $popularDict[$char] = 1;
+                    unset($this->b2j[$char]);
+                }
+                else {
+                    $this->b2j[$char][] = $i;
+                }
+            }
+            else {
+                $this->b2j[$char] = array(
+                    $i
+                );
+            }
+        }
+
+        // Remove leftovers
+        foreach(array_keys($popularDict) as $char) {
+            unset($this->b2j[$char]);
+        }
+
+        $this->junkDict = array();
+        if(is_callable($this->junkCallback)) {
+            foreach(array_keys($popularDict) as $char) {
+                if(call_user_func($this->junkCallback, $char)) {
+                    $this->junkDict[$char] = 1;
+                    unset($popularDict[$char]);
+                }
+            }
+
+            foreach(array_keys($this->b2j) as $char) {
+                if(call_user_func($this->junkCallback, $char)) {
+                    $this->junkDict[$char] = 1;
+                    unset($this->b2j[$char]);
+                }
+            }
+        }
+    }
+
+    /**
+     * Checks if a particular character is in the junk dictionary
+     * for the list of junk characters.
+     * @param $b
+     * @return boolean True if the character is considered junk. False if not.
+     */
+    private function isBJunk($b)
+    {
+        if(isset($this->juncDict[$b])) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Find the longest matching block in the two sequences, as defined by the
+     * lower and upper constraints for each sequence. (for the first sequence,
+     * $alo - $ahi and for the second sequence, $blo - $bhi)
+     *
+     * Essentially, of all of the maximal matching blocks, return the one that
+     * startest earliest in $a, and all of those maximal matching blocks that
+     * start earliest in $a, return the one that starts earliest in $b.
+     *
+     * If the junk callback is defined, do the above but with the restriction
+     * that the junk element appears in the block. Extend it as far as possible
+     * by matching only junk elements in both $a and $b.
+     *
+     * @param int $alo The lower constraint for the first sequence.
+     * @param int $ahi The upper constraint for the first sequence.
+     * @param int $blo The lower constraint for the second sequence.
+     * @param int $bhi The upper constraint for the second sequence.
+     * @return array Array containing the longest match that includes the starting position in $a, start in $b and the length/size.
+     */
+    public function findLongestMatch($alo, $ahi, $blo, $bhi)
+    {
+        $a = $this->a;
+        $b = $this->b;
+
+        $bestI = $alo;
+        $bestJ = $blo;
+        $bestSize = 0;
+
+        $j2Len = array();
+        $nothing = array();
+
+        for($i = $alo; $i < $ahi; ++$i) {
+            $newJ2Len = array();
+            $jDict = $this->arrayGetDefault($this->b2j, $a[$i], $nothing);
+            foreach($jDict as $jKey => $j) {
+                if($j < $blo) {
+                    continue;
+                }
+                else if($j >= $bhi) {
+                    break;
+                }
+
+                $k = $this->arrayGetDefault($j2Len, $j -1, 0) + 1;
+                $newJ2Len[$j] = $k;
+                if($k > $bestSize) {
+                    $bestI = $i - $k + 1;
+                    $bestJ = $j - $k + 1;
+                    $bestSize = $k;
+                }
+            }
+
+            $j2Len = $newJ2Len;
+        }
+
+        while($bestI > $alo && $bestJ > $blo && !$this->isBJunk($b[$bestJ - 1]) &&
+            !$this->linesAreDifferent($bestI - 1, $bestJ - 1)) {
+                --$bestI;
+                --$bestJ;
+                ++$bestSize;
+        }
+
+        while($bestI + $bestSize < $ahi && ($bestJ + $bestSize) < $bhi &&
+            !$this->isBJunk($b[$bestJ + $bestSize]) && !$this->linesAreDifferent($bestI + $bestSize, $bestJ + $bestSize)) {
+                ++$bestSize;
+        }
+
+        while($bestI > $alo && $bestJ > $blo && $this->isBJunk($b[$bestJ - 1]) &&
+            !$this->isLineDifferent($bestI - 1, $bestJ - 1)) {
+                --$bestI;
+                --$bestJ;
+                ++$bestSize;
+        }
+
+        while($bestI + $bestSize < $ahi && $bestJ + $bestSize < $bhi &&
+            $this->isBJunk($b[$bestJ + $bestSize]) && !$this->linesAreDifferent($bestI + $bestSize, $bestJ + $bestSize)) {
+                    ++$bestSize;
+        }
+
+        return array(
+            $bestI,
+            $bestJ,
+            $bestSize
+        );
+    }
+
+    /**
+     * Check if the two lines at the given indexes are different or not.
+     *
+     * @param int $aIndex Line number to check against in a.
+     * @param int $bIndex Line number to check against in b.
+     * @return boolean True if the lines are different and false if not.
+     */
+    public function linesAreDifferent($aIndex, $bIndex)
+    {
+        $lineA = $this->a[$aIndex];
+        $lineB = $this->b[$bIndex];
+
+        if($this->options['ignoreWhitespace']) {
+            $replace = array("\t", ' ');
+            $lineA = str_replace($replace, '', $lineA);
+            $lineB = str_replace($replace, '', $lineB);
+        }
+
+        if($this->options['ignoreCase']) {
+            $lineA = strtolower($lineA);
+            $lineB = strtolower($lineB);
+        }
+
+        if($lineA != $lineB) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Return a nested set of arrays for all of the matching sub-sequences
+     * in the strings $a and $b.
+     *
+     * Each block contains the lower constraint of the block in $a, the lower
+     * constraint of the block in $b and finally the number of lines that the
+     * block continues for.
+     *
+     * @return array Nested array of the matching blocks, as described by the function.
+     */
+    public function getMatchingBlocks()
+    {
+        if(!empty($this->matchingBlocks)) {
+            return $this->matchingBlocks;
+        }
+
+        $aLength = count($this->a);
+        $bLength = count($this->b);
+
+        $queue = array(
+            array(
+                0,
+                $aLength,
+                0,
+                $bLength
+            )
+        );
+
+        $matchingBlocks = array();
+        while(!empty($queue)) {
+            list($alo, $ahi, $blo, $bhi) = array_pop($queue);
+            $x = $this->findLongestMatch($alo, $ahi, $blo, $bhi);
+            list($i, $j, $k) = $x;
+            if($k) {
+                $matchingBlocks[] = $x;
+                if($alo < $i && $blo < $j) {
+                    $queue[] = array(
+                        $alo,
+                        $i,
+                        $blo,
+                        $j
+                    );
+                }
+
+                if($i + $k < $ahi && $j + $k < $bhi) {
+                    $queue[] = array(
+                        $i + $k,
+                        $ahi,
+                        $j + $k,
+                        $bhi
+                    );
+                }
+            }
+        }
+
+        usort($matchingBlocks, array($this, 'tupleSort'));
+
+        $i1 = 0;
+        $j1 = 0;
+        $k1 = 0;
+        $nonAdjacent = array();
+        foreach($matchingBlocks as $block) {
+            list($i2, $j2, $k2) = $block;
+            if($i1 + $k1 == $i2 && $j1 + $k1 == $j2) {
+                $k1 += $k2;
+            }
+            else {
+                if($k1) {
+                    $nonAdjacent[] = array(
+                        $i1,
+                        $j1,
+                        $k1
+                    );
+                }
+
+                $i1 = $i2;
+                $j1 = $j2;
+                $k1 = $k2;
+            }
+        }
+
+        if($k1) {
+            $nonAdjacent[] = array(
+                $i1,
+                $j1,
+                $k1
+            );
+        }
+
+        $nonAdjacent[] = array(
+            $aLength,
+            $bLength,
+            0
+        );
+
+        $this->matchingBlocks = $nonAdjacent;
+        return $this->matchingBlocks;
+    }
+
+    /**
+     * Return a list of all of the opcodes for the differences between the
+     * two strings.
+     *
+     * The nested array returned contains an array describing the opcode
+     * which includes:
+     * 0 - The type of tag (as described below) for the opcode.
+     * 1 - The beginning line in the first sequence.
+     * 2 - The end line in the first sequence.
+     * 3 - The beginning line in the second sequence.
+     * 4 - The end line in the second sequence.
+     *
+     * The different types of tags include:
+     * replace - The string from $i1 to $i2 in $a should be replaced by
+     *           the string in $b from $j1 to $j2.
+     * delete -  The string in $a from $i1 to $j2 should be deleted.
+     * insert -  The string in $b from $j1 to $j2 should be inserted at
+     *           $i1 in $a.
+     * equal  -  The two strings with the specified ranges are equal.
+     *
+     * @return array Array of the opcodes describing the differences between the strings.
+     */
+    public function getOpCodes()
+    {
+        if(!empty($this->opCodes)) {
+            return $this->opCodes;
+        }
+
+        $i = 0;
+        $j = 0;
+        $this->opCodes = array();
+
+        $blocks = $this->getMatchingBlocks();
+        foreach($blocks as $block) {
+            list($ai, $bj, $size) = $block;
+            $tag = '';
+            if($i < $ai && $j < $bj) {
+                $tag = 'replace';
+            }
+            else if($i < $ai) {
+                $tag = 'delete';
+            }
+            else if($j < $bj) {
+                $tag = 'insert';
+            }
+
+            if($tag) {
+                $this->opCodes[] = array(
+                    $tag,
+                    $i,
+                    $ai,
+                    $j,
+                    $bj
+                );
+            }
+
+            $i = $ai + $size;
+            $j = $bj + $size;
+
+            if($size) {
+                $this->opCodes[] = array(
+                    'equal',
+                    $ai,
+                    $i,
+                    $bj,
+                    $j
+                );
+            }
+        }
+        return $this->opCodes;
+    }
+
+    /**
+     * Return a series of nested arrays containing different groups of generated
+     * opcodes for the differences between the strings with up to $context lines
+     * of surrounding content.
+     *
+     * Essentially what happens here is any big equal blocks of strings are stripped
+     * out, the smaller subsets of changes are then arranged in to their groups.
+     * This means that the sequence matcher and diffs do not need to include the full
+     * content of the different files but can still provide context as to where the
+     * changes are.
+     *
+     * @param int $context The number of lines of context to provide around the groups.
+     * @return array Nested array of all of the grouped opcodes.
+     */
+    public function getGroupedOpcodes($context=3)
+    {
+        $opCodes = $this->getOpCodes();
+        if(empty($opCodes)) {
+            $opCodes = array(
+                array(
+                    'equal',
+                    0,
+                    1,
+                    0,
+                    1
+                )
+            );
+        }
+
+        if($opCodes[0][0] == 'equal') {
+            $opCodes[0] = array(
+                $opCodes[0][0],
+                max($opCodes[0][1], $opCodes[0][2] - $context),
+                $opCodes[0][2],
+                max($opCodes[0][3], $opCodes[0][4] - $context),
+                $opCodes[0][4]
+            );
+        }
+
+        $lastItem = count($opCodes) - 1;
+        if($opCodes[$lastItem][0] == 'equal') {
+            list($tag, $i1, $i2, $j1, $j2) = $opCodes[$lastItem];
+            $opCodes[$lastItem] = array(
+                $tag,
+                $i1,
+                min($i2, $i1 + $context),
+                $j1,
+                min($j2, $j1 + $context)
+            );
+        }
+
+        $maxRange = $context * 2;
+        $groups = array();
+        $group = array();
+        foreach($opCodes as $code) {
+            list($tag, $i1, $i2, $j1, $j2) = $code;
+            if($tag == 'equal' && $i2 - $i1 > $maxRange) {
+                $group[] = array(
+                    $tag,
+                    $i1,
+                    min($i2, $i1 + $context),
+                    $j1,
+                    min($j2, $j1 + $context)
+                );
+                $groups[] = $group;
+                $group = array();
+                $i1 = max($i1, $i2 - $context);
+                $j1 = max($j1, $j2 - $context);
+            }
+            $group[] = array(
+                $tag,
+                $i1,
+                $i2,
+                $j1,
+                $j2
+            );
+        }
+
+        if(!empty($group) && !(count($group) == 1 && $group[0][0] == 'equal')) {
+            $groups[] = $group;
+        }
+
+        return $groups;
+    }
+
+    /**
+     * Return a measure of the similarity between the two sequences.
+     * This will be a float value between 0 and 1.
+     *
+     * Out of all of the ratio calculation functions, this is the most
+     * expensive to call if getMatchingBlocks or getOpCodes is yet to be
+     * called. The other calculation methods (quickRatio and realquickRatio)
+     * can be used to perform quicker calculations but may be less accurate.
+     *
+     * The ratio is calculated as (2 * number of matches) / total number of
+     * elements in both sequences.
+     *
+     * @return float The calculated ratio.
+     */
+    public function Ratio()
+    {
+        $matches = array_reduce($this->getMatchingBlocks(), array($this, 'ratioReduce'), 0);
+        return $this->calculateRatio($matches, count ($this->a) + count ($this->b));
+    }
+
+    /**
+     * Helper function to calculate the number of matches for Ratio().
+     *
+     * @param int $sum The running total for the number of matches.
+     * @param array $triple Array containing the matching block triple to add to the running total.
+     * @return int The new running total for the number of matches.
+     */
+    private function ratioReduce($sum, $triple)
+    {
+        return $sum + ($triple[count($triple) - 1]);
+    }
+
+    /**
+     * Quickly return an upper bound ratio for the similarity of the strings.
+     * This is quicker to compute than Ratio().
+     *
+     * @return float The calculated ratio.
+     */
+    private function quickRatio()
+    {
+        if($this->fullBCount === null) {
+            $this->fullBCount = array();
+            $bLength = count ($this->b);
+            for($i = 0; $i < $bLength; ++$i) {
+                $char = $this->b[$i];
+                $this->fullBCount[$char] = $this->arrayGetDefault($this->fullBCount, $char, 0) + 1;
+            }
+        }
+
+        $avail = array();
+        $matches = 0;
+        $aLength = count ($this->a);
+        for($i = 0; $i < $aLength; ++$i) {
+            $char = $this->a[$i];
+            if(isset($avail[$char])) {
+                $numb = $avail[$char];
+            }
+            else {
+                $numb = $this->arrayGetDefault($this->fullBCount, $char, 0);
+            }
+            $avail[$char] = $numb - 1;
+            if($numb > 0) {
+                ++$matches;
+            }
+        }
+
+        $this->calculateRatio($matches, count ($this->a) + count ($this->b));
+    }
+
+    /**
+     * Return an upper bound ratio really quickly for the similarity of the strings.
+     * This is quicker to compute than Ratio() and quickRatio().
+     *
+     * @return float The calculated ratio.
+     */
+    private function realquickRatio()
+    {
+        $aLength = count ($this->a);
+        $bLength = count ($this->b);
+
+        return $this->calculateRatio(min($aLength, $bLength), $aLength + $bLength);
+    }
+
+    /**
+     * Helper function for calculating the ratio to measure similarity for the strings.
+     * The ratio is defined as being 2 * (number of matches / total length)
+     *
+     * @param int $matches The number of matches in the two strings.
+     * @param int $length The length of the two strings.
+     * @return float The calculated ratio.
+     */
+    private function calculateRatio($matches, $length=0)
+    {
+        if($length) {
+            return 2 * ($matches / $length);
+        }
+        else {
+            return 1;
+        }
+    }
+
+    /**
+     * Helper function that provides the ability to return the value for a key
+     * in an array of it exists, or if it doesn't then return a default value.
+     * Essentially cleaner than doing a series of if(isset()) {} else {} calls.
+     *
+     * @param array $array The array to search.
+     * @param string $key The key to check that exists.
+     * @param mixed $default The value to return as the default value if the key doesn't exist.
+     * @return mixed The value from the array if the key exists or otherwise the default.
+     */
+    private function arrayGetDefault($array, $key, $default)
+    {
+        if(isset($array[$key])) {
+            return $array[$key];
+        }
+        else {
+            return $default;
+        }
+    }
+
+    /**
+     * Sort an array by the nested arrays it contains. Helper function for getMatchingBlocks
+     *
+     * @param array $a First array to compare.
+     * @param array $b Second array to compare.
+     * @return int -1, 0 or 1, as expected by the usort function.
+     */
+    private function tupleSort($a, $b)
+    {
+        $max = max(count($a), count($b));
+        for($i = 0; $i < $max; ++$i) {
+            if($a[$i] < $b[$i]) {
+                return -1;
+            }
+            else if($a[$i] > $b[$i]) {
+                return 1;
+            }
+        }
+
+        if(count($a) == count($b)) {
+            return 0;
+        }
+        else if(count($a) < count($b)) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    }
 }
\ No newline at end of file

vendor/phpspec/phpspec/features/bootstrap/ApplicationContext.php

Unused Use Statements -2 removed lines

@@ -1,9 +1,7 @@
 <?php
 
-use Behat\Behat\Tester\Exception\PendingException;
 use Behat\Behat\Context\Context;
 use Behat\Gherkin\Node\PyStringNode;
-use Behat\Gherkin\Node\TableNode;
 use Fake\Prompter;
 use Fake\ReRunner;
 use Matcher\ApplicationOutputMatcher;

Spacing +15 added lines, -15 removed lines

@@ -97,7 +97,7 @@ 
      */
     public function iRunPhpspec($formatter = null, $option = null, $interactive = null, $spec = null)
     {
-        $arguments = array (
+        $arguments = array(
             'command' => 'run',
             'spec' => $spec
         );
@@ -109,7 +109,7 @@ 
         $this->addOptionToArguments($option, $arguments);
 
         $this->lastExitCode = $this->tester->run($arguments, array(
-            'interactive' => (bool)$interactive,
+            'interactive' => (bool) $interactive,
             'decorated' => false,
         ));
     }
@@ -118,15 +118,15 @@ 
      * @When I run phpspec and answer :answer when asked if I want to generate the code
      * @When I run phpspec with the option :option and (I) answer :answer when asked if I want to generate the code
      */
-    public function iRunPhpspecAndAnswerWhenAskedIfIWantToGenerateTheCode($answer, $option=null)
+    public function iRunPhpspecAndAnswerWhenAskedIfIWantToGenerateTheCode($answer, $option = null)
     {
-        $arguments = array (
+        $arguments = array(
             'command' => 'run'
         );
 
         $this->addOptionToArguments($option, $arguments);
 
-        $this->prompter->setAnswer($answer=='y');
+        $this->prompter->setAnswer($answer == 'y');
 
         $this->lastExitCode = $this->tester->run($arguments, array('interactive' => true));
     }
@@ -136,12 +136,12 @@ 
      */
     public function iRunPhpspecAndAnswerToBothQuestions($answer)
     {
-        $arguments = array (
+        $arguments = array(
             'command' => 'run'
         );
 
-        $this->prompter->setAnswer($answer=='y');
-        $this->prompter->setAnswer($answer=='y');
+        $this->prompter->setAnswer($answer == 'y');
+        $this->prompter->setAnswer($answer == 'y');
 
         $this->lastExitCode = $this->tester->run($arguments, array('interactive' => true));
     }
@@ -156,7 +156,7 @@ 
             if (preg_match('/(?P<option>[a-z-]+)=(?P<value>[a-z.]+)/', $option, $matches)) {
                 $arguments[$matches['option']] = $matches['value'];
             } else {
-                $arguments['--' . trim($option, '"')] = true;
+                $arguments['--'.trim($option, '"')] = true;
             }
         }
     }
@@ -167,7 +167,7 @@ 
      */
     public function iShouldSee($output)
     {
-        expect($this->tester)->toHaveOutput((string)$output);
+        expect($this->tester)->toHaveOutput((string) $output);
     }
 
     /**
@@ -255,7 +255,7 @@ 
      */
     public function iShouldBePromptedWith(PyStringNode $question)
     {
-        expect($this->prompter)->toHaveBeenAsked((string)$question);
+        expect($this->prompter)->toHaveBeenAsked((string) $question);
     }
 
     /**
@@ -278,12 +278,12 @@ 
      */
     public function iRunPhpspecWithConfigAndAnswerIfIWantToGenerateTheCode($config, $answer)
     {
-        $arguments = array (
+        $arguments = array(
             'command' => 'run',
             '--config' => $config
         );
 
-        $this->prompter->setAnswer($answer=='y');
+        $this->prompter->setAnswer($answer == 'y');
 
         $this->lastExitCode = $this->tester->run($arguments, array('interactive' => true));
     }
@@ -306,7 +306,7 @@ 
      */
     public function iRunPhpspecWithTheSpec($spec)
     {
-        $arguments = array (
+        $arguments = array(
             'command' => 'run',
             1 => $spec
         );
@@ -319,7 +319,7 @@ 
      */
     public function iRunPhpspecWithTheSpecAndTheConfig($spec, $config)
     {
-        $arguments = array (
+        $arguments = array(
             'command' => 'run',
             1 => $spec,
             '--config' => $config

vendor/phpspec/phpspec/spec/PhpSpec/CodeAnalysis/MagicAwareAccessInspectorSpec.php

Unused Use Statements -1 removed lines

@@ -4,7 +4,6 @@
 
 use Phpspec\CodeAnalysis\AccessInspectorInterface;
 use PhpSpec\ObjectBehavior;
-use Prophecy\Argument;
 
 class MagicAwareAccessInspectorSpec extends ObjectBehavior
 {

vendor/phpspec/phpspec/spec/PhpSpec/CodeAnalysis/StaticRejectingNamespaceResolverSpec.php

Unused Use Statements -1 removed lines

@@ -4,7 +4,6 @@
 
 use PhpSpec\CodeAnalysis\NamespaceResolver;
 use PhpSpec\ObjectBehavior;
-use Prophecy\Argument;
 
 class StaticRejectingNamespaceResolverSpec extends ObjectBehavior
 {