Craig Campbell - Blog

Anonymous PHP Functions

Craig Campbell — Sat, 24 Jul 2010 18:22:17 +0000

Most PHP developers are probably well aware of this already, but the release of PHP 5.3 brought a few cool features to the language including namespaces, late static binding, and anonymous functions (closures).

In the interest of keeping this brief I just wanted to provide a few simple examples.

Let's imagine you have an array of data:

$users = array(
             array('id' => 1, 'name' => 'Tom', 'birthdate' => '1980-05-05'),
             array('id' => 2, 'name' => 'Julia', 'birthdate' => '1985-07-07'),
             array('id' => 3, 'name' => 'Michael', 'birthdate' => '1974-11-17')
         );

Now let's say you wanted to grab all the user ids from this array. Normally you would do something like this:

$ids = array();
foreach ($users as $user) {
$ids[] = $user['id'];
}

With anonymous functions you could achieve the same thing by doing:

$ids = array_map(function ($user) {
return $user['id'];
}, $users);

Now let's say you wanted to filter out all the users born after 1980. The traditional way would look something like this:

$filtered_users = array();
$start_date = strtotime('1979-12-31');
foreach ($users as $user) {
    if (strtotime($user['birthdate']) > $start_date) {
        $filtered_users[] = $user;
    }
}

With anonymous functions:

$start_date = strtotime('1979-12-31');
$filtered_users = array_filter($users, function($user) {
global $start_date;
return strtotime($user['birthdate']) > $start_date;
});

I'm not suggesting that you necessarily SHOULD do this. The foreach loops are arguably more readable, and in simple benchmarks, they outperform using array functions 90% of the time. However, it is something else to add to your bag of tricks and can be useful in places where you need a one off callback function.

My First GitHub Repository : show-missing-revs

Craig Campbell — Wed, 30 Jun 2010 22:38:46 +0000

I signed up for GitHub a little while ago, but hadn't used the site for anything until just now.

I want to be more open about sharing my code with the world, and I was inspired by the irony of posting a Subversion utility script on GitHub.

As far as what the script does, it is for finding what revisions in one branch are missing in another.
I will give a brief overview:

Let's say you are developing a product in trunk and it is time for the 1.2 release. You create a 1.2 branch from trunk, push it out to the world, and begin developing version 1.3 in trunk. After 1.2 is released you start getting tons of bug reports. You work feverishly to fix the bugs in the 1.2 branch but sometimes forget to merge your bugfixes back into trunk. A month later, you are about ready to release version 1.3 from trunk, but some of the bugs you have already fixed in the 1.2 branch were never merged back into trunk. If they don't get merged you risk reintroducing bugs you have already fixed!

How on earth are you going to find out what revisions you forgot to merge?

Subversion has a way of doing this, but all it gives you is the revision numbers. Using my script you get the revision number, the user who made the commit, and the first line of the commit message. You have the option to target a specific user.

Using the script looks a little like this:

cd /path/to/trunk
sh /path/to/show_missing_revs.sh -b 1.2 -u craig

That will output something like:

Hopefully someone will find this useful.

You can find it on GitHub at http://github.com/ccampbell/show-missing-revs.

Open links in a new browser window using jQuery

Craig Campbell — Mon, 31 May 2010 13:08:39 +0000

I use jQuery as my javascript framework of choice because I love how simple it is, and how much you can do with just a single line of code.

I decided it would be a good idea to share some jQuery code snippets to do common tasks. So hopefully there will be plenty of posts where this one came from.

The easiest way to open a link in a new window is to do something like this:

<a href="http://www.google.com" target="_blank">search the web</a>

Unfortunately, the target attribute is not valid in XHTML strict so you have to use javascript if you want your pages to validate.

The first thing you have to do is give your links some sort of identifier:

<a href="http://www.google.com" rel="external">search the web</a>

You could use the domain to figure out if the link lives on your site or not, but I prefer to be explicit about which links should open in a new window.

Most tutorials now would recommend that you loop through every link on your page and rewrite them to have the target attribute, but that can be expensive and is not needed.

All you have to do is add the following javascript code:

$(document).ready(function() {
    $("a[rel='external']").live("click", function() {
        $(this).attr("target", "_blank");
    });
});

The code is pretty self explanatory, but I will give a brief overview.

$(document).ready(): This is jQuery's way of saying that the page is ready to go. You can read more about it here.
$("a[rel='external']"): This is the selector for the links. This means we are targeting links that have the rel attribute set to "external".
.live: .live is similar to .bind but the difference is that .live uses event delegation to bind a single event to the document. This means that all current and future links will exhibit the same behavior. See this page for more information.
$(this): This turns the link that was clicked into a jQuery object

One additional note about this tutorial is that HTML5 does support the target attribute so when that is widely used you can forget that this post ever happened.

Removing Apple Double "._" files in Mac OS X

Craig Campbell — Mon, 24 May 2010 01:43:56 +0000

When I work locally on projects I like to use symlinks for all of my shared libraries. It makes it way easier than having to manage a million different versions of the same files.

Recently I was creating a tarball (.tar) archive to deploy somewhere using the -h option to follow symlinks like so:

tar cvfh code.tar code

I noticed that many of the symlinked files that were copied into the archive ended up being transformed into apple double files. Of course, this is quite annoying, and I wanted to get rid of them. I did some googling and found the answer buried somewhere on the internets so I thought I'd make it easier to find.

All you have to do is add the following to your ~/.bash_profile:

# for Tiger OS 10.4 or earlier
export COPY_EXTENDED_ATTRIBUTES_DISABLE=true

# for Leopard OS 10.5 and later
export COPYFILE_DISABLE=true

That's all.

Tonightly has launched!

Craig Campbell — Wed, 14 Apr 2010 02:34:06 +0000

I realize most of the things I write about here are pretty technical so it feels a little bit strange to be breaking the mold, but I wanted to let people know about a very exciting project I have been working on in my spare time for nearly the past year.

The inspiration came one night when I was out with some friends and we were wondering "What is there to do tonight?". We realized there was no one stop solution to answer this question, and every existing event site out there is cluttered and confusing. The goal for this project was to build a very simple, clean site that would provide event lists for any event happening on the current day.

The functionality is really quite simple. You can register an account or login with your Facebook account to post events. You can post an event for any time in the future, but it won't show up on the site or be searchable until that day rolls around. In the meantime you can still promote it ahead of time on your own site or blog and link your friends to the listing.

You can browse events by rating (hot or not - rotten tomato style), views, neighborhood, or tags and can share events on Twitter, Facebook or via email through Tonightly.

I could go on and on about it, but I think it would be better to go check it out for yourself at http://www.tonightly.com.

Pseudo Namespaces With PHP and Memcached Revisited

Craig Campbell — Tue, 09 Mar 2010 02:27:54 +0000

A while back I wrote about a way to keep data valid across multiple pages by invalidating cache keys. I have since thought of a better way to handle this.

The basic idea is that anytime you have child objects related to a parent object you can use a property of the parent object to invalidate the children. To make this more clear let's revisit the original problem: You are building a blog with a lot of users where each user posts a bunch of articles. The articles are paginated and cached per page. If the user adds a new article, all the items on the page will shift and we need a way to invalidate all the pages in cache.

The approach mentioned in my previous article involved having a namespace key that would store a random integer which would then be incremented when there is an update. This has a few problems:

It is never 100% safe to rely on random numbers.: If there is a cache failure on one server and the namespace key falls out of cache then there is a chance that the random number generated will lead to a key containing data that was in cache a while ago. Also on that same note incrementing the version could still contain stale data in cache.
It creates unnecessary cache lookups.: The namespace lookups have to happen before you can perform the initial lookup. Cache is fast, but like anything else it should only be used when necessary.
It can cause cache contention issues.: If many people are all trying to access the same key at the same time then the requests start to bubble up and the last one has to wait for the others to finish. This is more prevalent in this situation because if there are 10 pages of articles, each page would have its own unique cache key, but all 10 pages would share the same namespace key.

Enough with the problems, let's take a look at the solution:

class User
{
    protected $_lastArticleUpdate;

    public function getArticles($page, $pageSize)
    {
        $cacheKey = __METHOD__ . $page . $pageSize . $this->_lastArticleUpdate;

        if (($articles = Cache::get($cacheKey)) !== false) {
            return $articles;
        }

        // cache miss, retrieve articles from database
    }
}

This is overly simplified, but you can see how much cleaner and simpler this approach is. The lastArticleUpdate property contains a timestamp. This timestamp would get updated everytime the user adds/removes/updates an article. Since the user object is already required in order to get a page of articles in this example, you already have this property accessible.

Memcached Multiget using PHP PECL Memcache class

Craig Campbell — Mon, 28 Dec 2009 00:57:21 +0000

At work I have been working with memcache quite a bit and coming up with creative ways to cache stuff. Perhaps I will elaborate on some of these in later posts, but for now I think I will focus on one interesting issue I ran into using multiget.

Using PECL Memcache extension the Memcache::get() method allows you to pass in a single key as a string or an array of keys to retrieve from cache. This can be very useful for retrieving lots of information with one request to memcache, however, there are a couple things to keep in mind. The first is something minor that I found annoying.

Let's say you request array('item_1', 'item_2') from cache. If only item 1 is in cache then the resulting array will be something like this: array('item_1' => 'this is the value for item 1'). This means you have to actually check if a key exists in the resulting array or not in order to know how to proceed.

The second thing had me banging my head against the wall for a short while since it was not possible to reproduce on a development environment. If you request multiple items from cache in one multiget request and the items requested are distributed over more than one server then they will not be returned in the same order that they were requested in.

While this seems to be the expected behavior, I couldn't find any information or documentation about this in the PHP documentation for memcache.

After a little while I thought of a workaround to this problem. The code is as follows:

<?php
/**
* gets multiple keys from cache and returns the values in the same order
* they were requested in
*
* @param array $keys
* @param bool $preserveOrder
* @return array
*/
public function getMulti(array $keys, $preserveOrder = true)
{
    // grab whatever items we can from cache
    $items = $this->get($keys);

    // if we don't care what order the keys are returned in
    if (!$preserveOrder) {
        return $items;
    }

    // set all keys to null so if something is not found in cache it won't
    // be set to a value
    $results = array_fill_keys($keys, null);

    // merge the two arrays so the returned values from cache overwrite
    // the starting values
    return array_merge($results, $items);
}

This pretty much solves both of the problems mentioned above. By using array_fill_keys we are able to guarantee that every item will be returned in the resulting array. By using array_merge any of the items actually returned will overwrite the values in the original while preserving the same order

Please note this code is part of a Memcache wrapper class.

Post processing search results without running SQL queries in loops

Craig Campbell — Sat, 29 Aug 2009 21:41:59 +0000

Recently at work we were presented with an interesting problem, one of many problems that came up from using the Google Search Appliance to index and handle search results on a large site (I will probably touch on some of the others in future blog posts). The problem is this:

We have a site containing many content items that are all indexed by the Google Search Appliance. We have to manually feed XML to the GSA since we have very specific business requirements and allowing Google to crawl our site will not work. This means that when there are updates to items we need to let the GSA know to reindex this item with the correct information. For most things this is fine, but for ratings if we have to queue an item up each time a user rates an item that would significantly slow down the site and prove to not be the best solution. The rating does not have to be 100% up to the minute, but if something is indexed today and then rated 100 times without being reindexed, the rating in the index could be very far off. This means we needed a way to keep the item's ratings accurate in the search results.

The solution I came up with (with the help of my coworker, Joseph) was to cache an array of (itemId => rating). The first idea was to cache everything at once, but considering the number of items is constantly growing there is a chance that this would exceed Memcached's 1MB limit per item in cache. So we decided to split the cache up into groups so some items would be in the first array, some in the second, etc.

One thing to keep in mind here is that we are already storing a de-normalized rating value so we do not have to calculate averages over huge amounts of data when we need to select an item's rating. That would almost certainly break this approach.

The final code looks something like this:

<?php
public function getRating($itemId)
{
    $numGroups = 5;
    $mod = $itemId % $numGroups;
    $cacheKey = __METHOD__ . '_' . $mod;

    if (($ratings = Core_Environment::getCache()->get($cacheKey)) === false) {

        $query = '/* ' . __METHOD__ . ' */' .
            "SELECT i.id id,
                    i.rating rating
               FROM item i
              WHERE MOD(i.id," . $numGroups . ") = :mod";

        $sth = $this->_db->prepare($query);
        $sth->bindValue(':mod', $mod);
        $sth->execute();
        $records = $sth->fetchAllAssoc();

        // format the array
        $ratings = array();
        foreach ($records as $record) {
            $ratings[$record['id']] = $record['rating'];
        }

        Core_Environment::getCache()->put(
            $cacheKey,
            $ratings,
            3600);
    }

    return $ratings[$itemId];
}

I think this is pretty self explanatory, but I will give a brief overview. Basically I am using the Modulo Operation to handle the cache grouping. With the number of groups set to 5, the remainder will always be a number between 0 and 4. This allows us to easily group the items into those 5 categories. This also means if there are 20,000 items in the system each group would contain 4,000 items (assuming the ids are all sequential). This allows us to call the getRating() method for each item returned in the search results, and chances are pretty good that they will all hit cache.

I know this might not always be necessary considering 1MB = 1,048,576 bytes and even if you figure as high as 15 bytes per item that could hold almost 70,000 item ratings in one array, but smaller arrays are easier/faster to work with, and it is better to be safe than sorry. I would also recommend storing the number of groups and cache expiration times in a configuration file somewhere so you don't need to make code changes to update them.

Pseudo Namespaces With PHP and Memcached

Craig Campbell — Wed, 27 May 2009 00:02:53 +0000

UPDATED 09 MAR 2010 SEE THIS POST

I have been so incredibly busy lately that I have not had anytime to write here. Anyway I just wanted to take some time to talk about something cool I have been doing for a project I have been working on outside of work.

By now everyone knows what Memcached is so I won't bore you with an introduction. Basically it is an insanely simple caching system designed to eliminate load on the database.

While in an ideal world you would just throw cache on everything and watch your application scale to infinity and beyond, things aren't always that simple. The problem I'm going to show you today has to do with pagination and cached database queries. I will try to make this pretty straightforward so anyone can follow.

There is a user named Pablo Picasso who is using your site. He makes Cap-Sacs for a living and has received 15 messages from people on the site who are interested in purchasing one from him. This means that page 1 displays messages 6 to 15 (the 10 most recent messages) and page 2 displays 1 to 5.

Let's now imagine you cache these pages of results. A new user comes to your site and wants to buy a pink Cap-Sac. They send Picasso a message so your application says, "Oooh Picasso just got a new message. That's pretty rad. Since the query to get his messages is Cached let's just drop the cache for page 1." Now what happens you ask?

The new message shows up on the top of page 1 as expected so what's the problem?? Picasso now has 16 messages. Page 1 will display messages 7 to 16 which is fine, but since page 2 was cached from before it is going to show messages 1 to 5 still. This means that as long as the cache lives poor message number 6 (the last message on page 1 before the new message was recieved) gets dropped from the result set completely. Not to mention that page 1 thinks Picasso has 16 messages while page 2 still thinks he has 15.

This can also allow duplicates of the same item to show up if for example the user had 22 messages and page 1 and 2 were cached but page 3 wasn't. In this case a new message would cause page 3 and page 1 to be correct but since page 2 is still hitting cache, the last item on page 2 would be the same as the first item on page 3.

So what can we do about this? I see a few options

Don't use memcached for paginated result sets
Live with missing and/or duplicate items from time to time in your pagination
Select everything at once and handle the pagination at the PHP level instead of in the database
Use Pseudo cache namespaces to invalidate all cache keys for paginated queries

And here is my analysis of the options:

Option 1: This seems to be the approach that is often taken where I work, and of course it will work, but what happens if the data rarely changes? In that case it seems rather silly to continue to hit the database over and over for the same data.
Option 2: Surprisingly I don't think option 2 is a terrible option because it will definitely scale pretty well. Facebook search results have duplicate items all over most likely for this very reason, but since, in my example, I am thinking about displaying accurate data to the user I would stay away from this. For search results I think this is a much more viable option.
Option 3: This option is another interesting one. It would arguably scale better than any of the other options I have proposed although the problem here is what if Lady Gaga is using your site and she has 15,000 messages from fans. We don't want to have to select 15,000 items from the database if this were to miss cache.
Option 4: Well considering the title of this post I think you all knew this is the road I was going to go down. You get the performance benefits of caching, and you get 100 percent data accuracy.

The approach here is really quite simple and similar to the example found on the memcached FAQ page.

What I have chosen to do is use the DAO name as my main namespace identifier along with the unique userId. Please understand this is a very crude implementation just to illustrate my idea. It is more or less procedural code so I would not recommend doing it like this. I have been using a Cache_Namespace class to handle common logic such as generating the key and grabbing/setting the generation version/incrementing the version. Anyway here goes:

<?php
/**
* this would get called to retrieve a page of a user's messages
*/
public function getMessages($userId, $pageNumber)
{
    $memcache = new Memcache();

    // this is the cache key to use to find the version to use
    $versionKey =  'Message_Dao_' . $userId . '_version';

    // if there is no cache hit for the version set it to a random value
    // and set it to never expire
    if (($version = $memcache->get($versionKey)) === false) {

        // we should use a random number here because otherwise there
        // is a chance the version key will expire and resetting it to 1
        // means incrementing it might not invalidate all cache keys
        // if the query has been cached at version 2 for example
        $version = rand(1, 9999);
        $memcache->put($versionKey, $version, 0);
    }

    // this will be the key we use to actually retrieve the data
    $queryCacheKey = __METHOD__ . '_' . $userId . '_' . $pageNumber .
        '_' . $version;

    // if there is no cache hit for this data then we need to run the query
    if (($records = $memcache->get($queryCacheKey)) === false) {

        // run query here SELECT * FROM blah blah blah blah
        // grab the result set
        $records = $sth->fetchAssoc();

        // store the results in cache
        $memcache->put($queryCacheKey, $records);
    }

    return $records;
}

/**
* this would get called when a user sends another user a message
*/
public function sendMessage($message, $toId, $fromId)
{
    // run insert INSERT INTO message blah blah
    // after adding the message to the database we need to invalidate
    // all cache keys for the person you are sending it to
    $versionKey = 'Message_Dao_' . $toId . '_version';

    $memcache = new Memcache();

    // we call add here because increment won't increment a value that
    // does not exist.  add() will only set a value if it doesn't exist
    // otherwise it will return false
    $memcache->add($versionKey, rand(1, 9999));
    $memcache->increment($versionKey);
}

I tried to comment that code pretty well. As you can see the version is used as part of the query cache key so incrementing its value by 1 will make all calls to that method not hit cache. If you have more than one method you want to invalidate you can give them the same namespace key as seen in line 11.

Okay that is all for now.

Simple Pagination With PHP and MySQL

Craig Campbell — Sat, 04 Apr 2009 02:41:30 +0000

Just when you thought I had run out of material to write about I am back! I have a few topics still lined up, but I have been so busy that I haven't had time to write anything.

The project I have been working on at work has lots of pagination in it, and the other day I was really frustrated with how difficult it was to do simple pagination and how many lines of code it took in the controller. Here I am going to present to you a pagination class I wrote and a usage example.

I am aware that there is a Zend_Pagination class in Zend Framework, but I'm not crazy about it. It offers some nice view helpers to draw pagination on a page, however, it is over 900 lines long, contains a lot of code you probably will never need, and is missing simple functions that you may need such as determining the page offset or the first and last item on the current page.

Here is the class I have written in its entirety (all of 237 lines including comments):

<?php
/**
* Pager
*
* @package Pager
* @author Craig Campbell <iamcraigcampbell@gmail.com>
*/
class Pager
{
    /**
     * @var int
     *
     * total number of items in the data set
     */
    protected $_totalItems;

    /**
     * @var int
     *
     * total number of pages
     */
    protected $_totalPages;

    /**
     * @var int
     *
     * total number of items per page
     */
    protected $_pageSize;

    /**
     * @var int
     *
     * current page number
     */
    protected $_currentPage;

    /**
     * @var int
     *
     * first item on current page
     */
    protected $_firstOnPage;

    /**
     * @var int
     *
     * last item on current page
     */
    protected $_lastOnPage;

    /**
     * constructor
     *
     * @param int $page page number
     * @param int $pageSize number of items per page
     * @return void
     */
    public function __construct($page = 1, $pageSize = 10)
    {
        if ($page < 1) {
            throw new Exception('page cannot be less than 1!');
        }
        $this->_currentPage = $page;

        if ($pageSize < 1) {
            throw new Exception('page size cannot be less than 1!');
        }
        $this->_pageSize = $pageSize;
    }

    /**
     * sets the total number of items in this data set
     *
     * usually comes from some kind of count query in the database
     *
     * @param int $number
     * @return void
     */
    public function setTotalItems($number)
    {
        $this->_totalItems = $number;

        // the first item on this page will be one above the offset
        $this->_firstOnPage = $this->getOffset() + 1;

        // total number of pages
        $this->_totalPages = ceil($number / $this->_pageSize);

        // if the total number of items is greater than the first item
        // and there are more pages
        if ($number > $this->_firstOnPage &&
            $this->_totalPages > $this->_currentPage) {

            $this->_lastOnPage = $this->getOffset() + $this->_pageSize;
            return;
        }

        $this->_lastOnPage = $number;
    }

    /**
     * determine the offset
     *
     * @return int
     */
    public function getOffset()
    {
        return ($this->_currentPage - 1) * $this->_pageSize;
    }

    /**
     * determines if there is a previous page
     *
     * @return bool
     */
    public function hasPrevious()
    {
        return ($this->_currentPage - 1) > 0;
    }

    /**
     * determines if there is a next page
     *
     * @return bool
     */
    public function hasNext()
    {
        return ($this->_currentPage + 1) <= $this->_totalPages;
    }

    /**
     * gets the previous page
     *
     * @return int
     */
    public function getPrevious()
    {
        if ($this->hasPrevious()) {
            return $this->_currentPage - 1;
        }
        return false;
    }

    /**
     * gets the next page
     *
     * @return int
     */
    public function getNext()
    {
        if ($this->hasNext()) {
            return $this->_currentPage + 1;
        }
        return false;
    }

    /**
     * gets the total number of items on the current page
     *
     * @return int
     */
    public function getCurrentPageSize()
    {
        return $this->_lastOnPage - $this->_firstOnPage + 1;
    }

    /**
     * gets the current page size
     *
     * @return int
     */
    public function getPageSize()
    {
        return $this->_pageSize;
    }

    /**
     * gets the total number of pages
     *
     * @return int
     */
    public function getTotalPages()
    {
        return $this->_totalPages;
    }

    /**
     * gets the first item on the current page
     *
     * @return int
     */
    public function getFirstOnPage()
    {
        return $this->_firstOnPage;
    }

    /**
     * gets the last item on the current page
     *
     * @return int
     */
    public function getLastOnPage()
    {
        return $this->_lastOnPage;
    }

    /**
     * gets the current page number
     *
     * @return int
     */
    public function getCurrentPage()
    {
        return $this->_currentPage;
    }

    /**
     * gets the total number of items
     *
     * @return int
     */
    public function getTotalItems()
    {
        return $this->_totalItems;
    }

    /**
     * determines if the current page has content
     *
     * @return bool
     */
    public function hasContent()
    {
        return $this->_currentPage <= $this->_totalPages;
    }
}

Keep in mind this is a rough draft, but it seems to work pretty well. All you need to tell the class is 3 things:

The current page number in the constructor
The number of items you would like to see per page in the constructor
The total number of items that you will be paginating in the setTotalItems() method

Now here is an example of this class in action (controller):

$pager = new Pager($_GET['page'], 15);
$dao = new User_Dao();
$users = $dao->getAll($pager);

Here is the method in the User_Dao to get the users from the database:

/**
* gets all users
*
* @param Pager $pager
* @return Collection
*/
public function getAll(Pager $pager)
{
    $query = '/* ' . __METHOD__ . ' */' .
        "SELECT SQL_CALC_FOUND_ROWS
                u.id id,
                u.email email
           FROM user u
       ORDER BY u.id
          LIMIT $pager->getPageSize()
         OFFSET $pager->getOffset()";

    $sth = $this->_db->prepare($query);
    $sth->execute();
    $records = $sth->fetchAllAssoc();

    $query = '/* ' . __METHOD__ . ' */' .
        "SELECT FOUND_ROWS() as total_records";

    $totalStatement = $this->_db->prepare($query);
    $totalStatement->execute();
    $record = $totalStatement->fetchAssoc();

    $pager->setTotalItems($record['total_records']);

    return $this->_buildCollection($records);
}

There are a few things to note here. SQL_CALC_FOUND_ROWS is a totally awesome mysql function that calculates the number of rows that would be returned if you did not include a LIMIT on the query. This is what is used to tell the pager how many total items there are. Also the DAO here is returning a collection. To see how that works check out this post I wrote a little while ago.

Since PHP passes objects by reference by default we can now use the same Pager object that we instantiated in our controller in our view. That would look something like this:

<h2>Page <?php echo $pager->getCurrentPage(); ?> of <?php echo $pager->getTotalPages(); ?></h2>
<h3>
    Displaying <?php echo $pager->getFirstOnPage(); ?> —
    <?php echo $pager->getLastOnPage(); ?> of <?php echo $pager->getTotalItems(); ?> Users
</h3>
<?php foreach ($users as $user): ?>
    <dl>
        <dt>id</dt>
        <dd><?php echo $user->id; ?></dd>
        <dt>email</dt>
        <dd><?php echo $user->email; ?></dd>
    </dl>
<?php endforeach; ?>
<?php if ($pager->hasPrevious()): ?>
    <p><a href="/view-users?page=<?php echo $pager->getPrevious(); ?>">previous</a></p>
<?php endif; ?>
<?php if ($pager->hasNext()): ?>
    <p><a href="/view-users?page=<?php echo $pager->getNext(); ?>">next</a></p>
<?php endif; ?>

I'm probably forgetting something here, but I think it is a good start and in my opinion it certainly eliminates any headaches caused from having to deal with pagination.

How to make an overlay using only one div

Craig Campbell — Thu, 12 Mar 2009 02:56:24 +0000

One thing I have realized in my journey across the internets is that there is no simple, clear way to make an overlay using only one div (at least that I could find). If you have no clue what I am talking about click on the "add comment" link, and you will see. The page dims, the curtain goes up and the audience applauds.

Just a small disclaimer: The CSS that I am about to show you will work just fine in all browsers except for Internet Explorer 6 (what a shock!). I will show you the necessary Javascript (using jQuery) needed to fix this.

The first step is to simply add one div inside the body tag like so:

The next step is to add the following to your stylesheet:

#overlay {
    display: none;
    position: fixed;
    top: 0px;
    left: 0px;
    width: 100%;
    height: 100%;
    z-index: 1000;
    background-color: #333;
    -moz-opacity: 0.5;
    opacity: .50;
    filter: progid:DXImageTransform.Microsoft.Alpha(opacity=50);
}

To go through this step by step:

display: none: This simply means don't show this div. The reason is obvious since we don't want our entire page to load with a colour on top of it. One thing to note is that we will have to use javascript to set the display here to block or something other than none when we want this to show up on the page.
position: fixed: This means that the top left point of the div is fixed at point (0,0) or whatever point you specify. This means intelligent browsers can scale the width and height to cover the whole window
z-index: 1000: You can think of the z-index as if you have many sheets of paper on top of another. Each layer is one above the previous. Unfortunately it doesn't always work as advertised. Setting this at 1000 just ensures that it is above all content on the page although it can really be any number greater than zero.
-moz-opacity: 0.5: This is a special css property that is specific to Mozilla Firefox. Like any of the other opacity settings: play around with it until it looks how you want it to.
opacity: .50: This is the default opacity property in css. Safari uses this.
filter: progid:DXImageTransform.Microsoft.Alpha(opacity=50): This whole nonsense is specifically for Internet Explorer 7. As you can see Microsoft so slyly inserted their name here.

Now you may be thinking, "That's it? We are done? That was so simple!". If only the world were that simple. We still have to take Internet Explorer 6 into account.

I'm pretty sure if Internet Explorer 6 were a child in elementary school it would be the last kid picked in gym class. Hmmm ... Actually it might be the kid that skipped gym class all together and was in the nurse's office being treated for its terrible diseases.

Anyway, the first thing we have to do is create a stylesheet specifically for IE6. To do that we use a CSS conditional statement in our html like so:

Now inside of overlay_ie6.css we add the following styles:

#overlay {
position: absolute;
filter: alpha(opacity=50);
}

This is because IE6 does not like position: fixed or the Microsoft filter used for IE7. Therefore we must do this so that it will begin to play nicely. The final step is adding a few lines of Javascript only for IE6. I am using jQuery cause it is my framework of choice and is very speedy and light weight. This is definitely a hack, and I do not really like hacks so if anyone has come across this problem before and has a more elegant solution I urge you to leave me a comment.

if (jQuery.browser.msie && jQuery.browser.version == 6) {
    var width = $(window).width();
    var height = $(window).height();
    var pageHeight = document.body.clientHeight;
    if (pageHeight > height) {
        height = pageHeight;
    }
    $("#overlay").css({width: width, height: height});
}

This code is fairly straight forward, but basically what it is doing is figuring out a pixel width and pixel height to set the overlay to for IE6. IE6 does not like using percentages in this case. First we get the height and width of the current window. Then we get the height of the window with content (assuming all of the horizontal content fits within the width of the window - no side scrolling). Whichever height is greater is the height we use at the end to explicitly set the height and width of the #overlay div.

That's all for now!

Syntax Highlighting For Your Blog Using TextMate!

Craig Campbell — Thu, 26 Feb 2009 05:37:34 +0000

I dare anyone to tell me a better way to spend the evening after an 11 hour workday staring at code than writing a blogpost about code. Haha, you'll have to forgive me if any of my writing seems scatterbrained that is most likely because my head is spinning like one of those amusement park rides that goes completely upside down and then stays there for 10 seconds before moving again.

Anyway I have only written a couple serious posts here and already I have had a few people ask me how I did my syntax highlighting. It is no secret online syntax highlighting solutions are not super amazing. They are pretty good, sure, but not awesome. That is where TextMate comes in. TextMate has a little known feature found in the Bundles menu under TextMate: Create HTML From Document.

That's it! Well not quite. The HTML TextMate generates is not perfect. For one it uses the <pre> tag which has been deprecated in XHTML 1.0 Strict. To fix that is easy just replace <pre> with <div> in the html as well as the styles. The next thing to do is move your styles out into their own stylesheet. One bizarre thing is that any user generated colours will appear in your stylesheet in the format color: rgba(255, 0, 9, 0.87); which will not work in Internet Explorer so you'll have to convert those to their hex values.

Also removing the <pre> tag will break the code in Internet Explorer:

pre.textmate-source {
    margin: 0px;
    padding: 0px 0px 0px 2px;
    font-family: Monaco, monospace;
    font-size: 12px;
    line-height: 1.3em;
    word-wrap: break-word;
    white-space: pre;
    white-space: pre-wrap;
    white-space: -moz-pre-wrap;
    white-space: -o-pre-wrap;
}

The fix is super simple, however. This is the one I am using on this site:

.textmate-source {
    margin-top: 30px;
    margin-bottom: 30px;
    font-family: "Monaco", monospace;
    font-size: 11.5px;
    line-height: 1.3em;
    word-wrap: break-word;
    white-space: pre;
}

.limit-height {
    height: 400px;
    overflow: scroll;
}

I added the extra margin in there just to give it some breathing room. Also if you want to make a scrollable box you can just add the "limit-height" class to the main div that holds your code. Another thing to note is that for some reason the "line-num" span class is in single quotes. It still validates, but you might as well make it double quotes for consistency. I am probably forgetting something, but I can barely keep my eyes open at the moment so I will add it if I think of it, but yeah very cool. Enjoy!

Cool Object Building With PHP

Craig Campbell — Tue, 24 Feb 2009 05:16:32 +0000

At work I write mostly PHP code and work among some very respected developers in the PHP community. One thing that bothers me about the PHP world is how most people think in terms of arrays instead of in terms of objects. This is understandable considering Object Oriented PHP didn't really come around until PHP 5 so using arrays is probably an old habit that is hard to get rid of, but that is no excuse. Arrays have their uses, but I think more often than not an object can be used instead.

One of the core problems most PHP developers run into is finding a way to map records in the database to PHP objects. This is understandable considering your database model is often very different from your object model, and at the moment PHP does not offer any great solutions that I know of. Basically my proposal involves two parts:

a DAO (data access object) class
a Builder class

What these classes do is very simple: The DAO contains the SQL to query the database and then calls a builder to take the resulting array and assemble an object (or a collection of objects) out of it which is then returned.

This implementation allows for no question about what is being returned and it forces you to use more objects in your code which is never a bad thing. Another plus is that you can cache the collections directly in memcache and therefore when you hit cache your PHP doesn't have to do any work at all with the data.

This is actually the method I am using on this site so I will demonstrate using real world examples, but before I do so I want to point out that much of the awesomeness in the example relies on a certain naming pattern for your classes. For example I have classes named Blog_Dao, Blog_Comment, Blog_Builder, etc.

The first code I am going to show you is the base DAO class I am using:

<?php
class Dao
{
    /**
     * @var Db
     */
    protected $_db;

    /**
     * @var Builder
     */
    protected $_builder;

    /**
     * constructor
     *
     * sets the database class this dao should use
     *
     * @return void
     */
    function __construct()
    {
        $this->_db = new Db();
    }

    /**
     * determines what builder class to use
     *
     * @param string $builder
     * @return Builder
     */
    protected function _getBuilder($builderName)
    {
        // if we have already instantiated a builder class
        if (!is_null($this->_builder)) {
            return $this->_builder;
        }

        // if we have not passed in a specific builder to use
        if (is_null($builderName)) {
            $builderName = str_replace('_Dao', '_Builder', get_class($this));
        }

        // make sure the builder exists
        if (!class_exists($builderName)) {
            throw new Exception($builderName . ' does not exist!');
        }

        // instantiate the builder
        $this->_builder = new $builderName;

        return $this->_builder;
    }

    /**
     * calls the builder to build a collection of the stuff returned from the
     * dao!
     *
     * @param mixed $records
     * @param string $builder name of class to use for building
     * @return Collection
     */
    protected function _buildCollection($records, $builder = null)
    {
        // if the database doesn't have any records
        if ($records === false) {
            return false;
        }

        $collection = new Collection();
        foreach ($records as $record) {
            $collection->append($this->_buildOne($record, $builder));
        }
        return $collection;
    }

    /**
     * calls the builder and builds a single object
     *
     * @param mixed
     * @param string $builder
     * @return Object
     */
    protected function _buildOne($record, $builder = null)
    {
        // if the database doesn't have any record
        if ($record === false) {
            return false;
        }

        $builder = $this->_getBuilder($builder);
        return $builder->assemble($record);
    }
}

The first thing you will probably notice is that $builder is optional! This means you only need to pass in a builder class if the builder is in some wacky place it shouldn't be. So the Blog_Comment_Dao class will default to the Blog_Comment_Builder which makes sense and it forces good use of objects cause it means everything you create a dao for is an object and that DAO should only return things related to that object. Another point of note is the Collection object. This is simply a child of ArrayObject to allow easier access to ArrayObject methods.

Anyway now it is time to see this in action! Here is actual code from this site to get all comments related to a given blog post taken from the Blog_Comment_Dao which extends the base Dao class:

/**
* retrieves all comments for a given blog
*
* @param int $blogId
* @return Collection
*/
public function get($blogId)
{
    $query = '/* ' . __METHOD__ . ' */' .
        "SELECT bc.id id,
                bc.name name,
                bc.website website,
                bc.email email,
                bc.body body,
                bc.posted_on posted_on
           FROM blog_comment bc
          WHERE bc.blog_id = :blog_id";

    $sth = $this->_db->prepare($query);
    $sth->bindValue(':blog_id', $blogId);
    $sth->execute();
    $records = $sth->fetchAllAssoc();

    return $this->_buildCollection($records);
}

Look how pretty that is! Now let's take a look at the Blog_Comment_Builder class to see how simple that is as well:

<?php
class Blog_Comment_Builder
{
    /**
     * creates a comment object from database record
     *
     * @param array
     * @return Blog_Comment
     */
    public function assemble(array $record)
    {
        $comment = new Blog_Comment();
        $comment->name = $record['name'];
        $comment->website = $record['website'];
        $comment->email = $record['email'];
        $comment->body = $record['body'];
        $comment->postedOn = new Date($record['posted_on']);
        return $comment;
    }
}

Something to note here is that these are not public properties. They are all protected, but each domain object extends a Domain_Object class that has magic __set() and __get() methods so you don't have to write setters and getters for every single property in every single class! For more on that check out this post by Matthew Purdon.

You can see that properties of objects can still be other objects such as the Date class here. In the case where you are showing a bunch of Users on your site and each one has a bunch of other classes associated it with it you probably wouldn't want to use the other class's builders because then you end up running queries in loops which is never a good thing. Instead you can handle that logic in the User_Builder cause at the end of the day even if there are other classes involved the Builder is just returning one object from one database record.

An obvious downfall here, of course, is that every object needs to have its own Builder class even though the builder seems like something that could happen automatically if there was better ORM support in PHP or any for that matter. This is something that PHP developers are used to, however, because no matter what framework you use, you still end up having to write tons of code to do even simple operations. Hopefully this will make your life easier.

Internet Explorer Ajax Requests Using GET

Craig Campbell — Sun, 22 Feb 2009 23:33:11 +0000

So after getting this page up and running I had to do my fair share of debugging to make things work with Internet Explorer. This is the part of the day that every web developer dreams about. "What is going to break this time??".

Anyway I decided to use my blog to share with you all solutions to problems I have come across so that you don't have to spend hours banging your head against the wall like I did.

The first topic I want to discuss in this series is ajax calls using GET.

To start I will paste to you the definition of GET from the World Wide Web Consortium

GET: The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI. If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the entity in the response and not the source text of the process, unless that text happens to be the output of the process.

Basically GET shows you what you should see based on the URI you request. For example on Facebook every user has their own profile defined by /profile.php?id=1234567 where the number following the = is your user id in the database.

Really GET should be used for just that: determining what to show you. Facebook uses GET to track things. Yes, Facebook tracks almost everything you do. For example when you go to the home page you will see &ref=logo or &ref=home in the URL depending on which link you clicked on. Facebook even attaches your user id to the url when you view another user's photos. This means they can find all the hotties that people look at pictures of the most, but that is a story for another time.

So you might wonder where I am going with this... On this site I set it up so blog comments are posted and retrieved with AJAX calls. This means the page doesn't have to refresh when you post a comment. Everything seemed great until I tried posting a comment on Internet Explorer. No matter how many times I refreshed the page I couldn't get my comment to show up. Does this mean it isn't being added to the database? Does this mean the AJAX call is not firing? No and no. What this means is that Internet Explorer caches AJAX requests made using GET.

For many things this would be fine like a page that is all static content, but for something like blog comments they are changing all the time (not on this site, however) this is unacceptable.

So there are a few ways to solve this problem including changing all requests to be POST. I opted to pass the current timestamp along in the URL. This tricks Internet Explorer into thinking that it is a page that has never been accessed before and you will receive the correct response :).

Here is the code (note I use JQuery for all my javascripts):

getComments : function()
{
    var timestamp = new Date().getTime();
    $.get(wwwUrl + "/ajax/blog/get-comments?blogId=" +
        this.id + "&timestamp=" + timestamp, function(html) {
        $("#comments").html(html);
    });
}

As you can see it is super simple. new Date().getTime(); returns the current UNIX timestamp in milliseconds so we get up to date comments! Go ahead and leave one to try it for yourself