I’m getting tired of having to manually copy the HTML code generated by Mathematica’s Export[file, “HTML”] command into the WordPress editor in order to post a notebook to my blog.So I decided to write a WordPress weblog client for Mathematica.The client uses the WordPress XML-RPC (XML remote procedure call) API to send blog post data directly from my home computer to my web server.
The first step was to find some documentation on the WordPress XML-RPC API, which I found on a few different sites:the main WP API codex, a helpful blog detailing more of the API functions than are listed in the codex, and the actual XML-RPC spec.
The basic steps in posting a Mathematica notebook to my WordPress blog are:
1. Export the Mathematica notebook as HTML 2. Encode the resulting HTML in an XML message using the XML-RPC format expected by WordPress 3. Send the XML to the WordPress server as an HTTP POST request 4. Decode the XML response sent back from the server 5. Repeat steps 2-4 to upload all image files generated by the HTML export to the server
In order to easily test that all this was working, I decided to install a local web server on my MacBook Pro.Rather than mess with trying to install Apache Tomcat from scratch, I opted to install MAMP, which is a self-contained web server for Macs that includes Apache, MySQL, and PHP all in one.
After using MAMP to create a web server on http://localhost:8888, I installed WordPress at http://localhost:8888/wordpress.So now I was up and running with a local WordPress installation that I could test my blog client code against.
Here’s the simple example notebook I want to post to my blog:
1. Export the Mathematica notebook as HTML
</p>
The first step is to export the notebook in HTML format.I took some pointers from another Mathematica-based blog in getting a first version of the following function to work.It's working at a basic level now, but it needs improvement.Mainly, I need to add a "ConversionRules" option to Export in order to wrap the various Mathematica styes (from Mathematica's own stylesheet) in custom tags, which will allow me to match the CSS classes referenced in the generated HTML with the CSS file used in my WordPress theme.
I feed this function a notebook file name, an HTML file name, and a date.It does the HTML export (which creates a .html file and bunch of .gif files for every cell in the notebook containing code) and then reads the HTML file back in and does some hacky string processing on it in order to convert local image file paths into file paths valid for my web server (which is what the date is used for).
I use the HTML export option "FullDocument"→False so the HTML is generated without headers (because WordPress will wrap the blog post content I send it with its own header material):
The Export command generates an HTML file:
... and an image file for every Input/Output cell:
Here are the thumbnails of the generated image files:
2. Encode the HTML in an XML-RPC formatted message
In order to use the WordPress weblog client API, I had to be able to create XML blobs using the XML-RPC encoding conventions.I decided to handle this in top level Mathematica by creating an XMLObject expression for each request, and using ExportString[\_XMLObject, "XML"] to create the XML blob as a String.This XML string then serves as the HTTP POST request body sent to the XML-RPC server.
The XML-RPC encoding functions for the atomic datatypes are below.I use a common head (xmlrpcencode) with a different DownValue for each XML-RPC datatype ("int", "double", "base64", etc.).Each XML-RPC datatype corresponds to a different Mathematica Head: Integer -> int, String -> string, Real -> double, "Base64" -> base64, and Boolean -> boolean:
Then there are two types of XML-RPC data structures: struct and array.A struct gets encoded from a list of rules, for which the Mathematica pattern is {__Rule} (see my NKS Summer School lecture on patterns in Mathematica). An array gets encoded from any List: {___}.The following DownValues take care of the data structure encodings.Note that they're set up recursively, so that the elements inside the lists get properly encoded.The XML-RPC spec allows for nesting of these data structures, so an element inside a struct can be another struct or array, and similarly for arrays.
This final DownValue creates the overall XMLObject, and serves as the entry point for creating the request:
Using this encoder I can generate arbitrary XML-RPC requests.So for example, here's the request given as an example in the XML-RPC spec:
And here's what an actual WordPress API request looks like (in this case, a request to create a new blog post):
Then I also need top level code for decoding the XML responses sent back by the server:
Here's an example of a decoding, using the example response given in the XML-RPC spec:
3. Send the XML to the WordPress server as an HTTP POST request
Now that I have the ability to encode and decode these XML-RPC blobs, I need to be able to send HTTP POST requests from Mathematica to the web server running WordPress.
The key to all this is the ability to send an HTTP POST request from Mathematica.While this isn't directly supported by any top-level function in Mathematica, you can accomplish it using the built-in J/Link framework, which allows you to instantiate and access methods in Java objects directly from Mathematica.A recent Wolfram Research blog post by Rob Raguet-Schofield explains very nicely how to send HTTP POST requests using J/Link.
I'll use my WordPress install running on localhost to illustrate the steps in creating and sending the POST request.
The basic idea is to instantiate an org.apache.commons.httpclient.HttpClient object, and set up its authentication credentials:
Then the real work happens by instantiating an org.apache.commons.httpclient.methods.PostMethod, and filling it out with the XML-RPC blob to serve as the request body.
Instantiate the PostMethod:
Here's explicitly what the XML-RPC request will look like:
(Note the XML preamble, e.g. "POST /RPC2 HTTP/1.0 User-Agent: Frontier/5.1.2 (WinNT) Host: betty.userland.com Content-Type: text/xml Content-length: 181" isn't included in the XML blob.That's because the preamble is added for you by the HttpClient when the POST request is sent.I learned this the hard way.I was manually adding the preamble, but all the POST requests were generating fault responses (malformed request).I had to packet-sniff a bunch of failed requests to realize they had two copies of the preamble in them: one generated by the HttpClient, and a superfluous one I was tacking on.)
The request is often referred to as the "payload":
Instantiate an org.apache.commons.httpclient.methods.StringRequestEntity:
... and add it to the PostMethod object:
Now execute the POST request:
If the request is well-formed, we get the response we're looking for from the server:
4. Decode the XML response sent back from the server
Now I just have to decode the XML response from the server into a Mathematica expression that I can digest easily.The code for that was described in step 2.
Since the API method I used was "metaWeblog.newPost", the server sent back the post ID of the newly created post:
And the post shows up on WordPress under post ID 392 (at "http://localhost:8888/wordpress/?p=392") as expected:
But notice that none of the images are showing up.That's because we haven't uploaded the images to the server yet ...
5. Upload all image files to the server
In step 1 I mentioned that the HTML export generates a bunch of image files on the client.Here are the thumbnails again:
These all have to be uploaded to the server, since the generated HTML is expecting them to be there.
We can use the API method "wp.uploadFile" to upload the image files.
Take the first of these image files:
... and encode it (as XML-RPC "base64" data) within a wp.uploadFile request:
(Note the idiom ExportString[Import[image, "String"], "Base64"] for encoding the image in base-64 as required by the XML-RPC spec.)
Now instantiate and execute a PostMethod as before, this time with the new image payload:
Success!The server responds with the URL of the uploaded image:
Do it again for the second image:
And now the images show up in the post:
Blog this notebook
Putting this all together, here's all the code thus far packaged up into a few functions:
