What just happened?

When the page is loaded, the get_bookmarks filter is executed:

add_filter('get_bookmarks', WPLiveRoll_GetBookmarksFilter);

At this point, our filter function WPLiveRoll_GetBookmarksFilter() takes care of the blogroll processing:

function WPLiveRoll_GetBookmarksFilter($items)
{
    // do nothing if in the admin menu
 
 if (is_admin())
     {
        return $items;
     }

Since the get_bookmarks filter is activated on the administration pages (where we do not want to do anything), we are making a check by using the conditional tag is_admin. It will return true if the user is currently viewing the admin panel pages, in which case, we simply return the unprocessed items.

Next, we loop through all the links in the blogroll, and check to see if they are enabled:

    // parse all blogroll items
    foreach($items as $item)
    {
         // check if the link is public
 if ($item->link_visible=='Y') 
          {

Now, when we have a published link we need to find the RSS feed from the site.

A detailed approach would involve loading the content of the page and processing it for the <link> tags and searching for one of the possible RSS formats.

For the purpose of this example, we will keep it simple by guessing the feed based on the site name, which will work for most blogs (you can develop a more comprehensive RSS discovery function as an exercise):

  $link_url=trailingslashit($item->link_url);

  // simple feed guessing
  if (strstr($link_url,"blogspot.com"))
  {
    // blogspot blog
    $feed_url=$link_url."feeds/posts/default/";
  }
  elseif (strstr($link_url,"typepad.com"))
  {
    // typepad blog
    $feed_url=$link_url."atom.xml";
  }
  else
  {
    // own domain or wordpress blog
    $feed_url=$link_url."feed/";
  }

Now that we have the feed URL, we can fetch the contents of the feed using the WordPress function fetch_rss():

  // use WordPress to fetch the RSS feed
  $feedfile = fetch_rss($feed_url);

The result should be an array of objects; each one representing information about a single post sorted by date.

First, we check to see if we get a valid response,

  // check if we got valid response
  if (is_array($feedfile->items )
  && !empty($feedfile->items ) )
  {

And then replace the blogroll URL and name with latest post's URL and title:

    // this is the last post
    $feeditem=$feedfile->items[0];
    // replace name and url with post link and title
      $item->link_url=$feeditem['link'];
      $item->link_name=$feeditem['title'];
    }
   }
  }
  // return the items back
  return $items;
}

In the end we return the items. Note that if we do not get a valid response, the original link will stay intact. It is a very simple automatic fallback in case we cannot parse the feed for some reason.

Our code needs RSS functionality, which comes through the rss.php file of the WordPress installation:

require_once(ABSPATH . WPINC . '/rss.php');

We included it using two WordPress defines, ABSPATH and WPINC, which contain the absolute path to the WordPress installation and the path to the WordPress includes folder.

RSS Feed Processing

WordPress provides a very easy to use function, fetch_rss(), to process the RSS feeds. The function relies internally on RSS feed library that comes included with WordPress, and takes care of the all the related work.

The function returns an array of feed items, which you can easily loop through to extract the information you need:

$feedfile = fetch_rss($feed_url);

foreach($feedfile->items as $item )
{

You may have noticed a pause when loading the blogroll for the first time. This is caused by the fetching of the feeds and is especially noticeable if you have many links in your blogroll.

This delay exists only for the first time when new feeds are parsed. The RSS library has a built-in mechanism for caching the feeds. That means that for the next request, the feed will be served from the local cache if it has not been updated in the meantime.

The method we use is simple and effective, but now we want more interactivity. We do not want any delay in loading; we want to show more recent posts, and show them in a pop-up window. In order to achieve all this, we need to use a language specifically written to handle events on a web page—JavaScript.