php/external/PHPUnit/Util/Metrics/Class.php

   1 <?php
   2 /**
   3  * PHPUnit
   4  *
   5  * Copyright (c) 2002-2008, Sebastian Bergmann <sb@sebastian-bergmann.de>.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  *   * Redistributions of source code must retain the above copyright
  13  *     notice, this list of conditions and the following disclaimer.
  14  *
  15  *   * Redistributions in binary form must reproduce the above copyright
  16  *     notice, this list of conditions and the following disclaimer in
  17  *     the documentation and/or other materials provided with the
  18  *     distribution.
  19  *
  20  *   * Neither the name of Sebastian Bergmann nor the names of his
  21  *     contributors may be used to endorse or promote products derived
  22  *     from this software without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  27  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  28  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  34  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35  * POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  * @category   Testing
  38  * @package    PHPUnit
  39  * @author     Sebastian Bergmann <sb@sebastian-bergmann.de>
  40  * @copyright  2002-2008 Sebastian Bergmann <sb@sebastian-bergmann.de>
  41  * @license    http://www.opensource.org/licenses/bsd-license.php  BSD License
  42  * @version    SVN: $Id: Class.php 1985 2007-12-26 18:11:55Z sb $
  43  * @link       http://www.phpunit.de/
  44  * @since      File available since Release 3.2.0
  45  */
  46
  47 require_once 'PHPUnit/Util/Class.php';
  48 require_once 'PHPUnit/Util/Metrics.php';
  49 require_once 'PHPUnit/Util/Filter.php';
  50
  51 PHPUnit_Util_Filter::addFileToFilter(__FILE__, 'PHPUNIT');
  52
  53 /**
  54  * Class-Level Metrics.
  55  *
  56  * @category   Testing
  57  * @package    PHPUnit
  58  * @author     Sebastian Bergmann <sb@sebastian-bergmann.de>
  59  * @copyright  2002-2008 Sebastian Bergmann <sb@sebastian-bergmann.de>
  60  * @license    http://www.opensource.org/licenses/bsd-license.php  BSD License
  61  * @version    Release: 3.2.9
  62  * @link       http://www.phpunit.de/
  63  * @since      Class available since Release 3.2.0
  64  */
  65 class PHPUnit_Util_Metrics_Class extends PHPUnit_Util_Metrics {
  66   protected $aif = 0;
  67   protected $ahf = 0;
  68   protected $ca = 0;
  69   protected $ce = 0;
  70   protected $coverage = 0;
  71   protected $dit = 0;
  72   protected $i = 0;
  73   protected $impl = 0;
  74   protected $loc = 0;
  75   protected $locExecutable = 0;
  76   protected $locExecuted = 0;
  77   protected $mif = 0;
  78   protected $mhf = 0;
  79   protected $noc = 0;
  80   protected $pf = 0;
  81   protected $vars = 0;
  82   protected $varsNp = 0;
  83   protected $varsI = 0;
  84   protected $wmc = 0;
  85   protected $wmcNp = 0;
  86   protected $wmcI = 0;
  87
  88   protected $project;
  89   protected $package = '';
  90   protected $class;
  91   protected $methods = array();
  92   protected $inheritedMethods = array();
  93   protected $dependencies = array();
  94   protected $publicMethods = 0;
  95
  96   protected static $cache = array();
  97   protected static $nocCache = array();
  98
  99   /**
 100    * Constructor.
 101    *
 102    * @param  ReflectionClass $class
 103    * @param  array           $codeCoverage
 104    * @access protected
 105    */
 106   protected function __construct(ReflectionClass $class, &$codeCoverage = array()) {
 107     $this->class = $class;
 108
 109     $className = $class->getName();
 110
 111     $packageInformation = PHPUnit_Util_Class::getPackageInformation($className);
 112
 113     if (! empty($packageInformation['fullPackage'])) {
 114       $this->package = $packageInformation['fullPackage'];
 115     }
 116
 117     $this->setCoverage($codeCoverage);
 118
 119     $this->dit = count(PHPUnit_Util_Class::getHierarchy($class->getName())) - 1;
 120     $this->impl = count($class->getInterfaces());
 121
 122     foreach ($this->class->getMethods() as $method) {
 123       if ($method->getDeclaringClass()->getName() == $className) {
 124         $this->methods[$method->getName()] = PHPUnit_Util_Metrics_Function::factory($method, $codeCoverage);
 125       } else {
 126         $this->inheritedMethods[$method->getName()] = PHPUnit_Util_Metrics_Function::factory($method, $codeCoverage);
 127       }
 128     }
 129
 130     $this->calculateAttributeMetrics();
 131     $this->calculateMethodMetrics();
 132     $this->calculateNumberOfChildren();
 133     $this->calculatePolymorphismFactor();
 134     $this->calculateDependencies();
 135   }
 136
 137   /**
 138    * Factory.
 139    *
 140    * @param  ReflectionClass $class
 141    * @param  array           $codeCoverage
 142    * @return PHPUnit_Util_Metrics_Class
 143    * @access public
 144    * @static
 145    */
 146   public static function factory(ReflectionClass $class, &$codeCoverage = array()) {
 147     $className = $class->getName();
 148
 149     if (! isset(self::$cache[$className])) {
 150       self::$cache[$className] = new PHPUnit_Util_Metrics_Class($class, $codeCoverage);
 151     }
 152
 153     else if (! empty($codeCoverage) && self::$cache[$className]->getCoverage() == 0) {
 154       self::$cache[$className]->setCoverage($codeCoverage);
 155     }
 156
 157     return self::$cache[$className];
 158   }
 159
 160   /**
 161    * @param  array $codeCoverage
 162    * @access public
 163    */
 164   public function setCoverage(array &$codeCoverage) {
 165     if (! empty($codeCoverage)) {
 166       $this->calculateCodeCoverage($codeCoverage);
 167
 168       foreach ($this->methods as $method) {
 169         $method->setCoverage($codeCoverage);
 170       }
 171     }
 172   }
 173
 174   /**
 175    * @param  PHPUnit_Util_Metrics_Project $project
 176    * @access public
 177    */
 178   public function setProject(PHPUnit_Util_Metrics_Project $project) {
 179     $this->project = $project;
 180
 181     $this->ca = 0;
 182     $this->ce = 0;
 183     $this->i = 0;
 184   }
 185
 186   /**
 187    * Returns the class.
 188    *
 189    * @return ReflectionClass
 190    * @access public
 191    */
 192   public function getClass() {
 193     return $this->class;
 194   }
 195
 196   /**
 197    * Returns the package of this class.
 198    *
 199    * @return string
 200    * @access public
 201    */
 202   public function getPackage() {
 203     return $this->package;
 204   }
 205
 206   /**
 207    * Returns the methods of this class.
 208    *
 209    * @return array
 210    * @access public
 211    */
 212   public function getMethods() {
 213     return $this->methods;
 214   }
 215
 216   /**
 217    * Returns the names of the classes this class depends on.
 218    *
 219    * @return array
 220    * @access public
 221    */
 222   public function getDependencies() {
 223     return $this->dependencies;
 224   }
 225
 226   /**
 227    * Lines of Code (LOC).
 228    *
 229    * @return int
 230    * @access public
 231    */
 232   public function getLoc() {
 233     return $this->loc;
 234   }
 235
 236   /**
 237    * Executable Lines of Code (ELOC).
 238    *
 239    * @return int
 240    * @access public
 241    */
 242   public function getLocExecutable() {
 243     return $this->locExecutable;
 244   }
 245
 246   /**
 247    * Executed Lines of Code.
 248    *
 249    * @return int
 250    * @access public
 251    */
 252   public function getLocExecuted() {
 253     return $this->locExecuted;
 254   }
 255
 256   /**
 257    * Returns the Number of Public Methods of the class.
 258    *
 259    * @return integer
 260    * @access public
 261    */
 262   public function getPublicMethods() {
 263     return $this->publicMethods;
 264   }
 265
 266   /**
 267    * Returns the Attribute Inheritance Factor (AIF) for the class.
 268    *
 269    * @return integer
 270    * @access public
 271    * @see    http://www.aivosto.com/project/help/pm-oo-mood.html
 272    */
 273   public function getAIF() {
 274     return $this->aif;
 275   }
 276
 277   /**
 278    * Returns the Attribute Hiding Factor (AHF) for the class.
 279    *
 280    * @return integer
 281    * @access public
 282    * @see    http://www.aivosto.com/project/help/pm-oo-mood.html
 283    */
 284   public function getAHF() {
 285     return $this->ahf;
 286   }
 287
 288   /**
 289    * Returns the Afferent Couplings (Ca) for the class.
 290    *
 291    * The number of other classes that depend upon a class is an indicator of
 292    * the class' responsibility.
 293    *
 294    * @return integer
 295    * @access public
 296    */
 297   public function getCa() {
 298     $this->calculateDependencyMetrics();
 299
 300     return $this->ca;
 301   }
 302
 303   /**
 304    * Returns the Efferent Couplings (Ce) for the class.
 305    *
 306    * The number of other classes that the class depends upon is an indicator
 307    * of the class' independence.
 308    *
 309    * @return integer
 310    * @access public
 311    */
 312   public function getCe() {
 313     $this->calculateDependencyMetrics();
 314
 315     return $this->ce;
 316   }
 317
 318   /**
 319    * Returns the Class Size (CSZ) of the class.
 320    *
 321    * @return integer
 322    * @access public
 323    * @see    http://www.aivosto.com/project/help/pm-oo-misc.html
 324    */
 325   public function getCSZ() {
 326     return count($this->methods) + $this->vars;
 327   }
 328
 329   /**
 330    * Returns the Class Interface Size (CIS) of the class.
 331    *
 332    * @return integer
 333    * @access public
 334    * @see    http://www.aivosto.com/project/help/pm-oo-misc.html
 335    */
 336   public function getCIS() {
 337     return $this->publicMethods + $this->varsNp;
 338   }
 339
 340   /**
 341    * Returns the Code Coverage for the class.
 342    *
 343    * @return float
 344    * @access public
 345    */
 346   public function getCoverage() {
 347     return $this->coverage;
 348   }
 349
 350   /**
 351    * Returns the Depth of Inheritance Tree (DIT) for the class.
 352    *
 353    * @return integer
 354    * @access public
 355    * @see    http://www.aivosto.com/project/help/pm-oo-ck.html
 356    */
 357   public function getDIT() {
 358     return $this->dit;
 359   }
 360
 361   /**
 362    * Returns the Instability (I) for the class.
 363    *
 364    * The ratio of efferent coupling (Ce) to total coupling (Ce + Ca) such that
 365    * I = Ce / (Ce + Ca). This metric is an indicator of the class' resilience
 366    * to change.
 367    *
 368    * The range for this metric is 0 to 1, with I=0 indicating a completely
 369    * stable class and I=1 indicating a completely instable class.
 370    *
 371    * @return float
 372    * @access public
 373    */
 374   public function getI() {
 375     $this->calculateDependencyMetrics();
 376
 377     return $this->i;
 378   }
 379
 380   /**
 381    * Returns the Number of Interfaces Implemented by the class (IMPL).
 382    *
 383    * @return integer
 384    * @access public
 385    * @see    http://www.aivosto.com/project/help/pm-oo-misc.html
 386    */
 387   public function getIMPL() {
 388     return $this->impl;
 389   }
 390
 391   /**
 392    * Returns the Method Inheritance Factor (MIF) for the class.
 393    *
 394    * @return float
 395    * @access public
 396    * @see    http://www.aivosto.com/project/help/pm-oo-mood.html
 397    */
 398   public function getMIF() {
 399     return $this->mif;
 400   }
 401
 402   /**
 403    * Returns the Method Hiding Factor (MHF) for the class.
 404    *
 405    * @return float
 406    * @access public
 407    * @see    http://www.aivosto.com/project/help/pm-oo-mood.html
 408    */
 409   public function getMHF() {
 410     return $this->mhf;
 411   }
 412
 413   /**
 414    * Returns the Number of Children (NOC) for the class.
 415    *
 416    * @return integer
 417    * @access public
 418    * @see    http://www.aivosto.com/project/help/pm-oo-ck.html
 419    */
 420   public function getNOC() {
 421     return $this->noc;
 422   }
 423
 424   /**
 425    * Returns the Polymorphism Factor (PF) for the class.
 426    *
 427    * @return float
 428    * @access public
 429    * @see    http://www.aivosto.com/project/help/pm-oo-mood.html
 430    */
 431   public function getPF() {
 432     return $this->pf;
 433   }
 434
 435   /**
 436    * Returns the Number of Variables (VARS) defined by the class.
 437    *
 438    * @return integer
 439    * @access public
 440    * @see    http://www.aivosto.com/project/help/pm-oo-misc.html
 441    */
 442   public function getVARS() {
 443     return $this->vars;
 444   }
 445
 446   /**
 447    * Returns the Number of Non-Private Variables (VARSnp) defined by the class.
 448    *
 449    * @return integer
 450    * @access public
 451    * @see    http://www.aivosto.com/project/help/pm-oo-misc.html
 452    */
 453   public function getVARSnp() {
 454     return $this->varsNp;
 455   }
 456
 457   /**
 458    * Returns the Number of Variables (VARSi) defined and inherited by the class.
 459    *
 460    * @return integer
 461    * @access public
 462    * @see    http://www.aivosto.com/project/help/pm-oo-misc.html
 463    */
 464   public function getVARSi() {
 465     return $this->varsI;
 466   }
 467
 468   /**
 469    * Returns the Weighted Methods Per Class (WMC) for the class.
 470    *
 471    * @return integer
 472    * @access public
 473    * @see    http://www.aivosto.com/project/help/pm-oo-ck.html
 474    */
 475   public function getWMC() {
 476     return $this->wmc;
 477   }
 478
 479   /**
 480    * Returns the Weighted Non-Private Methods Per Class (WMCnp) for the class.
 481    *
 482    * @return integer
 483    * @access public
 484    * @see    http://www.aivosto.com/project/help/pm-oo-misc.html
 485    */
 486   public function getWMCnp() {
 487     return $this->wmcNp;
 488   }
 489
 490   /**
 491    * Returns the Weighted Inherited Methods Per Class (WMCi) for the class.
 492    *
 493    * @return integer
 494    * @access public
 495    * @see    http://www.aivosto.com/project/help/pm-oo-misc.html
 496    */
 497   public function getWMCi() {
 498     return $this->wmcI;
 499   }
 500
 501   /**
 502    * Calculates the Attribute Inheritance Factor (AIF) and
 503    * Attribute Hiding Factor (AHF) metrics for the class.
 504    *
 505    * @access protected
 506    */
 507   protected function calculateAttributeMetrics() {
 508     $attributes = 0;
 509     $hiddenAttributes = 0;
 510     $inheritedAttributes = 0;
 511
 512     foreach ($this->class->getProperties() as $attribute) {
 513       if ($attribute->isPublic()) {
 514         $this->varsNp ++;
 515       } else {
 516         $hiddenAttributes ++;
 517       }
 518
 519       if ($attribute->getDeclaringClass()->getName() == $this->class->getName()) {
 520         $this->vars ++;
 521       } else {
 522         $inheritedAttributes ++;
 523       }
 524
 525       $this->varsI ++;
 526       $attributes ++;
 527     }
 528
 529     if ($attributes > 0) {
 530       $this->aif = (100 * $inheritedAttributes) / $attributes;
 531       $this->ahf = (100 * $hiddenAttributes) / $attributes;
 532     }
 533   }
 534
 535   /**
 536    * Calculates the Method Inheritance Factor (MIF)
 537    * Method Hiding Factor (MHF), Weighted Methods Per Class (WMC),
 538    * Weighted Non-Private Methods Per Class (WMCnp), and
 539    * Weighted Inherited Methods Per Class (WMCi) metrics for the class.
 540    *
 541    * @access protected
 542    */
 543   protected function calculateMethodMetrics() {
 544     $numMethods = 0;
 545     $hiddenMethods = 0;
 546     $inheritedMethods = 0;
 547
 548     $methods = array_merge($this->methods, $this->inheritedMethods);
 549
 550     foreach ($methods as $method) {
 551       $ccn = $method->getCCN();
 552
 553       if ($method->getMethod()->getDeclaringClass()->getName() == $this->class->getName()) {
 554         $this->wmc += $ccn;
 555
 556         if ($method->getMethod()->isPublic()) {
 557           $this->publicMethods ++;
 558           $this->wmcNp += $ccn;
 559         }
 560       } else {
 561         $inheritedMethods ++;
 562       }
 563
 564       if (! $method->getMethod()->isPublic()) {
 565         $hiddenMethods ++;
 566       }
 567
 568       $this->wmcI += $ccn;
 569       $numMethods ++;
 570     }
 571
 572     if ($numMethods > 0) {
 573       $this->mif = (100 * $inheritedMethods) / $numMethods;
 574       $this->mhf = (100 * $hiddenMethods) / $numMethods;
 575     }
 576   }
 577
 578   /**
 579    * Calculates the Number of Children (NOC) metric for the class.
 580    *
 581    * @access protected
 582    */
 583   protected function calculateNumberOfChildren() {
 584     $className = $this->class->getName();
 585
 586     if (! isset(self::$nocCache[$className])) {
 587       self::$nocCache = array();
 588     }
 589
 590     if (empty(self::$nocCache)) {
 591       foreach (get_declared_classes() as $_className) {
 592         $class = new ReflectionClass($_className);
 593         $parent = $class->getParentClass();
 594
 595         if ($parent !== FALSE) {
 596           $parentName = $parent->getName();
 597
 598           if (isset(self::$nocCache[$parentName])) {
 599             self::$nocCache[$parentName] ++;
 600           } else {
 601             self::$nocCache[$parentName] = 1;
 602           }
 603         }
 604       }
 605     }
 606
 607     if (isset(self::$nocCache[$className])) {
 608       $this->noc = self::$nocCache[$className];
 609     }
 610   }
 611
 612   /**
 613    * Calculates the Polymorphism Factor (PF) metric for the class.
 614    *
 615    * @param  ReflectionClass $class
 616    * @access protected
 617    */
 618   protected function calculatePolymorphismFactor() {
 619     $parentClass = $this->class->getParentClass();
 620
 621     if ($parentClass !== FALSE) {
 622       $overridableMethods = array();
 623
 624       foreach ($parentClass->getMethods() as $method) {
 625         if (! $method->isPrivate() && ! $method->isFinal() && ! $method->isAbstract()) {
 626           $overridableMethods[] = $method->getName();
 627         }
 628       }
 629
 630       if (! empty($overridableMethods)) {
 631         $overriddenMethods = 0;
 632
 633         foreach ($this->class->getMethods() as $method) {
 634           if ($method->getDeclaringClass()->getName() == $this->class->getName()) {
 635             $methodName = $method->getName();
 636
 637             if (in_array($methodName, $overridableMethods)) {
 638               $overriddenMethods ++;
 639             }
 640           }
 641         }
 642
 643         $this->pf = (100 * $overriddenMethods) / count($overridableMethods);
 644       }
 645     }
 646   }
 647
 648   /**
 649    * Calculates the Code Coverage for the class.
 650    *
 651    * @param  array $codeCoverage
 652    * @access protected
 653    */
 654   protected function calculateCodeCoverage(&$codeCoverage) {
 655     $statistics = PHPUnit_Util_CodeCoverage::getStatistics($codeCoverage, $this->class->getFileName(), $this->class->getStartLine(), $this->class->getEndLine());
 656
 657     $this->coverage = $statistics['coverage'];
 658     $this->loc = $statistics['loc'];
 659     $this->locExecutable = $statistics['locExecutable'];
 660     $this->locExecuted = $statistics['locExecuted'];
 661   }
 662
 663   /**
 664    * Calculates the dependencies for this class.
 665    *
 666    * @access protected
 667    */
 668   protected function calculateDependencies() {
 669     $parent = $this->class->getParentClass();
 670
 671     if ($parent && $parent->isUserDefined() && ! in_array($parent->getName(), $this->dependencies)) {
 672       $this->dependencies[] = $parent->getName();
 673     }
 674
 675     $interfaces = $this->class->getInterfaces();
 676
 677     foreach ($interfaces as $interface) {
 678       if ($interface->isUserDefined() && ! in_array($interface->getName(), $this->dependencies)) {
 679         $this->dependencies[] = $interface->getName();
 680       }
 681     }
 682
 683     $methods = array_merge($this->methods, $this->inheritedMethods);
 684
 685     foreach ($methods as $method) {
 686       foreach ($method->getDependencies() as $dependency) {
 687         if (! in_array($dependency, $this->dependencies)) {
 688           $this->dependencies[] = $dependency;
 689         }
 690       }
 691     }
 692   }
 693
 694   /**
 695    * Calculates the dependency-based metrics for this class.
 696    *
 697    * @access protected
 698    */
 699   protected function calculateDependencyMetrics() {
 700     if ($this->ca == 0 && $this->ce == 0 && $this->i == 0) {
 701       $className = $this->class->getName();
 702       $dependencies = $this->project->getDependencies();
 703
 704       foreach ($dependencies[$className] as $dependency) {
 705         if ($dependency > 0) {
 706           $this->ce ++;
 707         }
 708       }
 709
 710       unset($dependencies[$className]);
 711
 712       foreach ($dependencies as $_className => $_dependencies) {
 713         if ($_dependencies[$className] > 0) {
 714           $this->ca ++;
 715         }
 716       }
 717
 718       $sum = $this->ce + $this->ca;
 719
 720       if ($sum > 0) {
 721         $this->i = $this->ce / $sum;
 722       }
 723     }
 724   }
 725 }
 726 ?>