Make hot curry using Javascript

2008-12-11T06:24:00.000-08:00

Being originally a Java developer, the only Javascript that I used to write (during those days) was to validate web application forms. But I have come to realize that Javascript is an extremely powerful language. One example is
currying. A lot of people have written curry functions for various purposes, mainly callback functions for events. I wrote a generic curry function some time ago that can be used in any scenario where callbacks are required.

So here's a recipe for a hot curry:
Ingredients: Javascript, A pinch of mojo


/**
 * Changes the scope of function "fn" to the "scope" parameter specified or
 * if not, defaults to window scope. The scope of the function determines what
 * "this" keyword evaluates to, inside the function "fn". Any additional arguments
 * specified in this are passed to the underlying "curried" function. If the underlying
 * function is already passed some arguments, the optional arguments are appended
 * to the argument array of the underlying function. 
 * You can pass any number of arguments that are passed to the underlying (curried) function
 *
 * @param fn {Function} The function to curry
 * @param scope {Object} The scope to be set inside the curried function, if
 *              not specified, defaults to window
 * @param args... Any other optional arguments ot be passed to the curried function
 * @author anaik
 */
function $curry(fn, scope /*, opt arguments */) {
   scope = scope || window;
   var actualArgs = arguments;
   
   return function() {
      var args = [];
      for(var j = 0; j < arguments.length; j++) {
         args.push(arguments[j]);
      }
      for(var i = 2; i < actualArgs.length; i++) {
         args.push(actualArgs[i]);
      }
      return fn.apply(scope, args);
   };
}

Consider the following "class" Person. The getName method refers to other instance methods of the same class. Hence the "this" keyword inside this function refers to the Person instance.


function Person(firstName, lastName)   {
    var fname = firstName;
    var lname = lastName;
    return {
        getName: function(separator)  {
            return this.getFirstName() + separator + this.getLastName();
        },
        getFirstName: function()   {
            return fname;
        },
        getLastName: function() {
            return lname
        }
    }
}

But if you call this function on the click of a button like this:


var btn = document.getElementById("mybutt");
btn.onclick = person.getName;

The "this" reference changes to the button instance since it was attached as the onclick event handler for this button. In this case the method getName fails with error. To avoid this and preserve the "this" reference inside getName to the person instance we will "curry" this function like so:


var btn = document.getElementById("mybutt");
btn.onclick = $curry(person.getName, person);

But how would you pass the "separator" argument? Like this:


var btn = document.getElementById("mybutt");
btn.onclick = $curry(person.getName, person, ", ");

So there you go, we now have a generic curry that tastes good with everything javascript.

Publish Subscribe in Javascript

2008-12-05T10:45:00.000-08:00

Recently, I came across a couple of articles on Ajaxian that reminded me of an implementation I had written a few of months back. This can be easily extended to implement the HTML5 "postMessage" functionality in browsers not supporting HTML5 (I am working on this currently). Additionally, with a little additions, this library can be also used to implement asynchronous comet-like messages from the sever. Here's a sample usage code for the library usage and the library itself:

Usage:



/* 
 * Subscribe to all the channels. Subscriptions can be wildcards e.g.
 * "/foo/bar"   : Subscribes to the channel /foo/bar only
 * "/foo/bar/*"  : Subscribes to the channel all the children of /foo/bar/ e.g. /foo/bar/baz, /foo/bar/buz but not /foo/bar/baz/boo
 * "/foo/bar/**" : Subscribes to all the descentends of /foo/bar/ e.g. /foo/bar/baz, /foo/bar/baz/boo, /foo/bar/bar/baz/boo
 * Below, we shall receive all the messages to all the channels
 */
jaf.core.MessageBus.subscribe("/**", function(objMsg, strChannel) {
  alert(strChannel + ": " + objMsg);
});

/*
 * To publish a message, just call the MessageBus's publish method like so:
 */
jaf.core.MessageBus.publish("/foo/bar", {
   name: "MessageName",
   messageHeader: "This is a header string but can be any object",
   body: "This is body but can be any arbitrary object"
});

Library:


/**
 * Copyright: Aniket Naik
 * From the "jaf"
 * 
 */
// create a jaf.core namespace
// jaf.namespace("jaf.core");

var jaf = {};
jaf.core = {};

/**
 * @class
 * This class contains utility functions required throughout the framework
 */
jaf.core.Util = function()   {
   /** @scope jaf.core.Util */
   return   {
      /**
       * Trims the white spaces from the begining of the specified String
       * @param {String} s The String to trim
       * @return The "left trimmed" string
       */
      ltrim: function(s) {
         return s.replace(/(^\s+)/g, "");   
      },
      
      /**
       * Trims the white spaces from the end of the specified String
       * @param {String} s The String to trim
       * @return The "right trimmed" string
       */
      rtrim: function(s) {
         return s.replace(/\s+$/g, "");   
      },
      
      /**
       * Trims the white spaces from the begining and the end of the specified String
       * @param {String} s The String to trim
       * @return The "trimmed" string
       */
      trim: function(s) {
         return s.replace(/(^\s+)|\s+$/g, "");   
      },
      
      /**
       * Gets whether the specified String s starts with the given String
       * strSearch
       * @param {String} s The string to search
       * @param {String} strSearch The search String
       * @return true if s starts with strSearch
       * @see endsWith(String, String)
       */
      startsWith: function(s, strSearch)  {
         return s.indexOf(strSearch) == 0;
      },
      
      hasOwnProperty: function(object, property)   {
         if(object.hasOwnProperty)  {
            return object.hasOwnProperty(property);
         }
         var prop = object[property];
         return typeof(pro) !== "undefined" && prop !== object.constructor.prototype[property];
      },
      
      /**
       * Gets whether the specified String s ends with the given String
       * strSearch
       * @param {String} s The string to search
       * @param {String} strSearch The search String
       * @return true if s ends with strSearch
       * @see startsWith(String, String)
       */
      endsWith: function(s, strSearch)   {
         if(s.indexOf(strSearch) == -1)   {
            return false;
         }
         return (s.lastIndexOf(strSearch) + strSearch.length) == s.length;
      },
      
      /**
       * Gets the string representation of the specified object. This method is 
       * used for debugging
       * @param {Object} Object to convert to string
       * @return {String} The string representation of the object
       */
      toObjectSource: function(obj)   {
         if(obj == null)   {
            return "[null]";
         }
         if(obj == undefined) {
            return "[undefined]";
         }
         
         var str = "[";
         var member = null;
         for(var each in obj) {
            member = obj[each];
            str += each + "=" + member + ", "
         }
         return str + "]";
      },
      
      /**
       * Gets all the keys (properties) of the given object as an array
       * @param {Object} obj The object to retrieve keys
       * @param {Array} Properties of the object as an array
       */
      objectKeys: function(obj)  {
         var arr = [];
         for(key in obj)   {
            if(this.hasOwnProperty(obj, key))   {
               arr.push(key);
            }
         }
         return arr;
      }
      
   };
}();


/**
 * A Channel/Topic/Queue to which messages are published. Each channel is represented
 * by a path name of the form /some/channel/name which is hierarchical
 * @constructor
 * @param {String} strName The name of this channel. Should be of the form /some/name
 */
jaf.core.Channel = function(strName)  {
   var name = strName;
   var subscribers = [];
   
   /** @scope jaf.core.Channel */
   return {
      /**
       * Adds a subscriber to this channel. All the messages published to this
       * channel will be delivered to it.
       * @param {Function} funSubscriber The subscriber function. This function takes one
       *        parameter, the message object
       */
      addSubscriber: function(funSubscriber) {
         if(typeof(funSubscriber) === "function")  {
            subscribers.push(funSubscriber);
         }
      },
      
      /**
       * Removes a previously added subscriber from this channel
       * @param {Function} funSubscriber The subscriber to remove
       */
      removeSubscriber: function(funSubscriber) {
         for(var i = 0, len = subscribers.length; i < len; i++)   {
            if(subscribers[i] === funSubscriber) {
               return subscribers.splice(i, 1);
            } 
         }
         return null;
      },
      
      /**
       * Gets all subscribers as array
       * @return {Array} an array of subscribers added to this channel
       */
      getSubscribers: function()  {
         var len = subscribers.length;
         var copy  = new Array(len);
         for(var i = 0; i < len; i++)  {
            copy[i] = subscribers[i];
         }
         return copy;
      },
      
      /**
       * Publishes a messages to this channel. All the subscribers added to this
       * channel will receive this message
       * @param {Object} objMessage The message to publish
       */
      publish: function(objMessage) {
         for(var i = 0, len = subscribers.length; i < len; i++)   {
            subscribers[i](objMessage, strName);
         }
      },
      
      getName: function()  {
         return name;
      },
      
      toString: function() {
         return "Channel[" + name + "]";
      }
   };
};


/**
 * @class
 * Defines a simple publish/subscribe messaging system where messages can be sent
 * or subscribed for.
 * @constructor
 */
jaf.core.MessageBus = function(parentMessageBus)   {
   var channels = {};
   var patternSubscribers = {};
   var Util = jaf.core.Util;
   
   /**
    * IDEA: The parent child relationship will work as follows:
    * This message bus will subscribe to the parent message bus and listen to
    * all messages on all channels. As soon as messages come to those channels,
    * they will be published to channels with same path with this message bus
    * On the unload of this document or view, the listener to the parent message
    * bus is removed
    */
   var parent = parentMessageBus || null;
   
   /**
    * Creates a new Channel for the specified name. This method is always called
    * after calling checkChannelName(name)
    * @param {String} theName The name for this channel. This should be of the 
    * form "/some/name"
    * @return {Channel} the newly created channel object
    */
   function createChannel(theName)   {
      // trim the trailing slash if any
      if(theName.length > 1 && Util.endsWith(theName, "/"))  {
         theName = theName.substring(0, theName.length - 1);
      }
      return new jaf.core.Channel(theName);
   }
   
   /**
    * Gets the segments of the specified channel name as array.
    * e.g. If the channel name is specified as "/some/name",  an array containing
    * two segments is returned like this: ["some", "name"]
    * @param {String} theName The channel name 
    * @return {Array} The array containing the segments
    */
   function getSegments(theName) {
      var segs = theName.split("/");
      if(segs[0] === "")  {
         segs.slice(0, 1);
      }
      return segs;
      // return theName.split("/");
   }
   
   /**
    * Checks whether the specified channel name is a valid name
    * @param {String} theName The name of the channel
    */
   function checkChannelName(theName)   {
      if(!theName || Util.trim(theName).length == 0 || !Util.startsWith(theName, "/"))   {
         throw new Error("Invalid channel name: " + theName);
      }
   }
   
   /**
    * Determines if the specified name is a wildcard pattern
    * @return true if the name ends with /* or /**
    */
   function isPattern(theName)   {
      return Util.endsWith(theName, "/*") || Util.endsWith(theName, "/**");
   }
   
   /**
    * Determines if strName matches with channel name specified by
    * strChannel. This method also supports wildcard pattern matching
    * for two wildcards:

    * "/*" For children and "/**" For descendents
    * @return true if strName matches with strChannel
    */
   function matches(strName, strChannel) {
      if(strName == strChannel) {
         return true;
      }
      
      if(!isPattern(strName) || isPattern(strChannel))  {
         return false;
      }
      
      // okay theName is a pattern
      var segs = getSegments(strName);
      var channelSegs = getSegments(strChannel);
      var depth = segs.length;
      var channelDepth = channelSegs.length;
      
      if(depth > channelDepth)   {
         return false;
      }
      
      // if(isPattern(strName)) {
      segs.splice(segs.length - 1, 1);
      depth = segs.length;

      var channelPart = (channelSegs.slice(0, depth).join("/"));
      var namePart = (segs.join("/"));
      if(channelPart !== namePart)  {
         return false;
      }

      if(Util.endsWith(strName, "/**"))   {
         return true;
      }else {
         return (channelDepth - depth) == 1;
      }
      // }
   }
   
   /**
    * Adds any of the subscribers that are pattern subscribers to a Channel.
    * This is called internally when a message is published to a channel and
    * that channel does not exist yet. When this happens, a new Channel is created
    * and any previously registered pattern subscribers are added to the channel
    * @param {jaf.core.Channel} objChannel The channel to which wildcard or pattern 
    * subscribers are added if they match.
    */
   function addPatternSubscribers(objChannel)   {
      var patternChannels = Util.objectKeys(patternSubscribers);
      for(var i = 0, len = patternChannels.length; i < len; i++)  {
         var patternCh = patternChannels[i];
         if(matches(patternCh, objChannel.getName()))   {
            var subscribers = patternSubscribers[patternCh];
            if(subscribers)   {
               for(var j = 0, jlen = subscribers.length; j < jlen; j++)  {
                  objChannel.addSubscriber(subscribers[j]);
               }
            }
         }
      }
   }
   
   return {
      /**
       * Publishes the message objMessage to channel strChannel
       * All the subscribers registered with this channel will get the message
       * @param strChannel {String} The name of the channel to publish to
       * @param objMessage {Object} The message to publish
       */
      publish: function(strChannel, objMessage)  {
         if(isPattern(strChannel))  {
            alert("Publishing to wildcard channels coming soon.. ;)");
            // IDEA: Support publish to wildcard channels?
            return;
         }else {
            var channel = channels[strChannel];
            if(! channel)  {
               channel = createChannel(strChannel);
               channels[strChannel] = channel;
               addPatternSubscribers(channel);
            }
            channel.publish(objMessage);
         }
      },
      
      /**
       * Subscribes to specified channel. If the channel specified by strChannel
       * does not exist, its created. Any message published to this channel will
       * be delivered to funCallback who is the subscriber to this channel
       * @param strChannel {String} The name of the channel. This can be a wildcard
       * pattern like so: /some/channel/* or some/channel
       * @param funCallback {Function} The callback function that will be called
       * with message as the parameter
       */
      subscribe: function(strChannel, funCallback)   {
         // check if the channel name is valid
         checkChannelName(strChannel);
         
         // check for valid callback function
         if(!typeof(funCallback) === "function")   {
            throw new Error("Invalid subsription callback. Must be a function");
         }
         
         var subscriber = funCallback;
         
         // check if this subscription is a pattern i.e. /some/name/** | some/name/*
         if(isPattern(strChannel))  {
            if(patternSubscribers[strChannel])  {
               patternSubscribers[strChannel].push(subscriber);
            }else {
               patternSubscribers[strChannel] = [subscriber];
            }
            
            // check if this subscriber matches for any of the channel already created
            var channelNames = Util.objectKeys(channels);
            for(var i = 0, len = channelNames.length; i < len; i++)  {
               var cName = channelNames[i];
               if(matches(strChannel, cName)) {
                  channels[cName].addSubscriber(subscriber);
               }
            }
         }else {  //no pattern so existing or a new channel
            var channel = channels[strChannel];
            if(! channel)  {
               channel = createChannel(strChannel);
               channels[strChannel] = channel;
            }
            channel.addSubscriber(subscriber);
         }         
      },
      
      /**
       * Unsubscribes to specified channel. 
       * @param strChannel {String} The name of the channel (can be a wildcard
       * in which case funCallback from all the matching channels is removed
       * @param funCallback {Function} The callback function that was used when
       * subscribing
       */
      unsubscribe: function(strChannel, funCallback) {
         var subscriber = null;
         if(isPattern(strChannel))  {
            var arrSubs = patternSubscribers[strChannel];
            var subsIndex = -1;
            if(arrSubs) {
               for(var i = 0, len = arrSubs.length; i < len; i++) {
                  if(arrSubs[i] == funCallback) {
                     subsIndex = i;
                     break;
                  }
               }
               
               if(subsIndex != -1)  {
                  arrSubs.splice(subsIndex, 1);
               }
            }
         }
         
         // check if this subscriber matches for any of the channel already created
         var channelNames = Util.objectKeys(channels);
         for(var j = 0, jlen = channelNames.length; j < jlen; j++)  {
            var cName = channelNames[j];
            if(matches(cName, strChannel)) {
               subscriber = channels[cName].removeSubscriber(subscriber);
            }
         }
      },
      
      toString: function() {
         return "MessageBus"
      }
   };
}(null);

Lifeslave

Make hot curry using Javascript

Publish Subscribe in Javascript