The gateway to the server

Although I don’t have any immediate plans to implement a back-end for anything other than WordPress, I want to make sure it’s possible, so I have created a list of operations I want to be able to do on posts (well, OK, I haven’t actually written it down or anything, but it’s in my head. Somewhere). Each back-end needs to implement each call (even if it’s just a no-op).

If that was the only abstraction, though, we would end up with a lot of boilerplate code—or we would define some macros, which I’m not yet familiar with—because each operation would have to take care of pulling out whatever information it needed from the arguments it was handed—which will always include a blog structure as the first item.

Instead, I opted for a level of indirection. Instead of calling a back-end function directly, any time the back-end-agnostic code wants to perform an operation on an article, it goes through org-blog-call. org-blog-call figures out what engine the blog structure is using, constructs the name of the operation for the back-end associated with the blog, and then invokes it.

So it’s really pretty short—pulling out a single bit of info and checking for a function’s existence.

(defun org-blog-call (blog call &rest args)
  "Make the specified call to the appropriate blog engine.

This allows us to maintain multiple engines, with a set of
operations common to all, and call the appropriate function based
on the engine specification in the entry in `org-blog-alist'."
  (let ((entry (intern (concat "org-blog-" (cdr (assq :engine blog)) "-call"))))
    (if (fboundp entry)
        (apply entry blog call args)
      (error (format  "Can't find function %s" entry)))))

What this is invoking, in the case of a WordPress blog, is org-blog-wp-call. It doesn’t do whole heck of a lot, either, other than pull out the parameters that are common to each XML-RPC request, and invoking the actual function (whose name it has constructed, much like org-blog-call).

(defun org-blog-wp-call (blog call &rest args)
  "Easy calls to WordPress API functions.

This routine will take whatever information a user has available,
fill in the rest (if the user is willing to cooperate) and then
call the specified function and return the results."
  (let ((blog-id (cdr (assq :blog-id blog)))
        (func (intern (concat "org-blog-wp-" call)))
        (password (cdr (assq :password blog)))
        (username (cdr (assq :username blog)))
        (xmlrpc (cdr (assq :xmlrpc blog))))
    (if (fboundp func)
        (apply func xmlrpc blog-id username password args)
      (error "Can't find function %s" func))))

At this point, the actual XML-RPC call is pretty anticlimactic:

(defun org-blog-wp-post-create (xmlrpc blog-id username password wp)
  "Create a post on the blog."
  (xml-rpc-method-call xmlrpc
                       'wp.newPost
                       blog-id
                       username
                       password
                       (org-blog-post-to-wp wp)))

Hmmm. Looking back on this, I can see that I’m going to end up changing this at some point. I feel certain there are more direct, cleverer ways to implement this pattern—ones that would even allow me to pull out the open-coded XML-RPC call in org-blog-wp-params. So I’ll bee looking into this, though I still want to get through the initial implementation first.