Clover Coverage Report - XWiki Rendering - Parent POM 4.0-SNAPSHOT (Aggregated)
Coverage timestamp: Mon Mar 12 2012 18:03:13 CET
Overview   Package   File
    FRAMES   NO FRAMES     
../../../../../../img/srcFileCovDistChart10.png 0% of files have more coverage
204   874   115   2.72
70   588   0.56   75
75     1.53  
1    
 
  DefaultXWikiGeneratorListener       Line # 60 204 0% 115 23 93.4% 0.9340974
 
  (967)
 
1    /*
2    * See the NOTICE file distributed with this work for additional
3    * information regarding copyright ownership.
4    *
5    * This is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU Lesser General Public License as
7    * published by the Free Software Foundation; either version 2.1 of
8    * the License, or (at your option) any later version.
9    *
10    * This software is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13    * Lesser General Public License for more details.
14    *
15    * You should have received a copy of the GNU Lesser General Public
16    * License along with this software; if not, write to the Free
17    * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18    * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
19    */
20    package org.xwiki.rendering.internal.parser.wikimodel;
21   
22    import java.util.Collections;
23    import java.util.HashMap;
24    import java.util.HashSet;
25    import java.util.LinkedHashMap;
26    import java.util.List;
27    import java.util.Map;
28    import java.util.Set;
29    import java.util.Stack;
30   
31    import org.xwiki.rendering.wikimodel.IWemConstants;
32    import org.xwiki.rendering.wikimodel.WikiFormat;
33    import org.xwiki.rendering.wikimodel.WikiParameter;
34    import org.xwiki.rendering.wikimodel.WikiParameters;
35    import org.xwiki.rendering.wikimodel.WikiReference;
36    import org.xwiki.rendering.wikimodel.WikiStyle;
37    import org.xwiki.rendering.listener.CompositeListener;
38    import org.xwiki.rendering.listener.Format;
39    import org.xwiki.rendering.listener.HeaderLevel;
40    import org.xwiki.rendering.listener.MetaData;
41    import org.xwiki.rendering.listener.reference.ResourceReference;
42    import org.xwiki.rendering.listener.ListType;
43    import org.xwiki.rendering.listener.Listener;
44    import org.xwiki.rendering.listener.QueueListener;
45    import org.xwiki.rendering.parser.ResourceReferenceParser;
46    import org.xwiki.rendering.parser.ParseException;
47    import org.xwiki.rendering.parser.StreamParser;
48    import org.xwiki.rendering.renderer.PrintRenderer;
49    import org.xwiki.rendering.renderer.PrintRendererFactory;
50    import org.xwiki.rendering.renderer.printer.DefaultWikiPrinter;
51    import org.xwiki.rendering.syntax.Syntax;
52    import org.xwiki.rendering.util.IdGenerator;
53   
54    /**
55    * Transforms WikiModel events into XWiki Rendering events.
56    *
57    * @version $Id: 80958b15a84a776a583cdc7f8ec726235203be36 $
58    * @since 2.1RC1
59    */
 
60    public class DefaultXWikiGeneratorListener implements XWikiGeneratorListener
61    {
62    /**
63    * Identifier of the extension used to generate id blocks.
64    */
65    public static final String EXT_ID = "xwiki_id";
66   
67    private static final Map<WikiStyle, Format> STYLES_CONVERTER = new HashMap<WikiStyle, Format>();
68   
 
69  12 toggle static {
70  12 STYLES_CONVERTER.put(IWemConstants.CODE, Format.MONOSPACE);
71  12 STYLES_CONVERTER.put(IWemConstants.EM, Format.ITALIC);
72  12 STYLES_CONVERTER.put(IWemConstants.DEL, Format.STRIKEDOUT);
73  12 STYLES_CONVERTER.put(IWemConstants.INS, Format.UNDERLINED);
74  12 STYLES_CONVERTER.put(IWemConstants.MONO, Format.MONOSPACE);
75  12 STYLES_CONVERTER.put(IWemConstants.STRIKE, Format.STRIKEDOUT);
76  12 STYLES_CONVERTER.put(IWemConstants.STRONG, Format.BOLD);
77  12 STYLES_CONVERTER.put(IWemConstants.SUB, Format.SUBSCRIPT);
78  12 STYLES_CONVERTER.put(IWemConstants.SUP, Format.SUPERSCRIPT);
79  12 STYLES_CONVERTER.put(IWemConstants.TT, Format.MONOSPACE);
80   
81    // TODO: what is the best conversion for theses ?
82  12 STYLES_CONVERTER.put(IWemConstants.BIG, Format.NONE);
83  12 STYLES_CONVERTER.put(IWemConstants.CITE, Format.NONE);
84  12 STYLES_CONVERTER.put(IWemConstants.REF, Format.NONE);
85  12 STYLES_CONVERTER.put(IWemConstants.SMALL, Format.NONE);
86    }
87   
88    /**
89    * Listener(s) for the generated XWiki Events. Organized as a stack so that a buffering listener can hijack all
90    * events for a while, for example. All generated events are sent to the top of the stack.
91    */
92    private Stack<Listener> listener = new Stack<Listener>();
93   
94    private StreamParser parser;
95   
96    private ResourceReferenceParser linkReferenceParser;
97   
98    private ResourceReferenceParser imageReferenceParser;
99   
100    private IdGenerator idGenerator;
101   
102    private PrintRendererFactory plainRendererFactory;
103   
104    private int documentDepth = 0;
105   
106    private Stack<WikiFormat> currentFormatStack = new Stack<WikiFormat>();
107   
108    private WikiFormat lastEndFormat = null;
109   
110    private Syntax syntax;
111   
112    private MetaData documentMetadata;
113   
114    /**
115    * @see <a href="http://code.google.com/p/wikimodel/issues/detail?id=87">wikimodel issue 87</a>
116    * @since 3.0M3
117    */
 
118  1180 toggle public DefaultXWikiGeneratorListener(StreamParser parser, Listener listener,
119    ResourceReferenceParser linkReferenceParser, ResourceReferenceParser imageReferenceParser,
120    PrintRendererFactory plainRendererFactory, IdGenerator idGenerator, Syntax syntax)
121    {
122  1180 pushListener(listener);
123   
124  1180 this.parser = parser;
125  1180 this.linkReferenceParser = linkReferenceParser;
126  1180 this.imageReferenceParser = imageReferenceParser;
127  1180 this.idGenerator = idGenerator != null ? idGenerator : new IdGenerator();
128  1180 this.plainRendererFactory = plainRendererFactory;
129  1180 this.syntax = syntax;
130  1180 this.documentMetadata = new MetaData();
131  1180 this.documentMetadata.addMetaData(MetaData.SYNTAX, this.syntax);
132    }
133   
134    /**
135    * Returns the 'default' listener to send xwiki events to, the top of the listeners stack.
136    *
137    * @return the listener to send xwiki events to
138    */
 
139  17159 toggle public Listener getListener()
140    {
141  17159 return this.listener.peek();
142    }
143   
144    /**
145    * @since 2.5RC1
146    */
 
147  454 toggle protected ResourceReferenceParser getLinkReferenceParser()
148    {
149  454 return this.linkReferenceParser;
150    }
151   
152    /**
153    * @since 2.5RC1
154    */
 
155  190 toggle protected ResourceReferenceParser getImageReferenceParser()
156    {
157  190 return this.imageReferenceParser;
158    }
159   
160    /**
161    * Pushes a new listener in the listeners stack, thus making it the 'default' listener, to which all events are
162    * sent.
163    *
164    * @param listener the listener to add in the top of the stack
165    * @return the listener pushed in the top of the stack
166    */
 
167  1401 toggle private Listener pushListener(Listener listener)
168    {
169  1401 return this.listener.push(listener);
170    }
171   
172    /**
173    * Removes the listener from the top of the stack (the current 'default' listener).
174    *
175    * @return the removed listener
176    */
 
177  221 toggle private Listener popListener()
178    {
179  221 return this.listener.pop();
180    }
181   
182    /**
183    * Convert Wikimodel parameters to XWiki parameters format.
184    *
185    * @param params the wikimodel parameters to convert
186    * @return the parameters in XWiki format
187    */
 
188  4918 toggle protected Map<String, String> convertParameters(WikiParameters params)
189    {
190  4918 Map<String, String> xwikiParams;
191   
192  4918 if (params.getSize() > 0) {
193  640 xwikiParams = new LinkedHashMap<String, String>();
194  640 for (WikiParameter wikiParameter : params.toList()) {
195  775 xwikiParams.put(wikiParameter.getKey(), wikiParameter.getValue());
196    }
197    } else {
198  4278 xwikiParams = Listener.EMPTY_PARAMETERS;
199    }
200   
201  4918 return xwikiParams;
202    }
203   
 
204  422 toggle private Format convertFormat(WikiStyle style)
205    {
206  422 Format result = STYLES_CONVERTER.get(style);
207   
208  422 if (result == null) {
209  0 result = Format.NONE;
210    }
211   
212  422 return result;
213    }
214   
 
215  1264 toggle private void flush()
216    {
217  1264 flushInline();
218    }
219   
 
220  2483 toggle private void flushInline()
221    {
222  2483 flushFormat();
223    }
224   
 
225  10848 toggle protected void flushFormat()
226    {
227  10848 flushFormat(null, null);
228    }
229   
 
230  11138 toggle private void flushFormat(List<WikiStyle> xorStyles, List<WikiParameter> xorParameters)
231    {
232  11138 if (this.lastEndFormat != null) {
233  290 flushFormat(this.lastEndFormat.getStyles(), this.lastEndFormat.getParams(), xorStyles, xorParameters);
234    }
235    }
236   
 
237  290 toggle private void flushFormat(List<WikiStyle> formatStyles, List<WikiParameter> formatParameters,
238    List<WikiStyle> xorStyles, List<WikiParameter> xorParameters)
239    {
240  290 Set<WikiStyle> stylesToClose = new HashSet<WikiStyle>();
241  290 Set<WikiParameter> parametersToClose = new HashSet<WikiParameter>();
242   
243  290 if (xorStyles != null) {
244  42 for (WikiStyle style : formatStyles) {
245  26 if (!xorStyles.contains(style)) {
246  4 stylesToClose.add(style);
247    }
248    }
249    } else {
250  248 stylesToClose.addAll(formatStyles);
251    }
252   
253  290 if (xorParameters != null) {
254  42 for (WikiParameter parameter : formatParameters) {
255  32 if (!xorParameters.contains(parameter)) {
256  24 parametersToClose.add(parameter);
257    }
258    }
259    } else {
260  248 parametersToClose.addAll(formatParameters);
261    }
262   
263  576 for (; !stylesToClose.isEmpty() || !parametersToClose.isEmpty(); this.currentFormatStack.pop()) {
264  286 WikiFormat currentFormat = this.currentFormatStack.peek();
265   
266  286 List<WikiStyle> currentFormatStyles = currentFormat.getStyles();
267  286 WikiStyle currentFormatStyle = currentFormatStyles.isEmpty() ? null : currentFormatStyles.get(0);
268  286 List<WikiParameter> currentFormatParameters = currentFormat.getParams();
269   
270    // XOR
271  286 stylesToClose.remove(currentFormatStyle);
272  286 parametersToClose.removeAll(currentFormatParameters);
273   
274    // send event
275  286 Map<String, String> parameters;
276  286 if (!currentFormatParameters.isEmpty()) {
277  107 parameters = convertParameters(new WikiParameters(currentFormatParameters));
278    } else {
279  179 parameters = Listener.EMPTY_PARAMETERS;
280    }
281   
282  286 if (currentFormatStyle != null) {
283  211 getListener().endFormat(convertFormat(currentFormatStyle), parameters);
284    } else {
285  75 getListener().endFormat(Format.NONE, parameters);
286    }
287    }
288   
289  290 for (WikiFormat format : this.currentFormatStack) {
290  18 if (xorStyles != null) {
291  18 xorStyles.removeAll(format.getStyles());
292    }
293  18 if (xorParameters != null) {
294  18 xorParameters.removeAll(format.getParams());
295    }
296    }
297   
298  290 this.lastEndFormat = null;
299    }
300   
 
301  78 toggle @Override
302    public void beginDefinitionDescription()
303    {
304  78 getListener().beginDefinitionDescription();
305    }
306   
 
307  85 toggle @Override
308    public void beginDefinitionList(WikiParameters params)
309    {
310  85 flushInline();
311   
312  85 getListener().beginDefinitionList(convertParameters(params));
313    }
314   
 
315  62 toggle @Override
316    public void beginDefinitionTerm()
317    {
318  62 getListener().beginDefinitionTerm();
319    }
320   
 
321  1264 toggle @Override
322    public void beginDocument(WikiParameters params)
323    {
324  1264 if (this.documentDepth > 0) {
325  84 getListener().beginGroup(convertParameters(params));
326    } else {
327  1180 getListener().beginDocument(this.documentMetadata);
328    }
329   
330  1264 ++this.documentDepth;
331    }
332   
333    /**
334    * A format is a special formatting around an inline element, such as bold, italics, etc.
335    */
 
336  2188 toggle public void beginFormat(WikiFormat format)
337    {
338  2188 List<WikiStyle> formatStyles = format.getStyles();
339  2188 List<WikiParameter> formatParameters = format.getParams();
340   
341    // If there's any style or parameter defined, do something. The reason we need to check for this is because
342    // wikimodel sends an empty begin/endFormat event before starting an inline block (such as a paragraph).
343  2188 if (formatStyles.size() > 0 || formatParameters.size() > 0) {
344  290 flushFormat(formatStyles, formatParameters);
345   
346    // If everything is already part of the current style
347  290 if (formatStyles.size() > 0 || formatParameters.size() > 0) {
348  286 Map<String, String> parameters;
349  286 if (formatParameters.size() > 0) {
350  107 parameters = convertParameters(new WikiParameters(formatParameters));
351    } else {
352  179 parameters = Listener.EMPTY_PARAMETERS;
353    }
354   
355  286 if (formatStyles.size() > 0) {
356  211 boolean parametersConsumed = false;
357  211 for (WikiStyle style : formatStyles) {
358    // Exclude previous format styles
359  211 if (!parametersConsumed) {
360  211 getListener().beginFormat(convertFormat(style), parameters);
361  211 parametersConsumed = true;
362  211 this.currentFormatStack
363    .push(new WikiFormat(Collections.singleton(style), formatParameters));
364    } else {
365  0 getListener().beginFormat(convertFormat(style), Listener.EMPTY_PARAMETERS);
366  0 this.currentFormatStack.push(new WikiFormat(style));
367    }
368    }
369    } else {
370  75 getListener().beginFormat(Format.NONE, parameters);
371  75 this.currentFormatStack.push(new WikiFormat(formatParameters));
372    }
373    }
374    }
375    }
376   
 
377  1515 toggle @Override
378    public void beginSection(int docLevel, int headerLevel, WikiParameters params)
379    {
380  1515 if (headerLevel > 0) {
381  251 getListener().beginSection(Listener.EMPTY_PARAMETERS);
382    }
383    }
384   
 
385  1515 toggle @Override
386    public void beginSectionContent(int docLevel, int headerLevel, WikiParameters params)
387    {
388    // TODO add support for it
389    }
390   
 
391  221 toggle @Override
392    public void beginHeader(int level, WikiParameters params)
393    {
394    // Heading needs to have an id generated from a plaintext representation of its content, so the header start
395    // event will be sent at the end of the header, after reading the content inside and generating the id.
396    // For this:
397    // buffer all events in a queue until the header ends, and also send them to a print renderer to generate the ID
398  221 CompositeListener composite = new CompositeListener();
399  221 composite.addListener(new QueueListener());
400  221 composite.addListener(this.plainRendererFactory.createRenderer(new DefaultWikiPrinter()));
401   
402    // These 2 listeners will receive all events from now on until the header ends
403  221 pushListener(composite);
404    }
405   
 
406  0 toggle @Override
407    public void beginInfoBlock(String infoType, WikiParameters params)
408    {
409    // Not used by XWiki Syntax 2.0
410    }
411   
 
412  194 toggle @Override
413    public void beginList(WikiParameters params, boolean ordered)
414    {
415  194 flushInline();
416   
417  194 if (ordered) {
418  34 getListener().beginList(ListType.NUMBERED, convertParameters(params));
419    } else {
420  160 getListener().beginList(ListType.BULLETED, convertParameters(params));
421    }
422    }
423   
 
424  254 toggle @Override
425    public void beginListItem()
426    {
427  254 getListener().beginListItem();
428    }
429   
 
430  1029 toggle @Override
431    public void beginParagraph(WikiParameters params)
432    {
433  1029 getListener().beginParagraph(convertParameters(params));
434    }
435   
 
436  0 toggle @Override
437    public void beginPropertyBlock(String propertyUri, boolean doc)
438    {
439    // Not used by XWiki Syntax 2.0
440    }
441   
 
442  0 toggle @Override
443    public void beginPropertyInline(String str)
444    {
445    // Not used by XWiki Syntax 2.0
446    }
447   
 
448  34 toggle @Override
449    public void beginQuotation(WikiParameters params)
450    {
451  34 getListener().beginQuotation(convertParameters(params));
452    }
453   
 
454  57 toggle @Override
455    public void beginQuotationLine()
456    {
457  57 getListener().beginQuotationLine();
458    }
459   
 
460  67 toggle @Override
461    public void beginTable(WikiParameters params)
462    {
463  67 getListener().beginTable(convertParameters(params));
464    }
465   
 
466  268 toggle @Override
467    public void beginTableCell(boolean tableHead, WikiParameters params)
468    {
469  268 if (tableHead) {
470  101 getListener().beginTableHeadCell(convertParameters(params));
471    } else {
472  167 getListener().beginTableCell(convertParameters(params));
473    }
474    }
475   
 
476  127 toggle @Override
477    public void beginTableRow(WikiParameters params)
478    {
479  127 getListener().beginTableRow(convertParameters(params));
480    }
481   
 
482  78 toggle @Override
483    public void endDefinitionDescription()
484    {
485  78 flushInline();
486   
487  78 getListener().endDefinitionDescription();
488    }
489   
 
490  85 toggle @Override
491    public void endDefinitionList(WikiParameters params)
492    {
493  85 getListener().endDefinitionList(convertParameters(params));
494    }
495   
 
496  62 toggle @Override
497    public void endDefinitionTerm()
498    {
499  62 flushInline();
500   
501  62 getListener().endDefinitionTerm();
502    }
503   
 
504  1264 toggle @Override
505    public void endDocument(WikiParameters params)
506    {
507  1264 flush();
508   
509  1264 --this.documentDepth;
510   
511  1264 if (this.documentDepth > 0) {
512  84 getListener().endGroup(convertParameters(params));
513    } else {
514  1180 getListener().endDocument(this.documentMetadata);
515    }
516    }
517   
 
518  2188 toggle @Override
519    public void endFormat(WikiFormat format)
520    {
521    // If there's any style or parameter defined, do something. The reason we need to check for this is because
522    // wikimodel sends an empty begin/endFormat event before starting an inline block (such as a paragraph).
523  2188 if (format.getStyles().size() > 0 || format.getParams().size() > 0) {
524  290 this.lastEndFormat = format;
525    }
526    }
527   
 
528  221 toggle @Override
529    public void endHeader(int level, WikiParameters params)
530    {
531    // End all formats
532  221 flushInline();
533   
534  221 CompositeListener composite = (CompositeListener) getListener();
535   
536    // Get the listener where events inside the header were buffered
537  221 QueueListener queue = (QueueListener) composite.getListener(0);
538    // and the listener in which the id was generated
539  221 PrintRenderer renderer = (PrintRenderer) composite.getListener(1);
540   
541    // Restore the 'default' listener as it was at the beginning of the header
542  221 popListener();
543   
544  221 HeaderLevel headerLevel = HeaderLevel.parseInt(level);
545    // Generate the id from the content inside the header written to the renderer
546  221 String id = this.idGenerator.generateUniqueId("H", renderer.getPrinter().toString());
547  221 Map<String, String> parameters = convertParameters(params);
548   
549    // Generate the begin header event to the 'default' listener
550  221 getListener().beginHeader(headerLevel, id, parameters);
551    // Send all buffered events to the 'default' listener
552  221 queue.consumeEvents(getListener());
553    // Generate the end header event to the 'default' listener
554  221 getListener().endHeader(headerLevel, id, parameters);
555    }
556   
 
557  1515 toggle @Override
558    public void endSection(int docLevel, int headerLevel, WikiParameters params)
559    {
560  1515 if (headerLevel > 0) {
561  251 getListener().endSection(Listener.EMPTY_PARAMETERS);
562    }
563    }
564   
 
565  1515 toggle @Override
566    public void endSectionContent(int docLevel, int headerLevel, WikiParameters params)
567    {
568    // TODO add support for it
569    }
570   
 
571  0 toggle @Override
572    public void endInfoBlock(String infoType, WikiParameters params)
573    {
574    // Not used by XWiki Syntax 2.0
575    }
576   
 
577  194 toggle @Override
578    public void endList(WikiParameters params, boolean ordered)
579    {
580  194 if (ordered) {
581  34 getListener().endList(ListType.NUMBERED, convertParameters(params));
582    } else {
583  160 getListener().endList(ListType.BULLETED, convertParameters(params));
584    }
585    }
586   
 
587  254 toggle @Override
588    public void endListItem()
589    {
590  254 flushInline();
591   
592    // Note: This means we support Paragraphs inside lists.
593  254 getListener().endListItem();
594    }
595   
 
596  1029 toggle @Override
597    public void endParagraph(WikiParameters params)
598    {
599  1029 flushFormat();
600   
601  1029 getListener().endParagraph(convertParameters(params));
602    }
603   
 
604  0 toggle @Override
605    public void endPropertyBlock(String propertyUri, boolean doc)
606    {
607    // Not used by XWiki Syntax 2.0
608    }
609   
 
610  0 toggle @Override
611    public void endPropertyInline(String inlineProperty)
612    {
613    // Not used by XWiki Syntax 2.0
614    }
615   
 
616  34 toggle @Override
617    public void endQuotation(WikiParameters params)
618    {
619  34 getListener().endQuotation(convertParameters(params));
620    }
621   
 
622  57 toggle @Override
623    public void endQuotationLine()
624    {
625  57 flushInline();
626   
627  57 getListener().endQuotationLine();
628    }
629   
 
630  67 toggle @Override
631    public void endTable(WikiParameters params)
632    {
633  67 getListener().endTable(convertParameters(params));
634    }
635   
 
636  268 toggle @Override
637    public void endTableCell(boolean tableHead, WikiParameters params)
638    {
639  268 flushInline();
640   
641  268 if (tableHead) {
642  101 getListener().endTableHeadCell(convertParameters(params));
643    } else {
644  167 getListener().endTableCell(convertParameters(params));
645    }
646    }
647   
 
648  127 toggle @Override
649    public void endTableRow(WikiParameters params)
650    {
651  127 getListener().endTableRow(convertParameters(params));
652    }
653   
654    /**
655    * Called by wikimodel when there are 2 or more empty lines between blocks. For example the following will generate
656    * a call to <code>onEmptyLines(2)</code>:
657    * <p>
658    * <code><pre>
659    * {{macro/}}
660    * ... empty line 1...
661    * ... empty line 2...
662    * {{macro/}}
663    * </pre></code>
664    *
665    * @param count the number of empty lines separating the two blocks
666    */
 
667  32 toggle public void onEmptyLines(int count)
668    {
669  32 getListener().onEmptyLines(count);
670    }
671   
 
672  0 toggle @Override
673    public void onEscape(String str)
674    {
675    // The WikiModel XWiki parser has been modified not to generate any onEscape event so do nothing here.
676    // This is because we believe that WikiModel should not have an escape event since it's the
677    // responsibility of Renderers to perform escaping as required.
678    }
679   
 
680  6 toggle @Override
681    public void onExtensionBlock(String extensionName, WikiParameters params)
682    {
683  6 if (EXT_ID.equals(extensionName)) {
684  6 getListener().onId(params.getParameter("name").getValue());
685    }
686    }
687   
 
688  0 toggle @Override
689    public void onExtensionInline(String extensionName, WikiParameters params)
690    {
691  0 if (EXT_ID.equals(extensionName)) {
692  0 getListener().onId(params.getParameter("name").getValue());
693    }
694    }
695   
 
696  46 toggle @Override
697    public void onHorizontalLine(WikiParameters params)
698    {
699  46 getListener().onHorizontalLine(convertParameters(params));
700    }
701   
 
702  46 toggle @Override
703    public void onLineBreak()
704    {
705    // Note that in XWiki we don't differentiate new lines and line breaks since it's the Renderers that decide
706    // to generate new lines or line breaks depending on the context and the target syntax.
707  46 onNewLine();
708    }
709   
710    /**
711    * A macro block was found and it's separated at least by one new line from the next block. If there's no new line
712    * with the next block then wikimodel calls {@link #onMacroInline(String, org.xwiki.rendering.wikimodel.WikiParameters, String)}
713    * instead.
714    * <p>
715    * In wikimodel block elements can be:
716    * <ul>
717    * <li>at the very beginning of the document (no "\n")</li>
718    * <li>just after at least one "\n"</li>
719    * </ul>
720    */
 
721  209 toggle public void onMacroBlock(String macroName, WikiParameters params, String content)
722    {
723  209 getListener().onMacro(macroName, convertParameters(params), content, false);
724    }
725   
 
726  93 toggle @Override
727    public void onMacroInline(String macroName, WikiParameters params, String content)
728    {
729  93 flushFormat();
730   
731  93 getListener().onMacro(macroName, convertParameters(params), content, true);
732    }
733   
 
734  336 toggle @Override
735    public void onNewLine()
736    {
737  336 flushFormat();
738   
739    // Note that in XWiki we don't differentiate new lines and line breaks since it's the Renderers that decide
740    // to generate new lines or line breaks depending on the context and the target syntax.
741  336 getListener().onNewLine();
742    }
743   
744    /**
745    * {@inheritDoc}
746    * <p>
747    * Called when WikiModel finds an reference (link or image) such as a URI located directly in the text
748    * (free-standing URI), as opposed to a link/image inside wiki link/image syntax delimiters.
749    * </p>
750    *
751    * @see org.xwiki.rendering.wikimodel.IWemListener#onLineBreak()
752    */
 
753  36 toggle @Override
754    public void onReference(String reference)
755    {
756  36 onReference(reference, null, true, Listener.EMPTY_PARAMETERS);
757    }
758   
 
759  191 toggle @Override
760    public void onReference(WikiReference reference)
761    {
762  191 onReference(reference.getLink(), reference.getLabel(), false, convertParameters(reference.getParameters()));
763    }
764   
 
765  227 toggle protected void onReference(String reference, String label, boolean isFreeStandingURI, Map<String, String> parameters)
766    {
767  227 flushFormat();
768   
769    // If there's no resource reference parser defined, don't handle links...
770  227 if (getLinkReferenceParser() != null) {
771  227 onReference(getLinkReferenceParser().parse(reference), label, isFreeStandingURI, parameters);
772    }
773    }
774   
 
775  279 toggle protected void onReference(ResourceReference reference, String label, boolean isFreeStandingURI,
776    Map<String, String> parameters)
777    {
778    // Since WikiModel doesn't handle syntax in link labels and thus doesn't have begin/end events for links, we
779    // need to call the XWiki events and use an inline parser to parse the syntax in the label.
780  279 getListener().beginLink(reference, isFreeStandingURI, parameters);
781  279 if (label != null) {
782  119 try {
783    // TODO: Use an inline parser. See http://jira.xwiki.org/jira/browse/XWIKI-2748
784  119 WikiModelParserUtils parserUtils = new WikiModelParserUtils();
785  119 parserUtils.parseInline(this.parser, label, getListener());
786    } catch (ParseException e) {
787    // TODO what should we do here ?
788    }
789    }
790  279 getListener().endLink(reference, isFreeStandingURI, parameters);
791    }
792   
 
793  53 toggle @Override
794    public void onImage(String reference)
795    {
796  53 onImage(reference, true, Listener.EMPTY_PARAMETERS);
797    }
798   
 
799  42 toggle @Override
800    public void onImage(WikiReference reference)
801    {
802  42 onImage(reference.getLink(), false, convertParameters(reference.getParameters()));
803    }
804   
805    /**
806    * @since 2.5RC1
807    */
 
808  95 toggle protected void onImage(String reference, boolean isFreeStandingURI, Map<String, String> parameters)
809    {
810  95 flushFormat();
811   
812    // If there's no resource reference parser defined, don't handle images...
813  95 if (getImageReferenceParser() != null) {
814  95 onImage(getImageReferenceParser().parse(reference), isFreeStandingURI, parameters);
815    }
816    }
817   
818    /**
819    * @since 2.5RC1
820    */
 
821  110 toggle protected void onImage(ResourceReference reference, boolean isFreeStandingURI, Map<String, String> parameters)
822    {
823  110 getListener().onImage(reference, isFreeStandingURI, parameters);
824    }
825   
 
826  1923 toggle @Override
827    public void onSpace(String spaces)
828    {
829  1923 flushFormat();
830   
831    // We want one space event per space.
832  3886 for (int i = 0; i < spaces.length(); i++) {
833  1963 getListener().onSpace();
834    }
835    }
836   
 
837  951 toggle @Override
838    public void onSpecialSymbol(String symbol)
839    {
840  951 flushFormat();
841   
842  1908 for (int i = 0; i < symbol.length(); i++) {
843  957 getListener().onSpecialSymbol(symbol.charAt(i));
844    }
845    }
846   
 
847  0 toggle @Override
848    public void onTableCaption(String str)
849    {
850    // Not used by XWiki Syntax 2.0
851    }
852   
 
853  31 toggle @Override
854    public void onVerbatimBlock(String protectedString, WikiParameters params)
855    {
856  31 getListener().onVerbatim(protectedString, false, convertParameters(params));
857    }
858   
 
859  28 toggle @Override
860    public void onVerbatimInline(String protectedString, WikiParameters params)
861    {
862  28 flushFormat();
863   
864  28 getListener().onVerbatim(protectedString, true, convertParameters(params));
865    }
866   
 
867  3623 toggle @Override
868    public void onWord(String str)
869    {
870  3623 flushFormat();
871   
872  3623 getListener().onWord(str);
873    }
874    }
 
CloverReport generated by Clover Code Coverage v3.1.4
Mon Mar 12 2012 18:03:37 CET.		   Clover: Open Source License registered to XWiki.