The current version fixes a number of issues and makes various improvements. The API didn’t change much, although we did a few additions:

• Caching module, with an APC driver (memcached planned at a later time)
• Improved encoding support, adding encoding settings in database and output drivers
• CGI support
• Full SQL Server and Oracle support, including DBMeta drivers
• Forms externals (see below)
• Full LDAP support, including an LDAP authentication driver
• Much improved API browser (see below)

Forms externals:

Forms externals are a mechanism allowing a developer to build part of a form dynamically. Currently it allows a developer to retrieve options for selectable widgets directly from the model domain just by specifying a function or method to call. For example you could retrieve a list of users from a users set using <external type="set" source="myUsersSet::fetchFormOptions"/>. This method would return value/label pairs to be used as option items. It can also be used for hierarchical data types, where the hierarchy is represented by a multi-level array.

API browser:

The new API browser is based on the jQuery Finder plugin. There is still some quirks here and there, and we also intend to add additional functionality with subsequent releases (like a search function, allowing you to find the deprecated API, or all the interfaces, for example), but the main functionality is there and the result is already better than the original. Feel free to comment on it and suggest how we could improve it.

New server:

Two weeks ago we moved to a new and much bigger server. Now that we have enough flexibility we intend to put various services, including daily test reports from various sources (anyone will be able to setup a daily test that will be aggregated and displayed on our server). We’ll also start a few projects that will demonstrate how to use the framework. More information on that later.

Next release:

Our work will continue in the next release. It will include plugins, since after some discussion we now have a better idea of how we want to implement that. It will also include various improvements, most of them detailed in the roadmap.

Thanks for your interest and see you soon!

Today we released the next version of the Web:Extend framework, 0.4 beta.

This release introduces many many things. We improved the rendering pipeline; added an LDAP module (this is still a work in progress); improved the HTTP classes (cookies, sessions, file uploads); added QUnit, jQuery’s unit testing framework, to test these HTTP classes; and last but not least, added the UI module.

The UI module is our answer to RAD development. It works side by side with the model scaffolding classes to allow you to quickly design an application. It contains useful components like CRUD and pagination, that you only have to configure and render in your templates.

You can download the source code at sourceforge. It is licensed under the LGPL.

If you have some time to spend, head over to the documentation and leave us a comment, as we will use your input to improve the framework.

Next month we will release the Cache module along with a Plugins system, among other things. You might want to come back here in a week to discuss the RFC about these two additions.

Thanks for your interest.

The project is expected to stay in beta stage for at least a few months. At this time it is not stable enough for production, but it is stable enough to begin to learn about it and even to use it in small personal projects you might have. Most of the changes planned for the next releases do not change the API, with the exception of one or two function name changes. And although it’s a beta release, about 75% of the code is estimated to be covered by unit tests – and this will only improve with each new beta releases.

The documentation is becoming pretty good. A few chapters are still missing but they will be written shortly. All the essential chapters are available so learning the basics shouldn’t be a problem. A tutorial is even available (more will follow). You can also use the API viewer for fast lookup of classes or functions; once it’s loaded it runs locally.

This release introduces a few important features.

• the Forms Module now uses XSLT to efficiently transform XML-based form files into (X)HTML
• DbMeta allows you to query a database about its structure (get table list, columns, keys…)
• the Application Module implements the MVC pattern with a passive view
• the Model Module supports database scaffolding

This last item is pretty exciting, especially if you pair it with the upcoming UI Module, planned for the next release, 0.4 beta. It is scheduled to be released in about a month. We follow a 5-weeks per release cycle.

You can download the source code at sourceforge. It is licensed under the LGPL.

If you wish to help us, there is a lot you can do. The most important thing is to proof-read the documentation or the API and to forward us any problem you might have with it. Typos, invalid code, comprehension problems or anything else. You can also discuss the various RFC or try to learn how to use the framework and report bugs you may find. At a later time you will also be able to translate it in your language.

Please leave us any comment you might find relevant, as we will use your input to improve the framework.

Thanks for your interest.

The Problem

It is written deep in the PHP documentation that objects that implement the interface ArrayAccess do not work with the array_* functions. None of them. Not even array_key_exists. You would usually use this function to check if a key exists in the array, even if the associated value is null. But you can’t. Some people wrote bug reports to the PHP team about it. They were marked as bogus.

Of course, no error or warning is triggered when you use it with this function. It would be too easy. And this can leads to mistake, like the bug we found in our code.

So what can we use if array_key_exists doesn’t work?

The Solution

Instead of array_key_exists we can use the isset function. isset, used on an ArrayAccess object, will call its method offsetExists. This method returns a boolean: whether the offset exists or not.

If we implement offsetExists this way, we can use isset to check if an array has a key, including the ones associated with null values:

// $this->aRow is a real array stored as a protected property of the object

public function offsetExists($offset)
{
	return array_key_exists($offset, $this->aRow);
}

Using isset on an ArrayAccess object that implements this function will give the same result as using array_key_exists directly on the object. Example:

$o = new myArrayAccessClass;
$a = array();

// isset, used on an ArrayAccess object...
echo (int)isset($o['key']);
// ... is the same as array_key_exists used on a real array
echo (int)array_key_exists('key', $a);

We also added an unit test about this in our framework. Never knows, maybe array_key_exists is going to accept ArrayAccess objects in the future.

The Ugly

Well, I’m sure you can begin to see the ugly in this: isset giving the same results as array_key_exists on ArrayAccess objects, but different results on real arrays. That means needing to pay more attention to what you actually use these functions on.

Another ugly result is that you will need to do 2 tests when you accept both arrays and objects. If you received an array you’ll have to use array_key_exists, otherwise isset. This results in the following conditional statement:

if ((is_array($m) && array_key_exists($sKey, $m)) || (!is_array($m) && isset($m[$sKey])))
	; // insert code here...

Take care about these issues next time you use ArrayAccess!

Thanks for reading.

The Problem

SimpleXML uses some little hacks to do its tricks. It overloads the -> and [] operators. What that means is that if you extend SimpleXML and create a property in the child class, you will never be able to access this property, because SimpleXML will return a child node and ignore your property. You cannot either use the ArrayAccess interface to store your properties since SimpleXML already overload the [] operator to allow you to access the node’s attributes.

Why would you extend SimpleXML if you can’t set any property? Well you can of course add a few methods, to add missing functionality for example. But that’s about it. No properties. If you need to associate a SimpleXML node with a variable you must either create a child node, or create an attribute. Problem is, it won’t work with objects, arrays or resources.

Someone already tried to do it. Sorry Oliver Brown, but I don’t like your solution. I shall thank you however, since you allowed me to find a better way to do it. I’m sorry about not telling the world sooner about all this.

The Solution

The solution is currently available in the LGPL licensed Web:Extend framework, in the form of the weeSimpleXMLHack class. Although LGPL licensed, I (the original author) allow you to copy and paste this specific class in your project whatever the license is. In return, please just refer to this post in your code.

For your convenience I will paste the code below.

/**
	Extends SimpleXMLIterator to allow the setting and getting of properties.
	Properties must be accessed using the function property since -> is already used by SimpleXMLIterator
	(and its parent class SimpleXMLElement).
*/

class weeSimpleXMLHack extends SimpleXMLIterator
{
	/**
		Return the uniqid string for this object.

		@return The uniqid string.
	*/

	protected function hack()
	{
		if (empty($this['weeuniqidhack']))
			$this['weeuniqidhack'] = uniqid();
		return (string)$this['weeuniqidhack'];
	}

	/**
		Set or get a property of a SimpleXMLIterator object.

		@param	$sName	The name of the property.
		@param	$mParam The variable to attach to this element. If null it is not attached.
		@return	mixed	The variable attached with the specified name.
	*/

	public function property($sName, $mParam = null)
	{
		static $aProperties = null;

		if (!is_null($mParam))
			$aProperties[$this->hack()][$sName] = $mParam;

		if (!array_key_exists($sName, $aProperties[$this->hack()]))
			throw new IllegalStateException("The property doesn't exist.");

		return $aProperties[$this->hack()][$sName];
	}
}

If you compare this code and the original code from the framework you will notice a few differences. I’ve edited it a bit to make it more readable for people that do not know how the fire function works.

So how does it work? Well as you know you can create a method. In this method you can create a static variable that will be accessible only by the code in the method. Make this variable an array of properties. By making the method usable both as a getter and a setter you can set and get properties from this static array.

But that’s not enough. As you might already know, a static variable declared in a method will keep the same value for all the objects of the class. That is, if object #1 sets a static variable value to 1, then object #2 sets it to 2, it will have a value of 2 when object #1 tries to access it again. We do not want that since we want to be able to associate objects and more to our SimpleXML objects.

That’s where uniqid comes. uniqid creates a completely unique identifier. Great! We can now assign an unique identifier to each of our SimpleXML objects, and use that identifier to retrieve the properties of that object. We only call uniqid once and store it as a reserved attribute named weeuniqidhack. When the property method is called we can just get that identifier and do a get or a set on our static array without fearing conflicts with other SimpleXML objects properties.

You can now use this class by calling simplexml_load_string or simplexml_load_file and giving the class name, 'weeSimpleXMLHack', as the second parameter:

$oNode = simplexml_load_file('/path/to/my/file.xml', 'weeSimpleXMLHack');

This hack was used for more than a year in the Web:Extend framework and worked since the early releases of PHP5, so you can use it without any fear. The only drawback is that an attribute must be sacrificed to store the unique identifier.

I have other tips to share but they will be for another day. You might find some by browsing the framework’s code.

Thanks for reading.