After freshly installing Karmic (the desktop version looks very nice btw) on a new VirtualBox image and then updating with the latest, er, updates I was ready to begin.

The entire installation procedure is very simple, once all dependencies are met.

Firstly you must edit your sources list to include the DotDeb package repository and the old Jaunty security packages to meet dependencies.

$ sudo nano /etc/apt/sources.list

# php5.3
deb http://php53.dotdeb.org stable all
deb-src http://php53.dotdeb.org stable all
deb http://security.ubuntu.com/ubuntu jaunty-security main

Now update and upgrade Ubuntu

$ sudo apt-get update
$ sudo apt-get upgrade

You may find that you get the following warning:

WARNING: The following packages cannot be authenticated!
libevent-1.4-2
Install these packages without verification [y/N]?

I just answered Y and continued as normal

Once successfully upgraded then you can install Apache, MySQL and PHP as normal, feel free to cater the installation line to your tastes.

$ sudo aptitude install libicu38 apache2 apache2-mpm-prefork mysql-client-5.1 mysql-server-5.1 php5 php5-cli php5-mysql libapache2-mod-php5

You will get a warning about untrusted packages being installed but this simply means that the PHP5.3 stuff is not signed, so I typed in “yes” and carried on.

Robmorin commented in my Jaunty post that he had issues when installing PHP MCrypt. The answer can be found within the DotDeb comments

After you have installed everything you need to, test it out, either command line:

$ php -v
PHP 5.3.2-0.dotdeb.1 with Suhosin-Patch (cli) (built: Mar  9 2010 10:14:53)
Copyright (c) 1997-2009 The PHP Group
Zend Engine v2.3.0, Copyright (c) 1998-2010 Zend Technologies with Suhosin v0.9.29, Copyright (c) 2007, by SektionEins GmbH

Or by using phpinfo() page within your Apache installation:

$ sudo nano /var/www/info.php

<?PHP
phpinfo();
?>

then fire up http://localhost/info.php and at the top of the page you should see something along the lines of
PHP Version 5.3.2-0.dotdeb.1

Note: if your browser asks if you want to download info.php, simply restart Apache and try again:

$ sudo /etc/init.d/apache2 restart

All done. Not quite as simple as on Jaunty, but still better than compiling the source!

Post Script: Before starting this post, I did a quick search looking for tutorials to see if the work had already been done, but couldn’t find anything on installing PHP5.3 on Karmic. As there wasn’t anything I decided to continue with my tutorial and I ended up struggling for an hour or so with the dependency issues. Typically, after I had figured it out for myself, whilst searching for another dependency issue I found this post on the JMOZ blog about installing PH5.3 on Karmic Koala.  No idea why it’s not in Google, but either way, damn, I could have saved myself an hour or so!

We need to initially define our flags:

define('BASE', 0); // binary 00000000
define('F1', 1);   // binary 00000001
define('F2', 2);   // binary 00000010
define('F3', 4);   // binary 00000100

To start with we have no flags set, so if we set F1 using the following:

$f1_set = BASE + F1; // $f1_set = 1
echo "F1 set = $f1_set\n";

All is well and good, $f1_set = 1 as expected.

However, what if we set F1 again?

$f1_set_twice = $f1_set + F1; // $f1_set_twice = 2 !!! wrong !!!
echo "F1 set twice = $f1_set_twice\n";

As you can see, if we set F1 twice, it effectively “unsets” F1 and sets F2. Not what we were after.

So why is this? Well, it’s kind of obvious and I was being a bit of a muppet for not spotting it yesterday. The reason is pretty simple: 1 + 1 = 2. (I told you it was obvious!)

Clearly this is not what we want, but how can we solve this? By using the bitwise OR. If we change the statements slightly as follows:

$f1_or_set = BASE | F1; // $f1_or_set = 1
echo "F1 OR set = $f1_or_set\n";
 
$f1_or_set_twice = $f1_or_set | F1; // $f1_or_set_twice = 1 - huzzah!
echo "F1 OR set twice = $f1_or_set_twice\n";

As far as “unsetting” the flags if we use my original method we fall (again) into trouble.

$f1_and_f3 = BASE | F1 | F3; // $f1_and_f3 = 5;
$unset_f3 = $f1_and_f3 - F3; // $unset_f3 = 1
echo "Unset F3 = $unset_f3\n";
 
$unset_f1 = $f1_and_f3 - F1; // $unset_f1 = 4;
echo "Unset F1 = $unset_f1\n";

Now, if we try to “unset” F1 twice, we arrive at the problem.

$unset_f1 = $f1_and_f3 - F1; // $unset_f1 = 3;
echo "Unset F1 = $unset_f1\n";

Unsetting F1 twice here effectively turns off F3 and sets F1 and F2 – completely wrong!

Instead, if we use the &~ binary operator mentioned in Jesper’s comment all works as expected. (note: I can’t find mention of this operator in the PHP docs, please someone help me out)

$f1_and_f3 = BASE | F1 | F3; // $f1_and_f3 = 5;
$unset_f3 = $f1_and_f3 &~ F3; // $unset_f3 = 1
echo "Unset F3 = $unset_f3\n";
 
$unset_f1 = $f1_and_f3 &~ F1; // $unset_f1 = 4;
echo "Unset F1 = $unset_f1\n";

Even if we try to “unset” a flag twice, it still has the same results:

$unset_f1 = $f1_and_f3 &~ F1; // $unset_f1 = 4;
echo "Unset F1 = $unset_f1\n";
 
$unset_f1_twice = $unset_f1 &~ F1; // $unset_f1_twice = 4;
echo "Unset F1 twice = $unset_f1_twice\n";

Also in Jesper’s comment and original post was the use of the left shift operator: <<. After playing around with this it seems very simple to use, as follows:

$f1 = 1;    // 00000001
$f2 = 1<<1; // 00000010
$f3 = 1<<2; // 00000100
$f4 = 1<<3; // 00001000

Or to put it another way:

$f1 = 1;      // 00000001
$f2 = $f1<<1; // 00000010
$f3 = $f2<<1; // 00000100
$f4 = $f3<<1; // 00001000

After all this I think I am a little closer to understanding Bitwise operations, hopefully! Tomorrow I’ll have a crack at testing to see if a flag is turned on or not. Until then…

I have always wondered what the point of Bitwise Operators were,to me they seem to belong to a distant past. However, after reading a couple of great blog posts I have at last an understanding of how they can be put to use, and have started playing around with them a bit (ba dum!).

Jesper Noehr has written about using bitwise operators for a flexible permissions scheme within Python  and Jonathan Snook has taken the bitwise concept further creating a great calendar app in Javascript. After reading these I thought I better dive in, and an opportunity came along yesterday when I had to code a flagging system within PHP.

For the benefit of this post I have greatly simplified the problem but hopefully it should be enough to get an understanding and allow you to get started with playing around with bits.

The problem is as follows. I have a number of items and each item has 3 different flags associated with it. We’ll call these flags F1, F2 and F3. A single item can have none, some or all flags set, and needs to have the ability to turn each flag on or off independently. The “base” state for each item is that no flags are set.

Each flag is a boolean, on or off, or to put it another way, 1 or 0. This translates perfectly into binary numerals. If we visualise this with a number of examples:

No flags switched on

Just F1 switched on

Just F2 switched on

Just F3 switched on

F1 and F3 switched on

The reason we have translated the binary number for just F1 switched on to 001 and not 100 is because from a text point of view, we read F1, F2 then F3 from left to right, but from a numeric point of view we read numbers right to left, i.e. 1s then 10s then 100s then 1000s etc.

From the above examples, we can see that if F1 is already switched on, we can easily switch on F3 as well by simply turning on the F3 bit. We accomplish this by simply adding the F3 bit:
Base + F1 + F3 = 0 + 1 + 100 = 000 + 001 + 100  = 101

We can also remove flags, for example if we have F3 and F1 set, but then remove F1 we have:
101 – 001 = 101 – 1 = 100
But even though these are all ones and noughts we can translate these into decimal. PHP has a handy little utility function for this: decbin() [http://php.net/manual/en/function.decbin.php]

So now this makes it really easy to turn flags on an off.
In PHP it would be as follows:

define('BASE', 0);
define('F1', 1);
define('F2', 2);
define('F3', 4);
 
echo "No flags = ".BASE.":".decbin(BASE)."\n";
 
// switching flags on
$f1_on = BASE+F1;
echo "Turn on F1 = $f1_on:".decbin($f1_on)."\n";
 
$f2_on = $f1_on+F2;
echo "Turn on F2 = $f2_on:".decbin($f2_on)."\n";
 
$f3_on = $f2_on+F3;
echo "Turn on F3 = $f3_on:".decbin($f3_on)."\n";
 
// switching flags off
$f2_off = $f3_on-F2;
echo "Turn off F2 = $f2_off:".decbin($f2_off)."\n";
 
$f1_off = $f2_off-F1;
echo "Turn off F1 = $f1_off:".decbin($f1_off)."\n";

Save this as bits.php and then run it from the command line with:

$ php ./bits.php
No flags = 0:0
Turn on F1 = 1:1
Turn on F2 = 3:11
Turn on F3 = 7:111
Turn off F2 = 5:101
Turn off F1 = 4:100

All good so far, but now we need to see if a particular flag is switched on or off. I’ll publish that in my next blog post. So stay tuned.

I have recently dusted off an old laptop to play around with and do some “fun” development. One of the things I have done to this laptop is to install a LAMP stack using PHP 5.3 so I can play around and see what’s new and exciting.

I had a quick Google on how to install PHP 5.3 on Ubuntu and found Brandon Savage’s post on the very subject! Whilst he has a great write up it was one or two of his comments mentioning the DotDeb.Org package repository.

This was a breeze to use and in about 5 minutes I have PHP 5.3 running with Apache and MySQL on my clean Jaunty system.

The first thing to do is add the DotDeb.org repositories to your sources list:

$ sudo nano /etc/apt/sources.list

# php5.3
deb http://php53.dotdeb.org stable all
deb-src http://php53.dotdeb.org stable all

Now update and upgrade Ubuntu

$ sudo apt-get update
$ sudo apt-get upgrade

Now simply install apache mysql and php as usual

$ sudo aptitude install apache2 apache2-mpm-prefork mysql-client-5.1 mysql-server-5.1 php5 php5-cli php5-mysql libapache2-mod-php5

You will get a warning about untrusted packages being installed but this simply means that the PHP5.3 stuff is not signed, so I typed in “yes” and carried on. Obviously you can cater this line to your specific needs, but this is the basic stack up and running

When it was all complete I tested out my system:

$ php -v
PHP 5.3.0-0.dotdeb.8 with Suhosin-Patch 0.9.7 (cli) (built: Aug 12 2009 18:11:27)
Copyright (c) 1997-2009 The PHP Group
Zend Engine v2.3.0, Copyright (c) 1998-2009 Zend Technologies

and tested out my apache installation using a phpinfo() script:

$ sudo nano /var/www/info.php

then fired up http://localhost/info.php
<?PHP
phpinfo();
?>
and saw as the main header of the page:
PHP Version 5.3.0-0.dotdeb.8

All done. Simple!

We had a look around and we found a potential solution on this blog post.

We played around with this for a while but found that, whilst it was a good solution, it wasn’t quite suitable for our needs. What we needed was a solution which allowed us to have any number of columns and for each column to contain completely different content. The solution in the post demanded that each column start with the same HTML tag (H2 in the example). We decided to rewrite the function described above, based on the same principals, but updated and improved so it would fit our needs.

To see what the end result is, you can see a demo page.

The first thing the new function had to do was to split the content into the different columns using the more tag. In our tests, we found that Wordpress replaced the more tag with a span, but only in the first instance, all the rest were kept as a comment tag. The regular expression we used had to take this into account.

// the first "more" is converted to a span with ID
$columns = preg_split('/(<span id="more-\d+"><\/span>)|(<!--more-->)<\/p>/', $content);

This regular expression is not bullet proof, but it does the job for us. Specifically, if you are using a plugin like “Sociable” or something that appends stuff to the end of the content then this stuff will end up in the third column and not nicely across the bottom of the page. Also, it hasn’t been tested when adding images. These two issues weren’t going to be a problem for us, so the regular expression above is perfectly adequate for our needs.

Next we need to loop through each column, removing any stray <p> tags that may have been orphaned by the regular expression and putting the content into separate divs.

$col_count = count($columns);
for($i=0; $i<$col_count; $i++) {
 
	// check to see if there is a final, if not add it
	if(!preg_match('/<\/p>\s?$/', $columns[$i]) )  {
		$columns[$i] .= '</p>';
	}
	// check to see if there is an appending, if there is, remove
	$columns[$i] = preg_replace('/^\s?<\/p>/', '', $columns[$i]);
	// now add the div wrapper
	$columns[$i] = '<div class="dynamic-col-'.($i+1).'">'.$columns[$i].'</div>';
}

Finally we can join the columns back together to produce the final content.

$content = join($columns, "\n").'<div class="clear"></div>';

Notice that we have added a clearing div here. This is basically so you can clear the floats with CSS so any content displayed below the page content will be correctly positioned.

What if there isn’t a more tag? We will only have one column. As such there is no need to modify the content, so the code above should go into an if statement

if($col_count > 1) {
	...
}

The last job to do in this function is to clear out any blank <p> tags caused by the regular expression and return the content

// remove any left over empty tags
$content = str_replace('<p></p>', '', $content);
return $content;

This would normally all be contained in a function (we called my_multi_col_v2) that would be called as a filter function, however, we found that this was causing problems with the Wordpress excerpts, so instead we are overriding the default content display function in the page.php file.
In your page.php file, replace the line that calls the the_content() function

//the_content('Read the rest of this entry »');

Now we collect the content into a variable, then pass this variable to the new function, outputting the result. The function that gets the content instead of directly outputting it is get_the_content():

$content = get_the_content('',FALSE,''); //arguments remove 'more' text
echo my_multi_col_v2($content);

As we are using get_the_content() the default filtering that is normally done on the content is not being run. So at the top of our new function, we must manually run these

// run through a couple of essential tasks to prepare the content
$content = apply_filters('the_content', $content);
$content = str_replace(']]>', ']]>', $content);

This also caused a problem with line breaks when only displaying one column, so we needed to include an else statement that ran wpautop()

else {
	// this page does not have dynamic columns
	$content = wpautop($content);
}

So the final function looks like this:

function my_multi_col_v2($content){
	// run through a couple of essential tasks to prepare the content
	$content = apply_filters('the_content', $content);
	$content = str_replace(']]>', ']]>', $content);
 
	// the first "more" is converted to a span with ID
	$columns = preg_split('/(<span id="more-\d+"><\/span>)|(<!--more-->)<\/p>/', $content);
	$col_count = count($columns);
 
	if($col_count > 1) {
		for($i=0; $i<$col_count; $i++) {
			// check to see if there is a final </p>, if not add it
			if(!preg_match('/<\/p>\s?$/', $columns[$i]) )  {
				$columns[$i] .= '</p>';
			}
			// check to see if there is an appending </p>, if there is, remove
			$columns[$i] = preg_replace('/^\s?<\/p>/', '', $columns[$i]);
			// now add the div wrapper
			$columns[$i] = '<div class="dynamic-col-'.($i+1).'">'.$columns[$i].'</div>';
		}
		$content = join($columns, "\n").'<div class="clear"></div>';
	}
	else {
		// this page does not have dynamic columns
		$content = wpautop($content);
	}
	// remove any left over empty <p> tags
	$content = str_replace('<p></p>', '', $content);
	return $content;
}

The next thing to do is to update your CSS so it lays out the columns correctly. In the demo I have used three columns, and the CSS for it looks like this:

/* dynamic columns */
div.dynamic-col-1 { float: left; width: 38%; padding-right: 2%;}
div.dynamic-col-2 { float: left; width: 38%;padding-right: 2%;}
div.dynamic-col-3 { float: left; width: 20%;}
div.clear { clear: both; }

And that’s pretty much it. Have a look at the demo, below is a screenshot of the Wordpress editor screen so you can see that it really is controlled by the user, you should see the two more tags that are used to split the content into the three columns.

Wordpress multiple content columns, editor input

Please feel free to take this, improve it, update it, completely rewrite it. If you do please can you drop me a comment and let me know. And a big thanks to Kriesi for his initial work and for providing inspiration for this blog post. ]]> http://www.robsearles.com/2009/07/05/wordpress-multiple-content-columns/feed/ 26 http://www.robsearles.com/2009/06/05/php5-fake-method-overloading/ http://www.robsearles.com/2009/06/05/php5-fake-method-overloading/#comments Fri, 05 Jun 2009 08:44:35 +0000 Rob Searles http://www.robsearles.co.uk/?p=91 Been struggling for the past hour or so with method overloading within objects, so I thought I’d write a little not on my blog to hopefully help others and to remind myself.

The premise for this is that I was writing a new database wrapper class to speed up the rather rubbish database module I have been using previously. My plan was to encapsulate all my methods in the wrapper (such as get_table_name() etc) in my class then all others fire off to the ADODB class by PHPlens. My plan was to do this with method overloading, such as:

public function __call($m, $a) {
return $this->db->$m($a);
throw new Exception('Tried to call unknown method '.get_class($this->db).'::'.$m);
}

However, PHP5 doesn’t seem to support that, which is irritating. After some search on the web I find out that PHP5 doesn’t support real overloading.

So after much effort and searching the web and docs I decide to use the call_user_func_array(&obj) technique.

Finished method below:

public function __call($m, $a) {
// check the method being called exists
if (method_exists($this->db, $m)) {
return call_user_func_array(array(&$this->db, $m), $a);
}
else {
throw new Exception('Tried to call unknown method '.get_class($this->db).'::'.$m);
}
}

Seems to work, so please feel free to use

Note: This post has been copied from the old ibrow.com website, originally posted on 2007-07-04. See this entry for more details

Good Points

• It is PHP5 only (5.2 and above) so it allows for utilising the full power of OO PHP.
• It is light weight.
• True auto loading – it’s PHP5, you shouldn’t have to explicate load a class!
• The cascading file system – this is a joy to work with. It easily allows you to extend and add to modules, libraries, models and configuration files.
• Kohana has greatly speeded up the development of my prototype and has allowed me to focus on the actual functionality of the app, leaving all the boring, repetitive bits of coding to the framework.
• I have had to dig about under the bonnet a few times to see what’s going on, and I have been impressed by the clean and well structured code.
• The community – behind Kohana there is a small but active and knowledgeable community. I have been stuck a number of times when hacking around with Kohana, and on both occasions I have received prompt and useful replies.
• Most importantly it lets you code how you want, without getting in the way, whilst at the same time can take out a lot of the donkey work for repetitive tasks.

Bad Points

This is going to be difficult, but I’ll give it a try

• Documentation.  From what I can make out it has come on leaps and bounds over the past few months, however, it sometimes isn’t always clear. Also, the tutorial site hasn’t been updated for a good few months now.
• Limited number of modules currently available.

However, the above points aren’t deal breakers. Kohana is an open source project, and relatively young at that. This means that I can actively do something about both the documentation (it’s a wiki that anyone can register) and the modules. I just need to find some time and contribute!

Conclusion

As you might already be able to tell, my conclusion is going to be positive. I have really enjoyed playing around with Kohana, it is solid, secure and well designed. Being PHP5 only, not only can I utilise the full potential of PHP, but so can the framework. As said, I’m really glad I chose Kohana, and I am pretty excited about its future developments.

If anyone out there needs a solid, well thought out framework for PHP5, that is backed by an active community, you can’t go wrong if you chose Kohana.

Notes

I have been using Kohana version 2.3 exported from the SVN – details on the Kohana dev site.

Other Reviews

Don’t take my word for it, other people are talking about Kohana too

• Review at phoenixheart.net – very recent so a good review of the state that Kohana is in at the moment.
• The final part of a review comparing Zend, Symfony and Kohana. This review is about 6 months old, so the comments about the lack of documentation are slightly less accurate today.
• Comparision of Kohana and CodeIgnitor (the framework Kohana was originally forked from).

I run a LAMP development server off my laptop, and today some of the PHP I was writing was throwing up some errors. Unfortunately I hadn’t installed XDebug which makes life so much easier when debugging PHP.

Oh no, I though. I’ll have to download it, install it, update the PHP.ini file. Argh.

But wait…no! I have Ubuntu, all it took was 2 easy steps:

Step 1, install Xdebug

sudo apt-get install php5-xdebug

Step 2, restart Apache

sudo /etc/init.d/apache2 restart

Done! Easy peasy.

Thanks Ubuntu