Source: DependencyPostprocessor.js 
(function()
{
/*************************************************************************************/
var ASTHelper = Firecrow.ASTHelper;
var ValueTypeHelper = Firecrow.ValueTypeHelper;
var InclusionFinder = Firecrow.N_DependencyGraph.InclusionFinder;
var DependencyPostprocessor;
Firecrow.N_DependencyGraph.DependencyPostprocessor = DependencyPostprocessor = function()
{
this.inclusionFinder = new InclusionFinder();
};
DependencyPostprocessor.notifyError = function(message) { debugger; alert("DependencyPostprocessor - " + message); }
DependencyPostprocessor.processHtmlElement = function(model)
{
(new DependencyPostprocessor()).processHtmlElement(model);
};
DependencyPostprocessor.prototype =
{
processHtmlElement: function(htmlElement)
{
if(!this.inclusionFinder.isIncludedHtmlElement(htmlElement)) { return; }
var previousValue = htmlElement.shouldBeIncluded;
Firecrow.includeNode(htmlElement, true);
if(htmlElement.type == "script")
{
this.processElement(htmlElement.pathAndModel.model);
}
else if(htmlElement.type == "style" || htmlElement.type == "textNode") {}
else
{
var childNodes = htmlElement.childNodes;
if(childNodes != null)
{
for(var i = 0, length = childNodes.length; i < length; i++)
{
this.processHtmlElement(childNodes[i]);
}
}
}
},
processElement: function(element)
{
if (ASTHelper.isProgram(element)) { this.processProgram(element); }
else if (ASTHelper.isStatement(element)) { this.processStatement(element); }
else if (ASTHelper.isFunction(element)) { this.processFunction(element); }
else if (ASTHelper.isExpression(element)) { this.processExpression(element); }
else if (ASTHelper.isSwitchCase(element)) { this.processSwitchCase(element); }
else if (ASTHelper.isCatchClause(element)) { this.processCatchClause(element); }
else if (ASTHelper.isVariableDeclaration(element)) { this.processVariableDeclaration(element); }
else if (ASTHelper.isVariableDeclarator(element)) { this.processVariableDeclarator(element); }
else if (ASTHelper.isLiteral(element)) { this.processLiteral(element); }
else if (ASTHelper.isIdentifier(element)) { this.processIdentifier(element); }
else { this.notifyError("Error while processing code unidentified ast element"); }
},
processProgram: function(programElement)
{
if(!this.inclusionFinder.isIncludedProgram(programElement)) { return; }
Firecrow.includeNode(programElement, true);
if(programElement.body != null)
{
var body = programElement.body;
for(var i = 0, length = body.length; i < length; i++)
{
this.processElement(body[i]);
}
}
},
processStatement: function(statement)
{
if (ASTHelper.isEmptyStatement(statement)) { this.processEmptyStatement(statement); }
else if (ASTHelper.isBlockStatement(statement)) { this.processBlockStatement(statement); }
else if (ASTHelper.isExpressionStatement(statement)) { this.processExpressionStatement(statement); }
else if (ASTHelper.isIfStatement(statement)) { this.processIfStatement(statement); }
else if (ASTHelper.isWhileStatement(statement)) { this.processWhileStatement(statement); }
else if (ASTHelper.isDoWhileStatement(statement)) { this.processDoWhileStatement(statement); }
else if (ASTHelper.isForStatement(statement)) { this.processForStatement(statement); }
else if (ASTHelper.isForInStatement(statement)) { this.processForInStatement(statement); }
else if (ASTHelper.isLabeledStatement(statement)) { this.processLabeledStatement(statement); }
else if (ASTHelper.isBreakStatement(statement)) { this.processBreakStatement(statement); }
else if (ASTHelper.isContinueStatement(statement)) { this.processContinueStatement(statement); }
else if (ASTHelper.isReturnStatement(statement)) { this.processReturnStatement(statement); }
else if (ASTHelper.isWithStatement(statement)) { this.processWithStatement(statement); }
else if (ASTHelper.isTryStatement(statement)) { this.processTryStatement(statement); }
else if (ASTHelper.isThrowStatement(statement)) { this.processThrowStatement(statement); }
else if (ASTHelper.isSwitchStatement(statement)) { this.processSwitchStatement(statement); }
else if (ASTHelper.isVariableDeclaration(statement)) { this.processVariableDeclaration(statement);}
else { this.notifyError("Error: AST Statement element not defined: " + statement.type); }
},
processExpression: function(expression)
{
if (ASTHelper.isAssignmentExpression(expression)) { this.processAssignmentExpression(expression); }
else if (ASTHelper.isUnaryExpression(expression)) { this.processUnaryExpression(expression); }
else if (ASTHelper.isBinaryExpression(expression)) { this.processBinaryExpression(expression); }
else if (ASTHelper.isLogicalExpression(expression)) { this.processLogicalExpression(expression); }
else if (ASTHelper.isLiteral(expression)) { this.processLiteral(expression); }
else if (ASTHelper.isIdentifier(expression)) { this.processIdentifier(expression); }
else if (ASTHelper.isUpdateExpression(expression)) { this.processUpdateExpression(expression); }
else if (ASTHelper.isNewExpression(expression)) { this.processNewExpression(expression); }
else if (ASTHelper.isConditionalExpression(expression)) { this.processConditionalExpression(expression); }
else if (ASTHelper.isThisExpression(expression)) { this.processThisExpression(expression); }
else if (ASTHelper.isCallExpression(expression)) { this.processCallExpression(expression); }
else if (ASTHelper.isMemberExpression(expression)) { this.processMemberExpression(expression); }
else if (ASTHelper.isSequenceExpression(expression)) { this.processSequenceExpression(expression); }
else if (ASTHelper.isArrayExpression(expression)) { this.processArrayExpression(expression); }
else if (ASTHelper.isObjectExpression(expression)) { this.processObjectExpression(expression); }
else if (ASTHelper.isFunctionExpression(expression)) { this.processFunction(expression); }
else { this.notifyError("Error: AST Expression element not defined: " + expression.type); "";}
},
processFunction: function(functionDecExp)
{
if(!this.inclusionFinder.isIncludedFunction(functionDecExp)) { return; }
Firecrow.includeNode(functionDecExp, true);
Firecrow.includeNode(functionDecExp.body, true);
if(functionDecExp.id != null) { Firecrow.includeNode(functionDecExp.id);}
var params = functionDecExp.params;
if(params != null)
{
for(var i = 0, length = params.length; i < length; i++)
{
Firecrow.includeNode(params[i], true);
}
}
this.processFunctionBody(functionDecExp);
},
processFunctionBody: function(functionDeclExp)
{
this.processElement(functionDeclExp.body);
},
processBlockStatement: function(blockStatement)
{
if(!this.inclusionFinder.isIncludedBlockStatement(blockStatement)) { return; }
Firecrow.includeNode(blockStatement, true);
var body = blockStatement.body;
for(var i = 0, length = body.length; i < length; i++)
{
this.processElement(body[i]);
}
},
processEmptyStatement: function(emptyStatement)
{
},
processExpressionStatement: function(expressionStatement)
{
if(!this.inclusionFinder.isIncludedExpressionStatement(expressionStatement)) { return; }
Firecrow.includeNode(expressionStatement, true);
this.processElement(expressionStatement.expression);
},
processAssignmentExpression: function(assignmentExpression)
{
if(!this.inclusionFinder.isIncludedAssignmentExpression(assignmentExpression)) { return; }
if(assignmentExpression.shouldBeIncluded)
{
Firecrow.includeNode(assignmentExpression.left, true);
}
Firecrow.includeNode(assignmentExpression, true);
this.processElement(assignmentExpression.left);
this.processElement(assignmentExpression.right);
},
processUnaryExpression: function(unaryExpression)
{
if(!this.inclusionFinder.isIncludedUnaryExpression(unaryExpression)) { return; }
Firecrow.includeNode(unaryExpression, true);
this.processExpression(unaryExpression.argument);
},
processBinaryExpression: function(binaryExpression)
{
if(!this.inclusionFinder.isIncludedBinaryExpression(binaryExpression)) { return; }
Firecrow.includeNode(binaryExpression, true);
this.processElement(binaryExpression.left);
this.processElement(binaryExpression.right);
},
processLogicalExpression: function(logicalExpression)
{
if(!this.inclusionFinder.isIncludedLogicalExpression(logicalExpression)) { return; }
Firecrow.includeNode(logicalExpression, true);
this.processElement(logicalExpression.left);
this.processElement(logicalExpression.right);
},
processUpdateExpression: function(updateExpression)
{
if(!this.inclusionFinder.isIncludedUpdateExpression(updateExpression)) { return; }
Firecrow.includeNode(updateExpression, true);
this.processElement(updateExpression.argument);
},
processNewExpression: function(newExpression)
{
if(!this.inclusionFinder.isIncludedNewExpression(newExpression)) { return; }
Firecrow.includeNode(newExpression, true);
Firecrow.includeNode(newExpression.callee, true);
this.processElement(newExpression.callee);
this.processSequence(newExpression.arguments);
},
processConditionalExpression: function(conditionalExpression)
{
if(!this.inclusionFinder.isIncludedConditionalExpression(conditionalExpression)) { return; }
Firecrow.includeNode(conditionalExpression, true);
this.processElement(conditionalExpression.test);
this.processElement(conditionalExpression.consequent);
this.processElement(conditionalExpression.alternate);
},
processThisExpression: function(thisExpression) { },
processCallExpression: function(callExpression)
{
if(!this.inclusionFinder.isIncludedCallExpression(callExpression)) { return; }
Firecrow.includeNode(callExpression, true);
/*if(ASTHelper.isMemberExpression(callExpression.callee))
{
if(ASTHelper.isIdentifier(callExpression.callee.property))
{
Firecrow.includeNode(callExpression.callee.property);
}
if(ASTHelper.isIdentifier(callExpression.callee.object))
{
Firecrow.includeNode(callExpression.callee.object);
}
}*/
this.processElement(callExpression.callee);
this.processSequence(callExpression.arguments);
},
processMemberExpression: function(memberExpression)
{
if(!this.inclusionFinder.isIncludedMemberExpression(memberExpression)) { return; }
var isObjectIncluded = this.inclusionFinder.isIncludedElement(memberExpression.object);
var isPropertyIncluded = this.inclusionFinder.isIncludedElement(memberExpression.property);
var areChildrenIncluded = isObjectIncluded || isPropertyIncluded;
if(areChildrenIncluded)
{
Firecrow.includeNode(memberExpression, true);
}
if(!ASTHelper.isMemberExpression(memberExpression.parent)
&& !ASTHelper.isCallExpression(memberExpression.parent)
&& !ASTHelper.isCallExpression(memberExpression.object))
{
Firecrow.includeNode(memberExpression.object, true);
Firecrow.includeNode(memberExpression.property, true);
}
/*else
{
if(ASTHelper.isIdentifier(memberExpression.property)
&& !ASTHelper.isCallExpression(memberExpression.parent)
&& areChildrenIncluded)
{
Firecrow.includeNode(memberExpression.object);
Firecrow.includeNode(memberExpression.property);
}
} */
this.processElement(memberExpression.object);
this.processElement(memberExpression.property);
},
processSequenceExpression: function(sequenceExpression)
{
if(!this.inclusionFinder.isIncludedSequenceExpression(sequenceExpression)) { return; }
Firecrow.includeNode(sequenceExpression, true);
this.processSequence(sequenceExpression.expressions);
},
processArrayExpression: function(arrayExpression)
{
if(!this.inclusionFinder.isIncludedArrayExpression(arrayExpression)) { return; }
Firecrow.includeNode(arrayExpression, true);
this.processSequence(arrayExpression.elements);
},
processObjectExpression: function(objectExpression)
{
if(!this.inclusionFinder.isIncludedObjectExpression(objectExpression)) { return; }
Firecrow.includeNode(objectExpression, true);
var properties = objectExpression.properties;
for (var i = 0, length = properties.length; i < length; i++)
{
this.processObjectExpressionProperty(properties[i]);
}
},
processObjectExpressionProperty: function(objectExpressionProperty)
{
if(!this.inclusionFinder.isIncludedObjectExpressionProperty(objectExpressionProperty)) { return; }
Firecrow.includeNode(objectExpressionProperty, true);
Firecrow.includeNode(objectExpressionProperty.key, true);
this.processElement(objectExpressionProperty.value);
},
processIfStatement: function(ifStatement)
{
if(!this.inclusionFinder.isIncludedIfStatement(ifStatement)) { return; }
Firecrow.includeNode(ifStatement, true);
this.processElement(ifStatement.test);
//TODO - not sure about this: the problem is the if statement gets included, but it does not include the
//return statement in it's body - and i'm not sure whether it even should
if(ifStatement.test.shouldBeIncluded)
{
var returnStatement = ASTHelper.getDirectlyContainedReturnStatement(ifStatement.consequent);
if(returnStatement != null && returnStatement.hasBeenExecuted)
{
Firecrow.includeNode(returnStatement, true);
}
}
this.processElement(ifStatement.consequent);
if(ifStatement.alternate != null)
{
this.processElement(ifStatement.alternate);
}
},
processWhileStatement: function(whileStatement)
{
if(!this.inclusionFinder.isIncludedWhileStatement(whileStatement)) { return; }
Firecrow.includeNode(whileStatement, true);
this.processElement(whileStatement.test);
this.processElement(whileStatement.body);
},
processDoWhileStatement: function(doWhileStatement)
{
if(!this.inclusionFinder.isIncludedDoWhileStatement(doWhileStatement)) { return; }
Firecrow.includeNode(doWhileStatement, true);
this.processElement(doWhileStatement.test);
this.processElement(doWhileStatement.body);
},
processForStatement: function(forStatement)
{
if(!this.inclusionFinder.isIncludedForStatement(forStatement)) { return; }
Firecrow.includeNode(forStatement, true);
if(forStatement.init != null) { this.processElement(forStatement.init); }
if(forStatement.test != null) { this.processElement(forStatement.test); }
if(forStatement.update != null) {this.processElement(forStatement.update)}
this.processElement(forStatement.body);
},
processForInStatement: function(forInStatement)
{
if(!this.inclusionFinder.isIncludedForInStatement(forInStatement)) { return; }
Firecrow.includeNode(forInStatement, true);
this.processElement(forInStatement.left);
this.processElement(forInStatement.right);
this.processElement(forInStatement.body);
if(forInStatement.right.shouldBeIncluded) { forInStatement.left.shouldBeIncluded; }
},
processBreakStatement: function(breakStatement)
{
if(!this.inclusionFinder.isIncludedBreakStatement(breakStatement)) { return; }
Firecrow.includeNode(breakStatement, true);
},
processContinueStatement: function(continueStatement)
{
if(!this.inclusionFinder.isIncludedContinueStatement(continueStatement)) { return; }
Firecrow.includeNode(continueStatement, true);
},
processReturnStatement: function(returnStatement)
{
if(!this.inclusionFinder.isIncludedReturnStatement(returnStatement)) { return; }
Firecrow.includeNode(returnStatement, true);
if(returnStatement.argument != null) { this.processExpression(returnStatement.argument); }
},
processWithStatement: function(withStatement)
{
if(!this.inclusionFinder.isIncludedWithStatement(withStatement)) { return; }
Firecrow.includeNode(withStatement, true);
this.processExpression(withStatement.object);
this.processStatement(withStatement.body);
},
processThrowStatement: function(throwStatement)
{
if(!this.inclusionFinder.isIncludedThrowStatement(throwStatement)) { return; }
Firecrow.includeNode(throwStatement, true);
this.processExpression(throwStatement.argument);
},
processSwitchStatement: function(switchStatement)
{
if(!this.inclusionFinder.isIncludedSwitchStatement(switchStatement)) { return; }
Firecrow.includeNode(switchStatement, true);
this.processExpression(switchStatement.discriminant);
for(var i = 0; i < switchStatement.cases.length; i++)
{
this.processSwitchCase(switchStatement.cases[i]);
}
},
processSwitchCase: function(switchCase)
{
if(!this.inclusionFinder.isIncludedSwitchCase(switchCase)) { return; }
Firecrow.includeNode(switchCase, true);
if(switchCase.test != null)
{
Firecrow.includeNode(switchCase.test, true);
}
for(var i = 0; i < switchCase.consequent.length; i++)
{
this.processStatement(switchCase.consequent[i]);
}
},
processTryStatement: function(tryStatement)
{
if(!this.inclusionFinder.isIncludedTryStatement(tryStatement)) { return; }
Firecrow.includeNode(tryStatement, true);
this.processElement(tryStatement.block);
var handlers = tryStatement.handlers || (ValueTypeHelper.isArray(tryStatement.handler) ? tryStatement.handler : [tryStatement.handler]);
for(var i = 0; i < handlers.length; i++)
{
Firecrow.includeNode(handlers[i], true);
this.processCatchClause(handlers[i]);
}
if(tryStatement.finalizer != null)
{
this.processElement(tryStatement.finalizer);
}
},
processLabeledStatement: function(labeledStatement)
{
if(!this.inclusionFinder.isIncludedStatement(labeledStatement)) { return; }
Firecrow.includeNode(labeledStatement, true);
this.processElement(labeledStatement.body);
},
processVariableDeclaration: function(variableDeclaration)
{
if(!this.inclusionFinder.isIncludedVariableDeclaration(variableDeclaration)) { return; }
Firecrow.includeNode(variableDeclaration, true);
var declarators = variableDeclaration.declarations;
for (var i = 0, length = declarators.length; i < length; i++)
{
this.processVariableDeclarator(declarators[i]);
}
},
processVariableDeclarator: function(variableDeclarator)
{
if(!this.inclusionFinder.isIncludedVariableDeclarator(variableDeclarator)) { return; }
Firecrow.includeNode(variableDeclarator, true);
Firecrow.includeNode(variableDeclarator.id, true);
if(variableDeclarator.init != null)
{
this.processElement(variableDeclarator.init);
}
},
processPattern: function(pattern)
{
if(ASTHelper.isIdentifier(pattern)) { this.processIdentifier(pattern);}
},
processCatchClause: function(catchClause)
{
if(!this.inclusionFinder.isIncludedCatchClause(catchClause)) { return;}
Firecrow.includeNode(catchClause, true);
this.processElement(catchClause.param);
this.processStatement(catchClause.body);
},
processIdentifier: function(identifier) { },
processLiteral: function(literal)
{
if(literal.shouldBeIncluded == true && Firecrow.ValueTypeHelper.isObject(literal.value))
{
Firecrow.includeNode(literal.value, true);
}
},
processSequence: function(sequence)
{
var code = "";
for(var i = 0, length = sequence.length; i < length; i++)
{
this.processElement(sequence[i])
}
},
notifyError:function(message) { DependencyPostprocessor.notifyError(message); }
}
/*************************************************************************************/
})();
