When I did the real layout for the site I considered mobile devices, picking a font size and column width that I thought reasonable to read in landscape mode on an iPhone-sized screen.  As well as meaning less work and providing a more consistent interface, PRE-formatted code renders without being sliced off to the right, which is a big win over the mobile interface.

No question, neither one is perfect, but the choice is now yours.

I needed this sort of functionality in CFML, so after playing with a few different syntaxes and parsers for them, I decided that a direct port of the WordPress shortcodes implementation was the best choice.  The code is pretty small (the grammar is context free and the parser is RegEx-based), and the port (including unit tests) took perhaps an hour and a half.  I had to roll my own REReplaceCallback UDF to match one of the PHP builtins, as well as change the callback API slightly to deal with CFML idoms, but it's a pretty direct port.

So what can you do with shortcodes?  Here's a little demo, both of the front side (the content) and the backside (the handlers and processing).  There is also a link to the source, of course.  And like all my projects, there is a project page where current project information will always be available.

<cfscript>
string = "The catapult bifurcated the bearcat.";
fancyString = REReplaceCallback(string, "(\w*)(cat)(\w*)", doit, "all");
function doit(match) {
  if (match[2] EQ "") {
    return '#match[2]#<b><i>#match[3]#</i></b>#match[4]#';
  } else {
    return '<u>#match[2]#<b><i>#match[3]#</i></b>#match[4]#</u>';
  }
}
</cfscript>

As you'd imagine, the 'doit' function is invoked for each match of the regular expression (in this case looking for a literal "cat" surrounded by any number of word characters).  It then does a check on match[2] (the leading word characters) to see if it's empty and then forks based on that result (either underlining or not).  The 'match' array, as you might surmise, contains the matched expressions.  The first index is the entire expression, and an additional index is added for each subexpression in the regular expression.  In this case, there are three subexpressions, so the 'match' array will have length .

This particular conditional can be performed without a callback.  Here are a pair of REReplace calls that do it:

<cfscript>
string = "The catapult bifurcated the bearcat.";
fancyString = REReplace(string, "(\W|^)(cat)", "\1<b><i>\2</i></b>", "all");
fancyString = REReplace(fancyString, "(\w+)(cat)\w*", "<u>\1<b><i>\2</i></b>\3</u>", "all");
</cfscript>

The first one takes care of words starting with 'cat', the second words with 'cat' inside or at the end.  Note that this only works because the result of the first replace does NOT put word characters next to 'cat' in the replacement string.  If it did that, we'd be screwed, because the two replaces happen sequentially, not in parallel.

In this particular case, neither one of them is very readable.  :)  With a little cleanup and a well-named temp variable, I'd say the callback version has the potential to be more readable, but the pair of REReplaces is pretty much stuck as-is.  As things get more complicated, however, the callback approach becomes dramatically clearer.

The big win, of course, has nothing to do with conditional replaces.  Rather, it's the ability to execute arbitrary CFML code to generate the replace string based on the matched string.  Your callback can do anything you want: go hit the database, shell out to a web service, go grab a dynamically selected bean from ColdSpring and get a value from it, etc.  The sky's the limit.

Here's the REReplaceCallback UDF itself:

<cffunction name="REReplaceCallback" access="private" output="false" returntype="string">
  <cfargument name="string" type="string" required="true" />
  <cfargument name="pattern" type="string" required="true" />
  <cfargument name="callback" type="any" required="true" />
  <cfargument name="scope" type="string" default="one" />
  <cfscript>
  var start = 0;
  var match = "";
  var parts = "";
  var replace = "";
  var i = "";
  var l = "";
  while (true) {
    match = REFind(pattern, string, start, true);
    if (match.pos[1] EQ 0) {
      break;
    }
    parts = [];
    l = arrayLen(match.pos);
    for (i = 1; i LTE l; i++) {
      if (match.pos[i] EQ 0) {
        arrayAppend(parts, "");
      } else {
        arrayAppend(parts, mid(string, match.pos[i], match.len[i]));
      }
    }
    replace = callback(parts);
    start = start + len(replace);
    string = mid(string, 1, match.pos[1] - 1) & replace & removeChars(string, 1, match.pos[1] + match.len[1] - 1);
    if (scope EQ "one") {
      break;
    }
  }
  return string;
  </cfscript>
</cffunction>

Lots of stuff going on in there, but it's basically just doing a REFind with returnsubexpressions=true, ripping apart the string to pass the pieces to the callback function, and then reassembling the string afterwards.  It'd be trivially easy to make a REReplaceNoCaseCallback function, but I haven't done.  I've implemented the function with CFFUNCTION/CFARGUMENT tags so that I can have an optional fourth parameter on CF8, but the body as CFSCRIPT so that if you want to use the UDF in pure CFSCRIPT on CF9, you only have to rewrap the body (not reimplement).

This particular implementation differs from what you might expect in that the callback gets substrings instead of position/length tuples (i.e., the way REFind works).  I opted for this approach for two reasons: first it removes the need for the callback to have access to the raw string, and secondly all you do with the len/pos is rip the string apart to get the characters so why make every callback do it.

Why did I write this?  Just for fun?  No, not at all.  I needed a way of doing rich inline markup with tags that could be implemented via plugging for a project (you get one guess), and after playing with a couple formats I concluded that porting WordPress's shortcodes was as close to an optimal solution as I was going to get.  The shortcode implementation requires this sort of conditional replace operations, so I built this UDF.  If you do PHP, it's basically equivalent to preg_replace_callback but with CFML argument ordering.

Yes, I'll be sharing the CFC that implements shortcodes (complete with a port of the WordPress unit tests from PHPUnit to MXUnit), but not right this second.

I was initially disappointed when I looked at the source, because the MU bits seemed to be missing, but a little more digging showed telltale signs that it was at least partially integrated.  After setting up the installation, I found a mysterious "Network" option in my "Tools" menu, clicked it, and was presented with basically the MU installer UI.  Sweet!

Submitting that resulted in a page with three simple instructions: create the blogs.dir directory, install this new wp-config.php script (in a TEXTAREA), and update .htaccess with this new config (also in a TEXTAREA).  My suspicion is that if PHP had write access it would've done all three automatically.

After following instructions and clearing my cookies (not explicitly mentioned), I had a fully functional multihosted WordPress install with the normal MU site administrator menu and everything.  This is awesome.  And just in case that was unclear, it's awesome.  The database, of course, was refactored behind the scenes.  Unfortunately it still uses the tableset-per-blog paradigm (just minus the "_1″ infix for the root blog) rather than a single tableset with foreign keys, but there's no way they could change that without having all kinds of upgrade issues for existing WPMU installations.

There are still a pile of things to update (like the per-blog permalink config shouldn't attempt to write .htaccess) to get the WP.org functionality to morph into the WPMU functionality, but for the "normal" authoring tasks it appears to be as solid as ever.  I suspect a careful administrator could, with a bit of patience, produce a security setup that would let authors have the run of their site without breaking anything even before the actual restrictions are put in place by Automattic.

In any case, very exciting to see this integration project already so far along.  WordPress.org says 3.0 is slated for March, which is crazy soon, but I'm all for it.  I've been waiting to upgrade a pile of WP.org blogs to a WPMU instance for a while now, and this is going to make it much easier.

Biggest problem was that she was using a TypePad subdomain instead of a custom domain, which precluded any sort of transparent switch-over via DNS.  TypePad also doesn't have a half-way between drag'n'drop themes and roll-your-own, which meant that changing the site header to include a redirect was out.  So I had to resort to JS, which is hardly elegant, but it works well enough.  I was really hoping for .htaccess support, but pushing one up there had no effect, so they don't have it enabled in their Apache (or whatever) config.  Oh well.  Unfortunately this means search engines have to organically rebuild their indexes (since I can't give them a 301), but a robots.txt will at least ensure the old stuff drops out.

Once all that was sorted, however, things went pretty smoothly.  Found a great WordPress plugin for doing search and replace within your content, which made updating internal links a breeze.  It also happens to output search results in a fashion that was really easy to rip with jQuery into a list of files (pics, movies, etc) to grab with wget and then bulk upload into WordPress.  And let me tell you, bulk uploading into WordPress is kickass; Flash for the win!

Did a little minor theme work, changed permalinks to only use year/month/slug (to match TypePad), and that's about it.  Smooth as butter.

Welcome home, Carole.

What I have learned?

1. PHP's function libraries are insane.  I thought ColdFusion's (now CFML's) libraries had plenty of wonkiness, but PHP makes them look like the friggin' Pope.  Latest example: there is a 'sort' function that sorts an array.  It has an optional second parameter for controlling the type of sort.  But it's a whole separate function with identical parameters (called 'rsort') to sort descending.  Where's the optional third parameter for direction?  Or how implode accepts arguments in either order, but explode (it's inverse) does not.
2. Dollar signs are harder to type than hashes.  Not sure why, especially with my big hands, but whatever.
3. PHP's operators are lunacy.  Arrays are declared with "=>" for keys, by dereferenced with "['key']" syntax.  Object members are accessed with the "->" operator, and "." is for string concatenation.  And you can't combine the middle two in arbitrary ways (though some ways do work).
4. WordPress was designed by really smart people.  A little too smart, I think.  And even aside from the choice of language, the code style confirms without a doubt that they're PHP developers to the bone.
5. Implicit invocation is great, but while it fosters decoupling, overuse can create a developer's nightmare.  With too much indirection the code can't be easily read, so you have to simply memorize huge amounts of information in order to effectively work on an application.

Now before you go assuming I'm a PHP hater…

1. I largely put myself in this situation.  I was in charge of selecting WordPress MU for Mentor's infrastructure, knowing I was brining PHP into an 85% CFML / 10% Groovy / 5% Java shop.  Five people (of nine) on the team swear by it for our personal blogs, though I was the only one with any substantial experience hacking the engine itself.  Despite initial reservations from the boss, and others (including myself), time has shown that it was clearly a good choice.
2. PHP is friggin' fast.  Dear god is it fast.  With no concept of in-memory sharing across requests, everything has to reload on every request and it still screams.
3. WordPress is a really flexible platform.  It's provides a solid foundation, a kickass application framework built atop it, and a great blogging engine on top of that.  And if you get the right theme(s), you've got presentation and CSS as well.  It's not a CMS out of the box, but for what it's designed to do it's fantastic.
4. PHP's function types and higher order functions are kind of a mess, but at least they have them, and they support object methods.  You wouldn't believe how often this bites me in CFML.

Am I gonna drop CFML for PHP?  Hell no.  But despite PHP's and WordPress's warts, there's a lot of stuff worth of emulation.  Definitely reenforced my belief that CFML is an inherently iffy language for "down-n-dirty" development, even though it excels at templating and simplifying complex tasks.

On the surface, CFML is no where near as warty as PHP, but looking deeper and the story isn't so clear.  It seems like every couple weeks I discover or learn about some utterly bizarre behaviour that ColdFusion exhibits, and unlike PHP's weird function libraries, they're internal weirdnesses.  Functions can be stupid, but at least they're in your face.  You get a hard fail if you type one wrong.

Long post, and again, no real point.  Whatever.  It's Thursday, and better for my liver than drinking.

Being the good (if opinionated and occasionally obnoxious) open source aficionado that I am, after my initial reaction of outrage, I've revisted the issue and "fixed" the problem.  Aside from the install script (index-install.php), there was only one place that needed changing (in wpmu-settings.php).  The patch is below, made against WordPress mU 2.7.1:

Index: index-install.php
===================================================================
--- index-install.php   (revision 5342)
+++ index-install.php   (revision 5343)
@@ -362,8 +362,6 @@
        $weblog_title = ucfirst( $_SERVER[ 'HTTP_HOST' ] ) . ' Blogs';
        $email = '';
        $hostname = $_SERVER[ 'HTTP_HOST' ];
-       if( substr( $_SERVER[ 'HTTP_HOST' ], 0, 4 ) == 'www.' )
-               $hostname = str_replace( "www.", "", $_SERVER[ 'HTTP_HOST' ] );
        ?>
        <form method='post' action='index.php'>
                <input type='hidden' name='action' value='step2' />
@@ -511,8 +509,6 @@
        global $wpdb;
        $domain =   $wpdb->escape( $_POST[ 'basedomain' ] );
        $domain = str_replace( 'http://', '', $domain );
-       if( substr( $domain, 0, 4 ) == 'www.' )
-               $domain = substr( $domain, 4 );
        if( strpos( $domain, '/' ) )
                $domain = substr( $domain, 0, strpos( $domain, '/' ) );
        return $domain;
@@ -649,12 +645,6 @@
 $action = isset($_POST[ 'action' ]) ? $_POST[ 'action' ] : null;
 switch($action) {
        case "step2":
-               if( substr( $_POST[ 'basedomain' ], 0, 4 ) == 'www.' ) {
-                       printheader();
-                       nowww();
-                       continue;
-               }
-
                // get blog username, create wp-config.php
                step2();

@@ -662,7 +652,6 @@
                include_once('./wp-config.php');
                include_once('./wp-admin/includes/upgrade.php');

-               $_SERVER[ 'HTTP_HOST' ] = str_replace( 'www.', '', $_SERVER[ 'HTTP_HOST' ] ); // normalise hostname - no www.
                make_db_current_silent();
                populate_options();
                global $base;
Index: wpmu-settings.php
===================================================================
--- wpmu-settings.php   (revision 5342)
+++ wpmu-settings.php   (revision 5343)
@@ -6,8 +6,6 @@
 $wpmuBaseTablePrefix = $table_prefix;

 $domain = addslashes( $_SERVER['HTTP_HOST'] );
-if( substr( $domain, 0, 4 ) == 'www.' )
-       $domain = substr( $domain, 4 );
 if( strpos( $domain, ':' ) ) {
        if( substr( $domain, -3 ) == ':80' ) {
                $domain = substr( $domain, 0, -3 );

<?php
/*
Plugin Name: Unindex Search
Plugin URI: http://www.barneyb.com/
Description: Addes a NOINDEX meta tag for search result pages
Author: Barney Boisvert
Version: 0.1
*/
add_action('wp_head', 'unindexsearch_head');
function unindexsearch_head() {
  if (is_search()) {
    ?><meta name="robots" content="NOINDEX" />
    <?php
  }
}
?>

Simply checks if it's a search page and if so writes out the META tag.

Fuck You, WordPress.

While I certainly agree that the behaviour of typing 'www.barneyb.com' and 'barneyb.com' into a browser should be the same in nearly all cases (and it is in mine), using the bare domain as the canonical name is absurd.  If I'm hitting a website, it's canonical address should be the 'www' subdomain.  Exactly the same as every other protocol significant enough to warrant a globally accepted "standard" subdomain.  Setting up the bare domain to forward to the proper canonical subdomain is good manners, but the bare domain is not the web host.

WordPress MU, on the other hand, requires exactly the opposite.

My web site is located at www.barneyb.com.  Period.  End of story.  If you're lazy and type in 'barneyb.com', it'll happily forward you to the right location, because I'm a courteous administrator, but you'll not stay on 'barneyb.com'.  I'm lazy in most of my one-off demo apps and don't enforce canonicalization, so in those cases you can see either one in the address bar, but for my "official" web presence it's www.barneyb.com and only www.barneyb.com.

Perhaps worth mentioning is that my OpenID lives at http://barneyb.com/; it does not live at http://www.barneyb.com/.  Why?  Because while OpenID is HTTP-based, it's not part of my web site, and so doesn't belong on the 'www' subdomain.

I also split my HTTPS traffic to a separate subdomain (ssl.barneyb.com), though if you go there you'll be redirected back to www.barneyb.com unless you enter a specific application's path.  All those applications are not part of my "official" website; they're things like EventLog, Pic of the Day, timecard/invoicing, financial tracking, etc.

I'm going to intentionally not  dwell on this any more this evening.  My gut reaction is to say "you're stupid, I'm not going to use you" and stick to my Ant-based solution.  I'm not sure a bit of time to "cool down" will change that decision, but I'm going to give WPMU the benefit of the doubt and delay the decision until I'm not quite as pissed off.  It doesn't deserve it (software is supposed to serve the user, not the other way around), but I'm a courteous administrator after all.

Update (2009-05-04): I've come back and patched WordPress MU to allow the use of a 'www' subdomain.  Hopefully the change will eventually make it back to the main codebase, but I'm not holding my breath.

The WordPress stuff is going to be the biggest mess, I think.  I've been running a home-grown multiblogging app based on WordPress for the past several years and I'm doing away with it.  It's built with Ant and while you treat it as a single copy of the code, in reality you end up with a separate WordPress installation for each blog (with appropriate customizations, themes, etc.).  It gets the job done, but it's rather of cumbersome in various ways (no shared users, can't serve from a working copy, complex directory structure, etc.), so I'm going to bite the bullet and "upgrade" to MU.  Should make my life enormously easier in the long run, but in the short term I'm going to have to do some pretty invasive surgery to some plugins I cut corners on when I wrote them originally.  Also going to have to figure out how to migrate all the data into the slightly different MU schema.

Second to that will be Pic of the Day, simply because it has so many moving pieces, but I've done a lot of organizational work on it over the past year so it'll be a lot easier now than it would have been last summer when I was considering migrating to a new box.  I was hoping to switch to Railo to get it in an isolated JVM, but there are some issues preventing that, both with Railo and my code.  I don't have the RAM to run multiple copies of ColdFusion, nor the money to buy more, so it'll stay on a shared instance for now.  Fortunately, despite the fact that it's constantly churning it's gears, most of it can be taken offline for a day or three with no user-visible effect.  The user-visible portion of the app is a very narrow slice of the whole picture.

Finally, I'm trying really hard to ditch JRun for Tomcat everywhere.  The JRun connector is truly amazing in how it lets you virtualize your webroot, so it's not easy.  However, now that I've got Apache 2.2, I can bring mod_proxy_ajp and mod_rewrite to bear and hopefully get equivalent functionality.  I'm willing to sacrifice little bit of filesystem cleanliness for having a single web container for all my sites, but not much.  Fortunately, that's something I should be able to continuously refine and optimize over time, even after stuff is live.

I'm hoping to be all moved over within the month.  Long time, I know, but there's a lot of stuff to do, and this is  a "free time" project.  With the inability to effectively test and migrate individual pieces, I have to be really careful and that always takes longer.  Wish me luck!