Stubblog

Stubbles 0.8.0 released

nospam@example.com (Frank Kleine) — Sun, 29 Jun 2008 13:30:59 +0200

Stubbles 0.8.0 arrived today and brings a bunch of improvements to the existing functionality, most notably for the XML/XSL view engine: bug fixes, enhanced xsl templates, new multi-project structure, support for a common path for styles, images and Javascript used in several projects as well as the stage assistant which displays useful information when in dev or stage mode. Another important point is a reworked package structure, and the release of several star files as an alternative of having one big file. See ticket #139 for more details.

Furthermore we implemented an LDAP access API (no writes yet - we did not need them ) and a processor that allows an easy creation of RSS feeds within a project. For a comple list see the changelog.

With this release we raise the level from alpha to beta. All of our originally desired features are implemented and nearly all already proved their use in our applications. However we can not recommend a production use at the moment as the XML/XSL view engine still has to prove itself in our applications, and a lot of documentation is still missing, incomplete or outdated due to changes. This is what we will work on before the next major/minor release.

Grab the release from our downloads page.

JSON-RPC Proxy Generation with PHP

nospam@example.com (Stephan Schmidt) — Tue, 27 May 2008 22:31:11 +0200

Today I gave a talk about JSON-RPC Proxy Generation with PHP at the Dynamic Languages World Europe 2008 in Karlsruhe Germany. The presentation covers an introduction to the Proxy and Remote Proxy Design Patterns, JSON in JavaScript and PHP as well as the JSON-RPC protocol specification. Furthermore, the slides also cover the SMD specifications and show how to generate SMD with PHP.

Although Stubbles provides a ready-to-use processor for JSON-RPC and generating JavaScript proxy classes, the presentation takes you through all necessary steps that are needed to implement this on your own.

You can either view the presentation on slideshare.net, or get the PDF in our download area. If you decide to use our implementation, you can find more information in the Stubbles manual.

Stubbles 0.7.0 released

nospam@example.com (Frank Kleine) — Sun, 06 Apr 2008 19:31:33 +0200

A few moments ago I released version 0.7.0 of Stubbles. While still being an alpha version, this is most likely the last alpha version before we are going beta. The release was mainly targeted on improving the XML/XSL view engine, and we made quite some steps: we do not need any post interceptor any more when using the XML processor, the complete skin can now be cached as well as that the website cache can be applied onto the generated result. Other noteworthy points are an improved performance of the XML serializer when it comes to an large array of objects of the same instance as well as the replacement of the session resource manager by a new scope within the inversion of control package. Additionally the net::stubbles::util::net package was renamed to net::stubbles::peer as it has not that much to do with utilities itself and there are some plans for more subpackages.

For all changes see the changelog, and download the release from our download page.

Searching for a new job?

nospam@example.com (Frank Kleine) — Tue, 11 Mar 2008 16:56:59 +0100

Ìn case you are interested in a new job and speak german: Read on after the break.
Continue reading "Searching for a new job?"

Stubbles 0.6.0 released

nospam@example.com (Frank Kleine) — Wed, 27 Feb 2008 15:48:49 +0100

This morning I released version 0.6.0 of Stubbles. Main improvement is a new filter API that allows better and simpler creation of filters to retrieve values from the request - and in most usage scenarios one does not have to care about request value error factories any more. See creating filters on how to use the new API.

An important point for those who use the JSON-RPC processor: configuration of services via config/xml/json-rpc-service.xml is no longer supported, you need to migrate to config/json-rpc-service.ini, where the key marks the javascript classname and the value the full qualified classname of the class that contains the web methods.

Another point to note is that Stubbles no longer supports dots as package separator. We switched to Paamayim Nekudotayim already with release 0.5.0 but kept support until now to ease adoption. With this change we should have it simpler migrating to namespaces and PHP 5.3 once it is available.

As always, for a complete list of changes see our changelog.

Traits for PHP

nospam@example.com (Frank Kleine) — Mon, 18 Feb 2008 22:04:37 +0100

Just stumbled over a proposal for traits in PHP, proposed by Stefan Marr. Being a bit sceptical at first I came to the conclusion that this would be a really useful feature - and save us a bunch of doubled code in Stubbles. After reading the RFC until the end I noticed that I saw a similar concept some weeks before in Java: Qi4J tries to achieve the same, but requires very much code to get this done. As a language construct within PHP it would be very easy to do the same, but easier to learn and to use. Beside some keyword issues (the RFC uses "use" as keyword, but this will of course conflict with namespaces) I'm wondering what this will have an impact on reflection - the RFC stays unclear about this. What do I get when reflecting a method from a trait, or a method in a class that originally comes out of a trait?

However I'm not very confident that this feature will make its way into PHP - maybe I've read to much internals...

Stubbles 0.5.0 released

nospam@example.com (Frank Kleine) — Thu, 31 Jan 2008 22:47:20 +0100

A last day of a month - time to release a new Stubbles version. The release does not feature that much new features, we focused mainly on infrastructure and code quality improvements. The most important change of course is the change of the package separator. Instead of dots we now use Paamayim Nekudotayim, the double colon, which will be the package separator in PHP5.3 with namespaces. The change will ease our transformation towards namespaces. The dot is still supported, but this support will be removed in 0.6.0.

Code quality improvements come from using CodeSniffer for checking adherence to our coding guidelines which allowed us to reduce violences to zero in the main code. The unit tests are currently not checked, but we will take care of this in the future.
Another improvement is the switch from SimpleTest to PHPUnit as underlying unit test framework for our unit and integration tests. This allows us to get a code coverage for our tests (which is btw. more than 75%) as well as to calculate some metrics about code quality. It should be clearly stated that SimpleTest is neither a bad unit test framework nor that it would not be suited for a project like this. It has its advantages, but due to various reasons we need the figures about the code and it is currently not foreseeable when something like this will be available in SimpleTest.

For a complete list of changes see the changelog.

Do not trust the reflection API

nospam@example.com (Frank Kleine) — Sat, 26 Jan 2008 13:28:57 +0100

At least if it comes to internal classes. If you try to get informations about parameters from methods of internal classes - forget that. Examining several internal classes my key findings are: either there is no information about parameters available and the reflection API says the method does not have any parameters, or the information about the parameter is wrong. Some examples I retrieved with the following script:

Continue reading "Do not trust the reflection API"

vfsStream 0.3.0 and good bye SimpleTest

nospam@example.com (Frank Kleine) — Wed, 02 Jan 2008 23:46:00 +0100

Against my intent of starting to work on file modes for 0.3.0 I decided that it is time to get an own repository for vfsStream in order to maintain it independently from Stubbles, which was the perfect reason to open a new project on Google Code. I will see if this proves to be a good solution for day to day development.

The movement also marked the reason to try PHPUnit because I wanted to make use of its code coverage and its software metrics features. Especially the last one showed me a bunch of points that required refactoring before starting something big like supporting file modes. During refactoring some improvements made it into the code which justified a new release: vfsStream now supports rmdir(), and I made some API changes. I dropped vfsStreamDirectory::ceate() in favor of vfsStream::newDirectory() to be equivalent to vfsStream::newFile(). Additionally there is a new vfsStreamContent::at() method now, which allows to write code like this:


$parentDir = vfsStream::newDirectory('newdir')->at(vfsStreamWrapper::getRoot());
$file = vfsStream::newFile('file.txt')->withContent('foo')
                                      ->lastModified(time() - 86400)
                                      ->at($parentDir);

So far I'm very satisfied with the software analysis features of PHPUnit that I'm thinking very hard about saying good bye to SimpleTest in my other projects. Given the current state of SimpleTest's development I do not expect to get similar features in SimpleTest any time soon, and unfortunately I do not have the time to contribute to SimpleTest even if it would be a lot of fun I guess.

Stubbles 0.4.0 released

nospam@example.com (Frank Kleine) — Wed, 02 Jan 2008 22:32:00 +0100

Some minutes ago I released version 0.4.0 of Stubbles, still being an alpha version. The changelog lists more than half a dozen bc-breaks, where some of them where necessary to fix bugs, some to have better code and others to improve how the code should be used. While there have been only some small feature additions like the net::stubbles::php::string string en-/decoder classes and a SOAP API the main focus of the release was on stability, performance of the Memphis view engine and small feature improvements to ease the use. For a complete list of changes see the changelog and the list of closed tickets for this milestone.

As a side note, I think we have put way too much stuff into this release. We should have done more smaller releases instead. We will try to improve this in the next release cycle.

vfsStream 0.2.0 released

nospam@example.com (Frank Kleine) — Sat, 29 Dec 2007 14:33:58 +0100

Having done more work on vfsStream I felt it is time to do the next release before starting to work on the next big issue™. The new 0.2.0 release focuses on API improvements as well as support for differentiating between directories and files. API improvements are a new vfsStream::url() method to assist in creating correct vfsStream urls. Up until now you had to write something like
$url = vfsStreamWrapper::PROTOCOL . '://path/to/file.txt';
which is kind of ugly and unhandy to type. Now you can do
$url = vfsStream::url('path/to/file.txt'); which should be easier and less to type.
Another API improvement is the new vfsStream::newFile() method to be able to do
$file = vfsStream::newFile("foo.txt")->withContent("bar");
Following an advice by David Zülke I changed vfsStreamWrapper::register() to reset the directory root to null.

Additionally vfsStream now supports is_dir(), is_file() and is_readable(). However there is still a small drawback to is_readable(), as long as file mode is not supported existing pathes will lead to true, and non-existing pathes to false. Currently all files and directories always have 0777 as file mode. As I require support for file modes now this will be part of the 0.3.0 release.

Another thing I found during the last days is that realpath() seems only to work with real files, but not with any other URL types. That's a bit sad because it means one can not use this function if one wants to test its file operations with vfsStream.

vfsStream 0.1.0 released

nospam@example.com (Frank Kleine) — Fri, 14 Dec 2007 00:31:31 +0100

Some minutes ago I released the first version of vfsStream. vfsStream is a stream wrapper for a virtual file system that may be helpful in unit tests to mock the real file system. It can be used with any unit test framework, like PHPUnit or SimpleTest.

The first idea for this came up when I prepared my talk about stream wrappers for the PHP conference in Frankfurt-Mörfelden earlier this year (slides still available). Everybody knows that you should not use real databases in unit tests, so why should one use the real file system? Of course you can create an IO abstraction layer, but PHP offers such easy access to file contents via its file_get_content() and file_put_content() functions as well as with its other file system functions that it would be a bit overdone to create such a layer just for testing purposes. Additionally there are stream wrappers which allow you to create your own protocol and use it with exactly this file functions.

This was the point where I started thinking about it, so hacked together a first version as a prove-of-concept. Because it worked like a charm I started to use it in my own unit tests, which already saved me some time and problems. Today I decided it is time to release this as open source to the public to see if other people like the idea and have a use for it, therefore I did some refactorings, and did a first release. Unfortunately not everything works by now: It is currently not possible to rename a file or directory, and it is not possible to remove directories. Additionally file modes are completely ignored. The main reason for this is that I did not need one of this features until now. Feel free to send patches, wait until I have a need for it or beg me to implement them.

Tricky namespaces? No.

nospam@example.com (Frank Kleine) — Wed, 12 Dec 2007 09:38:36 +0100

So I put down this namespace examples together last night. But, what's happening in the examples regarding to resolution rules? (I won't post the code here again, have a look at the last entry for the example code.)

Version 1 and 2 two are the same, the place where we include other code does not influence naming rules in the current file. Why do we get instances of PHP's internal DateTime class instead of the one from Name::Space? Well, two things have to be considered:
1. We are in the global space, PHP will only look for DateTime in the global space.
2. The use-Statement declares that we want to create a shortcut to Name::Space, not to Name::Space::DateTime. If we wanted to use the class from Name::Space we would need to write $d = new Space::DateTime, which is version 3.
(We can not do a use Name::Space::DateTime here, this results in a fatal error. However, we could do use Name::Space::DateTime as DT and then write $d = new DT(), this will give instances of Name::Space::DateTime.)

With version 4 we have put our example code into its own namespace, but the result is still the same as in version 1 and 2. What's happening?
1. We are in namespace foo, and in namespace foo no class DateTime exists.
2. Our shortcut use Name::Space still does not refer to Name::Space::DateTime, to create instances from this class we still need to write $d = new Space::DateTime as in version 5. This means the class does not apply either in version 4.
3. As no further use declarations exist, PHP falls back to its internal DateTime class. (If this class would not exist, a call to the registered autoload function would be issued.)

Finally, version 6 gives the result we originally intended: The class Name::Space::DateTime is used instead of PHP's internal class. This is because we stated in the use declaration that we want to use Name::Space::DateTime as DateTime.

However, in the original posting of David Zülke in php internals he feared that the two instances of $d might be from different classes. Well, this might really happen under some circumstances. More after the break...
Continue reading "Tricky namespaces? No."

Tricky namespaces

nospam@example.com (Frank Kleine) — Wed, 12 Dec 2007 01:23:11 +0100

Today on php-internals David Zülke posted an interesting example with namespaces which made me think about the result of the small example. Well, my first guess was not right as my experiments showed. Therefore I tried different versions of the example to see the impact of namespace and use declarations. But first, the example:


Name/Space/DateTime.php
  namespace Name::Space;

  class DateTime {}

Name/Space/Ship.php
  namespace Name::Space;

  class Ship {
    public static function __autoload($className) {
      echo "loading $className\n";
      // ... autoloader, can load Name::Space::DateTime
    }
  }

somestuff.php
  function someStuffWeDoNotHaveControlOver() {
    $foo = new Name::Space::DateTime();
    var_dump($foo);
    // ...
  }

setup.php
  require_once('Name/Space/Ship.php');
  spl_autoload_register(array('Name::Space::Ship', '__autoload'));

Version 1, the original from David's posting:


require_once('setup.php');
use Name::Space;
$d = new DateTime();
var_dump($d);
require_once('somestuff.php'); // assumed to be here, was missing in the given example
someStuffWeDoNotHaveControlOver();
$d = new DateTime();
var_dump($d);

Result:



object(DateTime)#1 (0) {

}

loading Name::Space::DateTime

object(Name::Space::DateTime)#2 (0) {

}

object(DateTime)#2 (0) {

}

More after the break...
Continue reading "Tricky namespaces"

Gathering practical experience with namespaces

nospam@example.com (Frank Kleine) — Sun, 11 Nov 2007 17:09:00 +0100

Being a little bit bored today I started to port XJConf to PHP 5.3 using namespaces. Oh boy. You should never even think about porting your application completely to namespaces if you do not have enough unit tests! Consider something like this:


if (get_class($instance) == $someClassName) {
   // do this
}

It is most likely that $someClassName does contain the name of the class only without the namespace prefix. As get_class() now returns the full qualified class name this comparison will fail - you need to make sure that $someClassName contains the full qualified class name. I'm sure there is a lot of code out there like this or similar.

Another point is that you should not import classes from the same namespace, I had a situation where this lead to a fatal error because of loading the same class twice, however I was not able to create a reproducable test case after I solved the problem.

As I said I would not recommend the transition without unit tests, but you have to adjust them as well. For XJConf I just had to change two things (I'm using SimpleTest):

1. expectException() requires the full qualified class name of the expected exception now

2. creating mock objects: Mock::generate('Tag'); needs to be changed to Mock::generate('net::xjconf::Tag', 'MockTag'); to enable SimpleTest finding the correct class (full qualified class name), additionally you need to state a class name for the mock class to be created, else SimpleTest will fail to create the mock class because it would produce something like Mocknet::xjconf::Tag which of course results in a parse error.

Finally __autoload() makes really fun now. It receives the full qualified class name as argument, it is a simple task to change this into the correct path to the class file. If you do not use it until now due to the quirks required when not using class names like My_Application_Has_Really_Really_Long_Class_Names you should really consider using it after migrating your application to namespaces.