Change buildsystem to wrap modules in selfexecuting closure.

[Kanaye]

Currently we are removing all define() wrappers from modules, this makes "nicer" looking compiled code but can lead to bugs, imagine a case like this:

// A.js
define(function () {
  var locals = {test: 'TEST'};
  function A() {
    console.log(locals.test);
  }
 return A;
});

// B.js
define(function () {
  var locals = {};
  function B() {
   //do something
 }
});

// Entry.js
define(['A','B'], function (A, B) {
  A(); // should log TEST
})

Currenty we are compiling it to something like that:

// build.js
var locals = {test: 'TEST'};
function A() {
  console.log(locals.test);
}
var locals = {};
function B() {
  //do something
}
A(); // should log TEST

This is nice while don't have modules that use the same name. But today I stumbled accross one of these cases like the locals variable from the example.
While this safes some memory and memory management (due to less scopes) for the browser, it make it harder for us and is error prone.

I would change the built process to produce something like that:

var A = (function () {
  var locals = {test: 'TEST'};
  function A() {
    console.log(locals.test);
  }
 return A;
})();
var B = (function () {
 var locals = {};
/* ...*/
})();
/* ... */

What do you think ?

[astoilkov]

Yes. I agree. It will become much more stable.

[Kanaye]

I changed the behaviour to the following:

All modules that have a return statement with a simple identifier in the define function
have the name of the identifier as an export. E.g.:

define([], function () {
    var a = {};
    // ....
   return a;
});

will become

var a = (function () {
   var a = {};
   // ...
  return a;
})();

If they don't have a simple identifier as the return statment (e.g.return a.thing or return a ? a : b) it uses the filename of the module as the export name.

// file test
define([], function () {
  //...
  return a.b; 
});

will become:

var test = (function() {
  //...
  return a.b;
})();

If the function doesn't have a return statement it will just get wrapped.

define([], function () {
 //...
});

will become:

(function () {
//...
})();

I'm using esprime and escodegen for this. It's slower than working with regular expression.
But working with an ast instead of a regualr expression is way less error prone.
Also the differnce is only a few milliseconds on my machine and we have way slower tasks.

Btw. if you just want to have a quick look (or test) at a build of the current master,
you can get a version here: http://cdn.kanaye.net/blocks-alpha/blocks.js
Pushes to the master should be build and updated within ~2 hours.

[astoilkov]

Nice. Everything looks great.

Now we won't have the same bug prone architecture we had before. 🎉