PHP PHP_CodeSniffer_File::findExtendedClassName方法代码示例

 /**
  * Processes this test when one of its tokens is encountered.
  *
  * @param PHP_CodeSniffer_File $phpcsFile The current file being scanned.
  * @param int                  $stackPtr  The position of the current token
  *                                        in the stack passed in $tokens.
  * @param int                  $currScope A pointer to the start of the scope.
  *
  * @return void
  */
 protected function processTokenWithinScope(PHP_CodeSniffer_File $phpcsFile, $stackPtr, $currScope)
 {
     $className = $phpcsFile->getDeclarationName($currScope);
     $methodName = $phpcsFile->getDeclarationName($stackPtr);
     if (strcasecmp($methodName, $className) === 0) {
         $error = 'PHP4 style constructors are not allowed; use "__construct()" instead';
         $phpcsFile->addError($error, $stackPtr, 'OldStyle');
     } else {
         if (strcasecmp($methodName, '__construct') !== 0) {
             // Not a constructor.
             return;
         }
     }
     $tokens = $phpcsFile->getTokens();
     $parentClassName = $phpcsFile->findExtendedClassName($currScope);
     if ($parentClassName === false) {
         return;
     }
     $endFunctionIndex = $tokens[$stackPtr]['scope_closer'];
     $startIndex = $stackPtr;
     while ($doubleColonIndex = $phpcsFile->findNext(array(T_DOUBLE_COLON), $startIndex, $endFunctionIndex)) {
         if ($tokens[$doubleColonIndex + 1]['code'] === T_STRING && $tokens[$doubleColonIndex + 1]['content'] === $parentClassName) {
             $error = 'PHP4 style calls to parent constructors are not allowed; use "parent::__construct()" instead';
             $phpcsFile->addError($error, $doubleColonIndex + 1, 'OldStyleCall');
         }
         $startIndex = $doubleColonIndex + 1;
     }
 }

 /**
  * Processes this test, when one of its tokens is encountered.
  *
  * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
  * @param integer              $stackPtr  The position of the current token in
  *                                        the token stack.
  *
  * @return void
  */
 public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
 {
     $tokens = $phpcsFile->getTokens();
     if (isset($tokens[$stackPtr]['scope_closer']) === false) {
         return;
     }
     $className = $phpcsFile->getDeclarationName($stackPtr);
     $errorData = array(strtolower($tokens[$stackPtr]['content']));
     $nextClass = $phpcsFile->findNext(array(T_CLASS, T_INTERFACE, T_TRAIT), $tokens[$stackPtr]['scope_closer'] + 1);
     if ($nextClass !== false) {
         $nextClassName = $phpcsFile->getDeclarationName($nextClass);
         $extends = $phpcsFile->findExtendedClassName($nextClass);
         if ($className == $nextClassName && $extends != $className && substr($extends, -1 * (strlen($className) + 1)) == '\\' . $className) {
             // $nextClassName wraps $className in global namespace (probably)
             $phpcsFile->recordMetric($stackPtr, 'One class per file', 'yes');
         } else {
             $error = 'Each %s must be in a file by itself';
             $phpcsFile->addError($error, $nextClass, 'MultipleClasses', $errorData);
             $phpcsFile->recordMetric($stackPtr, 'One class per file', 'no');
         }
     } else {
         $phpcsFile->recordMetric($stackPtr, 'One class per file', 'yes');
     }
     if (version_compare(PHP_VERSION, '5.3.0') >= 0) {
         $namespace = $phpcsFile->findNext(array(T_NAMESPACE, T_CLASS, T_INTERFACE, T_TRAIT), 0);
         if ($tokens[$namespace]['code'] !== T_NAMESPACE) {
             $error = 'Each %s must be in a namespace of at least one level (a top-level vendor name)';
             $phpcsFile->addWarning($error, $stackPtr, 'MissingNamespace', $errorData);
             $phpcsFile->recordMetric($stackPtr, 'Class defined in namespace', 'no');
         } else {
             $phpcsFile->recordMetric($stackPtr, 'Class defined in namespace', 'yes');
         }
     }
 }

 /**
  * @param \PHP_CodeSniffer_File $phpCsFile
  * @param int $stackPointer
  *
  * @return bool
  */
 private function extendsAbstractPlugin(\PHP_CodeSniffer_File $phpCsFile, $stackPointer)
 {
     $extendedClassName = $phpCsFile->findExtendedClassName($stackPointer);
     if ($extendedClassName === 'AbstractPlugin') {
         return true;
     }
     return false;
 }

 public function process(CodeSnifferFile $file, $stackPtr)
 {
     if (!preg_match('@/[^/]+Bundle/Form/@', $file->getFilename())) {
         return;
     }
     if ($file->findExtendedClassName($stackPtr) !== 'AbstractType') {
         return;
     }
     $className = $file->getDeclarationName($stackPtr);
     if (!preg_match('/.*FormType$/D', $className)) {
         $file->addError(sprintf('Form types are expected to be named "<Something>FormType", "%s" found', $className), $stackPtr, 'Architecture.FormTypeConvention');
     }
 }

 public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
 {
     $className = $phpcsFile->getDeclarationName($stackPtr);
     $this->_dbClasses->registerClass($className, $phpcsFile->getFilename());
     $extends = $phpcsFile->findExtendedClassName($stackPtr);
     if ($extends !== false) {
         $this->_dbClasses->registerClassExtends($className, $extends);
     }
     $implements = $phpcsFile->findImplementsClassName($stackPtr);
     if (count($implements) > 0) {
         $this->_dbClasses->registerClassImplements($className, $implements);
     }
 }

 /**
  * Processes this test when one of its tokens is encountered.
  *
  * @param PHP_CodeSniffer_File $phpcsFile The current file being scanned.
  * @param int                  $stackPtr  The position of the current token
  *                                        in the stack passed in $tokens.
  * @param int                  $currScope A pointer to the start of the scope.
  *
  * @return void
  */
 protected function processTokenWithinScope(PHP_CodeSniffer_File $phpcsFile, $stackPtr, $currScope)
 {
     $methodName = $phpcsFile->getDeclarationName($stackPtr);
     $className = $phpcsFile->getDeclarationName($currScope);
     $isPhp4Constructor = strcasecmp($methodName, $className) === 0;
     $isPhp5Constructor = strcasecmp($methodName, '__construct') === 0;
     if ($this->php5Constructors != '0') {
         if ($isPhp4Constructor) {
             $error = "PHP4 style constructors are not allowed; use \"__construct\" instead";
             $phpcsFile->addError($error, $stackPtr);
         }
     } else {
         if ($isPhp5Constructor) {
             $error = "PHP5 style constructors are not allowed; use \"{$className}\" instead";
             $phpcsFile->addError($error, $stackPtr);
         }
     }
     if (!$isPhp4Constructor && !$isPhp5Constructor) {
         return;
     }
     $tokens = $phpcsFile->getTokens();
     $parentClassName = $phpcsFile->findExtendedClassName($currScope);
     $wrongConstructor = '';
     // prepares the error message and wrong constructor
     if ($this->php5Constructors != '0') {
         $error = 'PHP4 style calls to parent constructors are not allowed.';
         $error = "{$error} Please use \"parent::__construct\" instead.";
         if (false !== $parentClassName) {
             $wrongConstructor = $parentClassName;
         }
         // Else $wrongConstructor will be empty
         // and the test expression will always be false.
         // It doesn't check that no parent method should be called
         // when no parent class is defined.
     } else {
         $error = 'PHP5 style calls to parent constructors are not allowed.';
         if (false !== $parentClassName) {
             $error = "{$error} Please use \"parent::{$parentClassName}\" instead.";
         }
         $wrongConstructor = '__construct';
     }
     // looks for the use of a wrong constructor.
     $endFunctionIndex = $tokens[$stackPtr]['scope_closer'];
     $doubleColonIndex = $phpcsFile->findNext(array(T_DOUBLE_COLON), $stackPtr, $endFunctionIndex);
     while ($doubleColonIndex) {
         if ($tokens[$doubleColonIndex + 1]['code'] === T_STRING && $tokens[$doubleColonIndex + 1]['content'] === $wrongConstructor) {
             $phpcsFile->addError($error, $doubleColonIndex + 1);
         }
         $doubleColonIndex = $phpcsFile->findNext(array(T_DOUBLE_COLON), $doubleColonIndex + 1, $endFunctionIndex);
     }
 }

 /**
  * Processes the tokens within the scope.
  *
  * @param PHP_CodeSniffer_File $phpcsFile The file being processed.
  * @param int                  $stackPtr  The position where this token was
  *                                        found.
  * @param int                  $currScope The position of the current scope.
  *
  * @return void
  */
 protected function processTokenWithinScope(PHP_CodeSniffer_File $phpcsFile, $stackPtr, $currScope)
 {
     $className = $phpcsFile->getDeclarationName($currScope);
     $methodName = $phpcsFile->getDeclarationName($stackPtr);
     // Is this a magic method. IE. is prefixed with "__".
     if (preg_match('|^__|', $methodName) !== 0) {
         $magicPart = substr($methodName, 2);
         if (in_array($magicPart, $this->_magicMethods) === false) {
             $error = "Method name \"{$className}::{$methodName}\" is invalid; only PHP magic methods should be prefixed with a double underscore";
             $phpcsFile->addError($error, $stackPtr, 'MethodDoubleUnderscore');
         }
         return;
     }
     // PHP4 constructors are allowed to break our rules.
     if ($methodName === $className) {
         return;
     }
     // PHP4 destructors are allowed to break our rules.
     if ($methodName === '_' . $className) {
         return;
     }
     // If this is a child class, it may have to use camelCase.
     if ($phpcsFile->findExtendedClassName($currScope) || $this->findImplementedInterfaceName($currScope, $phpcsFile)) {
         return;
     }
     $methodProps = $phpcsFile->getMethodProperties($stackPtr);
     $scope = $methodProps['scope'];
     $scopeSpecified = $methodProps['scope_specified'];
     if ($methodProps['scope'] === 'private') {
         $isPublic = false;
     } else {
         $isPublic = true;
     }
     // If the scope was specified on the method, then the method must be
     // camel caps and an underscore should be checked for. If it wasn't
     // specified, treat it like a public method and remove the underscore
     // prefix if there is one because we can't determine if it is private or
     // public.
     $testMethodName = $methodName;
     if ($scopeSpecified === false && $methodName[0] === '_') {
         $testMethodName = substr($methodName, 1);
     }
     if (strtolower($testMethodName) !== $testMethodName) {
         $suggested = preg_replace('/([A-Z])/', '_$1', $methodName);
         $suggested = strtolower($suggested);
         $suggested = str_replace('__', '_', $suggested);
         $error = "Function name \"{$methodName}\" is in camel caps format, try '" . $suggested . "'";
         $phpcsFile->addError($error, $stackPtr, 'FunctionNameInvalid');
     }
 }