While developing Lystee, we used Django templates for server side templating and Handlebars.js for client side templating. While they are both great templating systems, often times we render a page server side and later update it client side, requiring us to have to duplicate many of our templates in Django templates and Handlebars.js. For Lucidity we went with a solution that lends itself better to reusability, Pystache. Pystache renders mustache templates in Python, and then we can use mustache.js for rendering the same template on the client.

Django templates provide a convenient {% trans "" } tag for which there is no mustache equivalent. So, how do we handle internationalization in Pystache? I forked Pystache and added a new tag, {{@ }} that calls into django.utils.translation.ugettext to translate whatever is inside the tag. This way we put our text that we need translated inside the tag like so: {{@Hello!}} and as long as we have the rest of our localization setup correctly, the text gets translated into the language sent in the Accept-Language header.

So that covers server side translation, but what about when the client needs to render a template, surely you don’t want to modify mustache.js and deal with the headache that JavaScript internationalization is? Of course not, but I have a simpler solution! Since the server sends the mustache template down, we can simply intercept that request, and send down a version with the {{@ }} pre-rendered by the server, and all other tags left intact so that mustache.js can render them. To do this, rather than call view.render() on your Pystache views, you can call view.renderOnlyLocalization() and get the template with only the {{@ }} tags rendered. So, given the following template:

{{@Hi}} {{name}} {{@How are you on this fine day of}} {{date}}

The server will send the following to the client, which can then be rendered via mustache.js:

Hi {{name}} How are you on this fine day of {{date}}

You can get the source here if you want to use this in your own projects or add on to it.

At 8byte8 we use MongoDB in many of our projects. There is an open ticket for supporting full text search natively in MongoDB, I am patiently waiting for the day that it gets implemented. In the meantime I am using a quick and dirty solution for providing the ability for users to search public lists in Lystee. You can perform a simple map reduce over the collection that you wish to build a search index for. Let’s say you have a collection with documents that have a description property, here is the JavaScript map job:

function() {
  var id = this._id;
  if(this.description != null) {
    var terms = this.description.split(/\s+/g);
    for(var i = 0; i < terms.length; i++) {
      var term = terms[i];
      if(term != null && term != '') {
        term = term.toLowerCase();
        var result = { };
        result[id] = 1;
        emit(term, result);
      }
    }
  }
}

Every document in the collection gets mapped over, if the document has a description field (presumably in paragraph form), the field gets split into multiple terms by splitting on whitespace. Each term gets lowercased, then emitted. The emit maps the _id of the document to how many times the term appears in the document.

Here is the JavaScript reduce step:

function(term, emits) {
  var result = {};
  for (var i = 0; i < emits.length; i++) {
    var emit = emits[i];
    for(var id in emit) {
      if(result.hasOwnProperty(id)) {
        result[id] += emit[id];
      }
      else {
       result[id] = emit[id];
      }
    }
  }
  return result;
}

Here the emits are aggregated and stored into an index collection that you can use for providing search functionality. The index collection _id field contains the term, and the value field contains a list of mappings of document _id‘s that contain the term to the amount of times the term appears in the document. As a side bonus you can also provide autocomplete functionality by using a regex to find documents, here is the Python PyMongo code to do so:

collection.find({'_id':re.compile('^' + t + '/*', re.IGNORECASE)})

This solution lacks some more advanced features that are desirable in text search engines, such as term stemming. If you need more advanced searching I recommend using software dedicated to text search, such as Solr.