Manuel Pichler - planet-php

PHP_Depend-0.9.10 released

nospam@example.com (Manuel Pichler) — Tue, 23 Feb 2010 20:36:01 +0100

I have just released the bug fix version 0.9.10 of PHP_Depend. This release contains several bug fixes and improvements for PHP_Depend.

Implemented #72__: Add NOAM, NOOM and NOCC metrics. Implemented in svn revision #1084.
Implemented #74: Make CRAP-index available. Implemented in svn revision #1063.
Implemented #105: Support for deep search implement. Implemented in svn revision #1078.
Fixed #106: Filter algorithm is broken for namespaced internal classes. Fixed in svn revision #1039.
Fixed #110: Duplicate "coupling" directory in test code. Fixed in svn revision #1032.
Fixed #111: Dynamic Strings are treated as literal strings. Fixed in svn revision #1037.
Fixed #114: Parsing error caused by complex string expressions fixed. Fixed in svn revision #1068.
Fixed #115: Summary and PHPUnit Report lists unknown classes. Fixed in svn revision #1101.
Fixed #116: Returns reference results in parsing error. Fixed in svn revision #1090.
Performance intensive calculation result cached.
Test code restructured and improved.
Concurrency issue for parallel running pdepend instances fixed.

As always, you can get the latest PHP_Depend version from its PEAR channel: pear.pdepend.org:

  mapi@arwen ~ $ pear channel-discover pear.pdepend.org
  mapi@arwen ~ $ pear install pdepend/PHP_Depend-beta

Or you can fetch the sources from the subversion reposition:

  mapi@arwen ~ $ svn co http://svn.pdepend.org/branches/0.9.0/

And additionally you can find a repository mirror on github:

  mapi@arwen ~ $ git clone git://github.com/manuelpichler/pdepend.git

phpUnderControl 0.5.1 released

nospam@example.com (Manuel Pichler) — Sun, 31 Jan 2010 21:16:35 +0100

Today I have released phpUnderControl version 0.5.1. It's a bug fix release that closes several issues open since a long time. First of all I would like to thank Sebastian Marek who was the main contributor to this releases, so a big thankyou to you.

Now phpUnderControl should work with CruiseControl 2.8.3. Thanks to Mike van Riel who provided some hints on this issue in a blog comment.
Fixed #983: Graph unitests throw fatal error when ezComponents not available.
Fixed #966: phpcs-details.xsl not showing file name.
Closed #863: Destination option is now deprecated.
Fixed #862: Command line switches without parameter don't work.
Fixed #861: Password is used as username in check outs. This patch was supplied by Thorsten Daners via e-mail.
Fixed #734: Now the build dropdown redirects to the correct build uri.
Implemented #703: PHPUnit test results are now the first entry on the project overview page.
Fixed #700: Throw an exception when the specified project does not exist.
Implemented #675: Use "php -l" for lint checking and not PHPUnit.
Implemented #625: Integrate PHP_Depend results.

Beside the new release some more things have changed. From now on the phpUnderControl development is hosted on github. This means that from now on the latest version of phpUnderControl can be obtained with the following command:

mapi@arwen ~ $ git clone \
               git://github.com/manuelpichler/phpUnderControl.git

Additionally we have moved the phpUnderControl's PEAR Channel Server from pear.phpunit.de to its own server pear.phpundercontrol.org. At this point I would like to thank Sebastian for providing phpUnderControl's infrastructure under the PHPUnit umbrella for the last three years.

mapi@arwen ~ $ pear uninstall phpunit/phpUnderControl
mapi@arwen ~ $ pear channel-discover pear.phpundercontrol.org
mapi@arwen ~ $ pear install --alldeps phpuc/phpUnderControl-beta
Starting to download phpUnderControl-0.5.1.tgz (539,717 bytes)
..........................................done: 539,717 bytes
install ok: channel://pear.phpundercontrol.org/phpUnderControl-0.5.1

PHP Mess Detector 0.2 released.

nospam@example.com (Manuel Pichler) — Tue, 29 Dec 2009 23:40:00 +0100

Today I have released version 0.2.0 of the PHP Mess Detector or short PHPMD. PHPMD is a simple, customizable and user friendly frontend application for PHP_Depend. It takes the raw metrics measured by PHP_Depend, compares them with appropriate thresholds and generates a report that lists those software artifacts with potential problems. Such a report can be taken as a basis for human code audits or you can use it as input for an automated build/reporting tool.

Most concepts behind PHPMD are based on those of the well known Java Tool PMD. It uses so called rule set files to organize different sets of rules. There are two purposes that are accomplished by these xml files. The first is to create custom sets of rules which fulfills the projects requirements. The second purpose is the configuration of each rule with thresholds, warning messages and other things. The format of these files is totally borrowed from PMD, so that the reuse existing rule sets in multi language environments should be easy. At the moment PHPMD has two build-in rule sets. One that detects software artifacts with high code size, and the second one detects unused code in your software.

Now lets start with a small How to use it. PHPMD can be called from the command line by typing phpmd, which prints a general help text.

mapi@arwen ~ $ phpmd 
Mandatory arguments:
1) A php source code filename or directory
2) A report format
3) A ruleset filename or a comma-separated string of ...

Optional arguments that may be put after the mandato...
--minimumpriority: rule priority threshold; rules with ...
--reportfile: send report output to a file; default to ...
--extensions: comma-separated string of valid source ...
--ignore: comma-separated string of patterns that are ...

Now let's call PHPMD on its own source, with a simple text report on STDOUT and the codesize ruleset:

mapi@arwen ~ $ phpmd ~/phpmd/source text codesize

/home/mapi/phpmd/source/PHP/PMD/RuleSetFactory.php:66 \
  This class has too many methods, consider refactoring it.
/home/mapi/phpmd/source/PHP/PMD/RuleSetFactory.php:267 \
  The method _parseSingleRuleNode() has a Cyclomatic \
  Complexity of 11.
/home/mapi/phpmd/source/PHP/PMD/RuleSetFactory.php:326 \
  The method _parseRuleReferenceNode() has a Cyclomatic \
  Complexity of 10.

The --reportfile option can be used, to redirect the report output into a file. So let us repeat the previous example that writes the report into a file, additionally uses the unusedcode rule and changes the format from text to xml.

mapi@arwen ~ $ phpmd ~/phpmd/source xml codesize,unusedcode \
  --reportfile ~/pmd.xml
mapi@arwen ~ $ cat ~/pmd.xml 
<?xml version="1.0" encoding="UTF-8" ?>
<pmd version="@package_version@" timestamp="...">
  <file name=".../source/PHP/PMD/RuleSetFactory.php">
    <violation beginline="66" endline="417" rule="TooManyMet ...>
      This class has too many methods, consider refactoring it.
    </violation>
    <violation beginline="267" endline="315" rule="Cyclomati ...>
      Method _parseSingleRule() has a Cyclomatic Complexity of 11.
    </violation>
    <violation beginline="326" endline="367" rule="Cyclomati ...>
      Method _parseRuleReference() has a Cyclomatic Complexity of 10.
    </violation>
  </file>
</pmd>

This xml file is compatible with those files generated by PMD and PHPUnit's deprecated --log-pmd option. So that it should be no problem to use this files in existing environments like Hudson, CruiseControl or Sonar.

Currently PHPMD supports the following three different report formats: Text, HTML and XML. And it has the build-in rule sets: codesize and unusedcode.

You can get the latest PHPMD version from its PEAR channel: pear.phpmd.org

mapi@arwen ~ $ pear channel-discover pear.pdepend.org
mapi@arwen ~ $ pear channel-discover pear.phpmd.org
mapi@arwen ~ $ pear install --alldeps phpmd/PHP_PMD-alpha

phpUnderControl 0.5.0 released

nospam@example.com (Manuel Pichler) — Sun, 06 Dec 2009 15:16:00 +0100

After quite some time of silence around phpUnderControl I have bundled the 0.5.0 release today. Beside minor changes, bugfixes and enhancements this release contains one new major feature, the PHP_CodeBrowser.

phpUnderControl integrating PHP_CodeBrowser

The PHP_CodeBrowser is a separate application that collects various XML log files with different project metrics/violations and presents them in a browseable source view with syntax highligting. This tool is a contribution by the Mayflower GmbH, where it was developed and now shared with the Open Source Community. At this point I would like to thank Mayflower as a whole and in particular at Elger and Thorsten, which were responsible for all technical aspects of this contribution.

To use the PHP_CodeBrowser you must add an additional execute publisher to your CruiseControl config.xml file that generates the PHP_CodeBrowser html report and an additional artifacts publisher to move the generated PHP_CodeBrowser report into the projects artifacts directory.

<?xml version="1.0" encoding="UTF-8" ?>
<cruisecontrol>
  <!-- ... -->
  <project name="PHP_Depend" buildafterfailed="false">
    <!-- ... -->
    <publishers>
      <!-- ... -->
      <execute command="phpcb 
        --log projects/${project.name}/build/logs 
        --source projects/${project.name}/source/PHP 
        --output projects/${project.name}/build/php-code-browser"/>
      <artifactspublisher 
        dir="projects/${project.name}/build/php-code-browser" 
        dest="artifacts/${project.name}" 
        subdirectory="php-code-browser"/>
      <!-- ... -->
    </publishers>
  </project>
</cruisecontrol>

But why do we use a CruiseControl publishers instead of a regular ant (Your build tool here) target? The answer is really simple. The PHP_CodeBrowser must be the very last artifact generated for a project, which means it must also run after PHPUnit, to collect the test result logs. But in most setups PHPUnit is configured with failonerror="on" to mark a build as failed, when an error occured during the test execution. But with this configuration a following PHP_CodeBrowser target would never be executed by ant, because the build failed already. This cannot happen with a CruiseControl publisher which is always executed in a separated process.

If you create a new project with phpUnderControl's project command, phpUnderControl will automatically search for an installed PHP_CodeBrowser and add the required publishers to your config.xml file when it is present.

mapi@arwen ~ $ phpuc project \
       --project-name PHP_Depend \
       --source-dir PHP \
       --test-case PHP_Depend_AllTests \
       --test-dir tests \
       --test-file PHP/Depend/AllTests.php \
       --version-control svn \
       --version-control-url http://svn.pdepend.org/branches/0.9.0 \
       /opt/cruisecontrol/cruisecontrol-bin-2.8.2

To get the latest version of phpUnderControl, you can use the PEAR-Channel-Server:

mapi@arwen ~ $ pear channel-discover pear.phpunit.de
mapi@arwen ~ $ pear install phpunit/phpUnderControl-beta

or you can check it out from the subversion repository:

mapi@arwen ~ $ svn co svn://phpunit.de/phpunit/phpUnderControl/trunk

First release of the staticReflection component.

nospam@example.com (Manuel Pichler) — Sun, 29 Nov 2009 21:45:00 +0100

Today I have released the first version of the staticReflection component. This component parses the source files of a project to provide reflection information identical to that provided by PHP's build in API, without loading the class declaration into the PHP runtime context. Due to the API compatibility the staticReflection component can simply be used as a drop-in replacement for the reflection extension.

A few weeks ago I started just another script that utilized the tokenizer extension to extract some information from source code files. At that point I thought that the time had come to realize a project that was on my todo for a very long time. And here is the result of the first iteration, a userland reflection implementation that is api compatible with PHP's internal reflection extension. Beside the source parser and the reflection ast this component provides a unified interface to both reflection versions, which makes it easy to switch between different implementations.

As a first use case for this component I have choosen autoload files, as they are used by the eZ Components. The generation of those files is really easy, simply parse a directory with source files and dump the result into a file.

<?php
use org\pdepend\reflection\Autoloader;
use org\pdepend\reflection\ReflectionSession;

// Include the bundled autoloader
include_once 'staticReflection/Autoloader.php';

// Register the autoload function
spl_autoload_register( array( new Autoloader(), 'autoload' ) );

// Create a new session
$session = new ReflectionSession();

// Create a directory query
$query = $session->createDirectoryQuery(  );

$autoload = array();
foreach ( $query->find( __DIR__ . '/../../source/' ) as $class )
{
    $autoload[$class->getName()] = $class->getFileName();
}

var_export( $autoload );

You can also use the static reflection implementation to analyze different versions of the same class in the same process, which is not possible with the build-in reflection API, because you cannot load multiple classes with the same name into the current runtime context.

Beside parsing of a given directory or file the staticReflection component also supports direct access to a concrete class or interface through the name. Therefor it uses so called source resolvers, that perform a mapping between class names and the associated source files. The current release has two build-in resolvers, one using autoload arrays as they are used by the eZ Components and the other one uses the PEAR naming conventions and the configured include_paths to determine the source file for a given class name. The following example illustrates the usage of the PEAR source resolver.

<?php
use org\pdepend\reflection\Autoloader;
use org\pdepend\reflection\ReflectionSession;
use org\pdepend\reflection\factories\StaticReflectionClassFactory;
use org\pdepend\reflection\resolvers\PearNamingResolver;

include_once 'staticReflection/Autoloader.php';

spl_autoload_register( array( new Autoloader(), 'autoload' ) );

$session = ReflectionSession::createStaticSession(
    new PearNamingResolver()
);

$class = $session->getClass( 'PEAR_Frontend' );
echo '- ', $class->getName(), PHP_EOL,
     '    ', $class->getFileName(), PHP_EOL;

This concept makes the component extremly flexible, because you can write your own source resolver that fulfills the requirements for your application.

Beside the source resolver concept the ReflectionSession can also be configured with a custom stack of ReflectionClassFactory objects that are used to retrieve a reflection class instance for a given class/interface name. To minimize the configuration overhead for common use cases the ReflectionSession class provides three build-in factory methods that create default session configurations for you:

ReflectionSession::createDefaultSession( SourceResolver ): This session configuration uses three different backends. First it asks the native backend for a reflection class. When this backend cannot handle the request the static reflection factory is asked for a matching class. Finally this configuration uses the null backend, which always returns an empty placeholder reflection class.
ReflectionSession::createStaticSession( SourceResolver ): This session setup first asks the static reflection implementation for a matching reflection class and falls back to the null backend when no matching class exists.
ReflectionSession::createInternalSession(): This factory method creates a session setup that is a simple wrapper around PHP's internal reflection api.

But you can always build your own session configuration with a custom factory stack, by calling the ReflectionSession::addClassFactory() method on the session instance.

<?php
use org\pdepend\reflection\Autoloader;
use org\pdepend\reflection\ReflectionSession;

include_once 'staticReflection/Autoloader.php';

spl_autoload_register( array( new Autoloader(), 'autoload' ) );

$session = new ReflectionSession();
$session->addClassFactory( new MyFooFactory() );
$session->addClassFactory( new MyBarFactory() );

So how can you use this cool component in your application? This is really simple, just replace all ReflectionClass instantiations with the following code:

<?php
// ...
// Previous instantiation
// $ref = new ReflectionClass( 'Foo_Bar_Baz' );

// New cool solution
$ref = ReflectionSessionInstance::get()->getClass( 'Foo_Bar_Baz' );

And add the following code to your bootstrap file:

<?php
// ...
ReflectionSessionInstance::set(
    ReflectionSession::createInternalSession()
);

Finally some words to the requirements and the installation of this component. This component requires PHP in a version greater or equal 5.3.0. For installation you can use PHP_Depend's PEAR channel:

mapi@arwen ~ $ pear channel-discover pear.pdepend.org
mapi@arwen ~ $ pear install pdepend/staticReflection-alpha

or you can download the latest version from the staticReflection svn respository:

mapi@arwen ~ $ svn co http://svn.reflection.pdepend.org/trunk \
                      staticReflection

Feel free to test this component and file bug-reports and/or feature-requests in the project issue tracker.

PHP_Depend PEAR Channel switched to Pirum

nospam@example.com (Manuel Pichler) — Sat, 28 Nov 2009 14:00:23 +0100

Today Fabien Potencier announced the first relase of the PEAR Channel server Pirum. The great benefit of this Channel server is that it provides a simple shell script to publish new PEAR package releases, a feature that I missed in the previously used Chiara PEAR Server. Pirum will make it really easy to publish new package versions through a simple build script

The setup was quick done, following the instructions on the pirum website, and importing the existing package files worked like a charm. The only problem I encountered was that both channel server implementations use a different directory structure. Pirum stores all the XML descriptors under a directory named /rest, while my Chiara Server installation has used /Chiara_PEAR_Server_REST, so that a first call to pear upgrade resulted in the following error:

manu@arwen ~ $ pear upgrade
Error getting channel info from pear.pdepend.org: \
File http://pear.pdepend.org:80/Chiara_PEAR_Server_REST/p/packages.xml \
not valid (received: HTTP/1.1 404 Not Found)

But a simple 301 redirect makes this software transition transparent for the PHP_Depend users. So when you will also switch to Pirum you should keep this in mind and test your channel server with an existing/configured local pear installation.

Finally, thanks to Fabien for this nitty-gritty tool, which will speed up the deployment process of PEAR packages, at least for me.

PHP_Depend jumps on the D-BUS

nospam@example.com (Manuel Pichler) — Wed, 18 Nov 2009 18:47:00 +0100

Today I had the chance to visit Derick's IPC talk PHP on the D-BUS. Beside the fact that it was an exciting talk, it inspired me to implement a small, but nice feature for PHP_Depend using the pecl/dbus extension.

PHP_Depend jumps on the D-BUS

Sometimes the parsing and analysis process of PHP_Depend can consume a lot of time to finish, so I always put the shell aside and do something different. Normally I take a look at the shell every few minutes to check if the process has finished, but it also happens that I totally forget that I have started a PHP_Depend process on my system. So I need something that says to me, "Hey, mapi PHP_Depend has finished its job...", and here comes D-BUS in the game.

With D-BUS it is really simple to send a message to a desktop notification panel, as it is available for desktop environments like Gnome or KDE. To use D-BUS in your php applications you must checkout the source code of pecl/dbus from the svn repository and compile it for your php installation.

mapi@arwen ~ $ svn co http://svn.php.net/repository/pecl/dbus/trunk \
               pecl-dbus
mapi@arwen ~ $ cd pecl-dbus
mapi@arwen pecl-dbus $ phpize
mapi@arwen pecl-dbus $ ./configure
mapi@arwen pecl-dbus $ make
mapi@arwen pecl-dbus $ sudo make install

That's it. Now you should see the --notify-me option when you open PHP_Depend's help screen.

mapi@arwen ~ $ ~/pdepend/pdepend.php --help
PHP_Depend @package_version@ by Manuel Pichler

// ... snipp ...

  --debug                   Prints debugging information.
  --help                    Print this help text.
  --version                 Print the current version.
  --notify-me               Show a notification after analysis.
  -d key[=value]            Sets a php.ini value.

Now you can add this option to your normal PHP_Depend command and it will show a notification window with the number of analyzed files and the time the process took.

mapi@arwen ~ $ ~/pdepend/pdepend.php --summary-xml=/tmp/summary.xml \
                                       --notify-me \
                                       ~/pdepend/PHP

For the moment this feature is only available through the 0.9.0 branch of PHP_Depend and not as a PEAR package.

PHP_Depend-0.9.6 released

nospam@example.com (Manuel Pichler) — Sun, 02 Aug 2009 21:32:00 +0200

Today I released PHP_Depend 0.9.6, which contains many bug fixes and improvements, but the main feature of this release is behind the scene, I have started to migrate PHP_Depend's internal system from plain Token object to an Abstract Syntax Tree.

Closed #57: Display caption for abbreviations in overview pyramid, implemented in svn revision #947.
Closed #80: Store default value for class properties.
Fixed #81: PHP_Depend does not support comma separated property declarations, fixed in svn revision #916.
Fixed #82: PHP_Depend does not support comma separated constant definitions, fixed in svn revision #931.
Closed #83: Make ClassOrInterfaceReference an ASTNode, implemented in svn revision #917.
Fixed #87: The parent keyword is not accepted as parameter type hint, fixed in svn revision #925.
Fixed #89: Coupling analyzer reports wrong results, fixed in svn revision #939
Fixed #90: Coupling analyzer does not handle PHP 5.3 function chains, fixed in svn revision #943.
Fixed #91: Parser throws an exception when __CLASS__ as default value of an array property, fixed in svn revision #944.
Closes #92: Use class constants as analyzer identifiers, implemented in svn revision #950.

You can get the latest PHP_Depend version from its PEAR channel: pear.pdepend.org

mapi@arwen ~ $ pear channel-discover pear.pdepend.org
mapi@arwen ~ $ pear install pdepend/PHP_Depend-beta

Why I love PHP

nospam@example.com (Manuel Pichler) — Thu, 23 Jul 2009 19:22:09 +0200

While working on PHP_Depend's parser I realized one major reason Why I love PHP, it's the flexibility of language. Even if you think you now know all ways to solve a problem, there is always one more way to solve it.

class f {
function bar() { echo __METHOD__, '()', PHP_EOL; }
function __toString() { return 'v'; }
}
class v { function __toString() { return 'c'; } }
class m { function __toString() { return 'bar'; } }
$c = 'f';
$${'v'} = new ${(string) new ${$v = 'v'}()}();
$$$$$$v->{(string) new m()}();

But to be serious, don't be worried, if you don't get it.

The value of complexity metrics - Cyclomatic Complexity (1/2)

nospam@example.com (Manuel Pichler) — Tue, 07 Jul 2009 21:20:00 +0200

Software metrics are currently on everyone's lips and a frequently discussed topic. There are many conference talks, blog posts and other presentations that talk about software metrics. But to me it seems as if this subject is a closed book for many developers, so I decided to write this little post about a special category of software metrics, the complexity metrics.

Complexity metrics are a theoretical approach to measure the subjective complexity of a software fragment, where the words software fragment stand for a paraphrase for functions, methods, classes and nearly every logical unit that can be found in a software system. The most prevalent procedure to calculate complexity values is static code analysis, where an application parses the raw source code of a project, counts different statements and expressions and packs up the determined results in simple classification numbers. And with this information you already know the main concepts behind most software metrics, classification numbers and counting. As you can see there is no magic behind the scene, the only thing required is a good background knowledge to interpret those values.

The Cyclomatic Complexity Number or short CCN is the oldest complexity metrics. The first time this software metric was mentioned was 1976 by Thomas J. McCabe. This metric counts the available decision paths in a software fragment to determine its complexity. Each decision path starts with one of the conditional statements from the following list, so that it is fairly easy to detect them in existing source code.

?
case
elseif
for
foreach
if
while

A look at this list of statements may result in the questions: Is this list wrong, it doesn't list else and default? But it is correct. The assumption is that both statements will contain the defaut execution path of a program which also exists when there are no special cases to capture.

Each decision path gets the value 1 and the sum of all these values represents the Cyclomatic Complexity of the analyzed software fragment. Note that each function and method also counts with a value of 1 With this knowlegde we can now calculate the complexity of the following example code:

<?php
class CyclomaticComplexityNumber
{
public function exampe( $x, $y ) // (1)
{
if ( $x > 23 || $y < 42 ) // (1)
{
for ( $i = $x; $i >= $x && $i <= $y; ++$i ) // (1)
{
}
}
else
{
switch ( $x + $y )
{
case 1: // (1)
break;
case 2: // (1)
break;
default:
break;
}
}
}
file_exists('/tmp/log') or touch('/tmp/log');
}

Based on the previous definition the Cyclomatic Complexity Number of the example code example is 5. But you may have noticed that this approach does not capture all decision paths that exist. We haven't catched those paths that came from the by the boolean expression || line 6 and && line 8, and the logical or expression in line 25. A variation of the Cyclomatic Complexity Number that also captures those paths is the so called CCN2. The CCN2 is the most widely used variation of this software metrics. Tools like PHPUnit, PMD and Checkstyle report it as Cyclomatic Complexity of an analyzed software fragment.

Now we get a complexity value of 8 when we apply the CCN2 to the previous example, what is a growt of the software's complexity of 60%.

Due to the fact that Cyclomatic Complexity Number was originally invented for procedural programming languages, this definition for the Cyclomatic Complexity Number still misses one element to measure the complexity of an object oriented software system. With the concept of exceptions a software gets additional decision paths for each catch statement used in the source code. While try contains the code for the regular execution code without special cases, similar to else and default statements.

?
&&
||
or
and
xor
case
catch
elseif
for
foreach
if
while

Now that we know what the Cyclomatic Complexity Number is, what can we do with the measured information? We can find the complexity hotspots in a system, for example the top ten artifacts with the highest complexity, but this is only important during an initial analyses phase to get the big picture of an application. For a continuous inspection this information is not so important. A continuous analyses requires thresholds that help to categories calculated values. During the time four values have emerged as good thresholds for the Cyclomatic Complexity Number of a software system.

A software fragment with a CCN value between 1-4 has low complexity.
A complexity value between 5-7 is moderate and still easy to understand.
Everything between 6-10 has a high complexity, while everything greater 10 is very complex and hard to understand.

You may ask, why should I care about the complexity of a software system, where is the value of benefit in this metric?

Mostly the complex parts of an application contain business critical logic. But this complexity has negative impacts on the readability and understandability of source code. Those parts will normally become a maintainence and bug fixing nightmare, because no one knows all the constraints, side effects and what's exactly going on in that part of the software. This situation results in the well known saying "Never touch a running system" which in turn mostly ends in copy&paste programming. The situation can even become more critical when the original author leaves the development team or the company.

Finally a small example how to apply the new knowledge about the Cyclomatic Complexity Number, thresholds and the negative impacts of complex software to an existing development process. The following source listing shows a complex method taken from PHP_Depend's source. This method has a Cyclomatic Complexity Number of 16 and I must admit that the original author needed some time to understand what was going on in this method.

<?php
// ...
private function _countCalls(AbstractCallable $callable)
{
$callT = array(
TokenizerI::T_STRING,
TokenizerI::T_VARIABLE
);
$chainT = array(
TokenizerI::T_DOUBLE_COLON,
TokenizerI::T_OBJECT_OPERATOR,
);
$called = array();
$tokens = $callable->getTokens();
$count = count($tokens);
for ($i = 0; $i < $count; ++$i) {
// break on function body open
if ($tokens[$i]->type === TokenizerI::T_CURLY_BRACE_OPEN) {
break;
}
}
for (; $i < $count; ++$i) {
// Skip non parenthesis tokens
if ($tokens[$i]->type !== TokenizerI::T_PARENTHESIS_OPEN) {
continue;
}
// Skip first token
if (!isset($tokens[$i - 1]) || !in_array($tokens[$i - 1]->type, $callT)) {
continue;
}
// Count if no other token exists
if (!isset($tokens[$i - 2]) && !isset($called[$tokens[$i - 1]->image])) {
$called[$tokens[$i - 1]->image] = true;
++$this->_calls;
continue;
} else if (in_array($tokens[$i - 2]->type, $chainT)) {
$identifier = $tokens[$i - 2]->image . $tokens[$i - 1]->image;
for ($j = $i - 3; $j >= 0; --$j) {
if (!in_array($tokens[$j]->type, $callT)
&& !in_array($tokens[$j]->type, $chainT)
) {
break;
}
$identifier = $tokens[$j]->image . $identifier;
}
if (!isset($called[$identifier])) {
$called[$identifier] = true;
++$this->_calls;
}
} else if ($tokens[$i - 2]->type !== TokenizerI::T_NEW
&& !isset($called[$tokens[$i - 1]->image])
) {
$called[$tokens[$i - 1]->image] = true;
++$this->_calls;
}
}
}

The first thing to do is to make sure that the test suite is good enough to ensure that the required refactorings will not change the public behavior of the component or class. When this is donw and we are sure our that api breaks will be detected by the test suitewe can start to extract logic into separate methods.

The following example shows the result of the refactoring:

<?php
// ...
private function _countCalls(AbstractCallable $callable)
{
$called = array();
$tokens = $callable->getTokens();
$count = count($tokens);
for ($i = $this->_findOpenCurlyBrace($tokens); $i < $count; ++$i) {
if ($this->_isCallableOpenParenthesis($tokens, $i) === false) {
continue;
}
if ($this->_isMethodInvocation($tokens, $i) === true) {
$image = $this->_getInvocationChainImage($tokens, $i);
} else if ($this->_isFunctionInvocation($tokens, $i) === true) {
$image = $tokens[$i - 1]->image;
} else {
$image = null;
}
if ($image !== null) {
$called[$image] = $image;
}
}
$this->_calls += count($called);
}

The subjective feeling of readability heavily depends on the complexity of control structures, as we can see by a comparison of the original and the refactored version of the method example. The new version with its Cyclomatic Complexity Number of 5 is much easier to read and understand.

This text is the first of two blog posts. The second article will give a short introduction into the NPath Complexity You liked this article and you are interested in this and other quality assurence related topics? - Then you should now order your copy of the Book Quality Assurance in PHP Projects. The book talks about nearly all aspect of quality assurence, with practical tips and expert knowledge contributed by certain PHP professionals.

PHP_Depend-0.9.5 released

nospam@example.com (Manuel Pichler) — Mon, 18 May 2009 22:21:14 +0200

Today I released PHP_Depend 0.9.5, which contains many bug fixes and improvements. The main features of this release are PHP 5.3 namespace support and a more robust parser that ignores most kinds of syntax errors,

Closed #2 Support PHP 5.3 namespace syntax, implemented since svn revision #789.
Closed #61 Catch parser errors and continue processing, implemented in svn revision #880.
Closed #63 Make ResultPrinter a configurable option, implemented in svn revision #668.
Fixed #64 The single cache directory causes permission denied on *NIX systems, fixed in svn revision #667.
Fixed #65 Endless loop for class and interface declarations without body, fixed in svn revision #672.
Closed #66 Dependency wiring should be done at the end of the parsing process, implemented in svn revision #855.
Fixed #69 Parser does not handle PHP 5.3 class names in function and method bodies, fixed in svn revision #688.
Fixed #70 Parser throws an unexpected token exception for closure, fixed in svn revision #726.
Fixed #71 Parser throws an unexpected token exception for signed default values, fixed in svn revision #740.
Fixed #73 Inconsistent state when an interface and a class with the same name exists, fixed in svn revision #776.
Fixed #76 Tokenizer keyword detection is broken, fixed in svn revision #871.

You can get the latest PHP_Depend version from its PEAR channel: pear.pdepend.org

mapi@arwen ~ $ pear channel-discover pear.pdepend.org
mapi@arwen ~ $ pear install pdepend/PHP_Depend-beta

PHP_Depend-0.9.4 released

nospam@example.com (Manuel Pichler) — Sat, 21 Feb 2009 21:15:00 +0100

Today I released PHP_Depend 0.9.4, which contains many bug fixes and improvements.

Fixed #92: Handling of types within instanceof-operator fixed.
Closed #90: Support for single file parsing/analyzing implemented.
Closed #88: Tokens provide information about the start and end column.
Closed #87: Support for type definitions within comments implemented.
Closed #40: Cli debug flag added. PHP_Depend will print additional debug information to STDERR when this cli switch is set.
The ProjectAwareI and NodeAwareI interfaces extend the AnalyzerI interface, which makes analyzer mocking easier.
Switch from PHP_Depend specific constants for public, protected, private methods & properties to modifiers compatible with PHP's reflection-extension.
Support for static modifier for properties&methods and final for methods added.
Support for class final modifier added.
Support for chained types like "false|Iterator" or "array(false|Iterator)" in doc comments added.

You can get the latest PHP_Depend version from its PEAR channel: pear.pdepend.org

mapi@arwen ~ $ pear channel-discover pear.pdepend.org
mapi@arwen ~ $ pear install pdepend/PHP_Depend

PHP_Depend-0.9.3 released

nospam@example.com (Manuel Pichler) — Mon, 19 Jan 2009 21:44:00 +0100

Just now I released PHP_Depend 0.9.3, the primary goal for this release was focused on less memory consumption. A run of PHP_Depend 0.9.2 against eZ Publish took up to 1GB and PHP_Depend 0.9.3 analyzes the same source with a memory limit of 160Mb.

Fixed #89: The source file is never set for methods, properties and constants.
Closed #82: Tokenizer cache added, reduces runtime up to 25%.
Closed #83: Storage layer for node tokens added, reduces memory consumption. .
Closed #85: TextUI displays the execution time and the memory usage(linux only).
Code restructured, input filters and iterator moved to package "Input".
Test suite restructured to reflect the actual project structure.

From now on you will get the latest PHP_Depend version through the new pear channel pear.pdepend.org, for a few weeks I will keep the old pear channel. Enter the following pear commands to upgrade PHP_Depend's channel.

mapi@arwen ~ $ pear channel-discover pear.pdepend.org
mapi@arwen ~ $ pear uninstall xplib/PHP_Depend
mapi@arwen ~ $ pear install pdepend/PHP_Depend

Or checkout version 0.9.3 from the PHP_Depend subversion repository.

mapi@arwen ~ $ svn co http://svn.pdepend.org/tags/0.9.3

Seven Things - Tagged by Kore Nordmann

nospam@example.com (Manuel Pichler) — Sat, 03 Jan 2009 12:51:00 +0100

Nowadays there are some really strange online habits, like this I was tagged post. Even if I ignore most of those customs this time I will go on with Kore's blog post and tell seven things about me.

Before I was a computer scientist I finished a training as precision mechanic.
My first programming language was a CNC dialect.
I like cycling mountains up and down with my racing bike.
I started PHP programming in 1999.
The first framework I have used was the legendary PHPLIB.
In December 2008 I started with photography.
I have to less time to realize all projects I think about.

And now I will split the baton I got from Kore in seven pieces and pass it on:

Sebastian Nohn, who inspired me to develop phpUnderControl.
Max Horvath, for his idea to implement scalar type hints in userland code.
Greg Sherwood, who developed the excellent PHP_CodeSniffer package.
Jakob Westhoff, for all his wired ideas, like the phidget project.
Tobias Struckmeier, who teached me how to produce suitable results with inkscape.
Lars Strojny, for his contributions to PHP.
Lars Jankowfsky, for representing PHP a the Plat Forms Contest.

These are the rules apparently:

Link your original tagger(s), and list these rules on your blog.
Share seven facts about yourself in the post - some random, some weird.
Tag seven people at the end of your post by leaving their names and the links to their blogs.
Let them know they've been tagged by leaving a comment on their blogs and/or Twitter.

PHP_Depend-0.9.1 released

nospam@example.com (Manuel Pichler) — Wed, 31 Dec 2008 10:31:00 +0100

Just now I released PHP_Depend 0.9.1, the major feature in this new version is an implementation of the NPath Complexity metric, beside that feature the main focus for this release was on performance improvements of the current implementation.

Closed #21: Support for the NPath Complexity metric.
Fixed #78: Parser fails for comment in function signature.
Closed #79: Token objects instead of arrays.

An additional test concept was introduced with the 0.9.* branch of PHP_Depend. Nightly builds test PHP_Depend against a series of open source projects to detect deadlocks like endless loop or similar issues. This procedure is also used to test each release candidate of PHP_Depend. The tested project are:

You can get the latest PHP_Depend version through its PEAR channel pear.xplib.de or as a subversion checkout of the 0.9.1 tag.
Please do not checkout "trunk", it is totally unstable at the moment and I will not provide any support for it.

mapi@arwen ~ $ svn co http://svn.pdepend.org/tags/0.9.1