| /* |
| * Copyright 2001-2005 The Apache Software Foundation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.servicemix.docs.confluence; |
| |
| import java.io.Writer; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.Stack; |
| import java.util.TreeMap; |
| import java.util.logging.Logger; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.mylyn.internal.wikitext.core.util.css.CssParser; |
| import org.eclipse.mylyn.internal.wikitext.core.util.css.CssRule; |
| import org.eclipse.mylyn.wikitext.core.parser.Attributes; |
| import org.eclipse.mylyn.wikitext.core.parser.DocumentBuilder; |
| import org.eclipse.mylyn.wikitext.core.parser.LinkAttributes; |
| import org.eclipse.mylyn.wikitext.core.parser.builder.AbstractXmlDocumentBuilder; |
| import org.eclipse.mylyn.wikitext.core.util.FormattingXMLStreamWriter; |
| import org.eclipse.mylyn.wikitext.core.util.XmlStreamWriter; |
| |
| /** |
| * A builder that can emit <a href="http://www.docbook.org/">Docbook</a> |
| * |
| */ |
| public class DocBookDocumentBuilder extends AbstractXmlDocumentBuilder { |
| |
| private static final Pattern PERCENTAGE = Pattern.compile("(\\d+)%"); //$NON-NLS-1$ |
| |
| private static final Pattern CSS_CLASS_INLINE = Pattern.compile("(^|\\s+)inline(\\s+|$)"); //$NON-NLS-1$ |
| |
| private static Set<Integer> entityReferenceToUnicode = new HashSet<Integer>(); |
| static { |
| entityReferenceToUnicode.add(215); |
| entityReferenceToUnicode.add(8211); |
| entityReferenceToUnicode.add(8212); |
| entityReferenceToUnicode.add(8220); |
| entityReferenceToUnicode.add(8221); |
| entityReferenceToUnicode.add(8216); |
| entityReferenceToUnicode.add(8217); |
| |
| } |
| |
| // private String bookTitle; |
| |
| private String namespace = "http://docbook.org/ns/docbook"; //$NON-NLS-1$ |
| |
| private final Map<String, String> acronyms = new HashMap<String, String>(); |
| |
| private int headingLevel = 0; |
| |
| private final Stack<BlockDescription> blockDescriptions = new Stack<BlockDescription>(); |
| |
| private final Stack<HeadingDescription> headingDescriptions = new Stack<HeadingDescription>(); |
| |
| private boolean automaticGlossary = true; |
| |
| public DocBookDocumentBuilder(Writer out) { |
| super(out); |
| } |
| |
| public DocBookDocumentBuilder(XmlStreamWriter writer) { |
| super(writer); |
| } |
| |
| protected XmlStreamWriter createXmlStreamWriter(Writer out) { |
| XmlStreamWriter writer = super.createXmlStreamWriter(out); |
| return new FormattingXMLStreamWriter(writer) { |
| @Override |
| protected boolean preserveWhitespace(String elementName) { |
| return elementName.equals("programlisting") || elementName.equals("code") || elementName.startsWith("literal"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| }; |
| } |
| |
| public String getNamespace() { |
| return namespace; |
| } |
| |
| public void setNamespace(String namespace) { |
| this.namespace = namespace; |
| } |
| |
| @Override |
| public void acronym(String text, String definition) { |
| String previousDef = acronyms.put(text, definition); |
| if (previousDef != null && previousDef.length() > definition.length()) { |
| acronyms.put(text, previousDef); |
| } |
| writer.writeStartElement("glossterm"); //$NON-NLS-1$ |
| characters(text); |
| writer.writeEndElement(); |
| } |
| |
| @Override |
| public void link(Attributes attributes, String href, final String text) { |
| link(attributes, href, new ContentEmitter() { |
| public void emit() { |
| writer.writeCharacters(text); |
| } |
| }); |
| } |
| |
| private void link(Attributes attributes, String href, ContentEmitter emitter) { |
| ensureBlockElementsOpen(); |
| if (href.startsWith("#")) { //$NON-NLS-1$ |
| if (href.length() > 1) { |
| writer.writeStartElement("link"); //$NON-NLS-1$ |
| writer.writeAttribute("linkend", href.substring(1)); //$NON-NLS-1$ |
| emitter.emit(); |
| writer.writeEndElement(); // link |
| } else { |
| emitter.emit(); |
| } |
| } else { |
| writer.writeStartElement("ulink"); //$NON-NLS-1$ |
| writer.writeAttribute("url", href); //$NON-NLS-1$ |
| emitter.emit(); |
| writer.writeEndElement(); // ulink |
| } |
| } |
| |
| private void transformId(String id) { |
| |
| } |
| |
| private interface ContentEmitter { |
| public void emit(); |
| } |
| |
| @Override |
| public void beginBlock(BlockType type, Attributes attributes) { |
| if (headingLevel == 0) { |
| beginHeading(1, new Attributes()); |
| endHeading(); |
| } |
| |
| String elementName; |
| String[] elementNames = null; |
| boolean allowTitle = false; |
| boolean closeElementsOnBlockStart = false; |
| BlockDescription previousBlock = null; |
| if (!blockDescriptions.isEmpty()) { |
| previousBlock = blockDescriptions.peek(); |
| } |
| |
| switch (type) { |
| case BULLETED_LIST: |
| elementName = "itemizedlist"; //$NON-NLS-1$ |
| break; |
| case NUMERIC_LIST: |
| elementName = "orderedlist"; //$NON-NLS-1$ |
| break; |
| case DEFINITION_LIST: |
| elementName = "variablelist"; //$NON-NLS-1$ |
| |
| // variablelist |
| // varlistentry+ |
| // term+ |
| // listitem |
| // |
| break; |
| case DEFINITION_TERM: |
| |
| BlockDescription blockDescription = findBlockDescription(BlockType.DEFINITION_LIST); |
| if (blockDescription.entrySize > 0) { |
| endBlockEntry(blockDescription); |
| } |
| openBlockEntry(blockDescription, new String[] { "varlistentry" }); //$NON-NLS-1$ |
| |
| elementName = "term"; //$NON-NLS-1$ |
| break; |
| case DEFINITION_ITEM: |
| elementName = "listitem"; //$NON-NLS-1$ |
| elementNames = new String[] { "para" }; //$NON-NLS-1$ |
| closeElementsOnBlockStart = true; |
| break; |
| case FOOTNOTE: |
| case PARAGRAPH: |
| elementName = "para"; //$NON-NLS-1$ |
| break; |
| case CODE: |
| elementName = "programlisting"; //$NON-NLS-1$ |
| break; |
| case PREFORMATTED: |
| elementName = "literallayout"; //$NON-NLS-1$ |
| break; |
| case QUOTE: |
| elementName = "blockquote"; //$NON-NLS-1$ |
| break; |
| case LIST_ITEM: |
| elementName = "listitem"; //$NON-NLS-1$ |
| elementNames = new String[] { "para" }; //$NON-NLS-1$ |
| closeElementsOnBlockStart = true; |
| break; |
| case TABLE: |
| elementName = "informaltable"; //$NON-NLS-1$ |
| break; |
| case TABLE_CELL_HEADER: |
| elementName = "th"; //$NON-NLS-1$ |
| break; |
| case TABLE_CELL_NORMAL: |
| elementName = "td"; //$NON-NLS-1$ |
| break; |
| case TABLE_ROW: |
| elementName = "tr"; //$NON-NLS-1$ |
| break; |
| case INFORMATION: |
| elementName = "important"; //$NON-NLS-1$ |
| allowTitle = true; |
| break; |
| case NOTE: |
| elementName = "note"; //$NON-NLS-1$ |
| allowTitle = true; |
| break; |
| case WARNING: |
| elementName = "warning"; //$NON-NLS-1$ |
| allowTitle = true; |
| break; |
| case TIP: |
| elementName = "tip"; //$NON-NLS-1$ |
| allowTitle = true; |
| break; |
| case PANEL: |
| elementName = "note"; // docbook has nothing better for 'note' //$NON-NLS-1$ |
| allowTitle = true; |
| break; |
| case DIV: |
| elementName = null; |
| break; |
| default: |
| throw new IllegalStateException(type.name()); |
| } |
| |
| int blockSize; |
| if (elementName != null) { |
| blockSize = 1; |
| |
| if (previousBlock != null && previousBlock.closeElementsOnBlockStart) { |
| endBlockEntry(previousBlock); |
| } |
| |
| writer.writeStartElement(elementName); |
| applyAttributes(attributes); |
| |
| if (elementNames != null) { |
| for (String name : elementNames) { |
| writer.writeStartElement(name); |
| } |
| } |
| |
| if (allowTitle && attributes.getTitle() != null) { |
| writer.writeStartElement("title"); //$NON-NLS-1$ |
| writer.writeCharacters(attributes.getTitle()); |
| writer.writeEndElement(); |
| } |
| } else { |
| blockSize = 0; |
| } |
| blockDescriptions.push(new BlockDescription(type, blockSize, elementNames, closeElementsOnBlockStart)); |
| } |
| |
| @Override |
| public void endBlock() { |
| final BlockDescription blockDescription = blockDescriptions.pop(); |
| int size = blockDescription.size + blockDescription.entrySize; |
| for (int x = 0; x < size; ++x) { |
| writer.writeEndElement(); |
| } |
| } |
| |
| private void endBlockEntry(BlockDescription blockDescription) { |
| for (int x = 0; x < blockDescription.entrySize; ++x) { |
| writer.writeEndElement(); |
| } |
| blockDescription.entrySize = 0; |
| } |
| |
| private void openBlockEntry(BlockDescription blockDescription, String[] entry) { |
| for (String ent : entry) { |
| writer.writeStartElement(ent); |
| } |
| blockDescription.entrySize += entry.length; |
| } |
| |
| @Override |
| public void beginHeading(int level, Attributes attributes) { |
| closeSections(Math.max(level - 1, 0)); |
| |
| while (headingLevel < level) { |
| headingLevel++; |
| |
| if (headingLevel == 1) { |
| writer.writeStartElement("chapter"); //$NON-NLS-1$ |
| writer.writeNamespace("", namespace); |
| |
| } else { |
| writer.writeStartElement("section"); //$NON-NLS-1$ |
| } |
| if (attributes != null) { |
| applyAttributes(attributes); |
| attributes = null; |
| } |
| |
| headingDescriptions.push(new HeadingDescription(level, attributes)); |
| } |
| |
| writer.writeStartElement("title"); //$NON-NLS-1$ |
| } |
| |
| @Override |
| public void endHeading() { |
| writer.writeEndElement(); // title |
| } |
| |
| @Override |
| public void beginDocument() { |
| baseInHead = false; |
| } |
| |
| @Override |
| public void beginSpan(SpanType type, Attributes attributes) { |
| ensureBlockElementsOpen(); |
| switch (type) { |
| case BOLD: |
| case STRONG: |
| writer.writeStartElement("emphasis"); //$NON-NLS-1$ |
| writer.writeAttribute("role", "bold"); //$NON-NLS-1$ //$NON-NLS-2$ |
| break; |
| case CITATION: |
| writer.writeStartElement("citation"); //$NON-NLS-1$ |
| break; |
| case CODE: |
| writer.writeStartElement("code"); //$NON-NLS-1$ |
| break; |
| case DELETED: |
| writer.writeStartElement("emphasis"); //$NON-NLS-1$ |
| writer.writeAttribute("role", "del"); //$NON-NLS-1$ //$NON-NLS-2$ |
| break; |
| case EMPHASIS: |
| writer.writeStartElement("emphasis"); //$NON-NLS-1$ |
| break; |
| case INSERTED: |
| writer.writeStartElement("emphasis"); //$NON-NLS-1$ |
| writer.writeAttribute("role", "ins"); //$NON-NLS-1$ //$NON-NLS-2$ |
| break; |
| case UNDERLINED: |
| writer.writeStartElement("emphasis"); //$NON-NLS-1$ |
| writer.writeAttribute("role", "underline"); //$NON-NLS-1$ //$NON-NLS-2$ |
| break; |
| case ITALIC: |
| writer.writeStartElement("emphasis"); //$NON-NLS-1$ |
| writer.writeAttribute("role", "italic"); //$NON-NLS-1$ //$NON-NLS-2$ |
| break; |
| case QUOTE: |
| writer.writeStartElement("quote"); //$NON-NLS-1$ |
| break; |
| case SPAN: |
| writer.writeStartElement("phrase"); //$NON-NLS-1$ |
| break; |
| case SUBSCRIPT: |
| writer.writeStartElement("subscript"); //$NON-NLS-1$ |
| break; |
| case SUPERSCRIPT: |
| writer.writeStartElement("superscript"); //$NON-NLS-1$ |
| break; |
| case MONOSPACE: |
| writer.writeStartElement("literal"); //$NON-NLS-1$ |
| break; |
| case LINK: { |
| LinkAttributes linkAttributes = (LinkAttributes) attributes; |
| String href = linkAttributes.getHref(); |
| if (href.startsWith("#")) { //$NON-NLS-1$ |
| writer.writeStartElement("link"); //$NON-NLS-1$ |
| if (href.length() > 1) { |
| writer.writeAttribute("linkend", href.substring(1)); //$NON-NLS-1$ |
| } |
| } else { |
| writer.writeStartElement("ulink"); //$NON-NLS-1$ |
| writer.writeAttribute("url", href); //$NON-NLS-1$ |
| } |
| } |
| break; |
| default: |
| Logger.getLogger(DocBookDocumentBuilder.class.getName()).warning("No docbook mapping for " + type); //$NON-NLS-1$ |
| writer.writeStartElement("phrase"); //$NON-NLS-1$ |
| break; |
| } |
| applyAttributes(attributes); |
| } |
| |
| private void applyAttributes(Attributes attributes) { |
| if (attributes.getId() != null) { |
| writer.writeAttribute("id", attributes.getId()); //$NON-NLS-1$ |
| } |
| if (attributes.getLanguage() != null) { |
| writer.writeAttribute("language", attributes.getLanguage()); //$NON-NLS-1$ |
| } |
| } |
| |
| @Override |
| public void endDocument() { |
| closeSections(0); |
| |
| writeGlossaryAppendix(); |
| |
| // writer.writeEndElement(); // book |
| writer.writeEndDocument(); |
| |
| acronyms.clear(); |
| } |
| |
| private void closeSections(int toLevel) { |
| if (toLevel < 0) { |
| toLevel = 0; |
| } |
| while (headingLevel > toLevel) { |
| writer.writeEndElement(); |
| --headingLevel; |
| headingDescriptions.pop(); |
| } |
| } |
| |
| private void writeGlossaryAppendix() { |
| if (!acronyms.isEmpty() && automaticGlossary) { |
| writer.writeStartElement("appendix"); //$NON-NLS-1$ |
| writer.writeAttribute("id", "glossary"); //$NON-NLS-1$ //$NON-NLS-2$ |
| writer.writeStartElement("title"); //$NON-NLS-1$ |
| writer.writeAttribute("id", "glossary-end"); //$NON-NLS-1$ //$NON-NLS-2$ |
| writer.writeCharacters("Glossary"); //$NON-NLS-1$ |
| writer.writeEndElement(); // title |
| writer.writeStartElement("glosslist"); //$NON-NLS-1$ |
| |
| for (Map.Entry<String, String> glossEntry : new TreeMap<String, String>(acronyms).entrySet()) { |
| |
| writer.writeStartElement("glossentry"); //$NON-NLS-1$ |
| |
| writer.writeStartElement("glossterm"); //$NON-NLS-1$ |
| writer.writeCharacters(glossEntry.getKey()); |
| writer.writeEndElement(); // glossterm |
| |
| writer.writeStartElement("glossdef"); //$NON-NLS-1$ |
| writer.writeStartElement("para"); //$NON-NLS-1$ |
| writer.writeCharacters(glossEntry.getValue()); |
| writer.writeEndElement(); // para |
| writer.writeEndElement(); // glossdef |
| |
| writer.writeEndElement(); // glossentry |
| } |
| writer.writeEndElement(); // glosslist |
| writer.writeEndElement(); // appendix |
| } |
| } |
| |
| @Override |
| public void endSpan() { |
| writer.writeEndElement(); |
| } |
| |
| @Override |
| public void characters(String text) { |
| ensureBlockElementsOpen(); |
| super.characters(text); |
| } |
| |
| @Override |
| public void charactersUnescaped(String literal) { |
| ensureBlockElementsOpen(); |
| // note: this *may* have HTML tags in it |
| writer.writeLiteral(literal); |
| // Logger.getLogger(DocBookDocumentBuilder.class.getName()).warning("HTML literal not supported in DocBook"); |
| } |
| |
| private void ensureBlockElementsOpen() { |
| if (!blockDescriptions.isEmpty()) { |
| BlockDescription blockDescription = blockDescriptions.peek(); |
| if (blockDescription.entrySize == 0 && blockDescription.nestedElementNames != null) { |
| openBlockEntry(blockDescription, blockDescription.nestedElementNames); |
| } |
| } |
| } |
| |
| @Override |
| public void entityReference(String entity) { |
| ensureBlockElementsOpen(); |
| if (entity.startsWith("#")) { //$NON-NLS-1$ |
| String numeric = entity.substring(1); |
| int base = 10; |
| if (numeric.startsWith("x")) { //$NON-NLS-1$ |
| numeric = entity.substring(1); |
| base = 16; |
| } |
| int unicodeValue = Integer.parseInt(numeric, base); |
| if (entityReferenceToUnicode.contains(unicodeValue)) { |
| writer.writeCharacters("" + ((char) unicodeValue)); //$NON-NLS-1$ |
| return; |
| } |
| } |
| writer.writeEntityRef(entity); |
| } |
| |
| @Override |
| public void image(Attributes attributes, String url) { |
| ensureBlockElementsOpen(); |
| String cssClass = attributes.getCssClass(); |
| boolean inlined = false; |
| if (cssClass != null && CSS_CLASS_INLINE.matcher(cssClass).find()) { |
| inlined = true; |
| } |
| emitImage(attributes, url, inlined); |
| } |
| |
| private void emitImage(Attributes attributes, String url, boolean inline) { |
| // see http://www.docbook.org/tdg/en/html/imagedata-x.html |
| ensureBlockElementsOpen(); |
| writer.writeStartElement(inline ? "inlinemediaobject" : "mediaobject"); //$NON-NLS-1$ //$NON-NLS-2$ |
| applyAttributes(attributes); |
| writer.writeStartElement("imageobject"); //$NON-NLS-1$ |
| writer.writeEmptyElement("imagedata"); //$NON-NLS-1$ |
| writer.writeAttribute("fileref", makeUrlAbsolute(url)); //$NON-NLS-1$ |
| String cssStyle = attributes.getCssStyle(); |
| if (cssStyle != null) { |
| String width = null; |
| String depth = null; |
| Iterator<CssRule> ruleIterator = new CssParser().createRuleIterator(cssStyle); |
| while (ruleIterator.hasNext()) { |
| CssRule rule = ruleIterator.next(); |
| if ("width".equals(rule.name)) { //$NON-NLS-1$ |
| width = rule.value; |
| } else if ("height".equals(rule.name)) { //$NON-NLS-1$ |
| depth = rule.value; |
| } |
| } |
| if (width != null) { |
| Matcher matcher = PERCENTAGE.matcher(width); |
| if (matcher.matches()) { |
| writer.writeAttribute("scale", matcher.group(1)); //$NON-NLS-1$ |
| } else { |
| writer.writeAttribute("width", width); //$NON-NLS-1$ |
| if (depth != null) { |
| writer.writeAttribute("depth", depth); //$NON-NLS-1$ |
| } |
| } |
| } |
| } |
| writer.writeEndElement(); // imageobject |
| writer.writeEndElement(); // inlinemediaobject or mediaobject |
| } |
| |
| @Override |
| public void imageLink(Attributes linkAttributes, final Attributes imageAttributes, String href, |
| final String imageUrl) { |
| link(linkAttributes, href, new ContentEmitter() { |
| public void emit() { |
| emitImage(imageAttributes, imageUrl, true); |
| } |
| }); |
| } |
| |
| @Override |
| public void lineBreak() { |
| ensureBlockElementsOpen(); |
| // no equivalent in DocBook. |
| characters("\n"); //$NON-NLS-1$ |
| } |
| |
| private BlockDescription findBlockDescription(BlockType type) { |
| for (int x = blockDescriptions.size() - 1; x >= 0; --x) { |
| BlockDescription blockDescription = blockDescriptions.get(x); |
| if (blockDescription.type == type) { |
| return blockDescription; |
| } |
| } |
| return null; |
| } |
| |
| private static class BlockDescription { |
| BlockType type; |
| |
| int size; |
| |
| int entrySize; // the size of an entry, if it is open, otherwise 0 |
| |
| final String[] nestedElementNames; |
| |
| final boolean closeElementsOnBlockStart; |
| |
| public BlockDescription(DocumentBuilder.BlockType type, int size, String[] nestedElementNames, boolean closeElementsOnBlockStart) { |
| this.size = size; |
| this.entrySize = nestedElementNames == null ? 0 : nestedElementNames.length; |
| this.type = type; |
| this.nestedElementNames = nestedElementNames; |
| this.closeElementsOnBlockStart = closeElementsOnBlockStart; |
| } |
| } |
| |
| private static class HeadingDescription { |
| |
| int level; |
| Attributes attributes; |
| |
| private HeadingDescription(int level, Attributes attributes) { |
| this.level = level; |
| this.attributes = attributes; |
| } |
| } |
| |
| /** |
| * Indicate if this builder should generate an automatic glossary if acronyms are used. When the automatic glossary |
| * is enabled and acronyms are used in the document, then an <code>appendix</code> with title 'Glossary' is added to |
| * the document, with a <code>glosslist</code> generated for all of the acronyms that appear in the document. The |
| * default is true. |
| */ |
| public boolean isAutomaticGlossary() { |
| return automaticGlossary; |
| } |
| |
| /** |
| * Indicate if this builder should generate an automatic glossary if acronyms are used. When the automatic glossary |
| * is enabled and acronyms are used in the document, then an <code>appendix</code> with title 'Glossary' is added to |
| * the document, with a <code>glosslist</code> generated for all of the acronyms that appear in the document. The |
| * default is true. |
| */ |
| public void setAutomaticGlossary(boolean automaticGlossary) { |
| this.automaticGlossary = automaticGlossary; |
| } |
| |
| } |
