Coverage Report

Coverage Report - org.apache.maven.doxia.module.confluence.ConfluenceSink

Classes in this File

Line Coverage

Branch Coverage

Complexity

ConfluenceSink

79%

213/269

56%

18/32

1,155

 package org.apache.maven.doxia.module.confluence;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.
  */
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.io.Writer;
 import java.util.Stack;
 
 import javax.swing.text.html.HTML.Attribute;
 
 import org.apache.maven.doxia.sink.AbstractTextSink;
 import org.apache.maven.doxia.sink.SinkEventAttributes;
 import org.apache.maven.doxia.util.HtmlTools;
 import org.codehaus.plexus.util.StringUtils;
 
 /**
  * Confluence Sink implementation.
  * <br/>
  * <b>Note</b>: The encoding used is UTF-8.
  *
  * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
  * @version $Id: ConfluenceSink.java 1091053 2011-04-11 12:55:07Z ltheussl $
  * @since 1.0
  */
 public class ConfluenceSink
     extends AbstractTextSink
     implements ConfluenceMarkup
 {
     /**  The writer to use. */
     private final PrintWriter out;
 
     /**  The writer to use. */
     private StringWriter writer;
 
     /** An indication on if we're in head mode. */
     private boolean headFlag;
 
     private int levelList = 0;
 
     /**  listStyles. */
     private final Stack<String> listStyles;
 
     /** An indication on if we're in verbatim box mode. */
     private boolean verbatimBoxedFlag;
 
     /** An indication on if we're in table header mode. */
     private boolean tableHeaderFlag;
 
     /** The link name. */
     private String linkName;
 
     /**
      * Constructor, initialize the Writer and the variables.
      *
      * @param writer not null writer to write the result. <b>Should</b> be an UTF-8 Writer.
      * You could use <code>newWriter</code> methods from {@link org.codehaus.plexus.util.WriterFactory}.
      */
     protected ConfluenceSink( Writer writer )
     {
         this.out = new PrintWriter( writer );
         this.listStyles = new Stack<String>();
 
         init();
     }
 
     /** {@inheritDoc} */
     public void anchor( String name )
     {
         write( ANCHOR_START_MARKUP + name + ANCHOR_END_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void anchor( String name, SinkEventAttributes attributes )
     {
         anchor( name );
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void anchor_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void author()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void author( SinkEventAttributes attributes )
     {
         author();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void author_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void body()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void body( SinkEventAttributes attributes )
     {
         body();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void body_()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void bold()
     {
         write( BOLD_START_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void bold_()
     {
         write( BOLD_END_MARKUP );
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void comment( String comment )
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void close()
     {
         out.write( writer.toString() );
         out.close();
 
         init();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void date()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void date( SinkEventAttributes attributes )
     {
         date();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void date_()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void definedTerm()
     {
         write( " " );
     }
 
     /** {@inheritDoc} */
     public void definedTerm( SinkEventAttributes attributes )
     {
         definedTerm();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definedTerm_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definition()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definition( SinkEventAttributes attributes )
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definition_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definitionList()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definitionList( SinkEventAttributes attributes )
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definitionList_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definitionListItem()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definitionListItem( SinkEventAttributes attributes )
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void definitionListItem_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void figure()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void figure( SinkEventAttributes attributes )
     {
         figure();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void figure_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void figureCaption()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void figureCaption( SinkEventAttributes attributes )
     {
         figureCaption();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void figureCaption_()
     {
         // nop;
     }
 
     /** {@inheritDoc} */
     public void figureGraphics( String name )
     {
         writeEOL();
         write( FIGURE_START_MARKUP + name + FIGURE_END_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void figureGraphics( String src, SinkEventAttributes attributes )
     {
         figureGraphics( src );
         if ( attributes != null && attributes.getAttribute( Attribute.ALT.toString() ) != null )
         {
             write( attributes.getAttribute( Attribute.ALT.toString() ).toString() );
             writeEOL( true );
         }
     }
 
     /** {@inheritDoc} */
     public void flush()
     {
         close();
         writer.flush();
     }
 
     /** {@inheritDoc} */
     public void head()
     {
         init();
 
         headFlag = true;
     }
 
     /** {@inheritDoc} */
     public void head( SinkEventAttributes attributes )
     {
         head();
     }
 
     /** {@inheritDoc} */
     public void head_()
     {
         headFlag = false;
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void horizontalRule()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void horizontalRule( SinkEventAttributes attributes )
     {
         horizontalRule();
     }
 
     /** {@inheritDoc} */
     public void italic()
     {
         write( ITALIC_START_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void italic_()
     {
         write( ITALIC_END_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void lineBreak()
     {
         write( LINE_BREAK_MARKUP );
         writeEOL();
     }
 
     /** {@inheritDoc} */
     public void lineBreak( SinkEventAttributes attributes )
     {
         lineBreak();
     }
 
     /** {@inheritDoc} */
     public void link( String name )
     {
         linkName = name;
     }
 
     /** {@inheritDoc} */
     public void link( String name, SinkEventAttributes attributes )
     {
         link( name );
     }
 
     /** {@inheritDoc} */
     public void link_()
     {
         linkName = null;
         write( LINK_END_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void list()
     {
         if ( !writer.toString().endsWith( EOL + EOL ) )
         {
             writeEOL( true );
         }
 
         levelList++;
     }
 
     /** {@inheritDoc} */
     public void list( SinkEventAttributes attributes )
     {
         list();
     }
 
     /** {@inheritDoc} */
     public void list_()
     {
         levelList--;
     }
 
     /** {@inheritDoc} */
     public void listItem()
     {
         write( StringUtils.repeat( "*", levelList ) + " " );
     }
 
     /** {@inheritDoc} */
     public void listItem( SinkEventAttributes attributes )
     {
         listItem();
     }
 
     /** {@inheritDoc} */
     public void listItem_()
     {
         writeEOL( true );
     }
 
     /** {@inheritDoc} */
     public void monospaced()
     {
         write( MONOSPACED_START_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void monospaced_()
     {
         write( MONOSPACED_END_MARKUP );
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void nonBreakingSpace()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void numberedList( int numbering )
     {
         levelList++;
 
         String style;
         switch ( numbering )
         {
             case NUMBERING_UPPER_ALPHA:
             case NUMBERING_LOWER_ALPHA:
             case NUMBERING_UPPER_ROMAN:
             case NUMBERING_LOWER_ROMAN:
             case NUMBERING_DECIMAL:
             default:
                 style = NUMBERING_MARKUP;
         }
 
         listStyles.push( style );
     }
 
     /** {@inheritDoc} */
     public void numberedList( int numbering, SinkEventAttributes attributes )
     {
         numberedList( numbering );
     }
 
     /** {@inheritDoc} */
     public void numberedList_()
     {
         levelList--;
         listStyles.pop();
     }
 
     /** {@inheritDoc} */
     public void numberedListItem()
     {
         writeEOL( true );
         String style = listStyles.peek();
         write( style + SPACE );
     }
 
     /** {@inheritDoc} */
     public void numberedListItem( SinkEventAttributes attributes )
     {
         numberedListItem();
     }
 
     /** {@inheritDoc} */
     public void numberedListItem_()
     {
         writeEOL( true );
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void pageBreak()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void paragraph()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void paragraph( SinkEventAttributes attributes )
     {
         paragraph();
     }
 
     /** {@inheritDoc} */
     public void paragraph_()
     {
         writeEOL( true );
         writeEOL();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void rawText( String text )
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section( int level, SinkEventAttributes attributes )
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section1()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section1_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section2()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section2_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section3()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section3_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section4()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section4_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section5()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section5_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void section_( int level )
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void sectionTitle()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void sectionTitle( int level, SinkEventAttributes attributes )
     {
         if ( level > 0 && level < 6 )
         {
             write( "h" + level + ". " );
         }
     }
 
     /** {@inheritDoc} */
     public void sectionTitle1()
     {
         sectionTitle( 1, null );
     }
 
     /** {@inheritDoc} */
     public void sectionTitle1_()
     {
         sectionTitle_( 1 );
     }
 
     /** {@inheritDoc} */
     public void sectionTitle2()
     {
         sectionTitle( 2, null );
     }
 
     /** {@inheritDoc} */
     public void sectionTitle2_()
     {
         sectionTitle_( 2 );
     }
 
     /** {@inheritDoc} */
     public void sectionTitle3()
     {
         sectionTitle( 3, null );
     }
 
     /** {@inheritDoc} */
     public void sectionTitle3_()
     {
         sectionTitle_( 3 );
     }
 
     /** {@inheritDoc} */
     public void sectionTitle4()
     {
         sectionTitle( 4, null );
     }
 
     /** {@inheritDoc} */
     public void sectionTitle4_()
     {
         sectionTitle_( 4 );
     }
 
     /** {@inheritDoc} */
     public void sectionTitle5()
     {
         sectionTitle( 5, null );
     }
 
     /** {@inheritDoc} */
     public void sectionTitle5_()
     {
         sectionTitle_( 5 );
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void sectionTitle_()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void sectionTitle_( int level )
     {
         writeEOL( true );
         writeEOL();
     }
 
     /** {@inheritDoc} */
     public void table()
     {
         // nop
         writeEOL( true );
         writeEOL();
     }
 
     /** {@inheritDoc} */
     public void table( SinkEventAttributes attributes )
     {
         table();
     }
 
     /** {@inheritDoc} */
     public void table_()
     {
         writeEOL( true );
         writeEOL();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void tableCaption()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void tableCaption( SinkEventAttributes attributes )
     {
         tableCaption();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void tableCaption_()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void tableCell()
     {
         write( " " );
     }
 
     /** {@inheritDoc} */
     public void tableCell( SinkEventAttributes attributes )
     {
         tableCell();
     }
 
     /** {@inheritDoc} */
     public void tableCell( String width )
     {
         tableCell();
     }
 
     /** {@inheritDoc} */
     public void tableCell_()
     {
         write( " " );
         write( TABLE_CELL_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void tableHeaderCell()
     {
         tableHeaderFlag = true;
         write( TABLE_CELL_HEADER_START_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void tableHeaderCell( SinkEventAttributes attributes )
     {
         tableHeaderCell();
     }
 
     /** {@inheritDoc} */
     public void tableHeaderCell( String width )
     {
         tableHeaderCell();
     }
 
     /** {@inheritDoc} */
     public void tableHeaderCell_()
     {
         write( TABLE_CELL_HEADER_END_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void tableRow()
     {
         write( TABLE_ROW_MARKUP );
     }
 
     /** {@inheritDoc} */
     public void tableRow( SinkEventAttributes attributes )
     {
         tableRow();
     }
 
     /** {@inheritDoc} */
     public void tableRow_()
     {
         if ( tableHeaderFlag )
         {
             tableHeaderFlag = false;
             write( TABLE_ROW_MARKUP );
         }
         writeEOL( true );
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void tableRows( int[] justification, boolean grid )
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void tableRows_()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void text( String text )
     {
         if ( headFlag )
         {
             return;
         }
 
         if ( linkName != null )
         {
             write( LINK_START_MARKUP );
         }
 
         content( text );
 
         if ( linkName != null )
         {
             write( LINK_MIDDLE_MARKUP + linkName );
         }
     }
 
     /** {@inheritDoc} */
     public void text( String text, SinkEventAttributes attributes )
     {
         text( text );
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void title()
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void title( SinkEventAttributes attributes )
     {
         title();
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void title_()
     {
         // nop
     }
 
     /**
      * Not used.
      * {@inheritDoc}
      */
     public void unknown( String name, Object[] requiredParams, SinkEventAttributes attributes )
     {
         // nop
     }
 
     /** {@inheritDoc} */
     public void verbatim( boolean boxed )
     {
         if ( boxed )
         {
             verbatimBoxedFlag = true;
         }
 
         if ( verbatimBoxedFlag )
         {
             write( "{code|borderStyle=solid}" );
         }
         else
         {
             write( "{noformat}" );
         }
         writeEOL( true );
     }
 
     /** {@inheritDoc} */
     public void verbatim_()
     {
         if ( verbatimBoxedFlag )
         {
             write( "{code}" );
         }
         else
         {
             write( "{noformat}" );
         }
 
         writeEOL( true );
         writeEOL();
     }
 
     // ----------------------------------------------------------------------
     // Private methods
     // ----------------------------------------------------------------------
 
     private void write( String text )
     {
         writer.write( unifyEOLs( text ) );
     }
 
     /**
      * Writes a system EOL.
      */
     private void writeEOL()
     {
         write( EOL );
     }
 
     /**
      * Writes a system EOL, with or without trim.
      */
     private void writeEOL( boolean trim )
     {
         if ( !trim )
         {
             writeEOL();
             return;
         }
 
         String tmp = writer.toString().trim();
         writer = new StringWriter();
         writer.write( tmp );
         write( EOL );
     }
 
     /**
      * Write HTML escaped text to output.
      *
      * @param text The text to write.
      */
     protected void content( String text )
     {
         write( escapeHTML( text ) );
     }
 
     /** {@inheritDoc} */
     protected void init()
     {
         super.init();
 
         this.writer = new StringWriter();
         this.headFlag = false;
         this.levelList = 0;
         this.listStyles.clear();
         this.verbatimBoxedFlag = false;
         this.tableHeaderFlag = false;
         this.linkName = null;
     }
 
     /**
      * Forward to HtmlTools.escapeHTML( text ).
      *
      * @param text the String to escape, may be null
      * @return the text escaped, "" if null String input
      * @see org.apache.maven.doxia.util.HtmlTools#escapeHTML(String)
      */
     protected static String escapeHTML( String text )
     {
         return HtmlTools.escapeHTML( text );
     }
 }

1		package org.apache.maven.doxia.module.confluence;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import java.io.PrintWriter;
23		import java.io.StringWriter;
24		import java.io.Writer;
25		import java.util.Stack;
26
27		import javax.swing.text.html.HTML.Attribute;
28
29		import org.apache.maven.doxia.sink.AbstractTextSink;
30		import org.apache.maven.doxia.sink.SinkEventAttributes;
31		import org.apache.maven.doxia.util.HtmlTools;
32		import org.codehaus.plexus.util.StringUtils;
33
34		/**
35		* Confluence Sink implementation.
36		* <br/>
37		* <b>Note</b>: The encoding used is UTF-8.
38		*
39		* @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
40		* @version $Id: ConfluenceSink.java 1091053 2011-04-11 12:55:07Z ltheussl $
41		* @since 1.0
42		*/
43		public class ConfluenceSink
44		extends AbstractTextSink
45		implements ConfluenceMarkup
46		{
47		/** The writer to use. */
48		private final PrintWriter out;
49
50		/** The writer to use. */
51		private StringWriter writer;
52
53		/** An indication on if we're in head mode. */
54		private boolean headFlag;
55
56	64	private int levelList = 0;
57
58		/** listStyles. */
59		private final Stack<String> listStyles;
60
61		/** An indication on if we're in verbatim box mode. */
62		private boolean verbatimBoxedFlag;
63
64		/** An indication on if we're in table header mode. */
65		private boolean tableHeaderFlag;
66
67		/** The link name. */
68		private String linkName;
69
70		/**
71		* Constructor, initialize the Writer and the variables.
72		*
73		* @param writer not null writer to write the result. <b>Should</b> be an UTF-8 Writer.
74		* You could use <code>newWriter</code> methods from {@link org.codehaus.plexus.util.WriterFactory}.
75		*/
76		protected ConfluenceSink( Writer writer )
77	64	{
78	64	this.out = new PrintWriter( writer );
79	64	this.listStyles = new Stack<String>();
80
81	64	init();
82	64	}
83
84		/** {@inheritDoc} */
85		public void anchor( String name )
86		{
87	4	write( ANCHOR_START_MARKUP + name + ANCHOR_END_MARKUP );
88	4	}
89
90		/** {@inheritDoc} */
91		public void anchor( String name, SinkEventAttributes attributes )
92		{
93	0	anchor( name );
94	0	}
95
96		/**
97		* Not used.
98		* {@inheritDoc}
99		*/
100		public void anchor_()
101		{
102		// nop
103	4	}
104
105		/**
106		* Not used.
107		* {@inheritDoc}
108		*/
109		public void author()
110		{
111		// nop
112	2	}
113
114		/** {@inheritDoc} */
115		public void author( SinkEventAttributes attributes )
116		{
117	0	author();
118	0	}
119
120		/**
121		* Not used.
122		* {@inheritDoc}
123		*/
124		public void author_()
125		{
126		// nop
127	2	}
128
129		/**
130		* Not used.
131		* {@inheritDoc}
132		*/
133		public void body()
134		{
135		// nop
136	2	}
137
138		/** {@inheritDoc} */
139		public void body( SinkEventAttributes attributes )
140		{
141	0	body();
142	0	}
143
144		/**
145		* Not used.
146		* {@inheritDoc}
147		*/
148		public void body_()
149		{
150		// nop
151	2	}
152
153		/** {@inheritDoc} */
154		public void bold()
155		{
156	4	write( BOLD_START_MARKUP );
157	4	}
158
159		/** {@inheritDoc} */
160		public void bold_()
161		{
162	4	write( BOLD_END_MARKUP );
163	4	}
164
165		/**
166		* Not used.
167		* {@inheritDoc}
168		*/
169		public void comment( String comment )
170		{
171		// nop
172	4	}
173
174		/** {@inheritDoc} */
175		public void close()
176		{
177	100	out.write( writer.toString() );
178	100	out.close();
179
180	100	init();
181	100	}
182
183		/**
184		* Not used.
185		* {@inheritDoc}
186		*/
187		public void date()
188		{
189		// nop
190	2	}
191
192		/** {@inheritDoc} */
193		public void date( SinkEventAttributes attributes )
194		{
195	0	date();
196	0	}
197
198		/**
199		* Not used.
200		* {@inheritDoc}
201		*/
202		public void date_()
203		{
204		// nop
205	2	}
206
207		/** {@inheritDoc} */
208		public void definedTerm()
209		{
210	4	write( " " );
211	4	}
212
213		/** {@inheritDoc} */
214		public void definedTerm( SinkEventAttributes attributes )
215		{
216	0	definedTerm();
217	0	}
218
219		/**
220		* Not used.
221		* {@inheritDoc}
222		*/
223		public void definedTerm_()
224		{
225		// nop
226	4	}
227
228		/**
229		* Not used.
230		* {@inheritDoc}
231		*/
232		public void definition()
233		{
234		// nop
235	4	}
236
237		/**
238		* Not used.
239		* {@inheritDoc}
240		*/
241		public void definition( SinkEventAttributes attributes )
242		{
243		// nop
244	0	}
245
246		/**
247		* Not used.
248		* {@inheritDoc}
249		*/
250		public void definition_()
251		{
252		// nop
253	4	}
254
255		/**
256		* Not used.
257		* {@inheritDoc}
258		*/
259		public void definitionList()
260		{
261		// nop
262	2	}
263
264		/**
265		* Not used.
266		* {@inheritDoc}
267		*/
268		public void definitionList( SinkEventAttributes attributes )
269		{
270		// nop
271	0	}
272
273		/**
274		* Not used.
275		* {@inheritDoc}
276		*/
277		public void definitionList_()
278		{
279		// nop
280	2	}
281
282		/**
283		* Not used.
284		* {@inheritDoc}
285		*/
286		public void definitionListItem()
287		{
288		// nop
289	4	}
290
291		/**
292		* Not used.
293		* {@inheritDoc}
294		*/
295		public void definitionListItem( SinkEventAttributes attributes )
296		{
297		// nop
298	0	}
299
300		/**
301		* Not used.
302		* {@inheritDoc}
303		*/
304		public void definitionListItem_()
305		{
306		// nop
307	4	}
308
309		/**
310		* Not used.
311		* {@inheritDoc}
312		*/
313		public void figure()
314		{
315		// nop
316	4	}
317
318		/** {@inheritDoc} */
319		public void figure( SinkEventAttributes attributes )
320		{
321	2	figure();
322	2	}
323
324		/**
325		* Not used.
326		* {@inheritDoc}
327		*/
328		public void figure_()
329		{
330		// nop
331	4	}
332
333		/**
334		* Not used.
335		* {@inheritDoc}
336		*/
337		public void figureCaption()
338		{
339		// nop
340	4	}
341
342		/** {@inheritDoc} */
343		public void figureCaption( SinkEventAttributes attributes )
344		{
345	2	figureCaption();
346	2	}
347
348		/**
349		* Not used.
350		* {@inheritDoc}
351		*/
352		public void figureCaption_()
353		{
354		// nop;
355	4	}
356
357		/** {@inheritDoc} */
358		public void figureGraphics( String name )
359		{
360	4	writeEOL();
361	4	write( FIGURE_START_MARKUP + name + FIGURE_END_MARKUP );
362	4	}
363
364		/** {@inheritDoc} */
365		public void figureGraphics( String src, SinkEventAttributes attributes )
366		{
367	2	figureGraphics( src );
368	2	if ( attributes != null && attributes.getAttribute( Attribute.ALT.toString() ) != null )
369		{
370	0	write( attributes.getAttribute( Attribute.ALT.toString() ).toString() );
371	0	writeEOL( true );
372		}
373	2	}
374
375		/** {@inheritDoc} */
376		public void flush()
377		{
378	50	close();
379	50	writer.flush();
380	50	}
381
382		/** {@inheritDoc} */
383		public void head()
384		{
385	2	init();
386
387	2	headFlag = true;
388	2	}
389
390		/** {@inheritDoc} */
391		public void head( SinkEventAttributes attributes )
392		{
393	0	head();
394	0	}
395
396		/** {@inheritDoc} */
397		public void head_()
398		{
399	2	headFlag = false;
400	2	}
401
402		/**
403		* Not used.
404		* {@inheritDoc}
405		*/
406		public void horizontalRule()
407		{
408		// nop
409	4	}
410
411		/** {@inheritDoc} */
412		public void horizontalRule( SinkEventAttributes attributes )
413		{
414	0	horizontalRule();
415	0	}
416
417		/** {@inheritDoc} */
418		public void italic()
419		{
420	4	write( ITALIC_START_MARKUP );
421	4	}
422
423		/** {@inheritDoc} */
424		public void italic_()
425		{
426	4	write( ITALIC_END_MARKUP );
427	4	}
428
429		/** {@inheritDoc} */
430		public void lineBreak()
431		{
432	36	write( LINE_BREAK_MARKUP );
433	36	writeEOL();
434	36	}
435
436		/** {@inheritDoc} */
437		public void lineBreak( SinkEventAttributes attributes )
438		{
439	0	lineBreak();
440	0	}
441
442		/** {@inheritDoc} */
443		public void link( String name )
444		{
445	10	linkName = name;
446	10	}
447
448		/** {@inheritDoc} */
449		public void link( String name, SinkEventAttributes attributes )
450		{
451	0	link( name );
452	0	}
453
454		/** {@inheritDoc} */
455		public void link_()
456		{
457	10	linkName = null;
458	10	write( LINK_END_MARKUP );
459	10	}
460
461		/** {@inheritDoc} */
462		public void list()
463		{
464	6	if ( !writer.toString().endsWith( EOL + EOL ) )
465		{
466	2	writeEOL( true );
467		}
468
469	6	levelList++;
470	6	}
471
472		/** {@inheritDoc} */
473		public void list( SinkEventAttributes attributes )
474		{
475	0	list();
476	0	}
477
478		/** {@inheritDoc} */
479		public void list_()
480		{
481	6	levelList--;
482	6	}
483
484		/** {@inheritDoc} */
485		public void listItem()
486		{
487	12	write( StringUtils.repeat( "*", levelList ) + " " );
488	12	}
489
490		/** {@inheritDoc} */
491		public void listItem( SinkEventAttributes attributes )
492		{
493	0	listItem();
494	0	}
495
496		/** {@inheritDoc} */
497		public void listItem_()
498		{
499	12	writeEOL( true );
500	12	}
501
502		/** {@inheritDoc} */
503		public void monospaced()
504		{
505	4	write( MONOSPACED_START_MARKUP );
506	4	}
507
508		/** {@inheritDoc} */
509		public void monospaced_()
510		{
511	4	write( MONOSPACED_END_MARKUP );
512	4	}
513
514		/**
515		* Not used.
516		* {@inheritDoc}
517		*/
518		public void nonBreakingSpace()
519		{
520		// nop
521	6	}
522
523		/** {@inheritDoc} */
524		public void numberedList( int numbering )
525		{
526	6	levelList++;
527
528		String style;
529	6	switch ( numbering )
530		{
531		case NUMBERING_UPPER_ALPHA:
532		case NUMBERING_LOWER_ALPHA:
533		case NUMBERING_UPPER_ROMAN:
534		case NUMBERING_LOWER_ROMAN:
535		case NUMBERING_DECIMAL:
536		default:
537	6	style = NUMBERING_MARKUP;
538		}
539
540	6	listStyles.push( style );
541	6	}
542
543		/** {@inheritDoc} */
544		public void numberedList( int numbering, SinkEventAttributes attributes )
545		{
546	0	numberedList( numbering );
547	0	}
548
549		/** {@inheritDoc} */
550		public void numberedList_()
551		{
552	6	levelList--;
553	6	listStyles.pop();
554	6	}
555
556		/** {@inheritDoc} */
557		public void numberedListItem()
558		{
559	10	writeEOL( true );
560	10	String style = listStyles.peek();
561	10	write( style + SPACE );
562	10	}
563
564		/** {@inheritDoc} */
565		public void numberedListItem( SinkEventAttributes attributes )
566		{
567	0	numberedListItem();
568	0	}
569
570		/** {@inheritDoc} */
571		public void numberedListItem_()
572		{
573	10	writeEOL( true );
574	10	}
575
576		/**
577		* Not used.
578		* {@inheritDoc}
579		*/
580		public void pageBreak()
581		{
582		// nop
583	4	}
584
585		/**
586		* Not used.
587		* {@inheritDoc}
588		*/
589		public void paragraph()
590		{
591		// nop
592	30	}
593
594		/** {@inheritDoc} */
595		public void paragraph( SinkEventAttributes attributes )
596		{
597	0	paragraph();
598	0	}
599
600		/** {@inheritDoc} */
601		public void paragraph_()
602		{
603	30	writeEOL( true );
604	30	writeEOL();
605	30	}
606
607		/**
608		* Not used.
609		* {@inheritDoc}
610		*/
611		public void rawText( String text )
612		{
613		// nop
614	2	}
615
616		/**
617		* Not used.
618		* {@inheritDoc}
619		*/
620		public void section( int level, SinkEventAttributes attributes )
621		{
622		// nop
623	0	}
624
625		/**
626		* Not used.
627		* {@inheritDoc}
628		*/
629		public void section1()
630		{
631		// nop
632	4	}
633
634		/**
635		* Not used.
636		* {@inheritDoc}
637		*/
638		public void section1_()
639		{
640		// nop
641	4	}
642
643		/**
644		* Not used.
645		* {@inheritDoc}
646		*/
647		public void section2()
648		{
649		// nop
650	4	}
651
652		/**
653		* Not used.
654		* {@inheritDoc}
655		*/
656		public void section2_()
657		{
658		// nop
659	4	}
660
661		/**
662		* Not used.
663		* {@inheritDoc}
664		*/
665		public void section3()
666		{
667		// nop
668	4	}
669
670		/**
671		* Not used.
672		* {@inheritDoc}
673		*/
674		public void section3_()
675		{
676		// nop
677	4	}
678
679		/**
680		* Not used.
681		* {@inheritDoc}
682		*/
683		public void section4()
684		{
685		// nop
686	4	}
687
688		/**
689		* Not used.
690		* {@inheritDoc}
691		*/
692		public void section4_()
693		{
694		// nop
695	4	}
696
697		/**
698		* Not used.
699		* {@inheritDoc}
700		*/
701		public void section5()
702		{
703		// nop
704	4	}
705
706		/**
707		* Not used.
708		* {@inheritDoc}
709		*/
710		public void section5_()
711		{
712		// nop
713	4	}
714
715		/**
716		* Not used.
717		* {@inheritDoc}
718		*/
719		public void section_( int level )
720		{
721		// nop
722	0	}
723
724		/**
725		* Not used.
726		* {@inheritDoc}
727		*/
728		public void sectionTitle()
729		{
730		// nop
731	2	}
732
733		/** {@inheritDoc} */
734		public void sectionTitle( int level, SinkEventAttributes attributes )
735		{
736	20	if ( level > 0 && level < 6 )
737		{
738	20	write( "h" + level + ". " );
739		}
740	20	}
741
742		/** {@inheritDoc} */
743		public void sectionTitle1()
744		{
745	4	sectionTitle( 1, null );
746	4	}
747
748		/** {@inheritDoc} */
749		public void sectionTitle1_()
750		{
751	4	sectionTitle_( 1 );
752	4	}
753
754		/** {@inheritDoc} */
755		public void sectionTitle2()
756		{
757	4	sectionTitle( 2, null );
758	4	}
759
760		/** {@inheritDoc} */
761		public void sectionTitle2_()
762		{
763	4	sectionTitle_( 2 );
764	4	}
765
766		/** {@inheritDoc} */
767		public void sectionTitle3()
768		{
769	4	sectionTitle( 3, null );
770	4	}
771
772		/** {@inheritDoc} */
773		public void sectionTitle3_()
774		{
775	4	sectionTitle_( 3 );
776	4	}
777
778		/** {@inheritDoc} */
779		public void sectionTitle4()
780		{
781	4	sectionTitle( 4, null );
782	4	}
783
784		/** {@inheritDoc} */
785		public void sectionTitle4_()
786		{
787	4	sectionTitle_( 4 );
788	4	}
789
790		/** {@inheritDoc} */
791		public void sectionTitle5()
792		{
793	4	sectionTitle( 5, null );
794	4	}
795
796		/** {@inheritDoc} */
797		public void sectionTitle5_()
798		{
799	4	sectionTitle_( 5 );
800	4	}
801
802		/**
803		* Not used.
804		* {@inheritDoc}
805		*/
806		public void sectionTitle_()
807		{
808		// nop
809	2	}
810
811		/** {@inheritDoc} */
812		public void sectionTitle_( int level )
813		{
814	20	writeEOL( true );
815	20	writeEOL();
816	20	}
817
818		/** {@inheritDoc} */
819		public void table()
820		{
821		// nop
822	8	writeEOL( true );
823	8	writeEOL();
824	8	}
825
826		/** {@inheritDoc} */
827		public void table( SinkEventAttributes attributes )
828		{
829	0	table();
830	0	}
831
832		/** {@inheritDoc} */
833		public void table_()
834		{
835	8	writeEOL( true );
836	8	writeEOL();
837	8	}
838
839		/**
840		* Not used.
841		* {@inheritDoc}
842		*/
843		public void tableCaption()
844		{
845		// nop
846	4	}
847
848		/** {@inheritDoc} */
849		public void tableCaption( SinkEventAttributes attributes )
850		{
851	0	tableCaption();
852	0	}
853
854		/**
855		* Not used.
856		* {@inheritDoc}
857		*/
858		public void tableCaption_()
859		{
860		// nop
861	4	}
862
863		/** {@inheritDoc} */
864		public void tableCell()
865		{
866	26	write( " " );
867	26	}
868
869		/** {@inheritDoc} */
870		public void tableCell( SinkEventAttributes attributes )
871		{
872	0	tableCell();
873	0	}
874
875		/** {@inheritDoc} */
876		public void tableCell( String width )
877		{
878	0	tableCell();
879	0	}
880
881		/** {@inheritDoc} */
882		public void tableCell_()
883		{
884	26	write( " " );
885	26	write( TABLE_CELL_MARKUP );
886	26	}
887
888		/** {@inheritDoc} */
889		public void tableHeaderCell()
890		{
891	4	tableHeaderFlag = true;
892	4	write( TABLE_CELL_HEADER_START_MARKUP );
893	4	}
894
895		/** {@inheritDoc} */
896		public void tableHeaderCell( SinkEventAttributes attributes )
897		{
898	0	tableHeaderCell();
899	0	}
900
901		/** {@inheritDoc} */
902		public void tableHeaderCell( String width )
903		{
904	0	tableHeaderCell();
905	0	}
906
907		/** {@inheritDoc} */
908		public void tableHeaderCell_()
909		{
910	4	write( TABLE_CELL_HEADER_END_MARKUP );
911	4	}
912
913		/** {@inheritDoc} */
914		public void tableRow()
915		{
916	14	write( TABLE_ROW_MARKUP );
917	14	}
918
919		/** {@inheritDoc} */
920		public void tableRow( SinkEventAttributes attributes )
921		{
922	0	tableRow();
923	0	}
924
925		/** {@inheritDoc} */
926		public void tableRow_()
927		{
928	14	if ( tableHeaderFlag )
929		{
930	2	tableHeaderFlag = false;
931	2	write( TABLE_ROW_MARKUP );
932		}
933	14	writeEOL( true );
934	14	}
935
936		/**
937		* Not used.
938		* {@inheritDoc}
939		*/
940		public void tableRows( int[] justification, boolean grid )
941		{
942		// nop
943	8	}
944
945		/**
946		* Not used.
947		* {@inheritDoc}
948		*/
949		public void tableRows_()
950		{
951		// nop
952	8	}
953
954		/** {@inheritDoc} */
955		public void text( String text )
956		{
957	210	if ( headFlag )
958		{
959	6	return;
960		}
961
962	204	if ( linkName != null )
963		{
964	10	write( LINK_START_MARKUP );
965		}
966
967	204	content( text );
968
969	204	if ( linkName != null )
970		{
971	10	write( LINK_MIDDLE_MARKUP + linkName );
972		}
973	204	}
974
975		/** {@inheritDoc} */
976		public void text( String text, SinkEventAttributes attributes )
977		{
978	2	text( text );
979	2	}
980
981		/**
982		* Not used.
983		* {@inheritDoc}
984		*/
985		public void title()
986		{
987		// nop
988	2	}
989
990		/** {@inheritDoc} */
991		public void title( SinkEventAttributes attributes )
992		{
993	0	title();
994	0	}
995
996		/**
997		* Not used.
998		* {@inheritDoc}
999		*/
1000		public void title_()
1001		{
1002		// nop
1003	2	}
1004
1005		/**
1006		* Not used.
1007		* {@inheritDoc}
1008		*/
1009		public void unknown( String name, Object[] requiredParams, SinkEventAttributes attributes )
1010		{
1011		// nop
1012	0	}
1013
1014		/** {@inheritDoc} */
1015		public void verbatim( boolean boxed )
1016		{
1017	6	if ( boxed )
1018		{
1019	6	verbatimBoxedFlag = true;
1020		}
1021
1022	6	if ( verbatimBoxedFlag )
1023		{
1024	6	write( "{code\|borderStyle=solid}" );
1025		}
1026		else
1027		{
1028	0	write( "{noformat}" );
1029		}
1030	6	writeEOL( true );
1031	6	}
1032
1033		/** {@inheritDoc} */
1034		public void verbatim_()
1035		{
1036	6	if ( verbatimBoxedFlag )
1037		{
1038	6	write( "{code}" );
1039		}
1040		else
1041		{
1042	0	write( "{noformat}" );
1043		}
1044
1045	6	writeEOL( true );
1046	6	writeEOL();
1047	6	}
1048
1049		// ----------------------------------------------------------------------
1050		// Private methods
1051		// ----------------------------------------------------------------------
1052
1053		private void write( String text )
1054		{
1055	700	writer.write( unifyEOLs( text ) );
1056	700	}
1057
1058		/**
1059		* Writes a system EOL.
1060		*/
1061		private void writeEOL()
1062		{
1063	112	write( EOL );
1064	112	}
1065
1066		/**
1067		* Writes a system EOL, with or without trim.
1068		*/
1069		private void writeEOL( boolean trim )
1070		{
1071	126	if ( !trim )
1072		{
1073	0	writeEOL();
1074	0	return;
1075		}
1076
1077	126	String tmp = writer.toString().trim();
1078	126	writer = new StringWriter();
1079	126	writer.write( tmp );
1080	126	write( EOL );
1081	126	}
1082
1083		/**
1084		* Write HTML escaped text to output.
1085		*
1086		* @param text The text to write.
1087		*/
1088		protected void content( String text )
1089		{
1090	204	write( escapeHTML( text ) );
1091	204	}
1092
1093		/** {@inheritDoc} */
1094		protected void init()
1095		{
1096	166	super.init();
1097
1098	166	this.writer = new StringWriter();
1099	166	this.headFlag = false;
1100	166	this.levelList = 0;
1101	166	this.listStyles.clear();
1102	166	this.verbatimBoxedFlag = false;
1103	166	this.tableHeaderFlag = false;
1104	166	this.linkName = null;
1105	166	}
1106
1107		/**
1108		* Forward to HtmlTools.escapeHTML( text ).
1109		*
1110		* @param text the String to escape, may be null
1111		* @return the text escaped, "" if null String input
1112		* @see org.apache.maven.doxia.util.HtmlTools#escapeHTML(String)
1113		*/
1114		protected static String escapeHTML( String text )
1115		{
1116	204	return HtmlTools.escapeHTML( text );
1117		}
1118		}