So back to data molestation in Javascript.
Now we have our post-processed data it's time to display it to the user.
Templating in Javascript seems to be in vogue at the moment, so there's a pretty decent selection to choose from. Originally I was using jquery-tmpl, but since that project got abandoned in favour of something more awesomer it was time to have a look at alternatives. I initially fell upon Mustache (to be honest, mainly because of the name) but founds myself butting up against the stringently 'logic-less' approach. I guess if you are stricter with your view-models it's less of an issue, but I just found it a little restrictive. Handlebars is an evolution of Mustache from Yehuda Katz (of Rails fame), and appears to scratch the itches that Mustache leaves me with in addition to being a superset of the Mustache syntax. Also, the name is still cool.
A quick note, before we get started. On my Mustache-based travels I stumbled across ICanHaz.js, which simplifies the process and has some really nice ideas. For example, on page load it grabs all of the templates and adds them to a globally available collection for ease of use. This becomes even more useful in Handlebars since it requires an additional compilation step. I ended up writing something very similar but considerably more primitive, and here it is:
1: var BandleHars = {
2: templateCache : {},
3: init : function() {
4: var templateList = $('script[type="text/html"]');
5: templateList.each(function(index, value) { BandleHars.templateCache[value.id] = Handlebars.compile($(value).html()); });
6: templateList.remove();
7: },
8: render : function(templateName, data) {
9: return this.templateCache[templateName](data)
10: }
11: };
12:
13: $(function() { BandleHars.init(); });
Right, let's get back to templating. First we need our data. I used a grab of the first few posts of this very site, pretty much as it's dumped out by System.Web.Script.Serialization.JavaScriptSerializer.
1: var data = [
2: {
3: "Comments" : [
4: { "Body" : ". . . the comment system.",
5: "CommentId" : 1,
6: "DateCreated" : "/Date(1248627151247)/",
7: "GravatarUrl" : "http://www.gravatar.com/avatar/d41d8cd98f00b204e9800998ecf8427e?d=identicon&s=64",
8: "Heading" : "Testing . . .",
9: "Poster" : "Tom",
10: "Website" : "http://monochromacy.net/"
11: },
12: { "Body" : "n/t",
13: "CommentId" : 2,
14: "DateCreated" : "/Date(1254127922440)/",
15: "GravatarUrl" : "http://www.gravatar.com/avatar/d41d8cd98f00b204e9800998ecf8427e?d=identicon&s=64",
16: "Heading" : "Notification Test",
17: "Poster" : "Test",
18: "Website" : ""
19: }
20: ],
21: "DateCreated" : "/Date(1248624603550)/",
22: "DateLastTouched" : "/Date(1248624603550)/",
23: "Heading" : "Oh hai!",
24: "PostId" : 1,
25: "Slug" : "Oh-hai",
26: "Summary" : "This weblog will be largely concerned with ASP.NET, C# and ...",
27: "Tags" : [ "Waffle" ]
28: },
29: /* SNIP */
30: {
31: "Comments" : [ ],
32: "DateCreated" : "/Date(1261657386630)/",
33: "DateLastTouched" : "/Date(1261657386630)/",
34: "Heading" : "Introducing Compares Favourably",
35: "PostId" : 8,
36: "Slug" : "Introducing-Compares-Favourably",
37: "Summary" : "So I made a database schema comparison tool for MSSQL 2005.\nCompares Favourably\n<p ...",
38: "Tags" : [ "ComparesFavourably", "dotNet", "Projects" ]
39: },
40: ];
41:
42: var dataSet = new DataContainer(data, 3);
43: dataSet.update = function()
44: {
45: // We'll come back to this . . .
46: };
47: dataSet.sortProperty = 'DateCreated';
48: $(function() { dataSet.update(); });
Here I'm setting up the DataContainer with three items to a page, sorted on the created data and then running the (currently empty) update function once the DOM has been loaded. Now it's time for some markup to display and manipulate our data.
1: <label>Paging</label>
2: <ul class="horizontal">
3: <li><a href="#" onclick="return dataSet.pageDown();">Page down</a></li>
4: <li><a href="#" onclick="return dataSet.pageUp();">Page up</a></li>
5: </ul>
6:
7: <label>Sort by</label>
8: <ul class="horizontal">
9: <li><a href="#" onclick="return dataSet.setSortProperty('Heading');">Heading</a></li>
10: <li><a href="#" onclick="return dataSet.setSortProperty('Summary');">Summary</a></li>
11: <li><a href="#" onclick="return dataSet.setSortProperty('Slug');">Slug</a></li>
12: <li><a href="#" onclick="return dataSet.setSortProperty('DateCreated');">Date Created</a></li>
13: </ul>
Nice and simple. This will page the data up and down, allow us to change the sort criteria, and includes some bonus hey-that's-not-what-label-elements-are-for abuse. Sue me. I figure a tag filter would make sense in this context and since this is dependant on the data it will need to be templated. First we need a container for our filter buttons:
1: <label>Tags</label>
2: <ul class="horizontal" id="tagsFilter"></ul>
And now a template for creating the filter links:
1: <script id="tagsFilterTemplate" type="text/html">
2: {{#each data}}<li><a href="#" onclick="return dataSet.addFilter('Tags', '{{this}}');">{{this}}</a></li>{{/each}}
3: <li><a href="#" onclick="return dataSet.removeFilter('Tags');">remove</a></li>
4: </script>
The above Bandlehars code (I hate that name already) will fetch and compile this template on body load, so now we just need to add this to our DataContainer update function to include the template rendering:
1: dataSet.update = function()
2: {
3: // There's still more to come!
4: $('#tagsFilter').html(Bandlehars.render('tagsFilterTemplate', { data : dataSet.getPropertyValues('Tags') }));
5: };
Now, once the page is loaded and then whenever it is filtered, the list of available tags will be updated. This means we can drill down further using additional filters. Worth noting is that we're wrapping our data in another object, since Handlebars doesn't accept raw arrays as a data context. So that's the filters sorted. But we still can't see the data itself. It's time for another container and another template.
1: <div id="data"></div>
2:
3: <script id="dataTemplate" type="text/html">
4: {{#each data}}
5: <div>
6: <h2><a href="http://monochromacy.net/Post/{{Slug}}.aspx">{{Heading}}</a></h2>
7: <p><em>{{DateCreated}}</em></p>
8: <p>{{Summary}}</p>
9: <label>Tags</label>
10: <ul class="horizontal">{{#each Tags}}<li><a href="#" onclick="return dataSet.addFilter('Tags', '{{this}}');">{{this}}</a></li>{{/each}}</ul>
11: </div>
12: {{/each}}
13: </script>
Now to add it to our DataContainer update function.
1: dataSet.update = function()
2: {
3: $('#data').html(Bandlehars.render('dataTemplate', { data : dataSet.getData() }));
4: $('#tagsFilter').html(Bandlehars.render('tagsFilterTemplate', { data : dataSet.getPropertyValues('Tags') }));
5: };
Well it's a start. What's next? How about comments.
1: <script id="dataTemplate" type="text/html">
2: {{#each data}}
3: <div>
4: <h2><a href="http://monochromacy.net/Post/{{Slug}}.aspx">{{Heading}}</a></h2>
5: <p><em>{{DateCreated}}</em></p>
6: <p>{{Summary}}</p>
7: <label>Tags</label>
8: <ul class="horizontal">{{#each Tags}}<li><a href="#" onclick="return dataSet.addFilter('Tags', '{{this}}');">{{this}}</a></li>{{/each}}</ul>
9: </div>
10: <br />
11: {{#if Comments.length}}
12: <div class="comments">
13: <h4>Comments</h4>
14: <ul>
15: {{#each Comments}}
16: <li>{{Heading}} - {{Body}} - {{Poster}}</li>
17: {{/each}}
18: </ul>
19: </div>
20: {{/if}}
21: <hr />
22: {{/each}}
23: </script>
As you can see, we've got a conditional part of the template in there. This is the kind of thing that Mustache consciously avoids, but I personally find quite useful.
A note about line 11 above. The Handlebars site says that the if block helper evaluates an empty array to false, and I also uncovered a pull request on Github mentioning this very thing that was merged on June 27. However, the latest download is the v1 beta-3 which was packaged on June 2, hence resorting to the .length trick. It looks like this won't be necessary after the next release.
Finally, .NET has done something weird and unseemly to our date values, so we need some way to tweak those back into shape. Thankfully another feature of Handlebars is the ability to add custom helpers.
1: Handlebars.registerHelper("dotNetDate", function(context) {
2: var m = context.match(/^\/Date\((\d+)\)\/$/);
3: var date = null;
4: if (m)
5: date = new Date(parseInt(m[1]));
6: return date.toLocaleDateString();
7: });
And we can invoke it using this:
{{dotNetDate DateCreated}}
Giving us our final version, which you can see running here:
DataContainer + Handlebars.js Example
The downsides? Unfortunately this is an SEO black hole since all of the real content is injected in via Javascript at page load. You'll need to render this on the server-side in order to receive any search engine attention at all. That said, there's Mustache implementations in a tonne of viable server-side languages and while the few changes to Handlebars almost certainly increase the complexity . . . hmmm. Time for another weekend project?