Ben Selby has released a Sublime Text 2 plugin for the popular PHP-based documentation generation project DocBlox.

It seems that the editor of the moment is Sublime Text 2 and sadly I have to tip my hat to Gary Rockett for showing it off to me one day.. Since that day, I've been a 100% convert. [...] So, I decided to peak into the PHPUnit [plugin from Stuart Herbert] to see if I could create a DocBlox Plugin. It turns out you have to write Plugins in Python, which is interesting, since I know very little python. There seemed to be enough code there to get me going, so I now have a working DocBlox Plugin.

The result is a plugin that, once installed gives you a new context menu option to "Generate documentation" for the selected file. The console shows the progress of the build. You can get the plugin from Package Control or by grabbing it from github directly.

Phil Sturgeon (an expert in all things related to the Fuel PHP framework) has written up a tutorial for NetTuts.com about creating a basic admin panel for your application based on the framework. This is the second part of a series looking at Fuel, building on the topics from the first.

In the first part of this series, we took a look at the basics of the FuelPHP framework. In this second-part, we'll be stepping it up a gear and move onto some more advanced topics! We'll be creating an admin panel for our application, cover the common uses of the ORM and use the Authentication package to restrict access.

He walks you through setting up Oil (the command-line tool that comes bundled with Fuel) and using it to create a new application. There's a few steps of configuration to connect to a database and setting up a few access groups (like "Banned", "Guests" and "Administrators"). Oil is used again to create users in the database and to auto-generate a lot of the controller/view code you'll need for the admin tool. He then gets into the more technical parts - updating the current code to be able to do things like using the ORM to fetch database results and being able to add comments to posts.

In this new post to his blog, Philip Norton reminds you about a handy feature of PHPUnit, the popular PHP unit testing tool, that can make generating tests for your application simpler - the skeleton class generator.

If you create classes in PHP then you should be unit testing them as much as you can. Setting up unit testing classes for your code can be time consuming and involve a bunch of copying and pasting. Thankfully, PHPUnit comes with a couple of helper functions that allow the creation of unit testing classes automatically, which can save a bit of copying and pasting.

He includes an example of a class named "Spider" and shows both the contents of the class and the resulting test that comes from running "phpunit --skeleton-test" on it. The resulting test has methods for each method in your class and marks them all as incomplete. As Philip notes, this is a good start but should never be relied upon as a test to leave as-is.

On the PHP On Windows section of the DZone.com site Giorgio Sironi has a new post looking at the process (and script he's created) to create a UML diagram with PHP from a project's current class structure.

Sometimes you need to share a design with your colleagues. You can walk him through the code, and explain which classes and interfaces you created, but there are higher abstracted models that you can show to him to make him grasp the picture quickly. One of these tools is UML, and in particular class diagrams.

His script creates a UML diagram from a PHP object graph, a sort of "reverse engineering" of the current object's hierarchy and relationships. It creates definitions that Yuml.me can use to generate the image and does some handy things like following the path down N levels until it hits "the bottom" and the ability to ignore certain namespaces (like "Zend_" or "Doctrine_") to help limit things down to just your application. He includes a sample set of tests to show it in action as well as a resulting UML diagram generated from the PHPUnit structure.

Dave Marshall has written up a new post showing how he's used memcache, Gearman and Dojo to create an asynchronous progress bar he uses when generating large reports.

I have a (highly optimised) report that takes way too long to generate, up to around 30 seconds. [There's] too many variables to prime caches for every possible combination [and] personally, I don't think the browsers inbuilt progress bar is enough feedback for todays web users.

He generates the data into memcache when the user requests it and uses the Gearman worker processes to handle requests for data that doesn't yet exist. The progress bar is a part of Dojo and uses the dijit.ProgressBar widget to keep checking the progress of the build. This way the user can even leave the page and come back if the process takes too long with no threat to the generating report. You can find all of his code he's used to make it happen on his github account.

In a new post to his blog Kore Nordmann talks about a tool he's developed that will "learn" XML schemas based on a document it's given. The tool, the XML-schema-learner, makes it as simple as a one-line command to generate the DTD file and transform it into a schema.

You can get the "XML schema learner" from my Github account: https://github.com/kore/XML-Schema-learner. Just clone it, and you can run the tests, or use the learn command to infer XML schemas from XML data.

He includes an example XML definition and the resulting DTD that the tool generates from it, defining each of the elements and attributes each can have. The tool can then take this DTD file and generate an XSD file, creating complex and simple types that match the original data.

In a new post to the SearchCo.de blog Ben Boyter generated a listing of the most commonly used PHP functions/structures based on the contents of several of the major PHP projects from around the web.

One thing that I considered some time ago was working out which are the most common functions in a language and adding this as an additional signal to ranking. I couldn't find anywhere else on the web with this question answered so I took my own approch. The method was to take a collection of large PHP projects, including, Wordpress, Mambo, Sphider, Smarty, Drupal, CodeIgniter, dump all their source code into a single file stripped of comments, and then run some simple regex over this file counting the occurance of each function.

His results show the top five as: array, isset, define, empty and assert. The last five ended up being: filemtime, sha1, array_unshift, get_current_user and strchr.

Lorna Mitchell has a tip for those using the Google Charts API to plot the data from their applications - a simple way to add multiple axis labels to the chart's output.

The axes in Google Charts are a bit interesting, because what they display bears absolutely no resemblance to what data is there - you label the axes separately, even if they are numbers. To label multiple things - in this example a scale and some units, you simply specify the axis more than once.

In her example it creates a bar graph that puts the values for "chxr" and "chxl" on the axis. The Google Charts API can be used to generate other sorts of dynamic graphs too including the traditional pie, line or scatter charts. It can also create things like QR codes and formula images, all on the fly.

On his blog today Sameer Borate has a new post looking at using Doctrine DBAL to make schemas rather than having to make them by hand each time (can be very useful for reloads with fixtures).

A tedious task during web development is that of database schema creation. A schema containing a few tables comprising of a small set of rows is quick, while that containing dozens of tables and large numbers of columns is a tedious process. I usually resort to a small php script with some regular expression tossed in to automatically create a schema from a text file definition. But that is a little buggy as I've to manually add the indexes and other small things. Now that Doctrine has released a DBAL library, this will provide a nice ability to automatically create sql schemas.

He introduces the DBAL abstraction layer and includes a basic script to create a schema for a MySQL database, manually adding the columns and setting up things like primary keys and foreign key constraints. He also includes the SQL statements that it will generate and execute on your Doctrine-based connection.

On the php|architect blog today there's a new post about a tool that helps you create Word documents directly from your PHP application - PHPDOCX.

PHPDOCX is a PHP library that allows its client code to generate Microsoft Word documents in the .docx format from PHP scripts. PHP is increasingly being used for disparate goals and has to deal with data that comes from strange sources and has to be produced in stranger formats. [...] Starting with the 1.5 version, which has been released on July 12th, PHPDOCX is now compatible with PHP 5.3. The adoption of PHP 5.3 from operating systems is growing and it will at last replace the previous versions of PHP also in the servers of hosting providers.

He mentions some of the features it includes (like the library and automatic insertion of things like headers and footers) as well as two requirements for the tool to work - the zip and xsl extensions.