nutella_framework 0.4.18 → 0.4.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0734b827e4685a852d4450fdc3c50bd8804acf3
-  data.tar.gz: 8583c6ca31c9dbe49ac53c7727f3bdb119f0c43f
+  metadata.gz: e75030070ab8a779a4d65831ce16b04f0c041253
+  data.tar.gz: f435d86a781e34feefe0dbf9e1e14f381c68b52c
 SHA512:
-  metadata.gz: 6cd6bc6aaeb4ce404e213d44895f39fae5b62bd9bf84bbd1388b2c499b7c86f583d7dfa33a856289c7db219c4504338410a027ea66a92ccbf857aa0cd86dc263
-  data.tar.gz: 4dc44527005a1985c8a11618688851ee44a0771cf3b59d2e820dfc6842649ca60348b910b32f1a276eaadfccd67a0a0f037b7e020c1f994664e73f92630b42bf
+  metadata.gz: d116c6122ee44805db23486e6c06ce502925169d1b93c207552ad63997e7be2e82cc8d36973f170b3bede3ddfbb03dd59463e339d4ad5aa3d786c5e0c0c266e9
+  data.tar.gz: 3ec338710b1ab2260bd86be237ae0950e309d99584b62e5ac24045d72eb9c4e15529ffeac1d4833718a1ffc3f67c7a6d65c4f246a34b72b0c1b05c7cf3464f13

data/Gemfile

@@ -9,7 +9,8 @@ gem 'thin', '~>1.6'
 gem 'nokogiri', '~>1.6'
 gem 'slop', '~>4.0'
 gem 'nutella_lib','~>0.4', '>=0.4.12'
-
+gem 'activesupport', '~>4.2'
+gem 'mandrill-api', '~>1.0', '>=1.0.53'
 
 group :development do
   gem 'shoulda', '~> 3.0'

data/README.md

@@ -3,7 +3,7 @@
 [![Build Status](https://travis-ci.org/nutella-framework/nutella_framework.svg?branch=master)](https://travis-ci.org/nutella-framework/nutella_framework)
 [![Code Climate](https://codeclimate.com/github/nutella-framework/nutella_framework/badges/gpa.svg)](https://codeclimate.com/github/nutella-framework/nutella_framework)
 
-nutella is a framework to build and run RoomApps. It's still _very_ under development so any help [finding and fixing bugs](https://github.com/nutella-framework/nutella_framework/issues) will be greatly appreciated!
+nutella is a framework to build and run Macroworlds. It's still _very_ under development so any help [finding and fixing bugs](https://github.com/nutella-framework/nutella_framework/issues) will be greatly appreciated!
 
 # Installing
 Nutella is written in ruby but it leverages a bunch of other technologies that need to be installed. You will need:

data/VERSION

@@ -1 +1 @@
-0.4.18
+0.4.19

data/framework_components/beacon-cloud-interface/js/lib/nutella_lib.js

@@ -10,11 +10,16 @@
  */
 
 var nutella_i = require('./nutella_i_browser');
+var nutella_version = require('./version');
 
 // Internal reference to this library (used below)
 var nutella = {};
 
 
+// Version number
+nutella.version = nutella_version.version;
+
+
 /**
  * Creates a new instance of nutella
  * and initialize it. This is a factory method.
@@ -84,12 +89,20 @@ nutella.parseURLParameters = function () {
 };
 
 
-nutella.version = '0.4.3';
+/**
+ * Utility method that parses the component ID from the URL.
+ *
+ * @return {String} the componentId of this component
+ */
+nutella.parseComponentId = function() {
+    return location.pathname.split('/')[4];
+};
+
 
 
 // Exports nutella object
 module.exports = nutella;
-},{"./nutella_i_browser":10}],2:[function(require,module,exports){
+},{"./nutella_i_browser":11,"./version":17}],2:[function(require,module,exports){
 /**********************
  * Simple MQTT client *
  **********************/
@@ -97,7 +110,6 @@ module.exports = nutella;
 "use strict";
 
 var mqtt_lib = require('./paho/mqttws31');
-//var mqtt_lib = require('./paho/mqttws31-min');                        TODO
 
 
 /**
@@ -278,6 +290,23 @@ var publishBrowser = function (client, backlog, channel, message) {
 
 
 
+/**
+ * Returns the client host
+ *
+ * @return {String}
+ */
+SimpleMQTTClient.prototype.getHost = function() {
+    return this.client._getHost();
+}
+
+
+
+/**
+ * Determines if a channel is wildcard or not.
+ *
+ * @param channel
+ * @return {boolean} true if the channel is a wildcard channel, false otherwise
+ */
 SimpleMQTTClient.prototype.isChannelWildcard = function(channel) {
     return channel.indexOf('#')>-1 || channel.indexOf('+')>-1 ;
 }
@@ -2517,6 +2546,607 @@ Paho.MQTT = (function (global) {
 })(window);
 module.exports=Paho.MQTT;
 },{}],4:[function(require,module,exports){
+/*jshint bitwise:false*/
+/*global unescape*/
+
+(function (factory) {
+    if (typeof exports === 'object') {
+        // Node/CommonJS
+        module.exports = factory();
+    } else if (typeof define === 'function' && define.amd) {
+        // AMD
+        define(factory);
+    } else {
+        // Browser globals (with support for web workers)
+        var glob;
+        try {
+            glob = window;
+        } catch (e) {
+            glob = self;
+        }
+
+        glob.SparkMD5 = factory();
+    }
+}(function (undefined) {
+
+    'use strict';
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /*
+     * Fastest md5 implementation around (JKM md5)
+     * Credits: Joseph Myers
+     *
+     * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
+     * @see http://jsperf.com/md5-shootout/7
+     */
+
+    /* this function is much faster,
+      so if possible we use it. Some IEs
+      are the only ones I know of that
+      need the idiotic second function,
+      generated by an if clause.  */
+    var add32 = function (a, b) {
+        return (a + b) & 0xFFFFFFFF;
+    },
+
+    cmn = function (q, a, b, x, s, t) {
+        a = add32(add32(a, q), add32(x, t));
+        return add32((a << s) | (a >>> (32 - s)), b);
+    },
+
+    ff = function (a, b, c, d, x, s, t) {
+        return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+    },
+
+    gg = function (a, b, c, d, x, s, t) {
+        return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+    },
+
+    hh = function (a, b, c, d, x, s, t) {
+        return cmn(b ^ c ^ d, a, b, x, s, t);
+    },
+
+    ii = function (a, b, c, d, x, s, t) {
+        return cmn(c ^ (b | (~d)), a, b, x, s, t);
+    },
+
+    md5cycle = function (x, k) {
+        var a = x[0],
+            b = x[1],
+            c = x[2],
+            d = x[3];
+
+        a = ff(a, b, c, d, k[0], 7, -680876936);
+        d = ff(d, a, b, c, k[1], 12, -389564586);
+        c = ff(c, d, a, b, k[2], 17, 606105819);
+        b = ff(b, c, d, a, k[3], 22, -1044525330);
+        a = ff(a, b, c, d, k[4], 7, -176418897);
+        d = ff(d, a, b, c, k[5], 12, 1200080426);
+        c = ff(c, d, a, b, k[6], 17, -1473231341);
+        b = ff(b, c, d, a, k[7], 22, -45705983);
+        a = ff(a, b, c, d, k[8], 7, 1770035416);
+        d = ff(d, a, b, c, k[9], 12, -1958414417);
+        c = ff(c, d, a, b, k[10], 17, -42063);
+        b = ff(b, c, d, a, k[11], 22, -1990404162);
+        a = ff(a, b, c, d, k[12], 7, 1804603682);
+        d = ff(d, a, b, c, k[13], 12, -40341101);
+        c = ff(c, d, a, b, k[14], 17, -1502002290);
+        b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+        a = gg(a, b, c, d, k[1], 5, -165796510);
+        d = gg(d, a, b, c, k[6], 9, -1069501632);
+        c = gg(c, d, a, b, k[11], 14, 643717713);
+        b = gg(b, c, d, a, k[0], 20, -373897302);
+        a = gg(a, b, c, d, k[5], 5, -701558691);
+        d = gg(d, a, b, c, k[10], 9, 38016083);
+        c = gg(c, d, a, b, k[15], 14, -660478335);
+        b = gg(b, c, d, a, k[4], 20, -405537848);
+        a = gg(a, b, c, d, k[9], 5, 568446438);
+        d = gg(d, a, b, c, k[14], 9, -1019803690);
+        c = gg(c, d, a, b, k[3], 14, -187363961);
+        b = gg(b, c, d, a, k[8], 20, 1163531501);
+        a = gg(a, b, c, d, k[13], 5, -1444681467);
+        d = gg(d, a, b, c, k[2], 9, -51403784);
+        c = gg(c, d, a, b, k[7], 14, 1735328473);
+        b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+        a = hh(a, b, c, d, k[5], 4, -378558);
+        d = hh(d, a, b, c, k[8], 11, -2022574463);
+        c = hh(c, d, a, b, k[11], 16, 1839030562);
+        b = hh(b, c, d, a, k[14], 23, -35309556);
+        a = hh(a, b, c, d, k[1], 4, -1530992060);
+        d = hh(d, a, b, c, k[4], 11, 1272893353);
+        c = hh(c, d, a, b, k[7], 16, -155497632);
+        b = hh(b, c, d, a, k[10], 23, -1094730640);
+        a = hh(a, b, c, d, k[13], 4, 681279174);
+        d = hh(d, a, b, c, k[0], 11, -358537222);
+        c = hh(c, d, a, b, k[3], 16, -722521979);
+        b = hh(b, c, d, a, k[6], 23, 76029189);
+        a = hh(a, b, c, d, k[9], 4, -640364487);
+        d = hh(d, a, b, c, k[12], 11, -421815835);
+        c = hh(c, d, a, b, k[15], 16, 530742520);
+        b = hh(b, c, d, a, k[2], 23, -995338651);
+
+        a = ii(a, b, c, d, k[0], 6, -198630844);
+        d = ii(d, a, b, c, k[7], 10, 1126891415);
+        c = ii(c, d, a, b, k[14], 15, -1416354905);
+        b = ii(b, c, d, a, k[5], 21, -57434055);
+        a = ii(a, b, c, d, k[12], 6, 1700485571);
+        d = ii(d, a, b, c, k[3], 10, -1894986606);
+        c = ii(c, d, a, b, k[10], 15, -1051523);
+        b = ii(b, c, d, a, k[1], 21, -2054922799);
+        a = ii(a, b, c, d, k[8], 6, 1873313359);
+        d = ii(d, a, b, c, k[15], 10, -30611744);
+        c = ii(c, d, a, b, k[6], 15, -1560198380);
+        b = ii(b, c, d, a, k[13], 21, 1309151649);
+        a = ii(a, b, c, d, k[4], 6, -145523070);
+        d = ii(d, a, b, c, k[11], 10, -1120210379);
+        c = ii(c, d, a, b, k[2], 15, 718787259);
+        b = ii(b, c, d, a, k[9], 21, -343485551);
+
+        x[0] = add32(a, x[0]);
+        x[1] = add32(b, x[1]);
+        x[2] = add32(c, x[2]);
+        x[3] = add32(d, x[3]);
+    },
+
+    /* there needs to be support for Unicode here,
+       * unless we pretend that we can redefine the MD-5
+       * algorithm for multi-byte characters (perhaps
+       * by adding every four 16-bit characters and
+       * shortening the sum to 32 bits). Otherwise
+       * I suggest performing MD-5 as if every character
+       * was two bytes--e.g., 0040 0025 = @%--but then
+       * how will an ordinary MD-5 sum be matched?
+       * There is no way to standardize text to something
+       * like UTF-8 before transformation; speed cost is
+       * utterly prohibitive. The JavaScript standard
+       * itself needs to look at this: it should start
+       * providing access to strings as preformed UTF-8
+       * 8-bit unsigned value arrays.
+       */
+    md5blk = function (s) {
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    },
+
+    md5blk_array = function (a) {
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+        }
+        return md5blks;
+    },
+
+    md51 = function (s) {
+        var n = s.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail,
+            tmp,
+            lo,
+            hi;
+
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        length = s.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+        }
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Beware that the final length might not fit in 32 bits so we take care of that
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+
+        md5cycle(state, tail);
+        return state;
+    },
+
+    md51_array = function (a) {
+        var n = a.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail,
+            tmp,
+            lo,
+            hi;
+
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+        }
+
+        // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
+        // containing the last element of the parent array if the sub array specified starts
+        // beyond the length of the parent array - weird.
+        // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
+        a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+
+        length = a.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= a[i] << ((i % 4) << 3);
+        }
+
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Beware that the final length might not fit in 32 bits so we take care of that
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+
+        md5cycle(state, tail);
+
+        return state;
+    },
+
+    hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
+
+    rhex = function (n) {
+        var s = '',
+            j;
+        for (j = 0; j < 4; j += 1) {
+            s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+        }
+        return s;
+    },
+
+    hex = function (x) {
+        var i;
+        for (i = 0; i < x.length; i += 1) {
+            x[i] = rhex(x[i]);
+        }
+        return x.join('');
+    },
+
+    md5 = function (s) {
+        return hex(md51(s));
+    },
+
+
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * SparkMD5 OOP implementation.
+     *
+     * Use this class to perform an incremental md5, otherwise use the
+     * static methods instead.
+     */
+    SparkMD5 = function () {
+        // call reset to init the instance
+        this.reset();
+    };
+
+
+    // In some cases the fast add32 function cannot be used..
+    if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
+        add32 = function (x, y) {
+            var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+                msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+            return (msw << 16) | (lsw & 0xFFFF);
+        };
+    }
+
+
+    /**
+     * Appends a string.
+     * A conversion will be applied if an utf8 string is detected.
+     *
+     * @param {String} str The string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.append = function (str) {
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        // then append as binary
+        this.appendBinary(str);
+
+        return this;
+    };
+
+    /**
+     * Appends a binary string.
+     *
+     * @param {String} contents The binary string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.appendBinary = function (contents) {
+        this._buff += contents;
+        this._length += contents.length;
+
+        var length = this._buff.length,
+            i;
+
+        for (i = 64; i <= length; i += 64) {
+            md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
+        }
+
+        this._buff = this._buff.substr(i - 64);
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     * Use the raw parameter to obtain the raw result instead of the hex one.
+     *
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            i,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = !!raw ? this._state : hex(this._state);
+
+        this.reset();
+
+        return ret;
+    };
+
+    /**
+     * Finish the final calculation based on the tail.
+     *
+     * @param {Array}  tail   The tail (will be modified)
+     * @param {Number} length The length of the remaining buffer
+     */
+    SparkMD5.prototype._finish = function (tail, length) {
+        var i = length,
+            tmp,
+            lo,
+            hi;
+
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(this._state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Do the final computation based on the tail and length
+        // Beware that the final length may not fit in 32 bits so we take care of that
+        tmp = this._length * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(this._state, tail);
+    };
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.reset = function () {
+        this._buff = "";
+        this._length = 0;
+        this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Releases memory used by the incremental buffer and other aditional
+     * resources. If you plan to use the instance again, use reset instead.
+     */
+    SparkMD5.prototype.destroy = function () {
+        delete this._state;
+        delete this._buff;
+        delete this._length;
+    };
+
+
+    /**
+     * Performs the md5 hash on a string.
+     * A conversion will be applied if utf8 string is detected.
+     *
+     * @param {String}  str The string
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.hash = function (str, raw) {
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        var hash = md51(str);
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    /**
+     * Performs the md5 hash on a binary string.
+     *
+     * @param {String}  content The binary string
+     * @param {Boolean} raw     True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.hashBinary = function (content, raw) {
+        var hash = md51(content);
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    /**
+     * SparkMD5 OOP implementation for array buffers.
+     *
+     * Use this class to perform an incremental md5 ONLY for array buffers.
+     */
+    SparkMD5.ArrayBuffer = function () {
+        // call reset to init the instance
+        this.reset();
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * Appends an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array to be appended
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+        // TODO: we could avoid the concatenation here but the algorithm would be more complex
+        //       if you find yourself needing extra performance, please make a PR.
+        var buff = this._concatArrayBuffer(this._buff, arr),
+            length = buff.length,
+            i;
+
+        this._length += arr.byteLength;
+
+        for (i = 64; i <= length; i += 64) {
+            md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
+        }
+
+        // Avoids IE10 weirdness (documented above)
+        this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     * Use the raw parameter to obtain the raw result instead of the hex one.
+     *
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            i,
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = !!raw ? this._state : hex(this._state);
+
+        this.reset();
+
+        return ret;
+    };
+
+    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.reset = function () {
+        this._buff = new Uint8Array(0);
+        this._length = 0;
+        this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Releases memory used by the incremental buffer and other aditional
+     * resources. If you plan to use the instance again, use reset instead.
+     */
+    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+
+    /**
+     * Concats two array buffers, returning a new one.
+     *
+     * @param  {ArrayBuffer} first  The first array buffer
+     * @param  {ArrayBuffer} second The second array buffer
+     *
+     * @return {ArrayBuffer} The new array buffer
+     */
+    SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
+        var firstLength = first.length,
+            result = new Uint8Array(firstLength + second.byteLength);
+
+        result.set(first);
+        result.set(new Uint8Array(second), firstLength);
+
+        return result;
+    };
+
+    /**
+     * Performs the md5 hash on an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array buffer
+     * @param {Boolean}     raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+        var hash = md51_array(new Uint8Array(arr));
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    return SparkMD5;
+}));
+
+},{}],5:[function(require,module,exports){
 /**
  * Application-level APIs for nutella, browser version
  */
@@ -2534,7 +3164,7 @@ var AppSubModule = function(main_nutella) {
 
 
 module.exports = AppSubModule;
-},{"./app_log":5,"./app_net":6}],5:[function(require,module,exports){
+},{"./app_log":6,"./app_net":7}],6:[function(require,module,exports){
 /**
  * App-level log APIs for nutella
  */
@@ -2586,7 +3216,7 @@ function logToJson( message, code, level) {
 
 module.exports = AppLogSubModule;
 
-},{"./app_net":6}],6:[function(require,module,exports){
+},{"./app_net":7}],7:[function(require,module,exports){
 /**
  * App-level Networking APIs for nutella
  */
@@ -2867,7 +3497,7 @@ function extractRunId(app_id, mqtt_channel) {
 
 module.exports = AppNetSubModule;
 
-},{"./util/net":13}],7:[function(require,module,exports){
+},{"./util/net":16}],8:[function(require,module,exports){
 /**
  * Framework-level APIs for nutella, browser version
  */
@@ -2885,7 +3515,7 @@ var FrSubModule = function(main_nutella) {
 
 
 module.exports = FrSubModule;
-},{"./fr_log":8,"./fr_net":9}],8:[function(require,module,exports){
+},{"./fr_log":9,"./fr_net":10}],9:[function(require,module,exports){
 /**
  * Framework-level log APIs for nutella
  */
@@ -2937,7 +3567,7 @@ function logToJson( message, code, level) {
 
 module.exports = FrLogSubModule;
 
-},{"./app_net":6}],9:[function(require,module,exports){
+},{"./app_net":7}],10:[function(require,module,exports){
 /**
  * Framework-level Networking APIs for nutella
  */
@@ -3438,7 +4068,7 @@ function extractAppId(mqtt_channel) {
 
 module.exports = FRNetSubModule;
 
-},{"./util/net":13}],10:[function(require,module,exports){
+},{"./util/net":16}],11:[function(require,module,exports){
 /**
  * Run-level and App-level Nutella instances for the browser
  */
@@ -3450,6 +4080,7 @@ var AppSubModule = require('./app_core_browser');
 var FrSubModule = require('./fr_core_browser');
 var NetSubModule = require('./run_net');
 var LogSubModule = require('./run_log');
+var LocationSubModule = require('./run_location');
 
 
 /**
@@ -3469,6 +4100,7 @@ var RunNutellaInstance = function (broker_hostname, app_id, run_id, component_id
     // Initialized the various sub-modules
     this.net = new NetSubModule(this);
     this.log = new LogSubModule(this);
+    this.location = new LocationSubModule(this);
     // Start pinging
     setInterval(function(){
         this.net.publish('pings', 'ping');
@@ -3569,7 +4201,291 @@ module.exports = {
     AppNutellaInstance : AppNutellaInstance,
     FrNutellaInstance : FrNutellaInstance
 };
-},{"./app_core_browser":4,"./fr_core_browser":7,"./run_log":11,"./run_net":12,"simple-mqtt-client":2}],11:[function(require,module,exports){
+},{"./app_core_browser":5,"./fr_core_browser":8,"./run_location":12,"./run_log":13,"./run_net":14,"simple-mqtt-client":2}],12:[function(require,module,exports){
+var LocationSubModule = function(main_nutella) {
+    this.nutella = main_nutella;
+
+    this._resources = {};
+    this._room = undefined;
+
+    this._resourcesReady = false;
+    this._roomReady = false;
+
+    var self = this;
+
+    // Download all resources
+    this.nutella.net.request("location/resources", {}, function(reply) {
+        reply.resources.forEach(function(resource) {
+            self._resources[resource.rid] = resource;
+        });
+        self._resourcesReady = true;
+
+        if(self._roomReady == true && readyCallback != undefined) {
+            readyCallback();
+        }
+    });
+
+    // Update resources
+    this.nutella.net.subscribe("location/resources/updated", function(message) {
+        var resources = message.resources;
+        resources.forEach(function(resource) {
+            self._resources[resource.rid] = resource;
+        });
+    });
+
+    // Add resources
+    this.nutella.net.subscribe("location/resources/added", function(message) {
+        var resources = message.resources;
+        resources.forEach(function(resource) {
+            self._resources[resource.rid] = resource;
+        });
+    });
+
+    // Remove resources
+    this.nutella.net.subscribe("location/resources/removed", function(message) {
+        var resources = message.resources;
+        resources.forEach(function(resource) {
+            delete self._resources[resource.rid];
+        });
+    });
+
+    // Download the room dimension
+    this.nutella.net.request("location/room", {}, function(reply) {
+        self._room = reply;
+        self._roomReady = true;
+
+        if(self._resourcesReady == true && readyCallback != undefined) {
+            readyCallback();
+        }
+    });
+
+    // Update room dimension
+    this.nutella.net.subscribe("location/room/updated", function(message) {
+        self._room = message;
+    });
+};
+
+// Resource list for notify the update
+updateResources = [];
+enterResources = [];
+exitResources = [];
+
+// Enter and exit callbacks
+enterCallback = undefined;
+exitCallback = undefined;
+
+// Ready callback
+readyCallback = undefined;
+
+
+Object.defineProperty(LocationSubModule.prototype, 'resources', {
+    get: function() {
+        var self = this;
+
+        var resources = [];
+
+        Object.keys(this._resources).forEach(function(key) {
+            resources.push(self._resources[key]);
+        });
+        return resources;
+    }
+});
+
+Object.defineProperty(LocationSubModule.prototype, 'resource', {
+    get: function() {
+        var self = this;
+
+        var resource = {};
+
+        // Create a virtual resource for every resource
+        Object.keys(this._resources).forEach(function(key) {
+            var r = self._resources[key];
+            Object.defineProperty(resource, r.rid, {
+                get: function() {
+                    var virtualResource = generateVirtualResource(r);
+                    return virtualResource;
+                }
+            });
+        });
+        return resource;
+    }
+});
+
+Object.defineProperty(LocationSubModule.prototype, 'room', {
+    get: function() {
+        return this._room;
+    }
+});
+
+function updateResource(resource) {
+    var newResource = {};
+    newResource.rid = resource.rid;
+    if(resource.continuous != undefined) newResource.continuous = resource.continuous;
+    if(resource.discrete != undefined) newResource.discrete = resource.discrete;
+
+    newResource.parameters = [];
+
+    for(p in resource.parameters) {
+        newResource.parameters.push({key: p, value: resource.parameters[p]});
+    }
+
+    nutella.net.publish("location/resource/update", newResource);
+}
+
+function generateVirtualResource(resource) {
+    var virtualResource = {};
+    Object.defineProperty(virtualResource, 'rid', {
+        get: function() {
+            return resource.rid;
+        }
+    });
+    virtualResource.continuous = {
+        get x() { return resource.continuous.x; },
+        set x(value) { resource.continuous.x = value; updateResource(resource); },
+
+        get y() { return resource.continuous.y; },
+        set y(value) { resource.continuous.y = value; updateResource(resource); }
+    };
+    virtualResource.discrete = {
+        get x() { return resource.discrete.x; },
+        set x(value) { resource.discrete.x = value; updateResource(resource); },
+
+        get y() { return resource.discrete.y; },
+        set y(value) { resource.discrete.y = value; updateResource(resource); }
+    };
+    virtualResource.proximity = {
+        get rid() { return resource.proximity.rid; },
+        get continuous() {
+            return {x: resource.proximity.continuous.x, y: resource.proximity.continuous.y};
+        },
+        get discrete() {
+            return {x: resource.proximity.discrete.x, y: resource.proximity.discrete.y};
+        }
+    };
+
+    Object.defineProperty(virtualResource, 'notifyUpdate', {
+        get: function () {
+            return updateResources.indexOf(virtualResource.rid) != -1;
+        },
+        set: function (condition) {
+            if(condition == true) {
+                if (updateResources.indexOf(virtualResource.rid) == -1) {
+                    updateResources.push(virtualResource.rid);
+                }
+            }
+            else {
+                if (updateResources.indexOf(virtualResource.rid) != -1) {
+                    updateResources.remove(updateResources.indexOf(virtualResource.rid));
+                }
+            }
+        }
+    });
+
+
+    Object.defineProperty(virtualResource, 'notifyEnter', {
+        get: function () {
+            return enterResources.indexOf(virtualResource.rid) != -1;
+        },
+        set: function (condition) {
+            if(condition == true) {
+                if (enterResources.indexOf(virtualResource.rid) == -1) {
+                    enterResources.push(virtualResource.rid);
+                    nutella.net.subscribe("location/resource/static/" + virtualResource.rid + "/enter", function(message) {
+                        message.resources.forEach(function(dynamicResource) {
+                            var staticVirtualResource = virtualResource;
+                            var dynamicVirtualResource = generateVirtualResource(dynamicResource);
+                            if(enterCallback != undefined) {
+                                enterCallback(dynamicVirtualResource, staticVirtualResource);
+                            }
+                        });
+                    });
+                }
+            }
+            else {
+                if (enterResources.indexOf(virtualResource.rid) != -1) {
+                    enterResources.splice(enterResources.indexOf(virtualResource.rid), 1);
+                    nutella.net.unsubscribe("location/resource/static/" + virtualResource.rid + "/enter");
+                }
+            }
+        }
+    });
+
+    Object.defineProperty(virtualResource, 'notifyExit', {
+        get: function () {
+            return exitResources.indexOf(virtualResource.rid) != -1;
+        },
+        set: function (condition) {
+            if(condition == true) {
+                if (exitResources.indexOf(virtualResource.rid) == -1) {
+                    exitResources.push(virtualResource.rid);
+                    nutella.net.subscribe("location/resource/static/" + virtualResource.rid + "/exit", function(message) {
+                        message.resources.forEach(function(dynamicResource) {
+                            var staticVirtualResource = virtualResource;
+                            var dynamicVirtualResource = generateVirtualResource(dynamicResource);
+                            if(exitCallback != undefined) {
+                                exitCallback(dynamicVirtualResource, staticVirtualResource);
+                            }
+                        });
+                    });
+                }
+            }
+            else {
+                if (exitResources.indexOf(virtualResource.rid) != -1) {
+                    exitResources.splice(exitResources.indexOf(virtualResource.rid), 1);
+                    nutella.net.unsubscribe("location/resource/static/" + virtualResource.rid + "/exit");
+                }
+            }
+        }
+    });
+
+    virtualResource.parameter = {};
+
+    var parameters = [];
+    for(p in resource.parameters) {
+        parameters.push({value: resource.parameters[p], key: p});
+    }
+    parameters.forEach(function(p) {
+        Object.defineProperty(virtualResource.parameter, p.key, {
+            get: function() {
+                return p.value;
+            },
+            set: function(value) {
+                resource.parameters[p.key] = value;
+                updateResource(resource);
+            }
+        });
+    });
+
+    return virtualResource;
+}
+
+LocationSubModule.prototype.resourceUpdated = function(callback) {
+    nutella.net.subscribe("location/resources/updated", function(message) {
+        message.resources.forEach(function(resource) {
+            var virtualResource = generateVirtualResource(resource);
+            if(updateResources.indexOf(resource.rid) != -1) {
+                callback(virtualResource);
+            }
+        });
+    });
+};
+
+// /location/resource/static/<rid>/enter
+LocationSubModule.prototype.resourceEntered = function(callback) {
+    enterCallback = callback;
+};
+
+LocationSubModule.prototype.resourceExited = function(callback) {
+    exitCallback = callback;
+};
+
+LocationSubModule.prototype.ready = function(callback) {
+    readyCallback = callback;
+};
+
+module.exports = LocationSubModule;
+
+},{}],13:[function(require,module,exports){
 /**
  * Run-level Logging APIs for nutella
  */
@@ -3621,13 +4537,14 @@ function logToJson( message, code, level) {
 
 
 module.exports = LogSubModule;
-},{"./run_net":12}],12:[function(require,module,exports){
+},{"./run_net":14}],14:[function(require,module,exports){
 /**
  * Run-level Network APIs for nutella
  */
 
 
 var AbstractNet = require('./util/net');
+var BinNet = require('./run_net_bin');
 
 
 /**
@@ -3639,6 +4556,8 @@ var NetSubModule = function(main_nutella) {
     // Store a reference to the main module
     this.nutella = main_nutella;
     this.net = new AbstractNet(main_nutella);
+    // Binary net sub module
+    this.bin = new BinNet(main_nutella, this);
 };
 
 
@@ -3707,7 +4626,168 @@ NetSubModule.prototype.handle_requests = function(channel, callback, done_callba
 
 module.exports = NetSubModule;
 
-},{"./util/net":13}],13:[function(require,module,exports){
+},{"./run_net_bin":15,"./util/net":16}],15:[function(require,module,exports){
+/**
+ * Run-level binary network APIs for nutella
+ */
+
+
+var SparkMD5 = require('spark-md5');
+
+
+/**
+ * Run-level binary network APIs for nutella
+ * @param main_nutella
+ * @constructor
+ */
+var BinNetSubModule = function(main_nutella, net_sub_module) {
+    // Store a reference to the main module
+    this.nutella = main_nutella;
+    this.net = net_sub_module;
+    this.file_mngr_url = 'http://' + main_nutella.mqtt_client.getHost() + ':57882';
+};
+
+
+
+/**
+ * Uploads a file to the nutella file server
+ * @param {File} file - the file we are uploading
+ * @param cb - the callback fired whenever a file is correctly uploaded
+ */
+BinNetSubModule.prototype.uploadFile = function(file, cb) {
+    var file_mngr_url = this.file_mngr_url;
+    var reader = new FileReader();
+    reader.onload = function(event) {
+        // 2. calculate md5 hash
+        var hexHash = SparkMD5.ArrayBuffer.hash(event.target.result );
+        var extension = getFileExtension(file);
+        var filename = hexHash + '.' + extension;
+        // 3. check if the file is already stored and, if so, get the url
+        isAlreadyUploaded(file_mngr_url, filename, function(fileURL) {
+            // 4a. if it does, execute callback and pass the file url
+            cb(fileURL);
+        }, function() {
+            // 4b. if it doesn't, upload
+            upload(file_mngr_url, file, filename, function(fileURL) {
+                // 5. execute callback and pass the file url
+                cb(fileURL);
+            });
+        });
+    };
+    // 1. read file
+    reader.readAsArrayBuffer(file);
+};
+
+
+//
+// Helper function
+// Extracts the extension from a file object
+//
+function getFileExtension(file) {
+    return file.name.substring(file.name.lastIndexOf('.')+1, file.name.length).toLowerCase()
+}
+
+
+//
+// Helper function
+// This function checks if a particular filename already exists.
+// If so it executes the first callback that is passed,
+// otherwise the second one
+//
+function isAlreadyUploaded(file_mngr_url, filename, file_exists_cb, file_absent_cb) {
+    var req = new XMLHttpRequest();
+    req.open("GET", file_mngr_url + "/test/" + filename);
+    req.onload = function(e) {
+        var url = JSON.parse(req.response).url;
+        if (url === undefined)
+            file_absent_cb();
+        else
+            file_exists_cb(url);
+    };
+    req.send();
+}
+
+
+//
+// Helper function
+// This function uploads a file with a certain file name.
+// If the upload is successful the first callback is executed,
+// otherwise the second one is.
+function upload(file_mngr_url, file, filename, success, error) {
+    // Assemble data
+    var fd = new FormData();
+    fd.append("filename", filename);
+    fd.append("file", file);
+    var req = new XMLHttpRequest();
+    req.open("POST", file_mngr_url + "/upload");
+    req.onload = function(e) {
+        var url = JSON.parse(req.response).url;
+        if (url === undefined)
+            error();
+        else
+            success(url);
+    };
+    req.send(fd);
+}
+
+
+
+/**
+ * Subscribes to a channel for binary files uptes.
+ *
+ * @param channel this can only be a simple channel not
+ * @param cb it takes two parameters, file and metadata
+ * @param done_callback
+ */
+BinNetSubModule.prototype.subscribe = function(channel, cb, done_callback) {
+    this.net.subscribe(channel, function(message, from) {
+        // Discard non-bin message
+        if (!message.bin) return;
+        // Execute callback
+        cb(message.url, message.metadata);
+    }, done_callback);
+};
+
+
+
+/**
+ * Unsubscribes from a channel
+ *
+ * @param channel
+ * @param done_callback
+ */
+BinNetSubModule.prototype.unsubscribe = function(channel, done_callback) {
+    this.net.unsubscribe(channel, done_callback);
+};
+
+
+
+/**
+ * Publishes a binary file to a certain channel.
+ *
+ * @param channel
+ * @param file 		File object https://developer.mozilla.org/en-US/docs/Web/API/File
+ * @param done_callback
+ */
+BinNetSubModule.prototype.publish = function(channel, file, metadata, done_callback) {
+    var net_mod = this.net;
+    this.uploadFile(file, function(url) {
+        net_mod.publish(channel, {bin: true, url: url, metadata: metadata});
+        // Execute optional done callback
+        if (done_callback!==undefined) done_callback();
+    });
+};
+
+
+
+
+
+
+
+
+
+module.exports = BinNetSubModule;
+},{"spark-md5":4}],16:[function(require,module,exports){
 /**
  * Network APIs abstraction
  */
@@ -3796,7 +4876,7 @@ AbstractNet.prototype.subscribe_to = function(channel, callback, appId, runId, d
  */
 AbstractNet.prototype.unsubscribe_from = function(channel, appId, runId, done_callback ) {
     // Pad channel
-    var padded_channel = this.pad_channel(channel, appId, run_id);
+    var padded_channel = this.pad_channel(channel, appId, runId);
     var idx = this.subscriptions.indexOf(padded_channel);
     // If we are not subscribed to this channel, return (no error is given)
     if(idx===-1) return;
@@ -4035,5 +5115,7 @@ AbstractNet.prototype.prepare_message_for_response = function (response, id) {
 
 // Export module
 module.exports = AbstractNet;
+},{}],17:[function(require,module,exports){
+module.exports.version = '0.5.4';
 },{}]},{},[1])(1)
 });