Manuel Pichler

As many of you may already have noticed, there will be a big change in my career as a professional software engineer and architect this summer. Together with Kore and Toby I am in the process of founding a company. The focus of this company will be on services all around the whole quality life cycle in PHP projects.

Under the hood of our company we will also offer support, trainings and consulting for several quality assurance tools, like pdepend, phpmd and phpUnderControl. For you, this opens a great opportunity. You can use the tools and the documentation, as well as participate in the community, as usual. But from now on you can also purchase professional support, if you get stuck or need general assitance. And when you miss a feature or need an individual extension for one of these tools, don't hesitate to contact us.

I am really excited what cool things will happen in the next couple of years and I am looking forward to cowork with professionals like Toby and Kore.

To finalize the little marketing for the company and its services I would appreciate to meet you, your colleagues and your compmany, to give presentations or into-depth trainings on one of the tools or on quality assurance in general.

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

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.

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.

Ok, it's day three after the famous PHP-Unconference-Hamburg and I still haven't found the time to write a review So lets start with a big thank you to all the organizers of this great event.

So lets start with the slides (german) from my talk Softwaremetriken verstehen und nutzen.

The NPath complexity calculation was broken in PHP_Depend 0.9.6. This bug was fixed in PHP_Depend 0.9.7.

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.

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

Now after a few beers and some grilled stuff I have the opportunity to hear the talk of Benjamin Eberlei on "Framework Quality" which contains some really nice details on that topic I have ignored or not thought about.

I am looking forward to a nice evening and drinks, talks, hacking and many informative discussions with Ulf from MySQL, Bastian and Thomas from Papaya, Tobias and Kore from eZ Systems and many others.

Are you also tired of all those monotonous and boring source code you read or write every day? No new challenges, always the same constructs and expression, must that really be so?

Fortunately do you use a programming language that comes with a wide range of opportunities to solve identical tasks in various ways. And here is a simple tip how you can bring variety in your source code with a single expression. Just use the whole range of valid new-expressions and donate your colleagues, customers and other persons with that varied and exciting christmas source code. A simple new MyClass () recognizes and understands finally everyone on the first glance

You should also vary the embedded expression which increases the number of possible solutions

In this sense, a lot of fun and a nice weekend...

Yesterday the ElePHPant pride arrived and now the kingpin has ten brothers and sisters

Die Karawane zieht weiter...

Even if there is not much noise around phpUnderControl and PHP_Depend at the moment, the development of both projects still goes on. Due to the fact that there are some personal movements in these days I have modified my priorities and everything evolves slower, but I plan to spend more time on these projects, at least from the last quarter of this year.

To put your minds on rest, the next release of phpUnderControl is nearly finished, so stay tuned.

Greetings Manuel

This should be the final beta release for PHP_Depend 0.8.0. Beside some minor bugfixes, it contains a last API change for the log sub component. This change removes constraints to the ctor signature of a logger implementation, which is now part of a separate interface.

The following list shows all changes in this version. A detailed description of all issues can be found in the PHP_Depend issue tracker!

• #29 Tooltip for the Overview Pyramid.
• #34 Support for pattern based package filter.
• #37 Remove Logger - XML Config dependency.
• #38 The Logger interface should not force a default ctor-signature.

As always you can use PHP_Depend's pear channel or its svn repository, to check out this new version. And feel free to discuss and follow the PHP_Depend development on its dedicated mailing list.

This new release of PHP_Depend took some time to be finished. This is because the initial idea of a simple adaption of JDepend evolved (supported thru this blog-post by Sebastian), and so PHP_Depend has become a complete software metric application. Many new features and enhancements have found their way into this version. One of the key features is the pluggable architecture for custom Loggers and Metric-Analyzers. This opens the possibility to hook own Logger- and Analyzer-implementations into the execution chain of PHP_Depend. Beside these architectural changes this PHP_Depend version is shipped with a large set of implemented software metrics.

ClassLevel (Class)

• dit: Depth of Inheritance Tree
• impl: Number of implemented interfaces
• cis: Class Interface Size
• csz: Class SiZe
• vars: Number of defined class properties
• varsi: Number of own and inherited class properties
• varsnp: Number of public class properties
• wmc: Weighted Method per Class(Sum of method Cyclomatic Complexity)
• wmci: Weighted Method per Class + inherited WMC
• wmcnp: Weighted Method per Class for all public class methods

CodeRank (Class, Package)

An adaption of google's PageRank algorithm for classes and packages.

• cr: Forward CodeRank (based on incoming edges)
• rcr: Reverse CodeRank (based on outgoing edges)

Coupling (Project)

• calls: Number of called methods and functions
• fanout: Number of referenced types

Cyclomatic Complexity (Project, Method, Function)

• ccn: Cyclomatic Complexity
• ccn2: Extended Cyclomatic Complexity

Dependency (Package)

For details see the following entry.

• ca: Afferent coupling
• ce: Efferent coupling
• a: Abstraction
• i: Instability
• d: Distance

Hierarchy (Project)

• clsa: Number of abstract classes.
• clsc: Number of concrete classes.
• roots: Number of root classes within the analyzed system.
• leafs: Number of leaf classes.
• maxDIT: Max Depth of Inheritance Tree value

Inheritance (Project)

• andc: Average Number of Derived Classes.
• ahh: Average Hierarchy Height

NodeCount (Project, Package, Class, Interface)

• nop: Number Of Packages
• noc: Number Of Classes
• noi: Number Of Interfaces
• nom: Number Of Methods
• nof: Number Of Functions

NodeLOC (Project, Package, Class, Interface, Method, Function)

• loc: Lines Of Code
• cloc: Comment Lines Of Code
• ncloc: Non Comment Lines Of Code

Due to the fact that PHP is a loosely typed programming language, PHP_Depend can only approximate some values. But the measured results can be improved with a good and complete source code documentation, because PHP_Depend takes advantage of different doc comment annotations (@throws, @var, @return). So I suggest the use of a tool like PHP_CodeSniffer, to achieve better results.

Beside all these metrics, PHP_Depend also provides a new chart type, the "Overview Pyramid". The Overview Pyramid can be a handy tool to analyze legacy code. If you have read the book Object-Oriented Metrics in Practice you should know howto interpret the Overview Pyramid, all others have to wait for a detailed description.

PHP_Depend Overview Pyramid for PHP_Depend

This new version can be installed with the PEAR-Installer. Just discover the pear.xplib.de channel and install the latest PHP_Depend release. After PHP_Depend has been installed successfully, the new command line tool pdepend should exist.

 mapi@arwen ~ $ pear channel-discover pear.xplib.de
 mapi@arwen ~ $ pear install xplib/PHP_Depend-beta
 mapi@arwen ~ $ pdepend --help
 PHP_Depend 0.8.0beta1 by Manuel Pichler

 Usage: pdepend [options] [logger] <dir[,dir[,...]]>

   --jdepend-chart=<file>    Generates a diagram of the analyzed packages.
   --jdepend-xml=<file>      Generates the package dependency log.

   --overview-pyramid=<file> Generates a chart with an Overview Pyramid for the
                             analyzed project.

   --summary-xml=<file>      Generates a xml log with all metrics.

   --coderank-mode=<*[,...]> Used CodeRank strategies. Comma separated list of
                             'inheritance'(default), 'property' and 'method'.

   --suffix=<ext[,...]>      List of valid PHP file extensions.
   --ignore=<dir[,...]>      List of exclude directories.
   --exclude=<pkg[,...]>     List of exclude packages.

   --without-annotations     Do not parse doc comment annotations.

   --help                    Print this help text.
   --version                 Print the current PHP_Depend version.

There is also a Subversion repository at http://svn.pdepend.org/, where the latest development version can be found.

Please test this beta release and file bug-reports and feature-requests in the PHP_Depend bug tracker.

I just arrived from my job and I found this shiny, new Zend PHP5 Certificate in the mailbox.

Here is a small code snippet that can be used to integrate php's internal lint syntax check into your build process. The ant task apply behaves like the exec task, but it accepts a nested fileset element. This allows to process a set of input files thru a single command.

This can also be used as an addition in your phpunit target or any other command which executes code during the build-process, when the command would quit due to a syntax error.