private void processSpec(ObjectSpecs objectSpecs, StructNode specNode) {
try {
String specText = specNode.getName();
boolean onlyWarn = false;
if (specText.startsWith("%")) {
specText = specText.substring(1);
onlyWarn = true;
}
String alias = null;
StringCharReader reader = new StringCharReader(specText);
if (reader.firstNonWhiteSpaceSymbol() == '"') {
alias = Expectations.doubleQuotedText().read(reader);
specText = reader.getTheRest();
}
Spec spec = pageSpecHandler.getSpecReader().read(specText, pageSpecHandler.getContextPath());
spec.setOnlyWarn(onlyWarn);
spec.setAlias(alias);
if (specNode.getSource() != null) {
spec.setPlace(new Place(specNode.getSource(), specNode.getFileLineNumber()));
}
spec.setProperties(pageSpecHandler.getProperties());
spec.setJsVariables(pageSpecHandler.getJsVariables());
objectSpecs.getSpecs().add(spec);
} catch (SyntaxException ex) {
ex.setLine(new Line(specNode.getSource(), specNode.getFileLineNumber()));
throw ex;
}
}
public PageSpec read(
InputStream inputStream,
String source,
String contextPath,
Page page,
SectionFilter sectionFilter,
Properties properties,
Map<String, Object> jsVariables,
Map<String, Locator> objects)
throws IOException {
try {
IndentationStructureParser structParser = new IndentationStructureParser();
List<StructNode> structs = structParser.parse(inputStream, source);
PageSpec pageSpec = new PageSpec(objects);
PageSpecHandler pageSpecHandler =
new PageSpecHandler(pageSpec, page, sectionFilter, contextPath, properties, jsVariables);
List<StructNode> allProcessedChildNodes =
new MacroProcessor(pageSpecHandler).process(structs);
new PostProcessor(pageSpecHandler).process(allProcessedChildNodes);
return pageSpecHandler.buildPageSpec();
} catch (SyntaxException ex) {
String exceptionSource = "<unknown location>";
Integer lineNumber = -1;
if (ex.getLine() != null) {
exceptionSource = ex.getLine().getText();
lineNumber = ex.getLine().getNumber();
}
throw new FileSyntaxException(ex, exceptionSource, lineNumber);
}
}
private List<String> findAllMatchingObjectNamesForExpression(
String objectExpression, StructNode source) {
String[] parts = objectExpression.split(",");
List<String> resultingObjectNames = new LinkedList<String>();
for (String part : parts) {
String singleExpression = part.trim();
if (singleExpression.isEmpty()) {
throw new SyntaxException(source, "Incorrect object expression");
}
if (GalenUtils.isObjectExpression(singleExpression)) {
Pattern objectPattern = GalenUtils.convertObjectNameRegex(singleExpression);
for (String objectName : pageSpecHandler.getSortedObjectNames()) {
if (objectPattern.matcher(objectName).matches()) {
resultingObjectNames.add(objectName);
}
}
} else {
resultingObjectNames.add(singleExpression);
}
}
return resultingObjectNames;
}
private PageSection findSection(String sectionName) {
if (parentSection != null) {
return findSection(sectionName, parentSection.getSections());
} else {
return findSection(sectionName, pageSpecHandler.getPageSections());
}
}
private void processObjectLevelRule(ObjectSpecs objectSpecs, StructNode sourceNode)
throws IOException {
String ruleText = sourceNode.getName().substring(1).trim();
Pair<PageRule, Map<String, String>> rule = findAndProcessRule(ruleText, sourceNode);
pageSpecHandler.setGlobalVariable("objectName", objectSpecs.getObjectName(), sourceNode);
List<StructNode> specNodes =
rule.getKey()
.apply(pageSpecHandler, ruleText, objectSpecs.getObjectName(), rule.getValue());
SpecGroup specGroup = new SpecGroup();
specGroup.setName(ruleText);
objectSpecs.addSpecGroup(specGroup);
for (StructNode specNode : specNodes) {
specGroup.addSpec(
pageSpecHandler
.getSpecReader()
.read(specNode.getName(), pageSpecHandler.getContextPath()));
}
}
private Pair<PageRule, Map<String, String>> findAndProcessRule(
String ruleText, StructNode ruleNode) {
for (Pair<Rule, PageRule> rulePair : pageSpecHandler.getPageRules()) {
Matcher matcher = rulePair.getKey().getPattern().matcher(ruleText);
if (matcher.matches()) {
int index = 1;
Map<String, String> parameters = new HashMap<String, String>();
for (String parameterName : rulePair.getKey().getParameters()) {
String value = matcher.group(index);
pageSpecHandler.setGlobalVariable(parameterName, value, ruleNode);
parameters.put(parameterName, value);
index += 1;
}
return new ImmutablePair<PageRule, Map<String, String>>(rulePair.getValue(), parameters);
}
}
throw new SyntaxException(ruleNode, "Could find rule matching: " + ruleText);
}
public void process(StructNode sectionNode) throws IOException {
if (sectionNode.getChildNodes() != null) {
String sectionName =
sectionNode.getName().substring(1, sectionNode.getName().length() - 1).trim();
PageSection section = findSection(sectionName);
if (section == null) {
section = new PageSection(sectionName);
if (parentSection != null) {
parentSection.addSubSection(section);
} else {
pageSpecHandler.addSection(section);
}
}
processSection(section, sectionNode.getChildNodes());
}
}
