Within the examples you’ll find:
$observer->expects($this->once())->method('update')
->with($this->equalTo('something'));


So what if the “update” function has two arguments, pretty easy:
$observer->expects($this->once())->method('update')
->with($this->equalTo('something'), $this->equalTo('something else'));


I guess Sebastian though that that there’s no need for documentation if something is so obvious

Feel free to Flattr this post at flattr.com, if you like it.

I’m also not sure whether I choose the right name for it … O_o

Feel free to Flattr this post at flattr.com, if you like it.

Feel free to Flattr this post at flattr.com, if you like it.

As you see it’s pretty easy to have lists of objects in PHP. You might also think that always creating to some list-object over and over again is very odd and you’re right. For the most common tasks like iterating through arrays, directory-lists and a few more task you can use objects which are shipped with the Standard PHP Library ,which is also part of PHP since version 5 and mandatory in 5.3. So the example shown above could also look like this:

As I said at the beginning, there are lots of situations where you might want to have a list for something and if you store that list in PHP the Iterator-pattern can keep your code clean and tasty

Feel free to Flattr this post at flattr.com, if you like it.

Instead of typing the “if(object == null)” phrase again and again, you could use the Null-Object pattern, you’ll see that this can make some situations much clearer.

Basically Null-Object ensures that the client always receives a valid object for it’s interaction, so that there’s no need to do the check shown above again and again. This happens since your concrete Null-Object just shares the interface, or inherits from the same class as it’s effective counterpart, but it’s implementation just leaves out any effectiveness.

So a code-example could look like this:

class CookieFactory {
public function makeInstance() {
if(date(‘l’)==‘Monday’) return new NullCookie();
return new RealCookie();
}
}

interface iCookie {
function getCalories();
}

class RealCookie implements iCookie {
protected $calories=250;
public function getCalories() {
return $this->calories;
}
}

class NullCookie implements iCookie {
public function getCalories() {
return 0;
}
}

I think you can imagine what happens when you make use of the CookieFactory - diet on monday

There’re also some disadvantages, your clients normally don’t have a chance to react that there’s something special happening, also the clients must “share” the same expectation what “do nothing” means, the number of required Null-Objects might be very large and unhandy and the Null-Object shares a very deep knowledge with the real one, so that it might be a large effort to create it if the real object is complex too.

I’m so glad that today is tuesday

Feel free to Flattr this post at flattr.com, if you like it.

Before I start to show how the entire script works I’d like to show you a small example so that you can see how the __halt_compiler(); function can be used to store some data at the end of a file:

$fp = fopen(__FILE__, ‘r’);
fseek($fp, __COMPILER_HALT_OFFSET__);
$i=0;
while($buffer = fgets($fp)) {
	echo ($i++). “:”. $buffer.“
”;
};
__HALT_COMPILER();Line 1
Line 2
Line 3
Last line

The first thing you might mention is, that the closing “?>” is missing, but since the function-name is nearly self-explaining you should realize very fast what the output of the script might be

If that’s working the question is what’s needed for a script which is meant to create and extract a archive? The first thing is a way to create the archive itself. I used the PHP-builtin ZipArchive for that. The second thing is a script which is able to extract this archiv (using the method show above). That’s handled by the following snippet:

try {
    $zipfilename = md5(time()).‘archive.zip’; //remove with tempname()
    $fp_tmp = fopen($zipfilename,‘w’);
    $fp_cur = fopen(__FILE__, ‘r’);
    fseek($fp_cur, __COMPILER_HALT_OFFSET__);
    $i=0;
    while($buffer = fread($fp_cur,10240)) {
        fwrite($fp_tmp,$buffer);
    }
    fclose($fp_cur);
    fclose($fp_tmp);
    $zipfile = new ZipArchive();
    if($zipfile->open($zipfilename)===true) {
        if(!$zipfile->extractTo(‘.’)) throw new Exception(‘extraction failed…’);
    } else throw new Exception(‘reading archive failed’);
    $zipfile->close();
    unlink($zipfilename);
} catch (Exception $e) {
    printf(“Error:
%s%s>”,$e->getMessage(),$e->getTraceAsString());
};
__HALT_COMPILER();[zipdata is appended here later]

As you see that’s no rocket-science just read the data, pass it to the ZipArchive object via a temporary file and extract the archive.
If that’s working then you need a script which brings the PHP extraction script and the zip-data together. And since we want to have a single script for the creation of our self extracting php archive, it would be very odd if we’d place the “template” for the extraction in a separate file. That’s the reason why I just use the same method as above for this script and this time the data is php code instead of zip-data:

try {
    $sourcefolder = ‘compressthis/’;                 // maybe you want to get this via CLI argument …
    $targetname = ‘phparchive.php’;
    $zipfilename = md5(time()).‘archive.zip’;         // replace with tempname()

    // create a archive from the submitted folder
    $zipfile = new ZipArchive();
    $zipfile->open($zipfilename,ZipArchive::CREATE);
    addFiles2Zip($zipfile,$sourcefolder,true);
    $zipfile->close();

    // compile the selfextracting php-archive
    $fp_dest =fopen($targetname,‘w’);
    $fp_cur = fopen(__FILE__, ‘r’);
    fseek($fp_cur, __COMPILER_HALT_OFFSET__);
    $i=0;
    while($buffer = fgets($fp_cur)) {
        fwrite($fp_dest,$buffer);
    }
    fclose($fp_cur);
    $fp_zip = fopen($zipfilename,‘r’);
    while($buffer = fread($fp_zip,10240)) {
        fwrite($fp_dest,$buffer);
    }
    fclose($fp_zip);
    fclose($fp_dest);
    unlink($zipfilename);

} catch (Exception $e) {
 echo $e->getTraceAsString();
}

function
addFiles2Zip(ZipArchive $zip,$path,$removeFirstFolder=false) {
    $d = opendir($path);
    while($file = readdir($d)) {
        if ($file == “.” || $file == “..”) continue;
        $curfile=($removeFirstFolder)?substr($path.$file,strpos($path,‘/’)+1):$path.$file;
        if(is_dir($path.$file)) {
            $zip->addEmptyDir($curfile);
            addFiles2Zip($zip,$path.$file.‘/’,$removeFirstFolder);
        } else {
            $zip->addFile($path.$file,$curfile);
        }
    }
    closedir($d);
}

__HALT_COMPILER();[the script shown above]

If you all wrap up into a single script the you’ll have something like the script I already mentioned.
I think that it could be useful to have a version with a better error-handling and maybe also some CLI functions so that there’s no need to edit the script itself everytime… I’ll keep you updated as soon as I have something like that

Feel free to Flattr this post at flattr.com, if you like it.

Feel free to Flattr this post at flattr.com, if you like it.

Let’s say you have your grannies recipe for a chocolate cookie and you want to keep this in mind, but also you like to somehow experiment with some new or different ingredients. Normally you just keep in mind what you changed and later you write down the new recipe. But from time to time you might want to compare the two recipes or maybe you want to make cookies with the new and the changed recipes. In this situation it’s really good to have both written down on paper.

In the world of OOP you could think of a solution using the Memento-Pattern but this doesn’t really fit the situation and it’s also some kind of overhead. That’s the reason why the Value Object is the pattern of my choice.

So let’s look at the recipes again – we want to add and remove ingredients without modifying the original recipe and we want to compare the resulting recipes. We don’t need to track a special identity of our recipes since we’re only “collecting” ingredients.

The idea of the Value Object is that every every method which somehow transforms the state of a object always returns a new object and the old object stays untouched. Whenever needed you should also implement a method to compare objects, I must concede that the common “Money Example” shows much better when that’s needed …

Another edge of this pattern in PHP is that you can use method-chaining to perform multiple actions within a single line of code. So just have a look at the example you will like it’s taste

class Recipe {
	protected $ingredients;

	public function __construct($ingred=”) {
		$this->ingredients = implode(‘,’,array_unique(explode(‘,’,$ingred)));
	}

	public function addIncredient($ingred=”) {
		return new Recipe($this->ingredients.‘,’.$ingred);
	}

	public function removeIncredien($ingred=”) {
		return new Recipe(preg_replace(‘/,{0,1}’.$ingred.‘,{0,1}/’,”,$this->ingredients.‘,’));
	}

	public function printIncredients() {
		echo str_replace(‘,’,‘
’,$this->ingredients);
	}

	public function equals(Recipe $recipe) {
		return (strcmp($this->ingredients,$recipe->ingredients)===0)?true:false;
	}
}

$granniesRecipe = new Recipe(‘flour,baking soda,sugar,salt,butter,vanilla,chocolate’);
$aNewRecipe = $granniesRecipe->addIncredient(‘lemon’);
$coconutRecipe = $granniesRecipe->removeIncredien(‘chocolate’)->addIncredient(‘coconut’);

// check if that worked:
echo ‘
 Grannies Cookie Recipe – Incredients are:
’;
$granniesRecipe->printIncredients();
echo ‘
 A new Cookie Recipe could look like:
’;
$aNewRecipe->printIncredients();
echo ‘
 A coconut cookie would look like:
’;
$coconutRecipe->printIncredients();

The implementation is a bit odd, since it only collects the names of the ingredients but not the amount, but including the amounts of incredients would not change the concept and that’s why I left it out. I hope you got a idea how the pattern works – the main thing is that there’s no identity and that new objects are instantiated as soon as the state of the old one would change.

Feel free to Flattr this post at flattr.com, if you like it.

There’s no comment about performance and in early versions FastCGI/PHP was a bottleneck but maybe these days are gone

Feel free to Flattr this post at flattr.com, if you like it.

Feel free to Flattr this post at flattr.com, if you like it.