Henrik continues his look at fluent arrays and strings in PHP with this second part of his series, adding JSON functionality into the mix.

Recently I've had the need to extend the interface further, among other things with JSON support. I've used code published by Nicolas Crovatti to do this.

His example shows how the script works to plot out some points for a table of stats. He follows this with an in-depth look at the different methods making up that fluent call (apply2Field, fill_ret, sum and plot). These make the array that can then be passed off to PHP, using json_encode to make an easy-consumable JSON message out of the results.

On the ProDevTips blog, Henrik has written up an extensive tutorial with plenty of code examples on working with something inspired by a few other languages - fluent arrays and strings.

I've been working some with jQuery and Ruby lately, as you might know they both have very neat fluent interfaces for writing short and easily understandable code. Especially Ruby's array and string handling should be something that can be done in PHP so I started googling. [...] It's probably very possible that what I'm looking for is already part of some PHP framework or such but I didn't want to spend more time looking than being productive.

Based on some Ruby examples, he defines a set of functions that can be use to create these fluent interfaces to the common PHP variable types (contained in a class for easy use). The entire source can be downloded here.

The Zend Developer Zone has another new tutorial from Padraic Brady talking about testing your applications (i.e. unit tests). In this new article, he expands on his previous one and dives a bit deeper into the behaviour-driven development process.

In this article, I introduce a TDD related practice called Behaviour-Driven Development which has been gathering attention for over a year and gaining converts (like me!).

He briefly covers what BDD is and how it can be used to solidify code against issues that might come up down the road (and how it compares to test-driven development). Some sample code/tests are included to give you a better idea of how it all fits together - a set of scenarios for any given "story". True to the title, Padraic writes his tests around the construction of a Klingon Bird of Prey ship.

In response to Travis Swicegood's post about fluent APIs, Alex Netkachov has added some of his own examples to the topic from the Zend Framework and the popular Javascript library, jQuery.

In his recent post Travis Swicegood is talking about the "Fluent API". This kind of API is very popular in scripting languages and I use it during my work with Zend Framework or jQuery projects. Another good example of such technique is Document Object Model API.

His examples show the method chaining that's the hallmark of fluent interfaces. Unfortunately, there's no good way to just make an object and call a fluent interface on it in PHP, so Alex suggests a simple little wrapper (that just returns the object) to make it easier.

Paul Jones gives readers a quick overview of two of the components in the Solar framework in a new post to his blog today - the Solar_Http_Request class and it's opposite, the Solar_Http_Response class.

As I noted in an earlier post, Solar how has classes to represent simple HTTP requests and responses.

The Solar_Http_Request functionality is only for making requests, but uses adapters to make it easier to swap out the connection method later on - plus it's fluent. He includes an example of it in action, calling a remote page with a GET, POST and a customized request (including special headers)

The other side of the equation, Solar_Http_Response allows you to set all of the response information manually (again, fluently) to make custom responses simple.

The Zend Developer Zone has posted a new article from editor of the dZone, Cal Evans, looking at using fluent interfaces in PHP.

Fluent Interfaces are not a new programming construct. However, PHP developers have not been able to use them until PHP 5. Now with PHP 5 and the ability to directly dereference an object, PHP developers can build objects using fluent interfaces.

He starts off with a look at what they are and how (and why) they can be used in an application. He includes code example to help show how you would create an interface (makeNormal).

The code and other information are pulled from a few sources:

• this article by Mike Naberezny
• a post from Paul Jones
• a blog post from Martin Fowler

Cal also mentions what he got into the fluent interfaces game for - creating a tag cloud with a fluent interface over the normal arguments/properties method.

In his latest post, Davey Shafik talks about a web service client that he's been working up for the Zend Framework, specifically dealing with the consuming and creation of REST services.

I am currently working on a ton of Web Services related things for the Zend Framework, one of my favorite, is the almost complete, Zend_Rest_Client. This is a replacement for Zend_Rest (as we're adding a server also).

Whilst it is almost impossible to emulate the PHP 5 SOAP extension, it is still possible to get a nice interface.

He gives some examples of its usage:

• creating a client with three lines of code
• showing off the "fluent API" of the component to make a REST request
• and a call normally, seperating the methods out into seperate lines

He also mentions that there's still a bit of work to be done, including returning the Zend_Rest_Server array responses back into normal PHP arrays.

On his blog today, Jonnay has posted information about a new library he's built up called "BunnyRegex", a way to make easy regular expressions and mini-languages inside of PHP.

Regular expressions are hard. They are hard to create, and even harder to read after the fact. Regular expressions, while quite powerful, are a blight upon readable code. There is no easy way to know that '/^d{4}/d{2}/d{2}$/' is a search for a string in the form of 'xxxx/xx/xx'. You have to know that ^ is the start of a line, d is a digit, / is / escaped, etc.

Granted, once you know regular expressions, that information is portable across which ever language you use, be it PHP, Perl, Javascript, whatever. But getting to that point is not easy, and even after you are there, the fact remains:Regular expressions are not human parseable. This is where BunnyRegex comes in.

He includes examples of the usage of the library (not as concise as a regex, but easier to read) and how you can also use it to create "fluent regular expressions". The library even allows you to do most of the normal things you would with a standard regex engine - match, grep, replace, and splitting data.

A little while back, the topic of "fluent interfaces" came up on several different blogs. Continuing that train of thought, Sebastian Bergmann has posted this new item over on his blog that highlights some of the "fluent interface" structures that PHPUnit 3.0 will allow.

One topic that has made a few appearances (#1, #2, #3) in PHP-related blogs lately is that of Fluent Interfaces. A good example of a fluent interface is the API of jMock.

PHPUnit 3.0 provides the same fluent interface for configuring its Mock Objects (because PHPUnit's implementation of Mock Objects is a port of jMock).

He shows a code exmaple of how to get it all working, showing how to create a chain of methods that leads to more readable, "fluent" code...

On his blog today, Tobias Schlitt has his look at fluent interfaces, and it's place in the eZ components libraries.

The new buzz term "fluent interface" has been mentioned a lot in the PHP world recently, so I will not again explain, what a "fluent interface" is. Andi already mentioned, that this way of desining an API is quite good and can give you a really handy interface, but he also points out, that one should make very careful use of the technique.

Also I did not know the term "fluent interface" before, we realized, that we already used this in the eZ components, to be more exact, in our Database package, which gives you a quite good ammount of SQL abstraction.

He gives a brief example from their code, and explains how it works. The statement selects from a table "Person" where the age is greater than 15 and orders it by the "full_name" field, limit of 10 rows returned. With the "fluent interface" concept, that's pretty much how the statement "reads" as well...