Coverage Report

Coverage Report - org.apache.maven.doxia.module.twiki.parser.SectionBlock

Classes in this File

Line Coverage

Branch Coverage

Complexity

SectionBlock

65%

29/44

62%

5/8

1,727

 package org.apache.maven.doxia.module.twiki.parser;
 
 /*
  * 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.lang.reflect.Method;
 import java.util.Collections;
 
 import org.apache.maven.doxia.sink.Sink;
 
 /**
  * Block that represents a section
  *
  * @author Juan F. Codagnone
  * @version $Id: SectionBlock.java 763762 2009-04-09 18:19:56Z ltheussl $
  */
 public class SectionBlock
     extends AbstractFatherBlock
 {
     /** {@inheritDoc} */
     private final String title;
 
     /** {@inheritDoc} */
     private final int level;
 
     /**
      * Creates the SectionBlock.
      * <p/>
      * No parameter can be <code>null</code>
      *
      * @param title  the section title.
      * @param level  the section level: 0 < level < 6
      * @param blocks child blocks
      */
     public SectionBlock( final String title, final int level, final Block[] blocks )
     {
         super( blocks );
         final int maxLevel = 5;
         if ( title == null )
         {
             throw new IllegalArgumentException( "title cant be null" );
         }
         else if ( level < 1 || level > maxLevel )
         {
             throw new IllegalArgumentException( "invalid level: " + level );
         }
 
         this.title = title;
         this.level = level;
     }
 
     /** {@inheritDoc} */
     final void before( final Sink sink )
     {
         sectionStart( sink );
         sectionTitle( sink );
         sink.text( title );
         sectionTitle_( sink );
 
     }
 
     /** {@inheritDoc} */
     final void after( final Sink sink )
     {
         sectionEnd( sink );
     }
 
     /**
      * call to sink.section<Level>()
      *
      * @param sink sink
      */
     private void sectionStart( final Sink sink )
     {
         invokeVoidVoid( sink, "section" + level );
     }
 
     /**
      * call to sink.section<Level>_()
      *
      * @param sink sink
      */
     private void sectionEnd( final Sink sink )
     {
         invokeVoidVoid( sink, "section" + level + "_" );
     }
 
     /**
      * Let you call sink's methods that returns <code>null</code> and have
      * no parameters.
      *
      * @param sink the Sink
      * @param name the name of the method to call
      */
     private void invokeVoidVoid( final Sink sink, final String name )
     {
         try
         {
             final Method m = sink.getClass().getMethod( name, new Class[] {} );
             m.invoke( sink, Collections.EMPTY_LIST.toArray() );
         }
         catch ( Exception e )
         {
             // FIXME
             throw new IllegalArgumentException( "invoking sink's " + name + " method: " + e.getMessage() );
         }
     }
 
     /**
      * Returns the level.
      *
      * @return <code>int</code> with the level.
      */
     public final int getLevel()
     {
         return level;
     }
 
     /**
      * Returns the title.
      *
      * @return <code>String</code> with the title.
      */
     public final String getTitle()
     {
         return title;
     }
 
     /** {@inheritDoc} */
     public final String toString()
     {
         final StringBuffer sb = new StringBuffer();
 
         sb.append( "Section  {title: '" );
         sb.append( getTitle() );
         sb.append( "' level: " );
         sb.append( getLevel() );
         sb.append( "}: [" );
         for ( int i = 0; i < getBlocks().length; i++ )
         {
             final Block block = getBlocks()[i];
 
             sb.append( block.toString() );
             sb.append( ", " );
         }
         sb.append( "]" );
         return sb.toString();
     }
 
     /** @param sink */
     private void sectionTitle( final Sink sink )
     {
         invokeVoidVoid( sink, "sectionTitle" + level );
     }
 
     /** @param sink */
     private void sectionTitle_( final Sink sink )
     {
         invokeVoidVoid( sink, "sectionTitle" + level + "_" );
     }
 }

1		package org.apache.maven.doxia.module.twiki.parser;
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.lang.reflect.Method;
23		import java.util.Collections;
24
25		import org.apache.maven.doxia.sink.Sink;
26
27		/**
28		* Block that represents a section
29		*
30		* @author Juan F. Codagnone
31		* @version $Id: SectionBlock.java 763762 2009-04-09 18:19:56Z ltheussl $
32		*/
33		public class SectionBlock
34		extends AbstractFatherBlock
35		{
36		/** {@inheritDoc} */
37		private final String title;
38
39		/** {@inheritDoc} */
40		private final int level;
41
42		/**
43		* Creates the SectionBlock.
44		* <p/>
45		* No parameter can be <code>null</code>
46		*
47		* @param title the section title.
48		* @param level the section level: 0 < level < 6
49		* @param blocks child blocks
50		*/
51		public SectionBlock( final String title, final int level, final Block[] blocks )
52		{
53	78	super( blocks );
54	76	final int maxLevel = 5;
55	76	if ( title == null )
56		{
57	0	throw new IllegalArgumentException( "title cant be null" );
58		}
59	76	else if ( level < 1 \|\| level > maxLevel )
60		{
61	4	throw new IllegalArgumentException( "invalid level: " + level );
62		}
63
64	72	this.title = title;
65	72	this.level = level;
66	72	}
67
68		/** {@inheritDoc} */
69		final void before( final Sink sink )
70		{
71	48	sectionStart( sink );
72	48	sectionTitle( sink );
73	48	sink.text( title );
74	48	sectionTitle_( sink );
75
76	48	}
77
78		/** {@inheritDoc} */
79		final void after( final Sink sink )
80		{
81	48	sectionEnd( sink );
82	48	}
83
84		/**
85		* call to sink.section<Level>()
86		*
87		* @param sink sink
88		*/
89		private void sectionStart( final Sink sink )
90		{
91	48	invokeVoidVoid( sink, "section" + level );
92	48	}
93
94		/**
95		* call to sink.section<Level>_()
96		*
97		* @param sink sink
98		*/
99		private void sectionEnd( final Sink sink )
100		{
101	48	invokeVoidVoid( sink, "section" + level + "_" );
102	48	}
103
104		/**
105		* Let you call sink's methods that returns <code>null</code> and have
106		* no parameters.
107		*
108		* @param sink the Sink
109		* @param name the name of the method to call
110		*/
111		private void invokeVoidVoid( final Sink sink, final String name )
112		{
113		try
114		{
115	192	final Method m = sink.getClass().getMethod( name, new Class[] {} );
116	192	m.invoke( sink, Collections.EMPTY_LIST.toArray() );
117		}
118	0	catch ( Exception e )
119		{
120		// FIXME
121	0	throw new IllegalArgumentException( "invoking sink's " + name + " method: " + e.getMessage() );
122	192	}
123	192	}
124
125		/**
126		* Returns the level.
127		*
128		* @return <code>int</code> with the level.
129		*/
130		public final int getLevel()
131		{
132	2	return level;
133		}
134
135		/**
136		* Returns the title.
137		*
138		* @return <code>String</code> with the title.
139		*/
140		public final String getTitle()
141		{
142	8	return title;
143		}
144
145		/** {@inheritDoc} */
146		public final String toString()
147		{
148	0	final StringBuffer sb = new StringBuffer();
149
150	0	sb.append( "Section {title: '" );
151	0	sb.append( getTitle() );
152	0	sb.append( "' level: " );
153	0	sb.append( getLevel() );
154	0	sb.append( "}: [" );
155	0	for ( int i = 0; i < getBlocks().length; i++ )
156		{
157	0	final Block block = getBlocks()[i];
158
159	0	sb.append( block.toString() );
160	0	sb.append( ", " );
161		}
162	0	sb.append( "]" );
163	0	return sb.toString();
164		}
165
166		/** @param sink */
167		private void sectionTitle( final Sink sink )
168		{
169	48	invokeVoidVoid( sink, "sectionTitle" + level );
170	48	}
171
172		/** @param sink */
173		private void sectionTitle_( final Sink sink )
174		{
175	48	invokeVoidVoid( sink, "sectionTitle" + level + "_" );
176	48	}
177		}