Alex Bilbie has passed along a link to a project he's been working on to try to simplify access to MongoDB databases from PHP - his MongoQB library:

A few years ago I released a MongoDB library for the CodeIgniter PHP framework which has become quite popular thanks to it's likeness to CodeIgniter's query builder library. I've just spent the last week travelling and to keep myself occupied I spent some time re-architecting the library's code; removing the framework dependancy, making it Composer friendly and adding a full suite of unit tests. Check out the code on Github - https://github.com/alexbilbie/MongoQB.

The library makes it simpler to do most of the usual CRUD (Create, Read, Update, Delete) operations with your Mongo data. Example code is included in the post. This is a nice lightweight alternative to things like the Doctrine query builder.

Giorgio Sironi has a new post to his blog about a "refactoring" he's done of PHPUnit's mock objects to make their creation with getMock easier.

Not an actual refactoring, but at least the introduction of a layer of indirection, a Parameter object, called PHPUnit_Framework_MockSpecification. I have already written the patch in a branch of my github repository. They are actually two independent patches, since PHPUnit core and the mocking component are in two separate repositories.

If you create a basic object, the creation is simple, but when you start wanting to use one of the other optional parameters down the line, things can get messy. His solution adds methods like disableOriginalConstructor and disableAutoload to make this simpler. You can find the patches on his github account.

UPDATE: This feature has been included in the latest PHPUnit master branch.

Starting off a new series on his blog Giorgio Sironi has posted two new tutorials looking at PHP design patterns - specifically the Abstract Factory and Builder patterns.

[This series will] touch the majority of the known design patterns, with a special look at their application in a php context. A running code sample will be provided for each part of this series, along with the theory and the terminology of each pattern.

In the Abstract Factory (or just Factory) post he includes a diagram of the pattern's relationship with other "participants" and has a Zend Framework-based code sample to create a simple WidgetHelper. In the second article he looks at the Builder pattern and how it can make creating instances of complex objects a bit easier. As before a diagram and code are included.

You can keep up with the rest of the posts in the series as they're added by following along here.

PHPBuilder.com has posted the second part of their series on creating a sample application - a time tracking app - with PHP and Adobe Air.

Welcome back. In part 1 of this series, you created some PHP remote services and the Clocked! widget application. Part 2 covers PHP administration and completion of the timer widget.

They're developing a Flex-based application (rather than the HTML/Javascript combo that can also be used with Air) so they'll be doing their work in Flex Builder. They set up a few placeholder functions like getClients, getProjects and getProjectsResult as well as support for the ticket and timer objects. Add in a few interface items like dropdowns for client and project selection and a start/stop button and you have the basic app laid out. The PHP interface to all of this Flex code comes in the next article of the series.

If your code is getting more and more complex all the time and you find yourself creating a similar group of objects over and over, you might check out Jani Hartikainen's latest advice and create a "builder" around them.

Sometimes if you have a complex class, which needs to be set up in a specific way: Perhaps it takes a lot of constructor arguments, or often requires calling some setters. [...] Sometimes if you have a complex class, which needs to be set up in a specific way: Perhaps it takes a lot of constructor arguments, or often requires calling some setters.

His example is a "message builder" wrapper that lets you specify the receiver, sender and message and inject them into a to() method call (with a fluent interface). He shows how to make sure that the object you need (the message object) is always complete.

The PHP-GTK Community website has three new posts today - two concerning pieces of PHP-GTK software and one with news about the new RPC services the website offers.

First off is a look at the emuControlCenter software (version 0.9), a rom-manager for console and computer games:

emuControlCenter (ecc) is a rom-manager for retro and new console/computer games. ecc is build for people who want's to play retro games quick 'n' easy, without searching to much, ECC supports images and previews them directy in the 'Resultview'. Also there is a 'ImageCenter' build-in for a fullsize preview!

Next up is the PHP_Gtk Builderthis site for more information.

Finally, there's some information posted about the new web service offered by the site:

Starting today, the community site exposes a new XML-RPC service offering access to its daily statistics, in addition to the existing geo_nick API.

They include the list of information pages on getting started and using the API (like the access_stats API and a tutorial on getting started with PHP-GTK and the geo_nick service).

Edin Kadribasic shares some great news on his blog this morning those using the PHP Windows builds will be happy to hear.

During my time at Emini I was using an old beat up machine to build PHP snapshots for Windows. It was only a Pentium II 400MHz and compiling a PHP snapshot on that machine took more than an hour. After leaving Emini I needed to find a new box for compiling PHP snapshots and PECL extensions for the Windows platform.

The light at the end of the tunnel came when Wez Furlong reminded him about a box OmniTI had that could handle just that. Now, what used to take over an hour to run takes around six minutes (a full compile of the latest snapshot with all of the extensions, including checkout and upload of the Win32 snapshot).

DevShed is continuing on with their look at using Builder objects (part 1, part 2) with the third and final part of the series - Developing a Form Director Class.

In this article I'll complete the builder pattern, since I'll demonstrate how to define and use a form director class, in this way putting the final strokes on the example that you learned in the previous tutorial.

The tutorial goes back over a few of the concepts and code from the previous part of the series before getting into the form generation with these handy objects. They also show the FormBuilder class (creative name, eh?) that will generate the form's elements as created previously. They wrap it all up with the only new functionality - the Builder object Director class, creating a simple contact form.

DevShed is continuing their "using builder objects in PHP5" series today with this new article, a look at implementing the builder objects in a simple, common bit of functionality - forms.

Mastering some of the most popular design patterns with PHP 5 can be sometimes an overwhelming process that requires hard work and experience. However, if you want to tackle the challenge and expand your existing background on them, this article might eventually find a place on your quick reference list.

They start by defining the basic form element class, helping to build out the different elemnts like inputs, selects, and submits. They extend and implement this class with their example, making a complete form with working elements inside.

DevShed kicks off another three-parts series today with part one of a look at working with builder objects in PHP5.

In this article, the first of a three-part series, you will be introduced to the basics of creating directors and builder objects with PHP 5. As usual, there will be copious examples to help you quickly start using the builder pattern in your own PHP projects.

Well, to put things in a simple perspective, when the builder pattern is applied, two objects are put into action to create a third one. First, these two objects create a director; as its name suggests, the director controls all aspects of the creation process and determines what pieces and modifications will be introduced into the target object. Finally, a builder is tasked with constructing the third object in question, in accordance with particular specifications. Sounds fairly simple, doesn't it?

They start with a look at starting with the Builder pattern, building a basic XML document to provide the structure for the target object. From that information, they show how to create the object and give a simple class to help direct that object along.