Coding Standard Sniff update

Allow more than needed indention as long as it is a multiple of 4

_cs/DokuWiki/DokuWikiCodingStandard.php

@@ -47,7 +47,7 @@ class PHP_CodeSniffer_Standards_DokuWiki_DokuWikiCodingStandard extends PHP_Code
             'Generic/Sniffs/PHP/DisallowShortOpenTagSniff.php',
             'Generic/Sniffs/PHP/ForbiddenFunctionsSniff.php',
             'Generic/Sniffs/WhiteSpace/DisallowTabIndentSniff.php',
-            'Generic/Sniffs/WhiteSpace/ScopeIndentSniff.php',
+            'DokuWiki/Sniffs/WhiteSpace/ScopeIndentSniff.php',
             'Zend/Sniffs/Files/ClosingTagSniff.php',
             'PEAR/Sniffs/Functions/ValidDefaultValueSniff.php',
             'Squiz/Sniffs/PHP/EvalSniff.php',

_cs/DokuWiki/Sniffs/WhiteSpace/ScopeIndentSniff.php

+<?php
+/**
+ * DokuWiki_Sniffs_Whitespace_ScopeIndentSniff based on
+ * Generic_Sniffs_Whitespace_ScopeIndentSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Andreas Gohr <andi@splitbrain.org>
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   CVS: $Id: ScopeIndentSniff.php 270281 2008-12-02 02:38:34Z squiz $
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Whitespace_ScopeIndentSniff.
+ *
+ * Checks that control structures are structured correctly, and their content
+ * is indented correctly.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.2.0
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class DokuWiki_Sniffs_WhiteSpace_ScopeIndentSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * The number of spaces code should be indented.
+     *
+     * @var int
+     */
+    protected $indent = 4;
+
+    /**
+     * Does the indent need to be exactly right.
+     *
+     * If TRUE, indent needs to be exactly $ident spaces. If FALSE,
+     * indent needs to be at least $ident spaces (but can be more).
+     *
+     * @var bool
+     */
+    protected $exact = false;
+
+    /**
+     * Any scope openers that should not cause an indent.
+     *
+     * @var array(int)
+     */
+    protected $nonIndentingScopes = array();
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return PHP_CodeSniffer_Tokens::$scopeOpeners;
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile All the tokens found in the document.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // If this is an inline condition (ie. there is no scope opener), then
+        // return, as this is not a new scope.
+        if (isset($tokens[$stackPtr]['scope_opener']) === false) {
+            return;
+        }
+
+        if ($tokens[$stackPtr]['code'] === T_ELSE) {
+            $next = $phpcsFile->findNext(
+                PHP_CodeSniffer_Tokens::$emptyTokens,
+                ($stackPtr + 1),
+                null,
+                true
+            );
+
+            // We will handle the T_IF token in another call to process.
+            if ($tokens[$next]['code'] === T_IF) {
+                return;
+            }
+        }
+
+        // Find the first token on this line.
+        $firstToken = $stackPtr;
+        for ($i = $stackPtr; $i >= 0; $i--) {
+            // Record the first code token on the line.
+            if (in_array($tokens[$i]['code'], PHP_CodeSniffer_Tokens::$emptyTokens) === false) {
+                $firstToken = $i;
+            }
+
+            // It's the start of the line, so we've found our first php token.
+            if ($tokens[$i]['column'] === 1) {
+                break;
+            }
+        }
+
+        // Based on the conditions that surround this token, determine the
+        // indent that we expect this current content to be.
+        $expectedIndent = $this->calculateExpectedIndent($tokens, $firstToken);
+
+        if ($tokens[$firstToken]['column'] !== $expectedIndent) {
+            if($this->exact || $tokens[$firstToken]['column'] < $expectedIndent){
+                $error  = 'Line indented incorrectly; expected ';
+                $error .= ($expectedIndent - 1).' spaces, found ';
+                $error .= ($tokens[$firstToken]['column'] - 1);
+                $phpcsFile->addError($error, $stackPtr);
+            }elseif((($tokens[$firstToken]['column'] - 1) % $this->indent)){
+                $error  = 'Line indented not by multiple of '.$this->indent.'; expected ';
+                $error .= ($expectedIndent - 1).' spaces, found ';
+                $error .= ($tokens[$firstToken]['column'] - 1);
+                $phpcsFile->addError($error, $stackPtr);
+            }
+        }
+
+        $scopeOpener = $tokens[$stackPtr]['scope_opener'];
+        $scopeCloser = $tokens[$stackPtr]['scope_closer'];
+
+        // Some scopes are expected not to have indents.
+        if (in_array($tokens[$firstToken]['code'], $this->nonIndentingScopes) === false) {
+            $indent = ($expectedIndent + $this->indent);
+        } else {
+            $indent = $expectedIndent;
+        }
+
+        $newline     = false;
+        $commentOpen = false;
+        $inHereDoc   = false;
+
+        // Only loop over the content beween the opening and closing brace, not
+        // the braces themselves.
+        for ($i = ($scopeOpener + 1); $i < $scopeCloser; $i++) {
+
+            // If this token is another scope, skip it as it will be handled by
+            // another call to this sniff.
+            if (in_array($tokens[$i]['code'], PHP_CodeSniffer_Tokens::$scopeOpeners) === true) {
+                if (isset($tokens[$i]['scope_opener']) === true) {
+                    $i = $tokens[$i]['scope_closer'];
+                } else {
+                    // If this token does not have a scope_opener indice, then
+                    // it's probably an inline scope, so let's skip to the next
+                    // semicolon. Inline scopes include inline if's, abstract
+                    // methods etc.
+                    $nextToken = $phpcsFile->findNext(T_SEMICOLON, $i, $scopeCloser);
+                    if ($nextToken !== false) {
+                        $i = $nextToken;
+                    }
+                }
+
+                continue;
+            }
+
+            // If this is a HEREDOC then we need to ignore it as the
+            // whitespace before the contents within the HEREDOC are
+            // considered part of the content.
+            if ($tokens[$i]['code'] === T_START_HEREDOC) {
+                $inHereDoc = true;
+                continue;
+            } else if ($inHereDoc === true) {
+                if ($tokens[$i]['code'] === T_END_HEREDOC) {
+                    $inHereDoc = false;
+                }
+
+                continue;
+            }
+
+            if ($tokens[$i]['column'] === 1) {
+                // We started a newline.
+                $newline = true;
+            }
+
+            if ($newline === true && $tokens[$i]['code'] !== T_WHITESPACE) {
+                // If we started a newline and we find a token that is not
+                // whitespace, then this must be the first token on the line that
+                // must be indented.
+                $newline    = false;
+                $firstToken = $i;
+
+                $column = $tokens[$firstToken]['column'];
+
+                // Special case for non-PHP code.
+                if ($tokens[$firstToken]['code'] === T_INLINE_HTML) {
+                    $trimmedContentLength
+                        = strlen(ltrim($tokens[$firstToken]['content']));
+                    if ($trimmedContentLength === 0) {
+                        continue;
+                    }
+
+                    $contentLength = strlen($tokens[$firstToken]['content']);
+                    $column        = ($contentLength - $trimmedContentLength + 1);
+                }
+
+                // Check to see if this constant string spans multiple lines.
+                // If so, then make sure that the strings on lines other than the
+                // first line are indented appropriately, based on their whitespace.
+                if (in_array($tokens[$firstToken]['code'], PHP_CodeSniffer_Tokens::$stringTokens) === true) {
+                    if (in_array($tokens[($firstToken - 1)]['code'], PHP_CodeSniffer_Tokens::$stringTokens) === true) {
+                        // If we find a string that directly follows another string
+                        // then its just a string that spans multiple lines, so we
+                        // don't need to check for indenting.
+                        continue;
+                    }
+                }
+
+                // This is a special condition for T_DOC_COMMENT and C-style
+                // comments, which contain whitespace between each line.
+                $comments = array(
+                             T_COMMENT,
+                             T_DOC_COMMENT
+                            );
+
+                if (in_array($tokens[$firstToken]['code'], $comments) === true) {
+                    $content = trim($tokens[$firstToken]['content']);
+                    if (preg_match('|^/\*|', $content) !== 0) {
+                        // Check to see if the end of the comment is on the same line
+                        // as the start of the comment. If it is, then we don't
+                        // have to worry about opening a comment.
+                        if (preg_match('|\*/$|', $content) === 0) {
+                            // We don't have to calculate the column for the
+                            // start of the comment as there is a whitespace
+                            // token before it.
+                            $commentOpen = true;
+                        }
+                    } else if ($commentOpen === true) {
+                        if ($content === '') {
+                            // We are in a comment, but this line has nothing on it
+                            // so let's skip it.
+                            continue;
+                        }
+
+                        $contentLength = strlen($tokens[$firstToken]['content']);
+                        $trimmedContentLength
+                            = strlen(ltrim($tokens[$firstToken]['content']));
+
+                        $column = ($contentLength - $trimmedContentLength + 1);
+                        if (preg_match('|\*/$|', $content) !== 0) {
+                            $commentOpen = false;
+                        }
+                    }//end if
+                }//end if
+
+                // The token at the start of the line, needs to have its' column
+                // greater than the relative indent we set above. If it is less,
+                // an error should be shown.
+                if ($column !== $indent) {
+                    if ($this->exact === true || $column < $indent) {
+                        $error  = 'Line indented incorrectly; expected ';
+                        if ($this->exact === false) {
+                            $error .= 'at least ';
+                        }
+
+                        $error .= ($indent - 1).' spaces, found ';
+                        $error .= ($column - 1);
+                        $phpcsFile->addError($error, $firstToken);
+                    }
+                }
+            }//end if
+        }//end for
+
+    }//end process()
+
+
+    /**
+     * Calculates the expected indent of a token.
+     *
+     * @param array $tokens   The stack of tokens for this file.
+     * @param int   $stackPtr The position of the token to get indent for.
+     *
+     * @return int
+     */
+    protected function calculateExpectedIndent(array $tokens, $stackPtr)
+    {
+        $conditionStack = array();
+
+        // Empty conditions array (top level structure).
+        if (empty($tokens[$stackPtr]['conditions']) === true) {
+            return 1;
+        }
+
+        $tokenConditions = $tokens[$stackPtr]['conditions'];
+        foreach ($tokenConditions as $id => $condition) {
+            // If it's an indenting scope ie. it's not in our array of
+            // scopes that don't indent, add it to our condition stack.
+            if (in_array($condition, $this->nonIndentingScopes) === false) {
+                $conditionStack[$id] = $condition;
+            }
+        }
+
+        return ((count($conditionStack) * $this->indent) + 1);
+
+    }//end calculateExpectedIndent()
+
+
+}//end class
+
+?>