Developer Tutorials' Webmaster Blog » PHP

Wordpress Comment Styling Round Up

JonGos — Fri, 30 May 2008 22:35:05 +0000

One question I hear people asking a lot is how to style the comment section in Wordpress. I didn’t have time to go in depth in my tutorial Designing and Coding a Wordpress Theme from Scratch but here are a few links from my del.icio.us to some blogs that break it down in far more detail.

NETTUTS: “Unraveling the Secrets Of the comments.php File”

One of the best tutorials I’ve ever seen related to customizing comments for Wordpress. Great for beginners because the explain EVERYTHING.

DARREN HOYT: “Styling Your Wordpress Comments”

Darren’s breakdown is a little bit less obtuse but gets the job done.

5THIRTY-ONE: “How To Style Wordpress Author Comments”

One of my favorite Wordpress designers makes his case.

THEMELAB: “Add Gravatar Support to Your Wordpress Comments”

Very basic guide on how to add images for your users.

TAMBA2: “Comment Styling”

Tamba2’s is a little old but still useful.

PHOTOMATT: “Display Comment Numbers”

This snippet of code from Photomatt is useful if you want to learn how to add numbers to your comments.

COLORFORGE: “Comment Template Deconstructed”

Wow, this guys comment template is incredibly beautiful and complex! Very much worth checking out.

Bookmark It

Hide Sites

Designing and Coding a Wordpress Theme From Scratch (Part 10)

JonGos — Wed, 30 Apr 2008 21:16:50 +0000

Part 3 - “Photoshop to XHTML in 24 Hours”
Part 4 - “Cleaning Up Your XHTML”
Part 5 - “Preloading Images with Javascript and CSS”
Part 6 - “Marking Up is Hard to Do” and “The Anatomy of a Wordpress Theme”
Part 7 - “Beginning with PHP for Wordpress”
Part 8 - “Putting the Press in Wordpress with PHP”
Part 9 - “Marking Up Header.php, Footer.php and Sidebar.php”

So far we’ve made a ton of progress with our theme design. We designed it in Photoshop, we converted to XHTML and then we began the somewhat tedious task of adding PHP. Now that we’ve created index.php, header.php, footer.php and sidebar.php, we can move on to creating the rest of the theme.

In “The Anatomy of a Wordpress Theme” we noted that Wordpress needs certain files for your theme to function properly. Here’s that list again:

404 Template = 404.php
~~Archive Template~~ = archive.php
~~Archive Index Page~~ = archives.php
Comments Template = comments.php
Footer Template = footer.php
Header Template = header.php
Links = links.php
Main Template = index.php
Page Template = page.php
~~Popup Comments Template~~ = comments-popup.php
Post Template = single.php
~~Search Form~~ = searchform.php
~~Search Template~~ = search.php
Sidebar Template = sidebar.php
Stylesheet = style.css

As you may have noticed, the items listed in bold are the only items we’ve created in our lessons thus far and there is still a lot of work to be done! Anything ~~struck through~~ is optional therefore this lesson won’t cover it but I have linked to pages where you can read about them on your own. While I can’t go into complete detail I will highlight some major points about each and then I’ll give you links to four sites that break the process down in detail and more thoroughly:

single.php

Single.php is the file referenced when someone clicks on the permalink for one of your posts. Thus it is the template for displaying a single post on your blog. On most blogs single.php an index.php are very similar except that in addition to querying we also have to query the comments page. We do this just before we close the loop with:

page.php

Page.php is the template for any page in your theme that doesn’t have it’s own .php template or that is not a blog entry. This is also the template for the static “Pages” that you create within the Wordpress Admin panel. It is usually also just like index.php except that it doesn’t include the loop or the_content().

links.php

Ignores Page content and instead displays your links using get_links_list.

404.php

Where you users land when they follow a bad link on your blog or click through to something that’s been removed. Codex offers some advice….

While you work hard to make sure that every link actually goes to a specific web page on your site, there is always a chance that a link clicked will slam dunk and become a famous 404 ERROR PAGE NOT FOUND. Some errors are avoidable, you should regularly check and double check all your links. Also, if you are deleting a popular but out-of-date post, consider deleting the body of the post, and replacing it with a link referring visitors to the new page.

This concludes “Designing and Coding a Wordpress theme from Scratch” . This guide was written as a starting point and a reference guide I can always be contacted at jongos [at] gmail if you are having trouble or need advice. Alternatively I’ve compiled a list of resources that I often reference when creating themes below.

In this tutorial I mentioned a theme that I was developing quite a bit. You can download it along with the PSD used to create it here. Keep in mind that the version you’re downloading is an early beta release. It’s bulky, clunky, not very pretty under the covers and has a mind of it’s own so I’m dubbing it the Rosie O Donnell release. Feel free to give me feedback on it, use it to double check your own code, or modify it to suit your needs.

DOWNLOAD THE AQUA MARINA WORDPRESS THEME

Recommended Further Reading

Stepping_Into_Templates
HTML to XHTML
So You Want To Create Wordpress Themes
From XHTML/CSS to Wordpress
Tamba2’s Guide
Slizing a Wordpress Theme

Bookmark It

Hide Sites

Learn regular expressions in PHP

Akash Mehta — Wed, 30 Apr 2008 11:00:04 +0000

Love them or hate them, regular expressions are here to stay. When it comes to quickly dealing with large blocks of data, batch processing operations or screen scraping, regular expressions are often the most effective solution. There’s just one problem, though - learning them can be as hard as learning a new language altogether. Here’s how to get off to a flying start.

First, you need to how regular expressions work. Stick with PCRE - the preg_* functions - they’re faster, more reliable and expressions for them are more common. The different styles of regular expressions each define a mini language for matching patterns within a block of text. Screen scraping is probably the most popular example. Consider this:

1
Not 1.
Yet another link.

What if you wanted to programmatically extract the link URLs and text from each of these? At this level of simplicty, some basic explode()s might be enough, and when you need to be more tolerant for the data, XML parsing is probably the way to go. But for now, just looking at that, regular expressions would be the easiest way. And we can build a pattern that defines what is to be matched so that the regular expression engine (in this case, PCRE) will find all matches and give them to us.

One of the best ways to understand regular expressions in practise, I find, is to consider mod_rewrite. You’ve seen those fantastic URLs on websites - e.g. http://example.com/users/myusername - these don’t actually exist as a file, but we can use Apache’s mod_rewrite engine to “rewrite” these URLs to other URLs. We might make that /users/(some username) go to /users.php?username=(the username). The best tutorial for this, by far, is the corz.org htaccess tips and tricks guide. Have a very thorough read through this and experiment with it extensively before you go on.

Next, get equipped to test out regular expressions. You’re probably using Firefox. If you aren’t, get it. Then get the Regular Expressions Tester Firefox extension. This will be invaluable for experimenting with regular expressions - the best way to learn.

Of course, you’ll need to be familiar with the PHP functions that will provide your regular expression workhorse. Bookmark the preg_match function’s manual entry and refer back to it as you need to. The manual page has some invaluable examples which you should read through extensively.

Finally, when in doubt, keep a cheatsheet at hand. ILoveJackDaniels.com has a fantastic regular expression cheatsheet that you should also bookmark.

With all these ready, you’ll be off to a great start. Remember, the best way to learn is to practise — read through real, working code, then write your own. Once you’ve finished all this, you’ll be a regular expression whiz in no time.

Bookmark It

Hide Sites

Designing and Coding a Wordpress Theme From Scratch (Part 7)

JonGos — Tue, 29 Apr 2008 13:51:45 +0000

This is the seventh post in series about creating Wordpress themes with your Photoshop designs. You may want to review before we continue….

Part 1 - “Tools For The Task” and “Preparation”
Part 2 - “Layout And Structure” and “Designing Wordpress Themes in Photoshop”
Part 3 - “Photoshop to XHTML in 24 Hours”
Part 4 - “Cleaning Up Your XHTML”
Part 5 - “Preloading Images with Javascript and CSS”
Part 6 - “Marking Up is Hard to Do” and “The Anatomy of a Wordpress Theme”

Beginning with PHP for WordPress

First we’ll duplicate index.html and rename the copy index.php. We’re only keeping the original .html file for reference to make sure that the finished PHP operates and looks the same.
Let’s open index.php in our text editor. Right now it’s just a .html renamed .php. Our job is to make make it true PHP.

Go ahead and create some more blank documents in your theme folder. Let’s call them header.php, footer.php and sidebar.php (if you have a side bar in your theme). We’re going to divide the HTML into the major sections and make each section it’s own PHP file to be marked up separately.
Cut everything that you consider the header of your document. Make sure all tags are closed. Below you’ll find an example of my code which is really irrelevant, your own code will look and function differently based on your unique design. Still, for the sake of a working example:




The Wonderful World of Web Design!







	
    The Blog Title
	
    
    ADVERTISE  |
    CONTACT  |
    RSS
    
    
    HOME
    NEWS
    BLOG
    HIRE ME
    PORTFOLIO
    QUESTIONS
    LINKS
    POPULAR

Paste your header information in to header.php. Do the same for sidebar and your footer, cutting the code from index.php and pasting it in the corresponding file.
I use comment tags like to write notes that help me remember what’s going on in my code.
If you do this correctly you’ll be left with a pretty sparse index.php document. All that should be left is some That’s good because now we’re going to tell index.php where to find all the information we just moved. We do this with PHP functions like so:

This get_ function does exactly what it sounds like it goes and fetches a requested document and displays the contents of that document in the area requested. My index.php document looked like this:

Ofcourse, for now we’ll leave the body
’s empty. This is where our content will eventually go.
You’ll notice that I have no sidebar, that’s because I call for it in the header.php document instead. Why? Because browsers read code from top to bottom and I want page to request the header and side bars to first before requesting the body.

In the next lesson we’ll start to analyze the PHP functions needed to request and display the dynamic content of a Wordpress theme.

Bookmark It

Hide Sites

Designing and Coding a Wordpress Theme From Scratch (Part 6)

JonGos — Tue, 29 Apr 2008 12:37:31 +0000

This is the sixth post in series about creating Wordpress themes with your Photoshop designs. You may want to review before we continue….

Marking Up Is Hard To Do

Wikipedia defines the term markup as a set of annotations to text that describe how it is to be structured, laid out, or formatted. When we say we’re going to ‘mark something up’ it means we’re formatting the document so that it can be read correctly by machines. Hypertext Markup Language (HTML) is the most common form. That can be marked up to Extensible Hyper-text Markup Language (XHTML) and beyond that to PHP to become dynamic.

Now that we’ve got our basic html layout design we can begin the hard work the transition from HTML to PHP.

Anatomy of a WordPress Theme

Before we get ahead of ourselves let’s analyze exactly what Wordpress is expecting from a theme. The Wordpress engine works primarily using separate PHP files for the different components of the core engine. The various parts of your theme will simply call for various parts of the core engine to display content. This makes it easy for you to style sections individually. It also can allow for some incredibly complex themes that are built on the Wordpress engine. Themes like the The Unstandard by Derek Punsalan and Redoable are great examples of how to rethink the Wordpress theme impressively.

Fundamentally, the WordPress Theme system is a way to “skin” your weblog. Yet, it is more than just a “skin.” Skinning your site implies that only the design is changed. WordPress Themes can provide much more control over the look and presentation of the material on your website.

A WordPress Theme is a collection of files that work together to produce a graphical interface with an underlying unifying design for a weblog. These files are called template files. A theme modifies the way the site is displayed, without modifying the underlying software. Themes may include customized template files, image files (*.jpg, *.gif), style sheets (*.css), custom Pages, as well as any necessary code files (*.php).

Here are the things Wordpress looks for a theme file:

404 Template = 404.php
Archive Template = archive.php
Archive Index Page = archives.php
Comments Template = comments.php
Footer Template = footer.php
Header Template = header.php
Links = links.php
Main Template = index.php
Page Template = page.php
Popup Comments Template = comments-popup.php
Post Template = single.php
Search Form = searchform.php
Search Template = search.php
Sidebar Template = sidebar.php
Stylesheet = style.css

For the most part, if you’re missing any of these parts your theme either won’t work or won’t fully function the way Wordpress wants it to. So far the only thing we’ve completed is stylesheet.css so where do the rest come from? In Part 7 we’ll create index.php and start marking up our XHTML to PHP.

Bookmark It

Hide Sites

Iterating PHP objects, and readable code too!

Akash Mehta — Tue, 29 Apr 2008 12:22:17 +0000

Today I’m going to take a look at object iteration, most commonly found in the Standard PHP Library, and explore using the Iterator interface to simplify looping.

It’s a generally accepted fact that more readable code is more maintainable and easier for other developers to pick up. Simple scripts can be easily worked around these principles, but the moment we explore any complexity the intricacies of the language impede basic readability - just look at the average Perl script, for example.

The Standard PHP Library (SPL) religiously utilises iteration for some outstanding results (and great code simplicity). PHP’s native language constructs are very readable, and by simplifying our code we can build applications faster and more effectively. The SPL demonstrates this with the power of its classes integrating with language constructs, such as the foreach loop.

Looping is probably one of the most common elements of PHP applications. Take this simple example, for instance:


$vegetables = array("tomato", "carrot", "cauliflower");
foreach ($vegetables as $vegetable) {
    print $vegetable . "\n";
}
?>

As you can see, this is a very simple example, and probably doesn’t reflect a lot of the loops in your day-to-day development. They might look a little more like this:


foreach (($records = $db->get($this, RECORDS_PER_PAGE)->rs->array) as $row) {
    print $row;
}
?>

That’s a bit of an exaggeration - assignments in a foreach loop is not a good idea and (thankfully) isn’t very common - but it demonstrates the fundamental problem with common uses of loops - they stop making sense.

What if we could improve that? Consider this example:


foreach ($db as $row) {
    // ...
}
?>

Where $db is an object. That’s right, iterating over an object. Now, typically when we iterate over an object, we get an array of its public properties. In this case, we can control from within the object $db precisely what we get when we iterate over it, by implementing the Iterator interface.

This can work just fine, as when you iterate over an object, you can probably write a little bit of code within that object so that it knows what you wanted in the previous more complex example. For example, if you’re running a database query then fetching the resultset, you can instead run the database query then “fetch” the entire database object. When you iterate over the database object, it now knows that you really want to iterate over the resultset - and it can do just that.

Here’s an example of the class that $db might be an instance of:


class MyDatabase implements Iterator
{
    private $data = array();
 
    public function __construct()
    {
        $this->data = array("Result 1", "Result 2");
    }
 
    public function rewind() {
        reset($this->data);
    }
 
    public function current() {
        $var = current($this->data);
        return $var;
    }
 
    public function key() {
        $var = key($this->data);
        return $var;
    }
 
    public function next() {
        $var = next($this->data);
        return $var;
    }
 
    public function valid() {
        $var = $this->current() !== false;
        return $var;
    }
}
?>

As you can see, it’s a perfectly normal class, implementing methods with names close to the standard array functions. When your object is iterated over, these Iterator methods will be called where needed. What actually happens inside the methods is up to you — in this instance, we store the data in an array, $this->data, but it could as well be a complex recordset or XML node tree. As long as calling the appropriate methods performs the action needed, our class can manage its data internally and all we have to do is iterate over it like any other PHP array.

And just for readability, we could always go a step further:


$books = &$db; // $books is now our $db object
foreach ($books as $book) {
    // ...
}
?>

Now isn’t that what you’d like to see when working with someone else’s code?

For further reading on object iteration, check out the manual page on iterating objects. Also take a look the standard PHP library functions.

Bookmark It

Hide Sites

PHP array_walk(): Run an array through a function

Akash Mehta — Tue, 22 Apr 2008 08:41:28 +0000

If you’ve been developing with PHP for a while, you’ve probably come across this situation in the past:


It’s a common sight: taking an array and running (well, walking) its elements through a particular function. Luckily, PHP provides a simple yet powerful function to overcome this: array_walk().
Usage

Using array walk is simple. It takes two arguments, an array of data and a callback function to pass the array to. It examines the array and calls the callback function with each element of the array, allowing you to run the entire array through the function without extracting the array yourself. Consider this:
&$element) $element = some_function($element, $key);

// becomes this:
array_walk($somearray, "some_function");

It’s cleaner, faster and more effective. It also gives your callback function more information than you might usually provide. The callback parameter can be any : “function_name”, array(’Class_name’, ‘method_name’) or even array($object, ‘method_name’) (where $object can be $this as needed).

Syntax

The syntax is very simple:
array_walk (array &$array, callback $callback[, mixed $userdata]);
The first parameter is the array that you want to run through the function. The second is the callback - for a function, class method or object method. The third allows you to pass a third parameter to the callback function from within the current context. This can be anything at all, and along with the array element and its key/index, will be passed directly to the function without modification.
For more details, see array_walk() in the PHP manual.


Bookmark It











Hide Sites

PHP-friendly web services/APIs for quick mashups

Akash Mehta — Fri, 04 Apr 2008 05:57:39 +0000

If you want to build a useful app quickly, you can’t go past a mashup. Take data from someone else’s service, come up with a useful way to mix it up and present it to your users in an innovative manner. Even better, as my recent PHP Site Search tutorial showed, you can build a mashup in just a few lines of code. But how do you find useful web services/APIs, and how do you process the data they provide?

Finding APIs/web services

Finding APIs and web services is really quite easy. If you regularly use a web application - for example, I’ve often used Twitter - check if the application provides an API (Twitter has quite a comprehensive one). Next, if you’re looking for data on a particular topic, try searching for it. A quick search for “map api” returns all kinds of useful results. Finally, if you just want to take a look at the internet’s available APIs, head to Programmable Web; they have by far the most comprehensive database available, and it’s fully searchable.

Handling API output

The easiest way is a really PHP-friendly APIs that provides serialized PHP. You can just fetch the URL with file_get_contents(), and run the output through unserialize(); in two lines of code, you have your data ready to work with.

However, most APIs won’t offer serialized PHP output; some might offer JSON, or JavaScript Object Notation, which is somewhat like PHP’s serialized data (although JSON is integrated in the JavaScript language). Others offer XML gateways, while some even provide SOAP, a (rather complicated) means for computers to talk to each other natively. You really have three options:

1. Interpret the output of the API or web service with a PHP-based parser, such as an XML parser (which you can easily find on phpclasses.org) or a SOAP client (try nusoap).
2. Use PHP sample code provided by the API/web service owner - e.g. this Google Checkout PHP sample. Some even provide PECl extensions.
3. Use a third-party library to access the service. For example, people have written PHP classes that allow you to interact with the Flickr API. PHP Classes.org has hundreds of these, and others are just a web search away.

Some PHP-friendly APIs

Of course, if you just want to get started right now and quickly add some functionality to your application, try these:

reCAPTCHA PHP library: add effective CAPTCHA to your application in pure PHP with reCAPTCHA
Yahoo PHP developer center: Yahoo! provides some very useful search APIs that you can probably use. Also see my PHP Site Search Made Easy tutorial making use of these APIs.
Flickr Services with PHP Response

Have a look through these APIs and you could be building a mashup quickly in no time.

Bookmark It

Hide Sites

PHP 6 now with .net: Visual Studio integration available already

Akash Mehta — Tue, 01 Apr 2008 09:47:02 +0000

Edit: This was partly an April Fool’s joke, as many PHP scripters would be incredulous at the mere idea of PHP integration with Microsoft products. However, as you might have noticed, much of this post is very much real - besides the compulsory .net with PHP 6, of course. The Phalanger project has made done some fantastic work on compiling PHP with .net/Mono, and is definitely worth a look.

When it comes to the enterprise software development market, Microsoft pretty much has it cornered. After all, who else can boast of a complete software ecosystem, fully supported by the company behind one of the world’s wealthiest men? From Visual Studio to the various certifications, VB being taught in schools and even the wide penetration of the Visual Studio family of development environments, MS has pretty much got it in one. But it’s .net that seals the deal: the cross-language runtime environment is perfect.

PHP, .net and Silverlight will be integrated out of the box, along with Visual Studio 2008. The project has long been in the works, but our sources have informed us of an impending announcement that PHP 6 will ship with .net. (Our sources are unreliable, but their information is fascinating! - Ashleigh Brilliant.) Versions 1.0, 2.0 or 3.5 of the .net framework will be a part of the basic requirements of PHP 6 as a result. Here’s a sample:

The .net integration was made possible by the Phalanger project, which has been working hard on this for quite a while - with the help of Redmond, of course.

The Visual Studio IDE typically ships as an IDE with a particular language, merging together when additional languages are added. Microsoft has since released Visual Studio 2008 Shell, an IDE with no particular language environment, in which PHP/Phalanger can be added. Debugging of .net and Silverlight is possible thanks to the integration of Visual Studio. Once installed, a new PHP project will be available from within Visual Studio 2008. WinBinder now has competition for Windows RAD PHP development:

Sysadmins with Windows servers running applications that conflict with the .net CLR are advised to upgrade to the Intercal interpreter once PHP 5 support is dropped.

Bookmark It

Hide Sites

Open Source Social Networking Server: Built on LAMP!

Akash Mehta — Fri, 28 Mar 2008 12:11:09 +0000

Social networking just keeps on growing. It seems every major public business wants a Facebook application, corporations are adding social features to their websites, and organisations are bringing social networking into their intranets. Previously, building your own social networking applications involved some serious engineering challenges. Thanks to Ringside Networks, that just got a lot easier, with an open source (LGPL) social networking server built entirely on LAMP.

So, what is Ringside, exactly? From a developer perspective, it’s a social networking application server built on PHP and MySQL, designed to be integrated into your existing applications. If you’ve already got a web application, just add Ringside to manage the social networking side of things. It’s thoroughly documented - just check out the seven page developer setup guide detailing everything you need to setup your LAMP stack and your Eclipse+PDT development environment. You can even install Ringside via PEAR: they’re serious about their PHP.

But what does Ringside mean for social networking? For a start, it could seriously break apart the market for social networking websites. Facebook application development? Forget it. Sure, there’s a big audience with Facebook, but OpenSocial will bring users away from specific providers, while Ringside will give them somewhere else to go. Thanks to Ringside, building a custom social networking application is now much easier, and while it still doesn’t have the simplicity of an online-DIY hosted solution like Ning, it will make it a lot easier to integrate social networking.

On a more general scale, this will also help immensely in bringing LAMP closer to the corporate world. Sure, many corporations are already on it, and if LAMP can handle Yahoo!, no challenge is too great. Still, formally-backed proprietary solutions such as Microsoft’s Windows Server and Small Business Server are highly effective for many areas of a business networ, and with those in place, IIS and ASP.net are the obvious next step. (And there’s always Community Server.) With Ringside, and the ease of building on open source platforms in general, there’s now a much stronger use case for corporations, and these high-end corporate LAMP jobs will no doubt raise the profile of our section of the industry in general.

So, as a LAMP developer, you now have this proposition before you: do you want to learn about the Facebook API, when you could start reading up on the Ringside manual?

Bookmark It

Hide Sites