It was a great idea, and I finally got around to writing one for my own plugins. I built it as an abstract class (and a tiny CSS file) that I extend for each plugin. Here you’ll get to see a quick tour of what the framework does. Let me know in the comments if you’re interested in seeing a walkthrough of how it was built, and feel free to download Efficient Related Posts to see it in action.

Here are some of the things it does:

• Stores plugin settings in a protected variable, making them easily available to all methods.
• Registers the options for the plugin (making sure it works in WPMU and that options.php can handle updates to the options).
• When an update to the plugin is available, it shows a changelog from the currently installed version to the newly available version (whether they’re one version apart or twenty).
  
• Adds an options page for the WordPress plugin settings, complete with a page heading and a Xavisys icon.
• Styles the options page as two columns with meta boxes (similar to the two column dashboard layout).
  
• Adds basic meta boxes to the sidebar of the options page, including one with a donate link, one with a link to the support forums, and one showing the latest news from Xavisys.
  
• It adds links to the plugin row on the plugins page. One link to the support forums and one to the plugin options page.
  
• It adds a dashboard widget with a feed from Xavisys, complete with the Xavisys logo and a way to subscribe via RSS to the Xavisys site.
  
  

It does all this based on variables set in the extending class. For example, the setup for Efficient Related Posts looks something like this:

require_once('xavisys-plugin-framework.php');
class efficientRelatedPosts extends XavisysPlugin {
	protected function _init() {
		$this->_hook = 'efficientRelatedPosts';
		$this->_file = plugin_basename( __FILE__ );
		$this->_pageTitle = __( 'Efficient Related Posts', $this->_slug );
		$this->_menuTitle = __( 'Related Posts', $this->_slug );
		$this->_accessLevel = 'manage_options';
		$this->_optionGroup = 'erp-options';
		$this->_optionNames = array('erp');
		$this->_optionCallbacks = array();
		$this->_slug = 'efficient-related-posts';
		$this->_paypalButtonId = '9996714';
	}
}

Related Posts:

• 10 Great WordPress Plugins
• How To Make Your Own WordPress Widget
• WordPress Core vs Canonical Plugins
• GPL Themes Get Some Love, Plugins Suffer?
• WordPress Developer Meeting – July 01, 2009

If you want to request a feature, or need support, go to the Efficient Related Posts Support Forum. More information is available on the Efficient Related Posts page.

Related Posts:

• The Problem with Related Post Plugins
• The Xavisys WordPress Plugin Framework
• 10 Great WordPress Plugins
• Manual Related Links
• Efficient Related Posts

Join the forum discussion on this post - (1) Posts

If you want to request a feature, or need support, go to the Twitter Widget Pro Forum. For more information, go to the Twitter Widget Pro page.

Related Posts:

• 10 Great WordPress Plugins
• The Xavisys WordPress Plugin Framework
• Twitter Widget Pro
• GPL Themes Get Some Love, Plugins Suffer?
• The Problem with Related Post Plugins

I also added in some links to the WordPress Twitter Widget Pro Support Forum to make it easier for you to ask questions or make suggestions or requests. For more information, go to the Twitter Widget Pro page.

Related Posts:

• 10 Great WordPress Plugins
• The Xavisys WordPress Plugin Framework
• Twitter Widget Pro
• GPL Themes Get Some Love, Plugins Suffer?
• The Problem with Related Post Plugins

Join the forum discussion on this post - (5) Posts

Related Posts:

• 10 Great WordPress Plugins
• The Xavisys WordPress Plugin Framework
• Twitter Widget Pro
• GPL Themes Get Some Love, Plugins Suffer?
• The Problem with Related Post Plugins

1. Akismet
2. Simple Trackback Validation
3. Headspace2
4. Clean Slugs
5. Google XML Sitemaps
6. Twitter Widget Pro
7. WP Super Cache
8. Sociable
9. Subscribe to Comments
10. Twitter Tools

Akismet

Akismet is the only useful plugin that ships with WordPress (so to speak). It requires that you sign up for an API key, but it’s well worth it. Comment spam is a huge problem on any site that allows comments. The WordPress Akismet plugin checks your comments against the Akismet web service to see if they look like spam or not and lets you review the spam it catches under your blog’s “Comments” admin screen. It’s actually quite effective, more than most (if not all) the other comment spam plugins I’ve tried.

Simple Trackback Validation

Fighting spam is the never ending task of anyone running a site that allows user content of any kind. Akismet does a great job of handling the comment spam, but Simple Trackback Validation fills in the gaps and handles trackbacks. Simple Trackback Validation Plugin performs a simple but very effective test on all incoming trackbacks in order to stop trackback spam. Basically, it makes sure that the page claiming to be posting a trackback actually links to the page it’s posting that trackback to.

Headspace2

WordPress is pretty good with search engine optimization right out of the box, just by turning on permalinks. However, there’s definitely plenty of room for improvement. HeadSpace2 is an all-in-one meta-data manager that allows you to fine-tune the SEO potential of your site. Headspace will help you to better handle your tags/keywords, meta descriptions, and it does a great job of cleaning up and customizing your title tag. No longer do you need a bunch of conditionals in your title tag. A simple wp_title(”) will suffice, and the rest can be handled by Headspace2.

Clean Slugs

Another plugin that will help you get a little better search engine optimization. Joost’s Clean Slugs plugin looks for and removes more than 650 “stop words” from your post or page title when the slug is created. These are words that most search engines ignore because they are inconsequential, so removing them will help your raking. Unlike all the other plugins on this list, this plugin can’t be downloaded from the Wordpress.org repository. To get this plugin, simply sign up for Joost’s WordPress Newsletter.

Google XML Sitemaps

While it’s true that search engines can spider or crawl your site by following links, having a proper XML sitemap allows you to make sure that every post/page is properly indexed, as well as letting you specify a priority level for each. This plugin will create a Google sitemaps compliant XML-Sitemap of your WordPress blog. It supports all of the WordPress generated pages as well as custom ones. Everytime you edit or create a post, your sitemap is updated and all major search engines that support the sitemap protocol, like ASK.com, Google, MSN Search and YAHOO, are notified about the update.

Twitter Widget Pro

Twitter offer javascript widgets that display your latest tweets, but there are a couple problems. First, you need to be able to modify your theme or put the code into a text widget. Secondly, since it’s javascript, search engines don’t see the content. Twitter Widget Pro is a widget that properly handles twitter feeds, including @username and link parsing. It supports displaying profiles images, and even lets you control whether to display the time and date of a tweet or how log ago it happened (about 5 hours ago, etc). It does all this as a server-side widget, so the content can all be parsed by search engines. Requires PHP5.

WP Super Cache

WP Super Cache is a static caching plugin for WordPress. It generates html files that are served directly by Apache without processing comparatively heavy PHP scripts. By using this plugin you will speed up your WordPress blog significantly, reduce CPU/memory usage, and lessen database strain. If you have a high-traffic WordPress site, this is absolutely necessary.

Sociable

Social marketing is a hot topic and many have found that it’s incredibly successful. There are a few plugins for WordPress that will help you with this. Add This, Share This, and Sociable are the most popular, and I think Sociable is the best. It’s the only one that allows all content to be loaded from your site, no scipts or images to load from some other site. The reason this is so important to me is that I don’t ever want my site to load slowly because of a different site. Sociable automatically add links to your favorite social bookmarking sites on your posts, pages and in your RSS feed. You can choose from 99 different social bookmarking sites!

Subscribe to Comments

Getting people to comment on your posts can be a challenge. Even more difficult is getting people to come back to the same post and continue a discussion. Subscribe to Comments is a robust plugin that enables commenters to sign up for e-mail notification of subsequent entries. The plugin includes a full-featured subscription manager that your commenters can use to unsubscribe to certain posts, block all notifications, or even change their notification e-mail address!

Twitter Tools

Twitter Tools is a plugin that creates a complete integration between your WordPress blog and your Twitter account. The only part of it that I use is the ability to automatically notify Twitter of new posts. The problem is that it prefaces all these Tweets with “New blog post:” and this text isn’t customizable. Additionally, it uses tinyurl to shorten the URL for the post, and I would prefer that it let me use something like SnipUrl which lets me track the number of clicks. Still, the fact that it’s all automatic saves a lot of time for me, especially on sites like Web Developer News where people other than me post articles on a regular basis.

Related Posts:

• The Xavisys WordPress Plugin Framework
• Twitter Widget Pro
• GPL Themes Get Some Love, Plugins Suffer?
• The Problem with Related Post Plugins

To read more about how to use the shortcodes and to download the plugin, go to the Twitter Widget Pro page. For support, go to the Twitter Widget Pro Forum

Related Posts:

• 10 Great WordPress Plugins
• The Xavisys WordPress Plugin Framework
• Twitter Widget Pro
• GPL Themes Get Some Love, Plugins Suffer?
• The Problem with Related Post Plugins

Xavisys Website Development

Start with just a link exactly as you would make it for any other purpose, and make sure to give the link an id so that we can use that to apply our styles:

<a href="http://xavisys.com" title="Professional WordPress Development" id="xavisys-logo">Xavisys Website Development</a>

That’s all the (X)HTML you’ll need to make your background image clickable. Your link should look something like this: Xavisys Website Development

So, how can we make a background image a clickable link? It turns out it can be done with a clever CSS trick. Let’s get started by adding the background image and make the link the same size as the image (so you can see the whole image). Since an anchor tag isn’t a block level element, we need to force it to display as “block” so that we can specify the size:

#xavisys-logo {
	background-image:url(/wp-content/uploads/2009/11/email_logo.gif);
	display:block;
	height:58px;
	width:200px;
}

At this point it should look something like this: Xavisys Website Development

Now all we need to do is hide the text. This can be done using “text-indent” and indenting the text completely off the screen like this:

#xavisys-logo {
	background-image:url(/wp-content/uploads/2009/11/email_logo.gif);
	display:block;
	height:58px;
	text-indent:-9999px;
	width:200px;
}

And the finished product looks like this: Xavisys Website Development

And there you have it – a quick CSS trick with clean markup that turns your background images into clickable links. The best thing is, these don’t adversely affect your SEO and can even be easily used inside of header tags if needed!

Related Posts:

• Becoming a Freelance Web Developer/Designer
• New Web Development Resource Launched
• Free Template: Minimalist
• Free Template: BlueBox
• Dilbert

The widget we’ll be creating will display upcoming posts (scheduled posts). A lot of sites schedule posts to automatically publish at a specific time, helping them keep a steady flow of articles. I know that I use this trick on Web Developer News and Attackr, and I’ll use it on this site as soon as I get some more articles written. Since the articles are already there and ready to be posted, why not tease them and give your readers something to look forward to? That’s exactly what this widget will do.

To start, you need to create a class for your widget that that extends WP_Widget. We’ll be using WP_Widget_Upcoming_Posts. Then you should hook into the widgets_init action and use register_widget() to register your new widget. The bare bones skeleton looks like this (and does nothing but throw a warning):

/**
 * Upcoming_Posts widget class
 */
class WP_Widget_Upcoming_Posts extends WP_Widget {
	// Our Widget methods will go here
}
function registerUpcomingPostsWidget() {
	register_widget('WP_Widget_Upcoming_Posts');
}
add_action('widgets_init', 'registerUpcomingPostsWidget');

Now, there are a few methods that you need to create. The first needs to be named the same as the class (WP_Widget_Upcoming_Posts in this case), which will be used to instantiate the widget. Do not use the PHP5 __construct, as the WP_Widget class uses that and you end up with an infinite loop if you do. Second, you must create a widget method, which is used to actually manage and display your widget. In our case we’ll also be overloading the update method to handle updates to widget settings and the form method which is used to display the setting form on the widget admin page. I’m going to go through each method, explain the code, and then put it all together.

First, the WP_Widget_Upcoming_Posts method:

function WP_Widget_Upcoming_Posts() {
	$widget_ops = array('classname' => 'widget_upcoming_entries', 'description' => __( "List scheduled/upcoming posts", 'upcoming_posts_widget') );
	$this->WP_Widget('upcoming-posts', __('Upcoming Posts', 'upcoming_posts_widget'), $widget_ops);
}

First, we set up the options for the widget. We set the classname to widget_upcoming_posts. This will be added to the li tag of the widget when it’s displayed. We also set the description, which is displayed when the widget box is expanded in the available widgets section of the new widgets admin page. These options are passed to WP_Widget along with the id base (upcoming-posts) and the widget name (Upcoming Posts).

function widget($args, $instance) {
	extract($args);

	$title = empty($instance['title']) ? __('Upcoming Posts', 'upcoming_posts_widget') : apply_filters('widget_title', $instance['title']);
	if ( !$number = (int) $instance['number'] )
		$number = 10;
	else if ( $number < 1 )
		$number = 1;
	else if ( $number > 15 )
		$number = 15;

	$queryArgs = array(
		'showposts'			=> $number,
		'what_to_show'		=> 'posts',
		'nopaging'			=> 0,
		'post_status'		=> 'future',
		'caller_get_posts'	=> 1,
		'order'				=> 'ASC'
	);

	$r = new WP_Query($queryArgs);
	if ($r->have_posts()) :
?>
	<?php echo $before_widget; ?>
	<?php echo $before_title . $title . $after_title; ?>
	<ul>
	<?php  while ($r->have_posts()) : $r->the_post(); ?>
	<li><?php if ( get_the_title() ) the_title(); else the_ID(); ?><?php edit_post_link('e',' (',')'); ?></li>
	<?php endwhile; ?>
	</ul>
	<?php echo $after_widget; ?>
<?php
	endif;
	wp_reset_query();  // Restore global post data stomped by the_post().
}

The first thing we do is extract $args, which gives you $name, $id, $before_widget, $after_widget, $before_title, $after_title, $widget_id, and $widget_name. We’ll use those throughout the rest of the function. Next we set $title. If it was specified in the settings for the widget, then use use it and apply the widget_title filter to it. If a title wasn’t specified, we use “Upcoming Posts”.

Next, we deal with the number of posts to display. If nothing was specified in the widget settings, we set $number to 10. If the user did specify the number of posts to display, we do some sanity checks to make sure that the number is at least 0 and no more than 15. This isn’t absolutely necessary, but it’s nice to set some limits to things don’t get out of hand.

Now we need to prepare to actually query the database and retrieve the posts. In order to get the posts we want, we set the following:

showposts

This sets the number of posts to display.

what_to_show

This specifies what items to retrieve from the database. We want posts, not pages, attachments, revisions, etc.

nopaging

If the blog is set up to show fewer posts per page than we’re trying to get, paging would interfere. We turn it off just to be safe.

post_status

Since this plugin displays scheduled posts, we need to make sure that the post status is future, not published, draft, etc.

caller_get_posts

This is to make sure that sticky posts aren’t re-ordered to the top.

order

The order defaults to descending, which means it displays post with the highest (most futuristic) date first. We want to display the next post (oldest scheduled post) first, so we set this to ASC for ascending.

Now that all the options are set, we run the query. We want to make sure that all output is inside the have_posts loop, so that if no posts are returned the widget doesn’t display (rather than showing the title with no posts). In order to fit within all themes, you want to make sure to always echo your output in this order: $before_widget, $before_title, $title, $after_title, your widget content, $after_widget. A theme can customize each of those before and after items to create the proper markup for their design, so it’s important to use them. Our widget content is simply an unordered list of posts. The only little extra I added is the edit_post_link(), which will display a link to edit the post if you are logged in with sufficient permissions. The last thing we do is reset the query, so that our widget query doesn’t mess up other queries.

The next method we need to set up is the update method. Technically this isn’t actually required, but it gives us a chance to sanitize input.

function update( $new_instance, $old_instance ) {
	$instance = $old_instance;
	$instance['title'] = strip_tags($new_instance['title']);
	$instance['number'] = (int) $new_instance['number'];

	return $instance;
}

As you can see, we strip tags from the title and make sure that number is and integer. You’ll notice that we take the old instance and update it with info from the new instance. This makes sure that no one tries to sneak in extra data by modifying the form on the widget admin page. It’s not necessary, but it’s a little more secure.

The last thing we need to do is set up the form method, which actually displays the settings on the widget admin page.

function form( $instance ) {
	$title = attribute_escape($instance['title']);
	if ( !$number = (int) $instance['number'] )
		$number = 5;
?>
	<p><label for="<?php echo $this->get_field_id('title'); ?>">
	<?php _e('Title:'); ?>
	<input class="widefat" id="<?php echo $this->get_field_id('title'); ?>" name="<?php echo $this->get_field_name('title'); ?>" type="text" value="<?php echo $title; ?>" /></label></p>

	<p><label for="<?php echo $this->get_field_id('number'); ?>">
	<?php _e('Number of posts to show:'); ?>
	<input id="<?php echo $this->get_field_id('number'); ?>" name="<?php echo $this->get_field_name('number'); ?>" type="text" value="<?php echo $number; ?>" /></label>
	<br /><small><?php _e('(at most 15)'); ?></small></p>
<?php
}

Since we will be putting the title into the value attribute of an input element, we want to make sure it’s safe to do so by using attribute_escape() first. Then we make sure that number is an integer and set it to 5 if it does not exist (this doesn’t actually set the widget settings to 5, it just displays a 5 in the form field rather than leaving it blank, giving the user and idea of what’s expected). Then we break out of PHP and actually display the form. The format I use is the default and will make your widget blend with the ones included with WordPress. It goes like this (with and without “hint text”):

<p>
	<label>
		Label Text
		<input>
	</label>
</p>

<p>
	<label>
		Label Text
		<input>
	</label>
	<br />
	<small>
		Hint Text
	</small>
</p>

That’s it! Your widget is done, it matches the existing widgets, and can be dropped into any widget-ready section of a WordPress 2.8+ blog! Download a slightly more advanced version of the Upcoming Posts Widget that includes caching, and try it out! you can also see the widget completed below:

/**
 * Upcoming_Posts widget class
 */
class WP_Widget_Upcoming_Posts extends WP_Widget {
	function WP_Widget_Upcoming_Posts() {
		$widget_ops = array('classname' => 'widget_upcoming_entries', 'description' => __( "List scheduled/upcoming posts", 'upcoming_posts_widget') );
		$this->WP_Widget('upcoming-posts', __('Upcoming Posts', 'upcoming_posts_widget'), $widget_ops);
	}

	function widget($args, $instance) {
		extract($args);

		$title = empty($instance['title']) ? __('Upcoming Posts', 'upcoming_posts_widget') : apply_filters('widget_title', $instance['title']);
		if ( !$number = (int) $instance['number'] )
			$number = 10;
		else if ( $number < 1 )
			$number = 1;
		else if ( $number > 15 )
			$number = 15;

		$queryArgs = array(
			'showposts'			=> $number,
			'what_to_show'		=> 'posts',
			'nopaging'			=> 0,
			'post_status'		=> 'future',
			'caller_get_posts'	=> 1,
			'order'				=> 'ASC'
		);

		$r = new WP_Query($queryArgs);
		if ($r->have_posts()) :
	?>
		<?php echo $before_widget; ?>
		<?php echo $before_title . $title . $after_title; ?>
		<ul>
		<?php  while ($r->have_posts()) : $r->the_post(); ?>
		<li><?php if ( get_the_title() ) the_title(); else the_ID(); ?><?php edit_post_link('e',' (',')'); ?></li>
		<?php endwhile; ?>
		</ul>
		<?php echo $after_widget; ?>
	<?php
		endif;
		wp_reset_query();  // Restore global post data stomped by the_post().
	}

	function update( $new_instance, $old_instance ) {
		$instance = $old_instance;
		$instance['title'] = strip_tags($new_instance['title']);
		$instance['number'] = (int) $new_instance['number'];

		return $instance;
	}

	function form( $instance ) {
		$title = attribute_escape($instance['title']);
		if ( !$number = (int) $instance['number'] )
			$number = 5;
	?>
		<p><label for="<?php echo $this->get_field_id('title'); ?>">
		<?php _e('Title:'); ?>
		<input class="widefat" id="<?php echo $this->get_field_id('title'); ?>" name="<?php echo $this->get_field_name('title'); ?>" type="text" value="<?php echo $title; ?>" /></label></p>

		<p><label for="<?php echo $this->get_field_id('number'); ?>">
		<?php _e('Number of posts to show:'); ?>
		<input id="<?php echo $this->get_field_id('number'); ?>" name="<?php echo $this->get_field_name('number'); ?>" type="text" value="<?php echo $number; ?>" /></label>
		<br /><small><?php _e('(at most 15)'); ?></small></p>
	<?php
	}
}
function registerUpcomingPostsWidget() {
	register_widget('WP_Widget_Upcoming_Posts');
}
add_action('widgets_init', 'registerUpcomingPostsWidget');

Related Posts:

• WordPress Core vs Canonical Plugins
• The WordPress has-patch marathon
• The Xavisys WordPress Plugin Framework
• WordPress Developer Meeting – July 01, 2009
• WordPress 2.8 Release Date

Recently however, I had a client that really wanted to be able to export data in csv format without ever creating a file on the webserver. Their concern was rooted in security, but the reality of the matter was that they were trying to obey the letter of the law with regards to company policies. Whether it was truly necessary or not is for another discussion. Instead, the technique is actually very useful so I thought I’d share.

The key to this is that the fopen function supports php input/output streams as wrappers.

Start by sending the headers to allow the user to download the csv file, then open a stream:

$fileName = 'somefile.csv';

header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
header('Content-Description: File Transfer');
header("Content-type: text/csv");
header("Content-Disposition: attachment; filename={$fileName}");
header("Expires: 0");
header("Pragma: public");

$fh = @fopen( 'php://output', 'w' );

At this point, anything you send to the newly opened stream ends up in the downloaded csv file. I did this in WordPress, but you can pull your data from anywhere, just pass an array to fputcsv(). In this case, $data is an associative array with the field name as the key and the field value as the value.

global $wpdb;
$query = "SELECT * FROM `{$wpdb->prefix}my_table`";
$results = $wpdb->get_results( $query, ARRAY_A );

$headerDisplayed = false;

foreach ( $results as $data ) {
	// Add a header row if it hasn't been added yet
	if ( !$headerDisplayed ) {
		// Use the keys from $data as the titles
		fputcsv($fh, array_keys($data));
		$headerDisplayed = true;
	}

	// Put the data into the stream
	fputcsv($fh, $data);
}
// Close the file
fclose($fh);
// Make sure nothing else is sent, our file is done
exit;

As you can see, the actual code is quite simple. Here it is all put together:

$fileName = 'somefile.csv';

header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
header('Content-Description: File Transfer');
header("Content-type: text/csv");
header("Content-Disposition: attachment; filename={$fileName}");
header("Expires: 0");
header("Pragma: public");

$fh = @fopen( 'php://output', 'w' );

global $wpdb;
$query = "SELECT * FROM `{$wpdb->prefix}my_table`";
$results = $wpdb->get_results( $query, ARRAY_A );

$headerDisplayed = false;

foreach ( $results as $data ) {
	// Add a header row if it hasn't been added yet
	if ( !$headerDisplayed ) {
		// Use the keys from $data as the titles
		fputcsv($fh, array_keys($data));
		$headerDisplayed = true;
	}

	// Put the data into the stream
	fputcsv($fh, $data);
}
// Close the file
fclose($fh);
// Make sure nothing else is sent, our file is done
exit;

I hope you find it useful!

Related Posts:

• WordPress 2.5 Shortcodes
• Wordpress Should Update get_sidebar to Work With Multiple Sidebars
• PHP function to Redirect a user with a message
• Replace every other occurrence with str_replace
• PHP Pagination with mysqli