add_filter( 'private_title_format', 'yourprefix_private_title_format' );
add_filter( 'protected_title_format', 'yourprefix_private_title_format' );

function yourprefix_private_title_format( $format ) {
	return '%s';
}

The above code will remove the prefix by changing the format from Private: %s and Protected: %s to just %s where %s is the existing post title.

If you’d like to change it to something else, you can just change what the function in my example returns. If you want to change them independently of each other, then you’ll need to use two separate callback functions.

<?php

// Add a new interval of a week
// See http://codex.wordpress.org/Plugin_API/Filter_Reference/cron_schedules
add_filter( 'cron_schedules', 'myprefix_add_weekly_cron_schedule' );
function myprefix_add_weekly_cron_schedule( $schedules ) {
	$schedules['weekly'] = array(
		'interval' => 604800, // 1 week in seconds
		'display'  => __( 'Once Weekly' ),
	);

	return $schedules;
}

// Schedule an action if it's not already scheduled
if ( ! wp_next_scheduled( 'myprefix_my_cron_action' ) ) {
	wp_schedule_event( time(), 'weekly', 'myprefix_my_cron_action' );
}

// Hook into that action that'll fire weekly
add_action( 'myprefix_my_cron_action', 'myprefix_function_to_run' );
function myprefix_function_to_run() {
	// Add some code here
}

?>

On a side note, I believe this must go in a plugin and not your theme’s functions.php which I hear loads too late.

Two such plugins I’d like to recommend are SublimeBrackets and SublimeTagmatcher. Both improve how the highlighting of opening and closing items are handled.

By default, Sublime just underlines paired brackets. When you have a ton of code, this can be really hard to see. SublimeBrackets changes this to something more apparent:

Much better, right? I personally use the solid background green style.

SublimeTagmatcher does something similar but for HTML tags. When you have your cursor inside of an HTML tag, it will highlight both the current tag and it’s opening or closing counterpart. This is helpful for making sure you have the correct number of opening and closing tags.

But first, here’s a quick refresher on how to internationalize code in WordPress:

<?php _e( 'Welcome to my blog!', 'my-plugin-text-domain' ); ?>

For dynamic strings, it’d be something like this:

<?php printf(
	__( 'Welcome to my blog, %s!', 'my-plugin-text-domain' ),
	$name
); ?>

But what about when you have multiple variables to use in your string? A common mistake is to do something like this:

<?php printf(
	__( 'Welcome to my blog, %s! Today\'s date is %s.', 'my-plugin-text-domain' ),
	$name,
	$date
); ?>

The issue with this is that you’re requiring the person’s name to always come before the date. If for internationalization reasons it needs to be in a different order, then it won’t work. You’ll end up with something like Today's date is Alex. Welcome to my blog, November 2nd!.

The solution is to use standard sprintf() argument swapping parameters:

<?php printf(
	__( 'Welcome to my blog, %1$s! Today\'s date is %2$s.', 'my-plugin-text-domain' ),
	$name,
	$date
); ?>

Now translators are free to re-order the string to whatever makes the most sense for the language in question without having to worry the order of the variables.

For a more in-depth review of this, check out the WordPress Codex where many real world examples can be found.

But first, here’s an example output with the optional dividers enabled:

   ID | First Name     | Last Name
-------------------------------------
    1 | Alex           | Mills
    2 | John           | Smith
    3 | Barack         | Obama
    4 | Fred           | Flinstone
12345 | ReallyLongName | IsReallyLong

This is the code I used to create the above example:

$data = array(
	'labels' => array(
		'ID' => 'ID',
		'firstname' => 'First Name',
		'lastname' => 'Last Name',
	),
	'align' => array(
		'ID' => 'right',
	),
	array(
		'ID' => 1,
		'firstname' => 'Alex',
		'lastname' => 'Mills',
	),
	array(
		'ID' => 2,
		'firstname' => 'John',
		'lastname' => 'Smith',
	),
	array(
		'ID' => 3,
		'firstname' => 'Barack',
		'lastname' => 'Obama',
	),
	// Array order doesn't matter as it's associative
	array(
		'ID' => 4,
		'lastname' => 'Flinstone',
		'firstname' => 'Fred',
	),
	array(
		'lastname' => 'IsReallyLong',
		'firstname' => 'ReallyLongName',
		'ID' => 12345,
	),
);

echo '<pre>';
table_output( $data );
echo '</pre>';

You can easily loop through your data and generate an array in that format. The arrays are associative so order doesn’t matter.

The labels array is optional and just allows you assign pretty labels for the columns. If this array is missing, then the data keys will be used.

The align array is also optional and allows you to pass a value of right in order to right-align the data in a column. Defaults to left align.

Now, to the functions that generate the table!

// Output a formatted table
function table_output( $data, $dividers = true ) {
	$rows = table_get_rows( $data, $dividers );

	echo implode( "\n", $rows );
}

// Return an array of table rows
function table_get_rows( $data, $dividers = true ) {
	// Find the column keys to use (use the first data row)
	$columns = array_keys( $data[0] );

	// Create the labels if they're missing
	if ( empty( $data['labels'] ) )
		$data['labels'] = array_combine( $columns, $columns );

	// Calculate column widths
	foreach ( $data as $key => $item ) {
		if ( 'align' === $key )
			continue;

		foreach ( $item as $column => $value ) {
			$length = strlen( $value );

			if ( empty( $widths[$column] ) || $widths[$column] < $length )
				$widths[$column] = $length;
		}
	}

	// Create the row sprintf() format
	foreach ( $columns as $column ) {
		$align = ( isset( $data['align'] ) && isset( $data['align'][$column] ) && 'right' == $data['align'][$column] ) ? '' : '-';
		$formats[] = '%' . $align . $widths[$column] . 's';
	}
	$divider = ( $dividers ) ? ' | ' : ' ';
	$format = implode( $divider, $formats );

	// Generate the label row
	$rows['labels'] = vsprintf( $format, _table_get_line_data( $columns, $data['labels'] ) );

	// Should there be a divider row?
	if ( $dividers )
		$rows['divider'] = str_repeat( '-', strlen( $rows['labels'] ) );

	// Generate the data rows
	foreach ( $data as $key => $values ) {
		if ( 'labels' === $key || 'align' === $key )
			continue;

		$rows[$key] = vsprintf( $format, _table_get_line_data( $columns, $values ) );
	}

	return $rows;
}

// Helper function to get the array of data for a table row in the correct order
function _table_get_line_data( $columns, $item ) {
	foreach ( $columns as $column ) {
		$data[$column] = ( isset( $item[$column] ) ) ? $item[$column] : '';
	}

	return $data;
}

Hope you find it useful!

As a reminder, here’s how you go about registering a custom taxonomy using the register_taxonomy() function:

add_action( 'init', 'register_sport_taxonomy' );

function register_sport_taxonomy() {
	register_taxonomy( 'sport', 'post', array(
		'labels' => array(
			'name' => 'Sports',
		),
		'hierarchical' => true, // Makes for a better selection box on write screen
	) );
}

And now, for my helper class:

(feel free to highlight and then copy/paste this code into your favorite text editor to make it easier to read)

/**
 * A helper class for registering and handling a custom rewrite tag for a custom taxonomy.
 *
 * @version 1.0.0
 */
class Add_Taxonomy_To_Post_Permalinks {

	/**
	 * Stores the taxonomy slug that this class will be handling. Don't edit this.
	 *
	 * @since 1.0.0
	 * @var string
	 */
	public $taxonomy;

	/**
	 * Stores the rewrite tag complete with percentage signs. Don't edit this.
	 *
	 * @since 1.0.0
	 * @var string
	 */
	public $rewrite_tag;

	/**
	 * Initializes the class by calling Add_Taxonomy_To_Post_Permalinks::register()
	 * as well as registering a filter that runs in get_permalink().
	 *
	 * @since 1.0.0
	 *
	 * @param string $taxonomy A taxonomy slug. Use the same one that you used with register_taxonomy().
	 * @return array $optional_args Optional configuration parameters. See Add_Taxonomy_To_Post_Permalinks::register().
	 */
	function __construct( $taxonomy, $optional_args = array() ) {
		if ( ! $this->register( $taxonomy, $optional_args ) )
			return;

		add_filter( 'post_link', array( &$this, 'filter_post_link' ), 10, 2 );
	}

	/**
	 * Registers the rewrite tag using add_rewrite_tag().
	 *
	 * Can accept an array of optional parameters:
	 *
	 * * tagname: The rewrite tag to use (no percentage signs). Defaults to the taxonomy slug.
	 * * regex: What regex to use to validate the value of the tag. Defaults to anything but a forward slash.
	 *
	 * @since 1.0.0
	 *
	 * @param string $taxonomy A taxonomy slug. Use the same one that you used with register_taxonomy().
	 * @return array $optional_args Optional configuration parameters. See function description.
	 */
	public function register( $taxonomy, $optional_args = array() ) {
		if ( ! taxonomy_exists( $taxonomy ) )
			return false;

		$this->taxonomy = $taxonomy;

		$this->rewrite_tag = ( ! empty( $optional_args['tagname'] ) ) ? $optional_args['tagname'] : $this->taxonomy;
		$this->rewrite_tag = '%' . $this->rewrite_tag . '%';

		$rewrite_tag_regex = ( ! empty( $optional_args['regex'] ) ) ? $optional_args['regex'] : '([^/]+)';

		// See http://codex.wordpress.org/Rewrite_API/add_rewrite_tag
		add_rewrite_tag( $this->rewrite_tag, $rewrite_tag_regex );

		return true;
	}

	/**
	 * Filters a post permalink to replace the tag placeholder with the first
	 * used term from the taxonomy in question.
	 *
	 * @since 1.0.0
	 *
	 * @param string $permalink The existing permalink URL.
	 * @return object $post The post object that this permalink belongs to.
	 */
	public function filter_post_link( $permalink, $post ) {
		// Abort early if the placeholder rewrite tag isn't in the generated URL
		if ( false === strpos( $permalink, $this->rewrite_tag ) )
			return $permalink;

		// Get the custom taxonomy terms in use by this post
		$terms = get_the_terms( $post->ID, $this->taxonomy );

		// If no terms are assigned to this post, use the taxonomy slug instead (can't leave the placeholder there)
		if ( empty( $terms ) ) {
			$permalink = str_replace( $this->rewrite_tag, $this->taxonomy, $permalink );
		}

		// Replace the placeholder rewrite tag with the first term's slug
		else {
			$first_term = array_shift( $terms );
			$permalink = str_replace( $this->rewrite_tag, $first_term->slug, $permalink );
		}

		return $permalink;
	}
}

To use the class, simply initiate a new instance of it and pass the taxonomy slug to it while doing so:

add_action( 'init', 'register_sport_taxonomy' );

function register_sport_taxonomy() {
	register_taxonomy( 'sport', 'post', array(
		'labels' => array(
			'name' => 'Sports',
		),
		'hierarchical' => true, // Makes for a better selection box on write screen
	) );

	$sport_taxonomy_permalinks
		= new Add_Taxonomy_To_Post_Permalinks( 'sport' );
}

Then go to Settings → Permalinks and add %taxonomy% to your structure, such as /%sport%/%year%/%monthnum%/%day%/%postname%/. It will then be replaced by the first term (sorted by term ID) of your custom taxonomy.

More complicated solutions are of course possible, such as picking which of multiple terms you want injected into the URL or multiple terms in the URL, but my class should give you a good starting point to work off of.

// Front end only, don't hack on the settings page
if ( ! is_admin() ) {
	// Hook in early to modify the menu
	// This is before the CSS "selected" classes are calculated
	add_filter( 'wp_get_nav_menu_items', 'replace_placeholder_nav_menu_item_with_latest_post', 10, 3 );
}

// Replaces a custom URL placeholder with the URL to the latest post
function replace_placeholder_nav_menu_item_with_latest_post( $items, $menu, $args ) {

	// Loop through the menu items looking for placeholder(s)
	foreach ( $items as $item ) {

		// Is this the placeholder we're looking for?
		if ( '#latestpost' != $item->url )
			continue;

		// Get the latest post
		$latestpost = get_posts( array(
			'numberposts' => 1,
		) );

		if ( empty( $latestpost ) )
			continue;

		// Replace the placeholder with the real URL
		$item->url = get_permalink( $latestpost[0]->ID );
	}

	// Return the modified (or maybe unmodified) menu items array
	return $items;
}

Place the above code in a plugin or just in your theme’s functions.php file.

Create a new “Custom Link” menu item where the URL is #latestpost (which will act as a placeholder and target for the code). You can title the item whatever you please. This code will then find that menu item (by looking for the placeholder URL) and then replace it’s URL with that of the latest post’s URL. Since the filter is before the code that adds the selected CSS classes runs, the menu highlighting will even work. When you visit the latest post on your blog, this menu item will light up.

Rather simple and elegant. You gotta love WordPress hooks.

The first is Text Domain and this is the text domain for your plugin, i.e. the first argument that you are passing to load_plugin_textdomain().

The second one is Domain Path and is optional. It’s only needed if you store your translation files in a subfolder inside of your plugin’s folder.

Here’s an example load_plugin_textdomain() call from one of my newest plugins:

load_plugin_textdomain(
	'add-descendants-as-submenu-items',
	false,
	dirname( plugin_basename( __FILE__ ) ) . '/localization/'
);

That loads translation files from a subfolder called “localization” inside of my plugin’s folder. This turns into the following plugin header:

Plugin Name:   Add Descendants As Submenu Items
Plugin URI:    http://www.viper007bond.com/wordpress-plugins/add-descendants-as-submenu-items/
Description:   Automatically all of a nav menu item's descendants as submenu items. Designed for pages but will work with any hierarchical post type or taxonomy.
Version:       1.1.0
Author:        Alex Mills (Viper007Bond)
Author URI:    http://www.viper007bond.com/

Text Domain:   add-descendants-as-submenu-items
Domain Path:   /localization/

An extra line break isn’t needed nor is the extra spacing but I added both just for aesthetic reasons.

And that’s it! WordPress will then attempt to translate the plugin’s name, URI, description, author, author URI, and version fields. I personally only include the plugin’s name and description in my translation template files though as I don’t feel translators need to localize the other fields.

If you need help generating a translation template file for your plugin, log into WordPress.org and then visit the “Admin” tab on your plugin’s page on WordPress.org. You can generate a POT file for your plugin there.

The easiest solution is to create a shortcut that will open Notepad and then tell it to open your hosts file. Right-click your desktop and select New → Shortcut. Paste the following into the field that pops up:

%windir%\system32\notepad.exe %windir%\System32\drivers\etc\hosts

Once you’re done creating the shortcut, right-click it and select “Properties”. Under the “Shortcut” tab is an “Advanced” button. Clicking it will show a checkbox for “Run as administrator”.

Start by opening Notepad in Administrator mode. Type “Notepad” into your Start Menu search box and then right-click it and select “Run as administrator”. This is important because otherwise you won’t be able to save your changes as the file is a protected one.

Now that you have Notepad open, do File -> Open and browse to C:\Windows\System32\drivers\etc. You won’t see any files because by default Notepad will only show *.txt files. To change this, click on the dropdown that is currently showing “Text Documents (*.txt)” and change it to “All Files (*.*)”. Now you’ll be able to see your hosts file.

Opening it will show a little documentation and some examples. If you want to add your own, just add it to the bottom in this format:

	127.0.0.1	yourdomain.com

Saving the file and then visiting the domain in your browser will now show you files served by your local development environment. Note: a hard refresh may be required to due to your browser’s DNS cache. This can be accomplished by pressing control and F5.

The answer is surprisingly simple: make a new instance of the wpdb class! Dion Hulse (DD32) was kind enough to point out this great solution to me a few weeks back and I thought it was worth sharing with you all.

$myotherdb = new wpdb( $dbuser, $dbpassword, $dbname, $dbhost );

$myotherdb->get_results( "SELECT id, name FROM mytable" );

I’ve used this in some plugins I’ve written in the past and it works incredibly well.

My co-worker and one of the lead developers of WordPress Peter Westwood (westi) wrote a really good blog post about this, however I wasn’t completely happy with his code so I’m writing this blog post to share how I would write some code to take advantage of this versatile filter. Don’t get me wrong — he wrote good and valid code, but it’s not exactly the easiest thing for a novice to extend for their own uses.

function youruniqueprefix_filter_gettext( $translated, $original, $domain ) {

	// This is an array of original strings
	// and what they should be replaced with
	$strings = array(
		'View all posts filed under %s' => 'See all articles filed under %s',
		'Howdy, %1$s' => 'Greetings, %1$s!',
		// Add some more strings here
	);

	// See if the current string is in the $strings array
	// If so, replace it's translation
	if ( isset( $strings[$original] ) ) {
		// This accomplishes the same thing as __()
		// but without running it through the filter again
		$translations = &get_translations_for_domain( $domain );
		$translated = $translations->translate( $strings[$original] );
	}

	return $translated;
}

add_filter( 'gettext', 'youruniqueprefix_filter_gettext', 10, 3 );

So as you can see at it’s core it accomplishes the same thing as Peter’s code however my code should be a bit more clear on how to make it translate multiple strings.

Hope someone finds this helpful!

An easier method would be to just convert an array into XML, the opposite of simplexml_load_string() if you will. So I wrote some code that does exactly that and I thought I’d share it incase anyone else would find it helpful.

Start by creating your array of data. I used a numeric array instead of an associative array because you can have duplicate elements in XML while you cannot have duplicate array keys.

$data = array(
	'name' => 'toplevelelement', // "name" required, all else optional
	'attributes' => array(
		'foo' => 'bar',
		'fruit' => 'apple',
	),
	'value' => 'Some random value.',
	array(
		'name' => 'achildelement',
		'value'=> 'Value',
	),
	array(
		'name' => 'anotherchildelement',
		'attributes' => array(
			'some' => 'attr',
		),
		array(
			'name' => 'grandchildelement',
		),
	),
);

An array such as that is easy to dynamically create based on your source data, it’s easy to read, and can be fairly easily manipulated.

name is the only required item of each array and it’s the tag name of the element. attributes is an array of attributes for the element and value is the value. Both of these are optional. Any children arrays are children elements and their structures should be the same.

Now here’s the code I wrote that converts the above array into some XML:

function generate_xml_element( $dom, $data ) {
	if ( empty( $data['name'] ) )
		return false;

	// Create the element
	$element_value = ( ! empty( $data['value'] ) ) ? $data['value'] : null;
	$element = $dom->createElement( $data['name'], $element_value );

	// Add any attributes
	if ( ! empty( $data['attributes'] ) && is_array( $data['attributes'] ) ) {
		foreach ( $data['attributes'] as $attribute_key => $attribute_value ) {
			$element->setAttribute( $attribute_key, $attribute_value );
		}
	}

	// Any other items in the data array should be child elements
	foreach ( $data as $data_key => $child_data ) {
		if ( ! is_numeric( $data_key ) )
			continue;

		$child = generate_xml_element( $dom, $child_data );
		if ( $child )
			$element->appendChild( $child );
	}

	return $element;
}

$doc = new DOMDocument();
$child = generate_xml_element( $doc, $data );
if ( $child )
	$doc->appendChild( $child );
$doc->formatOutput = true; // Add whitespace to make easier to read XML
$xml = $doc->saveXML();

You first create a blank canvas by creating a new instance of the DOMDocument class and then you pass the class instance (needed for creating elements in the correct character set and such) and the data array to the generate_xml_element() function. This function will create the top level element and then recursively call itself on any child elements until it’s gone through the whole array.

Once it’s done, you’ll need to append the element to the DOM using the inherited appendChild() function. Then calling saveXML will give you the XML output. The above example data array will give you something like this (maybe or maybe not nicely formatted with whitespace depending on what mood DOMDocument is in):

<?xml version="1.0"?>
<toplevelelement foo="bar" fruit="apple">
	Some random value.
	<achildelement>Value</achildelement>
	<anotherchildelement some="attr">
		<grandchildelement></grandchildelement>
	</anotherchildelement>
</toplevelelement>

And there you have it!

Before committing code, I explain it to Donkey Kong first to make sure it makes sense #codereview /cc @iamjohnford http://t.co/0dtFTYY

April 20th, 2011 1:12 PM via Twitter for MacReplyRetweetFavorite

@JohnJamesJacoby

John James Jacoby

(Also known as rubber duck debugging)

And instead of manually creating the HTML yourself, you wanted to use YouTube’s oEmbed provider to get the HTML. While that’s easy to do using WordPress’ existing functions (wp_oembed_get() for example), you must implement your own caching of the result as WordPress’ oEmbed class does not include any caching of it’s own.

However, WordPress comes with an [embed] shortcode that’s also secretly used for the shortcode-less embeds. A cool trick is to make that shortcode’s existing code (complete with caching) work for you! This post explains how to do it.

First, the code:

add_shortcode( 'youtube', 'my_youtube_shortcode' );

function my_youtube_shortcode( $atts ) {

	// We need to use the WP_Embed class instance
	global $wp_embed;

	// The "id" parameter is required
	if ( empty($atts['id']) )
		return '';

	// Construct the YouTube URL
	$url = 'http://www.youtube.com/watch?v=' . $atts['id'];

	// Run the URL through the  handler.
	// This handler handles calling the oEmbed class
	// and more importantly will also do the caching!
	return $wp_embed->shortcode( $atts, $url );
}

We start by gaining access to the WP_Embed instance that we’ll be making use of and then making sure we have the required video ID (you can do whatever you want here). We then create the full URL to the video that oEmbed will need. Lastly the real time saver — we pass the attributes (“id” will be ignored) and the constructed URL to the [embed] shortcode handler which will fetch the result and cache it.

Simple, huh?

One thing to note though: if you’re using this along with a non-default oEmbed provider, you’ll also need to whitelist it using wp_oembed_add_provider().

function viper_twitter_followers( $username = 'Viper007Bond' ) {

	// Just to keep the code below cleaner, create the cache key now
	$cache_key = "viper_twitter_followers_{$username}";

	// First we look for a cached result
	if ( false !== $followers = get_transient( $cache_key ) )
		return $followers;

	// Okay, no cache, so let's fetch it
	$result = wp_remote_retrieve_body( wp_remote_get( 'http://api.twitter.com/1/users/show.json?screen_name=' . urlencode($username) ) );

	// Check to make sure we got some data to work with
	if ( empty($result) ) {
		// Cache the failure for 1 min to avoid hammering Twitter
		set_transient( $cache_key, 0, 60 );
	}

	// Parse the data
	$data = json_decode( $result );

	// Make sure we were able to parse it
	// If not, cache the failure (like above)
	if ( !isset( $data->followers_count ) )
		set_transient( $cache_key , 0, 60 );

	// Success! Cache the result for an hour.
	$followers = (int) $data->followers_count;
	set_transient( $cache_key, $followers, 3600 );

	return $followers;
}

echo 'I have ' . viper_twitter_followers( 'Viper007Bond' ) . ' followers on Twitter!';

Reading Material:

• HTTP API: http://codex.wordpress.org/HTTP_API
• Transient API: http://codex.wordpress.org/Transients_API (expiring options basically)

If you have any questions about the above code, let me know and I’ll do my best to answer them.