post to wordpress.com with markdown

I’ve come to enjoy writing posts, transcriptions, reading notes, and even formal papers using markdown and its variants. I really want to do so with this blog as well, but it’s cumbersome. For wordpress.org sites, there is a plugin to use markdown. But of course, plugins aren’t available on the wp.com side. I started this blog as one of my first-ever entries into the world of the web, and went with wp.com because it was comfortable and easy. I certainly could migrate it to a self-hosted site, but if I’m doing that, then I’m going to move it off of wordpress altogether. I could also write the posts in markdown, transform them to html, and then cut-and-paste the html into a new post in the web browser. That sounds like a pain in the ass, and duplicates files where duplication isn’t necessary.

In the meantime, I still want to write my posts in markdown, store them as text files in my svn repo, and publish/push them directly to the site from the command line. This post is a first attempt at doing that. Here’s the strategy, which borrows a little bit from how static site generators like jekyll or growl work. It’s pretty simple in conception, but includes a couple of tricks in execution. The basic flow is this:

1. Write the post in markdown.
2. Transform the the post to html.
3. Push the newly html-encoded post to my this site using xml-rpc and the MetaWeblog API.

There is a slick python markdown module to handle the transformation part. There is also a library for using xml-rpc included in the standard library, which includes the MetaWeblog API. So the hard work is already done. In order to use the API, though, the application has to send a few different bits of info to the blog — blog_id, username, password, title, content, tags, categories, status. The title, content, tags, and categories need to be passed as a dictionary. I want an easy way to include that info on a post, so borrowing from the practice of static site generators, I decided to include a YAML header to each post, and parse that with pyYAML. So, each post includes a header like this:

---
title: title of the post
categories: categories
tags: list, of, tags
status: publish (or draft)
---

The three dashes are important, as they separate the YAML information from the post content, and the script uses a regex to accomplish that separation. Then, it parses the YAML and produces a dictionary of key:value pairs. So, there are two dependencies not in the standard library that you must make sure are installed on your PYTHONPATH for this to work– pyYAML and python-markdown.

Step one, import the dependencies:

1 2 3 4 5 6 7

#! /usr/bin/python import xmlrpclib import yaml import re import sys import markdown

Step two, compile a regex (borrowed from here) to split the YAML from the markdown content, open your file and extract the info:

RE_YAML = re.compile(r'(^---\s*$(?P<yaml>.*?)^---\s*$)?(?P<content>.*)',
    re.M | re.S)
postFile = open(sys.argv[1], 'r').read()
fileInfo = RE_YAML.match(postFile)
getYAML = yaml.load(fileInfo.groupdict().get('yaml'))
postMD = fileInfo.groupdict().get('content')

You’ll notice that this bit opens a filename passed as an argument from the command line, which is where I run the script from. You could also ask for raw_input or however you want to open the post file. The final three lines of that snippet split the file via regex and yaml.

Step three, transform the post and prepare the metadata for xml-rpc transport to the blog:

newPost = markdown.markdown(postMD, extentions=['footnotes', 'codehilite'])

blogurl = 'https://example.wordpresscom/xmlrpc.php'
username = '######'
passwrod = '######'
blogid = ''
server = xmlrpclib.ServerProxy(blogurl, allow_none=True)

if getYAML['status'] == 'publish':
    status = '1'
else: status = '0'

data = {}
data['title'] = getYAML['title']
data['description'] = newPost
data['categories'] = [getYAML['categories']]
data['mt_keywords'] = getYAML['tags']

Step four, send the new post to the blog and print a confirmation with the new post’s postid:

post_id = server.metaWeblog.newPost(blogid, username, password, data, status)
print "Created id - %s" %post_id

Step five, deploy the whole thing from the cli:

$ post name_of_post.txt

So, for that to work, you simply need to add an alias named post to your .bash_profile or .profile file, pointing to the script.

And that’s it. I’m also keeping a pickle of all my posts and their id numbers, in case I want to edit a post again later. The other thing I’m working on with this is a step prior to publishing that will us a regex to find images in the post, and then locate them from an images folder on my hard drive and upload them to wp.com using metaWeblog.newMediaObject. I’ll post it once I’ve got it running.

Two caveats — right now, this script always produces a new draft or published post, it doesn’t do any checking to see if the post already exists. That’s another thing I’ll try fixing in the near future. At least for now, as of this post right here, I can write in TextMate, store in my svn repo, and push a finished post to this blog from the command line. That makes me a little more happy.

About ctb

Associate Professor of Early Latin America Department of History University of Tennessee-Knoxville

‹ update to google tasks on the cli

dterm- the popup cli ›

Tagged with: markdown, wordpress.com
Posted in programming