1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295: 296: 297: 298: 299: 300: 301: 302: 303: 304: 305: 306: 307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329: 330: 331: 332: 333: 334: 335: 336: 337: 338: 339: 340: 341: 342: 343: 344: 345: 346: 347: 348: 349: 350: 351: 352: 353: 354: 355: 356: 357: 358: 359: 360: 361: 362: 363: 364: 365: 366: 367: 368: 369: 370: 371: 372: 373: 374: 375: 376: 377: 378: 379: 380: 381: 382: 383: 384: 385: 386: 387: 388: 389: 390: 391: 392: 393: 394: 395: 396: 397: 398: 399: 400: 401: 402: 403: 404: 405: 406: 407: 408: 409: 410: 411: 412: 413: 414: 415: 416: 417: 418: 419: 420: 421: 422: 423: 424: 425: 426: 427: 428: 429: 430: 431: 432: 433: 434: 435: 436: 437: 438: 439: 440: 441: 442: 443: 444: 445: 446: 447: 448: 449: 450: 451: 452: 453: 454: 455: 456: 457: 458: 459: 460: 461: 462: 463: 464: 465: 466: 467: 468: 469: 470: 471: 472: 473: 474: 475: 476: 477: 478: 479: 480: 481: 482: 483: 484: 485: 486: 487: 488: 489: 490: 491: 492: 493: 494: 495: 496: 497: 498: 499: 500: 501: 502: 503: 504: 505: 506: 507: 508: 509: 510: 511: 512: 513: 514: 515: 516: 517: 518: 519: 520: 521: 522: 523: 524: 525: 526: 527: 528: 529: 530: 531: 532: 533: 534: 535: 536: 537: 538: 539: 540: 541: 542: 543: 544: 545: 546: 547: 548: 549: 550: 551: 552: 553: 554: 555: 556: 557: 558: 559: 560: 561: 

<?php
    /**
     * @author   Jan Pecha, <janpecha@email.cz>
     * @license  New BSD License (BSD-3), see file license.md
     */

    namespace Cz;

    class PhpDepend
    {
        /** @var  bool|int */
        private $inClass = FALSE;

        /** @var  string */
        private $namespace = '';

        /** @var  string[] */
        private $classes;

        /** @var  string[] */
        private $dependencies;

        /** @var  array */
        private $tokens;

        /** @var  int */
        private $level;

        /** @var  array */
        private $use;

        private static $T_NAMESPACE;
        private static $T_NS_SEPARATOR;
        private static $T_TRAIT;



        public function __construct()
        {
            self::$T_NAMESPACE = PHP_VERSION_ID < 50300 ? -1 : T_NAMESPACE;
            self::$T_NS_SEPARATOR = PHP_VERSION_ID < 50300 ? -1 : T_NS_SEPARATOR;
            self::$T_TRAIT = PHP_VERSION_ID < 50400 ? -1 : T_TRAIT;
        }



        /**
         * Returns list of defined classes, interfaces & traits or NULL.
         * @return string[]|NULL
         */
        public function getClasses()
        {
            return $this->classes;
        }



        /**
         * Returns list of required classes, interfaces & traits or NULL.
         * @return string[]|NULL
         */
        public function getDependencies()
        {
            return array_keys($this->dependencies);
        }



        /**
         * Parses content of PHP file.
         * @param  string
         * @return bool  FALSE => file error
         */
        public function parseFile($filename)
        {
            $source = file_get_contents($filename);

            if($source !== FALSE)
            {
                $this->parse($source);
                return TRUE;
            }

            return FALSE;
        }



        /**
         * Parses given PHP code.
         * @param  string
         * @return void
         */
        public function parse($str)
        {
            $this->tokens = $this->tokensFromSource($str);
            $this->inClass = FALSE;
            $this->namespace = '';
            $this->classes = array();
            $this->dependencies = array();
            $this->use = array();
            $this->level = 0;

            while($token = $this->next())
            {
                $tokenId = is_array($token) ? $token[0] : $token;

                switch($tokenId)
                {
                    // depend
                    case T_NEW:
                    case T_EXTENDS:
                        $this->addDependency($this->readName());
                        break;

                    case T_DOUBLE_COLON:
                        $this->addDependency($this->readStaticClass());
                        break;

                    case T_IMPLEMENTS:
                        $this->addDependency($this->readImplements());
                        break;

                    // define
                    case T_CLASS:
                    case self::$T_TRAIT:
                        $this->inClass = TRUE;

                    case T_INTERFACE:
                        $this->addClass($this->namespace . '\\' . $this->readIdentifier());
                        break;

                    // namespace
                    case self::$T_NAMESPACE:
                        $this->namespace = $this->readIdentifier();
                        $this->use = array();
                        break;

                    // USE keywords
                    case T_USE:
                        if($this->inClass) // trait
                        {
                            $this->addDependency($this->readTrait());
                        }
                        else // namespace
                        {
                            $this->use = array_merge($this->use, $this->readUse());
                        }
                        break;

                    case '{':
                        $this->level++;

                        if($this->inClass === TRUE)
                        {
                            $this->inClass = $this->level;
                        }
                        break;

                    case '}':
                        if($this->inClass === $this->level)
                        {
                            $this->inClass = FALSE;
                        }

                        $this->level--;
                        break;
                }
            }
        }



        /**
         * @param  string
         * @return array
         */
        private function tokensFromSource($str)
        {
            return token_get_all($str);
        }



        /**
         * @param  string|string[]
         * @return $this
         */
        private function addClass($class)
        {
            if($class)
            {
                if(!is_array($class))
                {
                    $class = array($class);
                }

                foreach($class as $name)
                {
                    $name = trim($name, '\\');

                    if($name !== '')
                    {
                        $this->classes[] = $name;
                    }
                }
            }

            return $this;
        }



        /**
         * @param  string|string[]
         * @return $this
         */
        private function addDependency($class)
        {
            if($class)
            {
                if(!is_array($class))
                {
                    $class = array($class);
                }

                foreach($class as $name)
                {
                    $name = trim($name, '\\');

                    if($name !== '')
                    {
                        $this->dependencies[$name] = TRUE;
                    }
                }
            }

            return $this;
        }



        /**
         * @return string|array|FALSE
         */
        private function next()
        {
            $next = current($this->tokens);
            next($this->tokens);
            return $next;
        }



        /**
         * @return string|array|FALSE
         */
        private function prev()
        {
            return prev($this->tokens);
        }



        /**
         * @return string|FALSE
         */
        private function readName()
        {
            return $this->expandName($this->readIdentifier(TRUE));
        }



        /**
         * @return string[]
         */
        private function readImplements()
        {
            $implements = array();

            while(($name = $this->readName()) !== FALSE)
            {
                $implements[] = $name;
                $token = $this->next();

                if($token !== ',' && (!is_array($token) && $token[0] !== T_WHITESPACE))
                {
                    $this->prev(); // TODO:??
                    break;
                }
            }

            return $implements;
        }



        /**
         * @param  bool
         * @return string
         */
        private function readIdentifier($readNamespaceKeyword = FALSE)
        {
            $name = FALSE;
            while($token = $this->next())
            {
                if(!is_array($token))
                {
                    $this->prev();
                    break;
                }

                if($readNamespaceKeyword && $token[0] === T_NAMESPACE)
                {
                    $name = '\\' . $this->namespace;
                    continue;
                }

                switch($token[0])
                {
                    case T_STRING:
                    case self::$T_NS_SEPARATOR:
                        $readNamespaceKeyword = FALSE;
                        $name .= $token[1];

                    case T_WHITESPACE:
                        break;

                    default:
                        $this->prev();
                        return $name;
                }
            }

            return $name;
        }



        /**
         * @return array  [short-name => full-class-name, ...]
         */
        private function readUse()
        {
            $use = array();
            $short = FALSE;
            while($name = $this->readIdentifier())
            {
                $token = $this->next();
                $wasGroup = FALSE;

                if($token === '{') // group statement
                {
                    $wasGroup = TRUE;
                    $nextToken = $this->readUseGroup($name, $use);

                    if ($nextToken !== NULL) {
                        $token = $nextToken;
                    }

                } else {
                    $short = self::generateShort($name, TRUE);

                    if(is_array($token))
                    {
                        if($token[0] === T_AS)
                        {
                            $short = $this->readIdentifier();
                            $token = $this->next();
                        }
                    }
                }

                if(!$wasGroup && ($token === ',' || $token === ';'))
                {
                    $use[$short] = $name;
                    $short = FALSE;
                }
            }

            return $use;
        }


        /**
         * @param  string
         * @return mixed|NULL  token or NULL
         */
        private function readUseGroup($rootName, array &$uses)
        {
            $token = NULL;
            $rootName = rtrim($rootName, '\\') . '\\';

            while ($name = $this->readIdentifier()) {
                $short = self::generateShort($name, TRUE);
                $token = $this->next();

                if(is_array($token))
                {
                    if($token[0] === T_AS)
                    {
                        $short = $this->readIdentifier();
                        $token = $this->next();
                    }
                }

                if($token === ',' || $token === '}')
                {
                    $uses[$short] = $rootName . $name;
                    $short = FALSE;

                    if ($token === '}') {
                        $token = $this->next();
                        break;
                    }
                }
            }

            return $token;
        }



        private function readStaticClass()
        {
            $name = FALSE;
            $i = 0;

            while($token = $this->prev())
            {
                $i++;
                if(is_array($token))
                {
                    if($token[0] === T_DOUBLE_COLON)
                    {
                        continue;
                    }

                    if(($token[0] === T_STRING || $token[0] === self::$T_NS_SEPARATOR)
                        && !($token[1] === 'self' || $token[1] === 'parent' || $token[1] === 'static'))
                    {
                        $name = $token[1] . $name;
                        continue;
                    }
                }

                break;
            }

            if($name !== FALSE)
            {
                $name = $this->expandName($name);
            }

            while($i > 0)
            {
                $this->next();
                $i--;
            }

            $this->next(); // consume content after T_DOUBLE_COLON
            return $name;
        }



        private function readTrait()
        {
            $traits = array();

            while($name = $this->readName())
            {
                $traits[] = $name;
                $token = $this->next();

                if($token === ',' || $token === ';' || $token === '{')
                {
                    if($token === ';')
                    {
                        break;
                    }

                    if($token === '{')
                    {
                        $level = 0;

                        while($t = $this->next())
                        {
                            if($t === '{')
                            {
                                $level++;
                            }
                            elseif($t === '}')
                            {
                                $level--;

                                if($level < 1)
                                {
                                    return $traits;
                                }
                            }
                        }
                    }
                }
                else
                {
                    break;
                }
            }

            return $traits;
        }



        /**
         * @param  string
         * @return string
         */
        private function expandName($name)
        {
            if($name[0] === '\\' || !$name)
            {
                return $name;
            }
            else
            {
                $short = self::generateShort($name);

                if(isset($this->use[$short]))
                {
                    return $this->use[$short] . '\\' . substr($name, strlen($short)+1);
                }
            }
            return $this->namespace . '\\' . $name;
        }



        private static function generateShort($name, $fromRight = FALSE)
        {
            $short = trim($name, '\\');
            $pos = $fromRight ? strrpos($short, '\\') : strpos($short, '\\');

            if($pos !== FALSE)
            {
                if($fromRight)
                {
                    $short = substr($short, $pos + 1);
                }
                else
                {
                    $short = substr($short, 0, $pos);
                }
            }

            return $short;
        }
    }