Bundle arithmetic now supports parens.

.gitignore

@@ -5,3 +5,4 @@ test/output
 test/output.js
 test/output.js.map
 dist
+.idea/

README.md

@@ -259,6 +259,14 @@ builder.bundle('app/**/* - [app/**/*]', 'dependencies.js', { minify: true, sourc
 
 The above means _take the tree of app and all its dependencies, and subtract just the modules in app_, thus leaving us with just the tree of dependencies of the app package.
 
+#### Example - Multiple Common Bundles
+
+Parentheses are supported, so the following would bundle everything in common with `page1` and `page2`, and also everything in common between `page3` and `page4`:
+
+```javascript
+builder.bundle('(app/page1.js & app/page2.js) + (app/page3.js & app/page4.js)', 'common.js');
+```
+
 #### Example - Direct Trace API
 
 Instead of using the arithmetic syntax, we can construct the trace ourselves.

lib/arithmetic.js

@@ -13,37 +13,106 @@ var verifyTree = require('./utils').verifyTree;
 
 function parseExpression(expressionString) {
   expressionString = ' + ' + expressionString;
-  var args = expressionString.split(/ [\+\-\&] /);
 
+  var index = 0;
   var operations = [];
+  var operatorRegex = /[\+\-\&]/;
+  var errorMessagesFromIndex = 3;
 
-  var curLen = 0;
-  for (var i = 0; i < args.length - 1; i++) {
-    var operator = expressionString[curLen + 1];
-    var moduleName = args[i + 1];
+  function getNextIdentifier() {
+    eatWhitespace();
+    var firstChar = expressionString.charAt(index);
 
-    curLen += moduleName.length + 3;
+    if (operatorRegex.test(firstChar)){
+      throw 'Syntax Error: Identifier or sub expression expected after <' + expressionString.slice(errorMessagesFromIndex).substr(0, index - errorMessagesFromIndex) + '> but found <' + firstChar + '> instead';
+    }
 
-    if (operator !== '+' && operator !== '-' && operator !== '&')
-      throw new TypeError('Expected operator before ' + operator);
-    if (!moduleName)
-      throw new TypeError('A module name is needed after ' + operator);
+    if (firstChar === '(') {
+      var closingParenIndex = index,
+          numOpenBeforeSelf = 0;
+
+      while (++closingParenIndex < expressionString.length){
+        if (expressionString.charAt(closingParenIndex) === '('){
+          numOpenBeforeSelf++;
+        } else if (expressionString.charAt(closingParenIndex) === ')') {
+          if (numOpenBeforeSelf){
+            numOpenBeforeSelf--;
+          } else {
+            break;
+          }
+        }
+      }
+      if (expressionString.charAt(closingParenIndex) !== ')'){
+        throw 'Syntax Error: Expression <' + expressionString.substr(index) + '> is never terminated. Did you forget to add a closing ")"?';
+      }
 
-    // detect [moduleName] syntax for individual modules not trees
-    var singleModule = moduleName.substr(0, 1) == '[' && moduleName.substr(moduleName.length - 1, 1) == ']';
-    if (singleModule)
-      moduleName = moduleName.substr(1, moduleName.length - 2);
+      var wholeExpression = expressionString.substring(index + 1, closingParenIndex);
+      index = closingParenIndex + 1;
+      return { bulkOperation: wholeExpression };
+    }
 
-    var canonicalized = moduleName.substr(0, 1) == '`' && moduleName.substr(moduleName.length - 1, 1) == '`';
-    if (canonicalized)
-      moduleName = moduleName.substr(1, moduleName.length - 2);
+    var result = "";
+    //scan the identifier
+    for (; index < expressionString.length; index++) {
+      if (/\s/.test(expressionString.charAt(index))) {
+        return result;
+      } else {
+        result += expressionString.charAt(index);
+      }
+    }
+    return result;
+  }
 
-    operations.push({
-      operator: operator,
-      moduleName: moduleName,
-      singleModule: singleModule,
-      canonicalized: canonicalized
-    });
+  function getNextOperator() {
+    eatWhitespace();
+    if (index === expressionString.length) return null;
+
+    var candidateResult = expressionString.charAt(index++); //all operators are single characters at the moment
+
+    if (!operatorRegex.test(candidateResult)){
+      throw 'Syntax Error: An operator was expected after <' + expressionString.slice(errorMessagesFromIndex).substr(0, index - 1 - errorMessagesFromIndex) + '> but found <' + expressionString.substring(index - 1) + '> instead';
+    }
+
+    return candidateResult;
+  }
+
+  function eatWhitespace() {
+    //wind past whitespace
+    for (; index < expressionString.length; index++) {
+      if (/\S/.test(expressionString.charAt(index))) {
+        break;
+      }
+    }
+  }
+
+  var operator;
+  while (index < expressionString.length && (operator = getNextOperator())) {
+    var moduleNameOrSubExpression = getNextIdentifier();
+
+    if (typeof moduleNameOrSubExpression === 'object'){
+      operations.push({
+        operator: operator,
+        bulkOperation: moduleNameOrSubExpression.bulkOperation
+      });
+    } else {
+      // detect [moduleName] syntax for individual modules not trees
+      var singleModule = moduleNameOrSubExpression.substr(0, 1) == '[' && moduleNameOrSubExpression.substr(moduleNameOrSubExpression.length - 1, 1) == ']';
+      if (singleModule) {
+        moduleNameOrSubExpression = moduleNameOrSubExpression.substr(1, moduleNameOrSubExpression.length - 2);
+      }
+
+      var canonicalized = moduleNameOrSubExpression.substr(0, 1) == '`' && moduleNameOrSubExpression.substr(moduleNameOrSubExpression.length - 1, 1) == '`';
+      if (canonicalized) {
+        moduleNameOrSubExpression = moduleNameOrSubExpression.substr(1, moduleNameOrSubExpression.length - 2);
+      }
+
+      operations.push({
+        operator: operator,
+        moduleName: moduleNameOrSubExpression,
+        singleModule: singleModule,
+        canonicalized: canonicalized
+      });
+    }
   }
 
   return operations;
@@ -149,7 +218,7 @@ function expandGlobAndCanonicalize(builder, operation) {
   });
 }
 
-exports.traceExpression = function(builder, expression, traceOpts) {
+exports.traceExpression = function traceExpression(builder, expression, traceOpts) {
   if (!expression)
     throw new Error('A module expression must be provided to trace.');
 
@@ -159,12 +228,22 @@ exports.traceExpression = function(builder, expression, traceOpts) {
   // expand any globbing operations in the expression
   var expandPromise = Promise.resolve();
   operations.forEach(function(operation) {
-    expandPromise = expandPromise.then(function() {
-      return Promise.resolve(expandGlobAndCanonicalize(builder, operation))
-      .then(function(expanded) {
-        expandedOperations = expandedOperations.concat(expanded);
+    if (operation.bulkOperation) {
+      var expandedTreePromise = traceExpression(builder, operation.bulkOperation, traceOpts)
+      expandPromise = expandPromise.then(function() {
+        return Promise.resolve(expandedTreePromise)
+               .then(function(fullTree){
+                 expandedOperations = expandedOperations.concat({ preExpandedTree: fullTree, operator: operation.operator })
+               });
       });
-    });
+    } else if (operation.operator) {
+      expandPromise = expandPromise.then(function() {
+        return Promise.resolve(expandGlobAndCanonicalize(builder, operation))
+               .then(function (expanded) {
+                 expandedOperations = expandedOperations.concat(expanded);
+               });
+      });
+    }
   });
 
   return expandPromise.then(function() {
@@ -174,7 +253,10 @@ exports.traceExpression = function(builder, expression, traceOpts) {
         // tree . module
         if (op.singleModule)
           return getTreeModuleOperation(builder, op.operator)(curTree, op.moduleName);
-
+
+        if (op.preExpandedTree){
+          return getTreeOperation(op.operator)(curTree, op.preExpandedTree);
+        }
         // tree . tree
         return builder.tracer.traceCanonical(op.moduleName, traceOpts)
         .then(function(nextTrace) {