Objective-C uses a message passing syntax. Whereas languages like C++ bind method names to some code during compilation, Objective-C resolves message receivers during runtime. Message names are typically longer than method names because they also contain identifying information about the message's parameters, separated by colons.

Whereas in C++ you may call something like:

obj->method(foo, bar)

In Objective-C you would call:

[obj method:foo andBar:bar]

And we'd consider the message name to be method:andBar:. Yes, even the colons are part of the message name. In our bridge, that method invocation would become:

(#/method:andBar: obj foo bar)

Now that we know this, we can start using Apple's API to pull objects out of the runtime. Open up a REPL with Clozure CL as your inferior Lisp. First we need to load up the bridge.

CL-USER> (require 'objc-support)

Many commonly used Foundation Framework objects are available for us immediately. These objects start with the prefix ns-. An NSDate would become an ns-date. An NSString would become an ns-string. Say we wanted to create an NSDate with the current date and time, and print its string representation. Let's put this functionality in a function called today_as_string.

Take a look at the difference as to how methods are called in Objective-C. today_as_string, implemented in Objective-C, and then Lisp.

NSString* today_as_string() {
  NSDate *today = [NSDate date];
  NSString *date_string = [today description];
  [today release];
  return date_string;
}

---

(defun today-as-string ()
  (let* ((today (#/date ns:ns-date))
         (date-string (#/description today)))
    (#/release today)
    date-string))

Based on the Clozure documentation (§15.3.3), an autorelease pool is created for us in the toplevel. This means as good citizens, we should manually release the memory when we finish using it. Calling [NSDate date] automatically calls init and alloc on the instance, and the (#/release today) call above dovetails that by decreasing the reference count.

For more detail on reference counting, please see Apple's "Advanced Memory Management Programming Guide".

Here are some other things to note. We can get a reference to any class by passing its camel-cased name to @class.

CL-USER> (objc:@class "NSString")
#<OBJC:OBJC-CLASS NS:NS-STRING (#x7FFF75FE69F8)>

We can determine if an object is a null pointer by using %null-ptr-p:

CL-USER> (%null-ptr-p (#/date ns:ns-date))
NIL
CL-USER> (%null-ptr-p (%null-ptr))
T

We are given a reader macro for generating NSStrings (prefix it with a pound sign, #), and we can get a Lisp string out of an NSString with Clozure's lisp-string-from-nsstring function:

CL-USER> (ccl::lisp-string-from-nsstring #@"test")
"test"

The use of the pound sign in the above code ((#/date ns:ns-date)) is a reader macro as well. You can get a hint as to how it works by checking the contents of the package nextstep-functions.

Let's make two useful functions for accessing the CalendarStore, then try to retrieve a list of calendar names from Clozure.

(defun icalsync-cl-calendar-store ()
  "Return the calendar store. Equivalent to
    [CalCalendarStore defaultCalendarStore]."
  (#/defaultCalendarStore ns:cal-calendar-store))

(defun icalsync-cl-all-calendars ()
  "Return a list of all calendars in the default calendar
    store. Equivalent to [[CalCalendarStore defaultCalendarStore]
    calendars]."
  (#/calendars (icalsync-cl-calendar-store)))

(let ((calendars (icalsync-cl-all-calendars)))
  (loop for i upto (1- (#/count calendars))
     for calendar = (#/objectAtIndex: calendars i)
     do (format t "~A, " (ccl::lisp-string-from-nsstring (#/title calendar)))))

Calendar, Matthew Snyder, Do, Buy, Inbox, Example, 

Our handling of the NSArray is a little clumsy. We can't just mapcar over it, we need to explicitly iterate over its elements by index. That's why nsclasp is helpful, as it contains a method to make this a little nicer:

(let* ((calendars (nsclasp:ns-array->list (icalsync-cl-all-calendars))))
  (format t "~{~a, ~}" (mapcar (lambda (c) (ccl::lisp-string-from-nsstring (#/title c))) calendars)))

But no matter how you do it, you should have been able to retrieve all your calendar names. As it turns out, this is an important piece of information to have, as the Foundation Framework doesn't yet allow us to create the kind of calendar that would sync with iCloud for us. For the time being, we have to create the calendar we want our TODOs synced to, in iCal.

Now let's combine this on the tail end of creating an iCal reminder, and sending it to a calendar.

Tasks exist in iCal as instances of the CalTask object of the CalendarStore Framework. Every task has a title, UID, a parent calendar, alarms, due dates, completed dates, notes, and other such attributes. We have to describe a mapping. Our input function takes an Emacs buffer and returns a list of parsed TODOs, and what calendar they should be synced to.

(defun icalsync-el-transform-todos (buffer)
  "Turn an org mode buffer into a list of iCal tasks.

A function that describes one way to retrieve all of the valid
TODOs from a buffer for turning into respective iCal tasks. You
can write a function that best suits your workflow. The function
is expected to take the name of a buffer, or a buffer, and return
a list of plists, each one representing a TODO item / iCal task.

FIXME(msnyder): Use org-map-entries to make this easier."
  (save-excursion
   (let ((calendar-uid (icalsync-el-calendar-name)) todos)
     (switch-to-buffer buffer)
     (beginning-of-buffer)
     (while (re-search-forward org-todo-line-regexp nil t)
      (let* ((todo-text (match-string-no-properties 3))
             (components (org-heading-components))
             (todo-state (nth 2 components))
             (headline (nth 4 components))
             (scheduled-time (org-get-scheduled-time (point)))
             todo-uid)
        (if (and todo-state
                 (funcall icalsync-el-valid-p-function todo-state todo-text))
            (progn (if (string-match org-todo-line-tags-regexp headline)
                       (setq headline (nth 4 (org-heading-components)))
                       (setq todos
                             (cons (list :buffer
                                         (buffer-file-name)
                                         :point
                                         (point)
                                         :calendar-uid
                                         calendar-uid
                                         :incomplete-p
                                         (funcall
                                          icalsync-el-incomplete-p-function
                                          todo-state)
                                         :title
                                         (org-trim headline)
                                         :scheduled
                                         (and
                                          scheduled-time
                                          (decode-time scheduled-time))
                                         :uid
                                         (cdr
                                          (assoc
                                           "ICALSYNC-UID"
                                           (org-entry-properties)))
                                         :dt
                                         (and
                                          (cdr
                                           (assoc
                                            "ICALSYNC-DT"
                                            (org-entry-properties)))
                                          (read
                                           (cdr
                                            (assoc
                                             "ICALSYNC-DT"
                                             (org-entry-properties))))))
                                   todos)))))))
     todos)))

I've created a basic Org file.

#+TITLE: example.org

* TODO Recycling
  SCHEDULED: <2012-04-15 Sun>
* TODO Trash
* TODO Fix toilet

I run the function on it, and after getting asked which calendar I want the items to belong to, I get the following list of lists.

(icalsync-el-transform-todos "example.org")

:buffer

/…/example.org

:point

78

:calendar-uid

C854CB60…

:incomplete-p

t

:title

Fix toilet

:scheduled

nil

:uid

nil

:dt

nil

:buffer

/…/example.org

:point

60

:calendar-uid

C854CB60…

:incomplete-p

t

:title

Trash

:scheduled

nil

:uid

nil

:dt

nil

:buffer

/…/example.org

:point

17

:calendar-uid

C854CB60…

:incomplete-p

t

:title

Recycling

:scheduled

(0 0 0 15 4 2012 0 t -14400)

:uid

nil

:dt

nil

When we upload a task into the Calendar Store, we're going to provide its title, deadline, and whether or not it's complete. There's also priority, which would be nice, but not necessary for the time being. Once the upload is successful, we're going to also retrieve the task's UID, and its dateStamp property, and save them in the property drawer of the TODO, in order to make synchronization easier.

(defun icalsync-el-upload-todo (todo)
  (let (todo-uid)
    (save-excursion
     (setq todo-uid
           (icalsync-capture-ccl-result
            (format "(icalsync-cl-create-task '%S)" todo)))
     (find-file (getf todo :buffer)) (goto-char (getf todo :point))
     (goto-char (car (org-get-property-block nil nil t)))
     (org-set-property "ICALSYNC-UID" todo-uid)
     (org-set-property "ICALSYNC-DT" (current-time)))))

(defun icalsync-el-upload-todos (todos)
  (loop for todo in todos do (icalsync-el-upload-todo todo)))

From here, all we need to do is run the Emacs Lisp functions needed to transform all the TODOs and upload them into the Calendar Store. Keep iCal open when you do this and make sure the Reminder list is visible.

(setq *todos* (icalsync-el-transform-todos "example.org"))
(icalsync-el-upload-todos *todos*)

Et voila!

So now you have your Org-mode tasks in a Reminder list on your iPhone. Brilliant! You wander around the town, happily marking off the items you've completed. How can we make Org-mode aware of the items that were checked off?

This is a very rudimentary method, but it works. What we'll do is update TODOs based on buffer, the same way we uploaded them to iCal. For a given buffer, we'll walk through the TODOs, seeing if they have a UID handed out by the calendar store. If so, we ask the calendar store about it. We compare the time-stamp of the TODO to the time-stamp of the reminder, and if the reminder has been changed more recently, we update the TODO.

(defun icalsync-el-download-todo (todo)
  (save-excursion (find-file (getf todo :buffer))
   (goto-char (getf todo :point))
   (let* ((result
           (icalsync-capture-ccl-result
            (format "(icalsync-cl-task->plist (icalsync-cl-get-task %S))"
                    (getf todo :uid))))
          (t1
           (apply 'encode-time
                  (read (cdr (assoc "ICALSYNC-DT" (org-entry-properties))))))
          (t2 (apply 'encode-time (getf result 'datestamp))))
     (if (time-less-p t1 t2)
         (progn (if (getf result 'completeddate) (org-todo 'done))
                (org-set-property "ICALSYNC-DT" (format "%S" t2)))))))

Not the use of the function icalsync-cl-task->plist. Since we can't hand off a CalTask object from Clozure to Emacs Lisp, I've written a function that distills a task down to its most important parts.

(defvar *task-properties* (list "title"
                                "uid"
                                "priority"
                                "dueDate"
                                "dateStamp"
                                "completedDate"))

(defun icalsync-cl-task->plist (task)
  "Convert a CalTask to a plist of properties. The list of properties
    is described by *task-properties*."
  (loop for property in *task-properties*
        for value = (funcall (intern property "NEXTSTEP-FUNCTIONS") task)
        append (list (intern (format nil "~:@(~a~)" property))
                     (icalsync-cl-coerce-value value))))