Will iterate the tokens for $inspectableTokens, once found it'll find
the next content taht doesn't have the token $skipTokens and validate
it has no parentheses

@param  Testable $testable The testable object
@return void
198990
public function apply($testable, array $config = array()) {
		$message = 'Construct {:name} should not contain parentheses and be on its own line.';
		$tokens = $testable->tokens();
		$inspectable = $testable->findAll($this->inspectableTokens);
		$lines = $testable->lines();

		foreach ($inspectable as $key) {
			$token = $tokens[$key];
			$lineIndex = $token['line'] - 1;
			if (isset($lines[$lineIndex])) {
				$line = $lines[$lineIndex];
				$next = $key + 1;
				if (in_array($token['id'], $this->ownLineTokens)) {
					$pattern = '/^' . $this->pattern . '$/';
				} else {
					$pattern = '/' . $this->pattern . '$/';
				}
				if (preg_match($pattern, $line) === 0) {
					$this->addViolation(array(
						'message' => String::insert($message, array(
							'name' => $token['name'],
						)),
						'line' => $token['line'],
					));
				}
			}
		}
	}
1213245
protected function ensureMatchesPattern($fieldName, $regex, $valueToTest, $exceptionCode = 0)
    {
        if (preg_match($regex, $valueToTest) !== 1) {
            $message = sprintf('%s does not match the regular expression "%s", got "%s"', $fieldName, $regex, $valueToTest);
            throw new EnsureMatchesPatternException($message, $exceptionCode);
        }
    }
1002697
public function traverse(callable $visitor)
    {
        if ($this->_query) {
            return;
        }

        if (!$this->_castedExpressions) {
            $this->_processExpressions();
        }

        foreach ($this->_values as $v) {
            if ($v instanceof ExpressionInterface) {
                $v->traverse($visitor);
            }
            if (!is_array($v)) {
                continue;
            }
            foreach ($v as $column => $field) {
                if ($field instanceof ExpressionInterface) {
                    $visitor($field);
                    $field->traverse($visitor);
                }
            }
        }
    }
1196150
public static function isNumeral(Tokenizer $tokenizer, $string, array &$matches)
    {
        if (!$tokenizer->getNextToken() && self::isNumeralString($string, $matches, $tokenizer->getRegexBoundaries())) {
            $tokenizer->setNextToken(self::getNumeralString($matches));
        }
    }
617516
public function apply($testable, array $config = array()) {
		$message = 'Casting in the incorrect format, try: "(array) $object;"';
		$tokens = $testable->tokens();
		$filtered = $testable->findAll($this->tokens);

		foreach ($filtered as $id) {
			$token = $tokens[$id];
			$html = '';
			foreach (array_slice($tokens, $id, 3) as $t) {
				$html .= $t['content'];
			}
			if (preg_match($this->pattern, $html) === 0) {
				$this->addViolation(array(
					'message' => $message,
					'line' => $token['line'],
				));
			}
		}
	}
685889
public function setCallable($callable)
    {
        $matches = array();
        if (is_string($callable) && preg_match('!^([^\:]+)\:([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)$!', $callable, $matches)) {
            $class = $matches[1];
            $method = $matches[2];
            $callable = function() use ($class, $method) {
                static $obj = null;
                if ($obj === null) {
                    $obj = new $class;
                }
                return call_user_func_array(array($obj, $method), func_get_args());
            };
        }

        if (!is_callable($callable)) {
            throw new \InvalidArgumentException('Route callable must be callable');
        }

        $this->callable = $callable;
    }
1084111
protected function _setTokenizer($tokenizer)
    {
        if ($tokenizer !== null && !($tokenizer instanceof TokenizerInterface)) {
            throw $this->_createInvalidArgumentException($this->__('Invalid tokenizer'), null, null, $tokenizer);
        }

        $this->tokenizer = $tokenizer;
    }
709331
public static void assertAccessibility(WebDriver webDriver, Testable testable) {
        assertThat(webDriver, is(compliantTo(testable)));
    }
1200352
public function parse($tokens = null, $additional = [], $embedded = false)
    {
        if (is_string($tokens)) {
            $tokens = $this->tokenize($tokens, $additional, $embedded);
        } elseif (!$tokens instanceof TokenIterator) {
            // Todo: Own Exceptions
            throw new \InvalidArgumentException('$tokens must be string or TokenIterator');
        }

        return $this->_process($tokens);
    }
249286
public function skipByToken($token, $copy = false)
    {
        $string = $this->$token;

        return $this->skip($string, $copy);
    }
691323
public function dirtyExit($tokenName)
    {
        if (!isset($this->dirtyExitRecovery[$tokenName])) {
            throw new Exception('No dirty exit recovery data for '. $tokenName);
            $this->cleanExit = true;
            return;
        }
        $this->exitState = $tokenName;
        $this->interrupt = true;
        $this->cleanExit = false;
    }
95917
public function apply($testable, array $config = array()) {
		$tokens = $testable->tokens();
		$message = 'Weak comparison operator {:key} used, try {:value} instead';
		$filtered = $testable->findAll(array_keys($this->inspectableTokens));

		foreach ($filtered as $id) {
			$token = $tokens[$id];
			$this->addWarning(array(
				'message' => String::insert($message, array(
					'key' => token_name($token['id']),
					'value' => $this->inspectableTokens[$token['id']],
				)),
				'line' => $token['line'],
			));
		}
	}
1112081
protected function performStringCallable($callable)
    {
        if ( ! preg_match('#^(?<class>[\\a-z0-9_]+)@(?<method>[a-z0-9_]+)$#i', $callable, $matches)) {
            throw new \UnexpectedValueException("Unable to process callable string '{$callable}'");
        }

        $instance = app($matches['class']);

        $result = $instance->{$matches['method']}($this);

        return $result === null ? true : (bool) $result;
    }
478043
final protected function checkStrSyntax(): void
    {
        BearerAuthScheme::mandatory($this->value, self::MAX_LENGTH);
        parent::checkStrSyntax();
        
        $this->alphaNumToken = AlphaNumToken::mandatory($this->matches[1], self::TOKEN_LEN);
        $this->dateTime = DateTimeWithFormat::mandatory($this->matches[2], self::DATETIME_FORMAT);
    }
1192272
public function replaceTokens($regexp, $fn)
	{
		$this->inspector    = null;
		$this->template     = TemplateModifier::replaceTokens($this->template, $regexp, $fn);
		$this->isNormalized = false;
	}
1187970
public function process(\ReflectionProperty $property, TestCase $test)
    {
        /** @var \ReflectionProperty $property */
        $propertyDocComment = $property->getDocComment();
        if (preg_match(self::REGEX_MOCK, $propertyDocComment, $matches)) {
            $isPrivate = $property->isPrivate();
            if ($isPrivate) {
                $property->setAccessible(true);
            }
            $mock = $this->mockObjectFactory->create($matches[1]);
            $property->setValue($test, $mock);
            if ($isPrivate) {
                $property->setAccessible(false);
            }
        }
    }
543110
public static void assertAccessibility(String htmlString, Testable testable) {
        assertThat(htmlString, is(compliantTo(testable)));
    }