@Override
public List<Block> execute(Object parameters, String content, MacroTransformationContext context)
throws MacroExecutionException {
XDOM parsedDom;
// get a parser for the desired syntax identifier
Parser parser = getSyntaxParser(context.getSyntax().toIdString());
try {
// parse the content of the wiki macro that has been injected by the component manager the
// content of the macro call itself is ignored.
parsedDom = parser.parse(new StringReader(content));
} catch (ParseException e) {
throw new MacroExecutionException(
"Failed to parse content ["
+ content
+ "] with Syntax parser ["
+ parser.getSyntax()
+ "]",
e);
}
List<MacroBlock> potentialCells = parsedDom.getChildrenByType(MacroBlock.class, false);
int count = this.countCells(potentialCells);
if (count == 0) {
throw new MacroExecutionException(
"TableRow macro expect at least one cell macro as first-level children");
}
// Make the actual cells, injecting <td> tags around cell macros
this.makeCells(potentialCells);
return Collections.singletonList((Block) parsedDom);
}
/** {@inheritDoc} */
public List<Block> execute(
SectionMacroParameters parameters, String content, MacroTransformationContext context)
throws MacroExecutionException {
XDOM parsedDom;
// get a parser for the desired syntax identifier
Parser parser = getSyntaxParser(context.getSyntax().toIdString());
try {
// parse the content of the wiki macro that has been injected by the
// component manager
// the content of the macro call itself is ignored.
parsedDom = parser.parse(new StringReader(content));
} catch (ParseException e) {
throw new MacroExecutionException(
"Failed to parse content ["
+ content
+ "] with Syntax parser ["
+ parser.getSyntax()
+ "]",
e);
}
List<MacroBlock> potentialColumns = parsedDom.getChildrenByType(MacroBlock.class, false);
int count = this.countColumns(potentialColumns);
if (count == 0) {
throw new MacroExecutionException(
"Section macro expect at least one column macro as first-level children");
}
double computedColumnWidth = ((TOTAL_WIDTH - COLUMN_RIGHT_PADDING_RATE * (count - 1)) / count);
// Make the actual columns injecting divs around column macros
this.makeColumns(potentialColumns, computedColumnWidth);
// finally, clear the floats introduced by the columns
Map<String, String> clearFloatsParams = new HashMap<String, String>();
clearFloatsParams.put(PARAMETER_STYLE, STYLE_CLEAR_BOTH);
parsedDom.addChild(new GroupBlock(clearFloatsParams));
Map<String, String> sectionParameters = new HashMap<String, String>();
if (parameters.isJustify()) {
sectionParameters.put(PARAMETER_STYLE, STYLE_TEXT_ALIGN_JUSTIFY);
}
Block sectionRoot = new GroupBlock(sectionParameters);
sectionRoot.addChildren(parsedDom.getChildren());
return Collections.singletonList(sectionRoot);
}
@Override
public XDOM parse(Reader source) throws ParseException {
try {
RootNode rootNode = PEGDOWN_PROCESSOR.parseMarkdown(IOUtils.toString(source).toCharArray());
String markdownAsHtml = new ToHtmlSerializer().toHtml(rootNode);
XDOM xdom =
this.xhtmlParser.parse(
new StringReader("<html><body>" + markdownAsHtml + "</body></html>"));
// Replace the Syntax MetaData which is set with XHTML with Markdown.
return new XDOM(
xdom.getChildren(),
new MetaData(
Collections.<String, Object>singletonMap(MetaData.SYNTAX, Syntax.MARKDOWN_1_0)));
} catch (IOException e) {
throw new ParseException("Failed to convert Markdown to HTML", e);
}
}
@Test
public void testAddingMetadataSource() throws Exception {
XDOM xdom = mocker.getComponentUnderTest().parse("", Syntax.PLAIN_1_0, DOCUMENT_REFERENCE);
assertThat((String) xdom.getMetaData().getMetaData(MetaData.SOURCE), equalTo(SOURCE));
}
@Test
public void testNoMetadataSource() throws Exception {
XDOM xdom = mocker.getComponentUnderTest().parse("", Syntax.PLAIN_1_0);
assertThat(xdom.getMetaData().getMetaData(MetaData.SOURCE), nullValue());
}
@Override
public List<Block> execute(
IncludeMacroParameters parameters, String content, MacroTransformationContext context)
throws MacroExecutionException {
// Step 1: Perform checks.
if (parameters.getReference() == null) {
throw new MacroExecutionException(
"You must specify a 'reference' parameter pointing to the entity to include.");
}
DocumentReference includedReference = resolve(context.getCurrentMacroBlock(), parameters);
checkRecursiveInclusion(context.getCurrentMacroBlock(), includedReference);
if (!this.documentAccessBridge.isDocumentViewable(includedReference)) {
throw new MacroExecutionException(
String.format(
"Current user [%s] doesn't have view rights on document [%s]",
this.documentAccessBridge.getCurrentUserReference(),
this.defaultEntityReferenceSerializer.serialize(includedReference)));
}
Context parametersContext = parameters.getContext();
// Step 2: Retrieve the included document.
DocumentModelBridge documentBridge;
try {
documentBridge = this.documentAccessBridge.getDocument(includedReference);
} catch (Exception e) {
throw new MacroExecutionException(
"Failed to load Document ["
+ this.defaultEntityReferenceSerializer.serialize(includedReference)
+ "]",
e);
}
// Step 3: Display the content of the included document.
// Check the value of the "context" parameter.
//
// If CONTEXT_NEW then display the content in an isolated execution and transformation context.
//
// if CONTEXT_CURRENT then display the content without performing any transformations (we don't
// want any Macro
// to be executed at this stage since they should be executed by the currently running Macro
// Transformation.
DocumentDisplayerParameters displayParameters = new DocumentDisplayerParameters();
displayParameters.setContentTransformed(parametersContext == Context.NEW);
displayParameters.setExecutionContextIsolated(displayParameters.isContentTransformed());
displayParameters.setSectionId(parameters.getSection());
displayParameters.setTransformationContextIsolated(displayParameters.isContentTransformed());
displayParameters.setTransformationContextRestricted(
context.getTransformationContext().isRestricted());
displayParameters.setTargetSyntax(context.getTransformationContext().getTargetSyntax());
Stack<Object> references = this.inclusionsBeingExecuted.get();
if (parametersContext == Context.NEW) {
if (references == null) {
references = new Stack<Object>();
this.inclusionsBeingExecuted.set(references);
}
references.push(includedReference);
}
XDOM result;
try {
result = this.documentDisplayer.display(documentBridge, displayParameters);
} catch (Exception e) {
throw new MacroExecutionException(e.getMessage(), e);
} finally {
if (parametersContext == Context.NEW) {
references.pop();
}
}
// Step 4: Wrap Blocks in a MetaDataBlock with the "source" meta data specified so that we know
// from where the
// content comes and "base" meta data so that reference are properly resolved
MetaDataBlock metadata = new MetaDataBlock(result.getChildren(), result.getMetaData());
String source = this.defaultEntityReferenceSerializer.serialize(includedReference);
metadata.getMetaData().addMetaData(MetaData.SOURCE, source);
if (parametersContext == Context.NEW) {
metadata.getMetaData().addMetaData(MetaData.BASE, source);
}
return Arrays.<Block>asList(metadata);
}