On WebSpeaks.in today there's a recent post that introduces you to something more and more applications are using - especially frameworks - method chaining in PHP OOP apps.

In this article we will learn an advanced OOPS programming concept in PHP known as Method chaining. If you have worked on PHP frameworks like Zend, Magento or CakePHP, you might have noticed a very convinient style of accessing methods of different classes. [...] This type of programming technique is known as method chaining. If you are thinking how is it possible to perform this chaining, then don't worry. Today we will learn this fancy concept.

They create a simple class, a Person, and show the difference between calling several methods on the created object versus a method chained example that calls all three, making updates to the object itself ($this). There's also a bit more complicated example with three different classes in the mix.

If you were a fan of the PHP quizes that Mark van der Velden has posted in the past, you'll be happy to know he's come back with part four of the series after a bit of a hiatus.

It has been a while, but here is part 4 of the PHP Quiz series! A few questions to crack your brain about, or perhaps you know them all? Try them and find out! Also do read the idea behind these quizzes, here: The PHP Quiz series

In this quiz he tests your knowledge of class visibility, fluent method handling, class extension, strptime and a tricky "for" loop. Take the quiz and see how you do.

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.

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.