David Raynes

RandomEntries 1.0

2009-04-24T05:15:00Z

I’ve managed to resurrect and rewrite my old old RandomEntries plugin. Turns out it was really really inefficient on blogs with a sufficient number of entries. Currently it will only work on index templates (or, more specifically, in contexts without a stashed entries list) because it works at the SQL level, but I plan to address that in the future.

So, an example of usage, to select 5 random entries:

<mt:entries limit="5" random="1">
* <mt:entrytitle>
</mt:entries>

Note the use of limit instead of lastn. This plugin will not work with lastn as lastn implies a specific sorting to the entries that overrides the random sorting.

The RandomEntries plugin requires Movable Type 4.25 and works with the mt:entries tag so generally it should work with most mt:entries arguments (except lastn and sort_by). You can download it from the github repository for the plugin.

TaskMaster for Movable Type 1.0

2009-04-19T03:10:00Z

One of the things I’ve wanted for a while with Movable Type was more control of periodic tasks. I’ve been able to get by with just looking at code and manual SQL commands, but that’s hardly a long-term solution. Thus was born TaskMaster.

TaskMaster, currently, has four commands it implements:

list

Lists all the known periodic tasks

% perl ./tools/task-master list
CleanTemporaryFiles:
        Label: Remove Temporary Files
        Frequency: 1h
        Component: Core
FuturePost:
        Label: Publish Scheduled Entries
        Frequency: 1m
        Component: Core
JunkExpiration:
        Label: Junk Folder Expiration
        Frequency: 12h
        Component: Core
RemoveExpiredSearchCaches:
        Label: Remove Expired Search Caches
        Frequency: 1d
        Component: Core
RemoveExpiredUserSessions:
        Label: Remove Expired User Sessions
        Frequency: 1d
        Component: Core
UpdateEvents:
        Label: Poll for new events
        Frequency: 30m
        Component: Action Streams

status

Lists the last time some or all periodic tasks were completed

% perl ./tools/task-master status
Publish Scheduled Entries last finished at: Sat Apr 18 21:49:29 2009
Poll for new events last finished at: Tue Jan 27 10:44:08 2009
Remove Temporary Files last finished at: Tue Jan 27 10:44:08 2009
Remove Expired Search Caches last finished at: Tue Jan 27 10:44:08 2009
Remove Expired User Sessions last finished at: Tue Jan 27 10:44:08 2009
Junk Folder Expiration last finished at: Tue Jan 27 10:44:08 2009

run

Runs a task or tasks normally (i.e., respects frequency setting)

% perl ./tools/task-master run FuturePost     
Publish Scheduled Entries last finished at: Sat Apr 18 22:58:24 2009

forcerun

Forces a task or tasks to run, regardless of frequency

% perl ./tools/task-master forcerun FuturePost
Publish Scheduled Entries last finished at: Sat Apr 18 22:58:58 2009

TaskMaster 1.0 is currently available from my github account.

PW101: Hello World for Template Tags (pt. 1)

2009-04-01T14:00:00Z

The first thing that was available to plugin developers for Movable Type was writing new template tags, so let’s start there.

We’re going to:

Create a plugin skeleton
Add a template tag named ‘helloworld’ that will output a greeting (“Hello World!”)

My goals for this are to demonstrate:

Basic plugin structure and layout
Basic template tag development

So, to start with, we need to tell Movable Type about the plugin we’re writing. Let’s create a directory under the plugins/ directory in the Movable Type installation for our plugin called HelloWorld.

So the structure we have so far should look like this:

plugins/
    HelloWorld/

Adding the config.yaml file

Next we need to add a file to describe the plugin to Movable Type. The config.yaml file does just that. The file is in YAML format and while there are ways to insert code into it, I generally avoid that practice and try to keep it strictly informational.

So, the config.yaml is essentially just a list of key/value pairs that tell Movable Type about the plugin:

name: Hello World
description: Adds the mt:helloworld tag
version: 1.0

tags:
    function:
        helloworld: $HelloWorld::HelloWorld::Tags::_hdlr_hello_world

Most of those should be fairly self-explanatory (name is the plugin’s name, description its description, and so forth). The tags key contains information about the template tags that the plugin provides. The function sub-key states that anything underneath it is a simple or regular tag. The keys underneath that are the names of the template tags themselves, and the values are references to the code that will handle them when they are encountered in a template. Generally, the format for that reference is $PluginId::Module::method.

So, now we have a directory for out plugin and a config.yaml file describing it. What’s left? Why, implementing the plugin, of course!

Creating the template tag

I like to keep all the template tags for a given plugin in the Tags module for that plugin within the PluginName module (i.e., PluginName::Tags) to avoid any module naming collisions between plugins, just in case.

You may have noticed the naming convention I used in the reference for the template tag handler ($PluginId::PluginName::Tags::_hdlr_tag_name). This notation serves two purposes. It instructs Movable Type as to which component/plugin to set as the current component when calling the tag handler (the $PluginId part) for use with various component specific actions, like loading application templates, and it also points to the tag handler itself (PluginName::Tags::_hdlr_tag_name).

But, you want code! Here is plugins/HelloWorld/lib/HelloWorld/Tags.pm:

package HelloWorld::Tags;

use strict;
use warnings;

sub _hdlr_hello_world {
    return "Hello World!";
}

1;

The lib/ directory within a plugin’s directory is automatically added to the list of directories searched by perl for modules when Movable Type loads the plugin.

So, the _hdlr_hello_world method. All template tag handlers need to do one thing: return a value to place into the template being built. When you want to return nothing, be sure to actually return an empty string instead of a bare return, since a bare return actually returns an undefined value and that signals to Movable Type that an error has occurred.

Here is what the filesystem should look like now:

plugins/
    HelloWorld/
        config.yaml
        lib/
            HelloWorld/
                Tags.pm

Testing out the plugin

Movable Type comes with a tool that can actually build templates on the command line: tools/mt-tmpl-preview. It reads the template to build from STDIN and we can make use of it to test out our plugin like this (from the MT directory):

% echo '<mt:helloworld>' | MT_BLOG=1 ./tools/mt-tmpl-preview
Hello World!
%

The MT_BLOG environment variable needs to be set to the id of an existing blog in the installation.

You can see that the expected results are what is returned. Hooray! But, what if you want to test this in a more automated fashion?

Enter MT::Test

Automated unit testing is your new bicycle. It will solve all your problems and shampoo your carpet. Well, not really. But it is still very handy.

So for this plugin, we will create two test files. One to verify that everything is syntactically correct and one (for now) to verify that things are functioning correctly.

First, we have plugins/HelloWorld/t/00-compile.t:

use lib qw( t/lib lib extlib );
use strict;
use warnings;

use MT::Test;
use Test::More tests => 2;

require MT;

# Verify that the plugin loads into MT
ok(MT->component ('helloworld'), "HelloWorld plugin loaded correctly");
# Verify that the Tags module loads without error
require_ok('HelloWorld::Tags');

1;

And then plugins/HelloWorld/t/30-tags.t:

use lib qw( t/lib lib extlib );
use strict;
use warnings;

# Create a test db and add some data
use MT::Test qw( :db :data );
use Test::More tests => 1;

# verify that the tag output is the expected one
tmpl_out_like(
    '<mt:helloworld>', {}, {}, qr/^Hello World!$/,
    "mt:helloworld produces 'Hello World!'");

1;

To get things up and running with MT::Test you will need to grab the test code here (by clicking the download button, unpacking, and copying the t/ directory into your Movable Type install). With that in place, you can use the prove utility to run the tests:

% prove ./plugins/HelloWorld/t/*.t
./plugins/HelloWorld/t/00-compile....ok                                      
./plugins/HelloWorld/t/30-tags.......ok                                      
All tests successful.
Files=2, Tests=3,  6 wallclock secs ( 2.56 cusr +  0.88 csys =  3.44 CPU)
%

The code for all this can be downloaded from the Plugin Writing 101 github repository. I’ll be tagging the code for each entry; you can find the code for this entry here.

Next time:

Making use of arguments in your template tag
Making your template tag context aware

Plugin Writing 101: About the series

2009-03-25T04:10:00Z

I just thought I should follow up the Intro with some of my thoughts and expectations for this series of plugin development posts I’m writing and for whom I am writing them.

My main goals are:

To teach plugin development for Movable Type. I am planning to focus on the perl side of plugin development, mostly because that is where I work. I have not yet had any real need to develop a significant amount of php plugin code for Movable Type.
To communicate and demonstrate what I consider to be best practices for plugin development. Maybe you agree. Maybe you disagree. I would love to hear your opinion and I am open to discussion, but these are practices I use in my day-to-day plugin development work that I have put together over the last couple years.

What I am not going to do:

Teach perl. There are so many better resources for this than me. I’m going to do my best to avoid any wacky perl-specific techniques, so anybody with a general programming background should be able to follow along, but I am not here to teach you how to write perl.
Write your plugin for you. I am more than happy to discuss the myriad of options for integrating code into Movable Type, but anything beyond that is generally going to be outside the scope of this series. If you need a plugin written, there is a great bunch of folks that do just that at Six Apart Services as well as many distinguished members of the ProNet and Movable Type community at large.

I am in the process of finishing up the first Hello World plugin post right now, so that should be up soon. My goal is to get roughly one actual programming post up per week.

Plugin Writing 101: Intro

2009-03-21T14:00:00Z

I think I’m actually going to do it now. Somehow I’ve managed to light a fire under myself to get this started.

So, Plugin Writing 101. I don’t yet have any kind of set outline for this, but I figure I’ll start with the standard ‘Hello World’ style plugins (yes, plugins). The first should be finished in another day or two. I’ll also try to demonstrate my personal set of plugin development best practices as I go.

Hopefully, I’ll manage to make some sense. And, please, feel free to let me know what topics you would like me to touch upon.

T-Shirt Temptation

2009-03-21T03:45:00Z

I’ve never bought anything from Threadless before, but I have to admit this is very very tempting. I just thought I should share.

Awesome, innit?

Toddlers, Technology and Touchscreens

2009-03-01T21:43:37Z

It’s amazing to watch the boys interact with the technology around them everyday. As cliche as it sounds, they really do have a different and amazing perspective on things.

So much of what we use around them involves touchscreens (iPhones, Nintendo DS, etc.), so they just assume that lots of other things work that same way. They try to interact with our laptops by touching the screens. When we put on a DVD for them, they will sometimes try and interact with the menus by tapping the screen with their fingers. By the time they’re old enough to really use those things themselves, maybe touchscreens will be as ubiquitous as they think they are right now.

Must Be Doing Something Right

2009-02-01T03:50:01Z

It’s not because they say please and thank you so often (and appropriately). It’s not that they hug each other and say they’re sorry (eventually) after they fight. It’s not that they love fruit, oatmeal, cheese, pancakes and any number of non-candy foods.

The one reason I think we must be doing something right is that William loves to rock out to classic rock (especially The Who lately).

Because Giant Gaming Tables Are Awesome

2009-01-30T05:42:10Z

rayners http://rayners.org/

Because tests and bugs are fun

2009-01-06T03:15:06Z

A colleague of mine just shared this particular frustration:

yargh. my test passes if all of the objects are created within the same second, but fails if not. don’t ask how long it took me to figure that one out.

I would have tweeted it, but it was a bit too long and I didn’t want to break it up. I found it pretty amusing, but I have an odd sense of humor and I have been spending alot of time with unit tests lately.

New Urban Fantasy Anthology: Mean Streets

2009-01-03T03:25:00Z

I was browsing through SF Signal’s latest books received post and I was happy to notice an anthology of urban fantasy containing stories by two of my current favorite authors: Jim Butcher (of The Dresden Files) and Simon R. Green (of The Nightside). This is in addition to stories by two authors (Kat Richardson and Thomas E. Sniegoski) I have not yet read, but I would certainly be willing to try out if they are included with the previous two.

That one went right on my wishlist. It’ll be out in a few days and I may just have to snag it.

Upgraded to MT 4.23

2009-01-02T03:52:25Z

So, yeah, it’s a month late or so, but I’ve been really busy. I finally upgraded this site to Movable Type 4.23. Maybe I’ll even write more plugins sometime soon.

I apologize about the feed updates

2008-11-22T05:27:41Z

I’m deploying a development version of my MediaConsumer plugin and a number of entries might appear as updated in feed readers as I start applying it.

Pilot Ordered for A Game of Thrones

2008-11-18T04:50:00Z

From Pat’s Fantasy Hotlist: ASOIAF on HBO: It’s a go!:

Martin fans rejoice! ;-)

Well, let me get things started by saying “Yippie!”

More information at The Hollywood Reporter: HBO conjuring fantasy series.

Legend of the Seeker premieres this weekend

2008-10-28T02:30:00Z

The television series based on the first novel of Terry Goodkind’s Sword of Truth series, Wizard’s First Rule, premieres this weekend in syndication.

There are a number of folks out there that are very much not fans of Terry Goodkind, but I enjoyed the novel when I read it years ago; it was hardly the best novel of the 20th century to be sure, but I liked it. Between that and the fact that Sam Raimi is involved with it as executive producer, I am more than willing to give this series the benefit of the doubt and watch a few episodes before I decide to give up on it. If nothing else, I hope this will be at least a marginal enough success so that other great fantasy novels could be serialized into season (or longer) television programming.