I've had the pleasure over the last few weeks of rewriting the already awesome Zenbe Lists iPhone app, and porting it over to the iPad.
Two days have passed since the inital release, and I'm happy to say that we've received a beyond flattering mention on Gizmodo.
Thank you Gizmodo!
It was bound to happen sooner or later — a new blog post! (only took me 1,207 days.)
Anyways, I'd like to talk a bit about a project I've been working on to extract dates from their natural language representation. The project is called natty, and Ive decided to open source it under an MIT license.
What natty does is attempt to define a formal grammar describing all the crazy ways people refer to dates that are relative (or not) to the current date. Some typical examples are: monday of next week, next tuesday, or the 28th of february at 6pm. The casual observer may suggest a series of regular expressions to do the job, but will soon find that the grammar describing such things is far from regular, and tends to be quite ambiguous.
ANTLR fits the bill nicely as we can use syntactic predicates to deal with ambiguities (by enabling infinite lookahead,) and semantic predicates to deal with the parts of our grammar that inch towards context sensitivity.
Defining the grammar is one thing, but actually extracting meaningful information is another. To solve this, I'm using ANTLR's abstract syntax tree (AST) rewrite rules to build an intermediate representation that defines the date as a generic, tree-like structure. Once built, this structure can be walked, invoking common date manipulation methods along the way to arrive at the correct date.
This approach has several advantages over a more naive, non-grammar based approach. The most significant of which is the ability to offload the generation of messy parsing code to a code generator instead of a human. We still have to deal with a complex grammar specification, but the grammar is infinitely less complex than the generated code, and will prove to be far less brittle when making future changes.
Another significant advantage is the theoretical ease at which the parser can be ported to a new language — choose a new ANTLR target, implement a few generic date manipulation methods, and call it a day.
More information about the project is available on the natty website, and the source can be found on GitHub. Enjoy.
Just a follow-up to my last post on Ajax busy indicators, where I described how to implement a single image/callback to indicate the status of all the Ajax requests on your site. The limitation was that the image had to always be placed in a pre-defined spot on the page, which is less than desirable. This can be overcome by dynamically changing the position of your image based on which link/button was pressed. Consider the following javascript:
function setBusyNextTo(link) {
linkPosition = Position.cumulativeOffset(link);
linkDimensions = Element.getDimensions(link);
imageHeight = Element.getDimensions('busy_img').height;
x = linkPosition[0] + linkDimensions.width;
y = linkPosition[1] + (linkDimensions.height / 2) - (imageHeight / 2);
$('busy_img').style.top = y + "px";
$('busy_img').style.left = x + "px";
}
You can hook this up to your ajax links (or buttons) using the after callback:
<%= link_to_remote("Action", {
:url => {:action => "ajax_action"},
:after => "setBusyNextTo(this)"})%>
This will place the activity indicator directly to the right of the link that was clicked. The code in my previous post will take care of actually displaying the indicator (via a generic callback.) Note that this code makes no assumptions as to the physical size of the indicator image - The image will be vertically centered next to the link. This makes it possible to try out a bunch of different indicators by simply changing the src attribute of your indicator's image tag. The vertical positioning will be taken care of, but the horizontal positioning may be a bit trickier. You will have to make sure that your link or button has enough empty space to the right of it to avoid placing your indicator on top of something.
This idea can be taken a step further by adding the positioning functionality to our links and buttons unobtrusively (say, in the body's onload handler.) This can be accomplished with the following beautiful piece of javascript:
$$("a").each(function(anchor) {
anchor.onclick= function() {setBusyNextTo(this)};
});
Be careful with this method though, as this will only affect those dom elements that were originally created at the last browser page load (as opposed to the last javascript dom manipulation.)