View Javadoc

1   package org.apache.maven.usability.plugin;
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 org.apache.maven.usability.plugin.io.xpp3.ParamdocXpp3Reader;
23  import org.codehaus.plexus.util.IOUtil;
24  import org.codehaus.plexus.util.ReaderFactory;
25  import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
26  
27  import java.io.BufferedReader;
28  import java.io.File;
29  import java.io.IOException;
30  import java.io.InputStream;
31  import java.io.Reader;
32  import java.net.MalformedURLException;
33  import java.net.URL;
34  import java.net.URLClassLoader;
35  import java.util.HashMap;
36  import java.util.Iterator;
37  import java.util.List;
38  import java.util.Map;
39  
40  public class ExpressionDocumenter
41  {
42  
43      private static final String[] EXPRESSION_ROOTS = { "project", "settings", "session", "plugin", "rootless" };
44  
45      private static final String EXPRESSION_DOCO_ROOTPATH = "META-INF/maven/plugin-expressions/";
46  
47      private static Map expressionDocumentation;
48  
49      public static Map load()
50          throws ExpressionDocumentationException
51      {
52          if ( expressionDocumentation == null )
53          {
54              expressionDocumentation = new HashMap();
55  
56              ClassLoader docLoader = initializeDocLoader();
57  
58              for ( int i = 0; i < EXPRESSION_ROOTS.length; i++ )
59              {
60                  InputStream docStream = null;
61                  try
62                  {
63                      docStream = docLoader
64                          .getResourceAsStream( EXPRESSION_DOCO_ROOTPATH + EXPRESSION_ROOTS[i] + ".paramdoc.xml" );
65  
66                      if ( docStream != null )
67                      {
68                          Map doco = parseExpressionDocumentation( docStream );
69  
70                          expressionDocumentation.putAll( doco );
71                      }
72                  }
73                  catch ( IOException e )
74                  {
75                      throw new ExpressionDocumentationException( "Failed to read documentation for expression root: " + EXPRESSION_ROOTS[i], e );
76                  }
77                  catch ( XmlPullParserException e )
78                  {
79                      throw new ExpressionDocumentationException( "Failed to parse documentation for expression root: " + EXPRESSION_ROOTS[i], e );
80                  }
81                  finally
82                  {
83                      IOUtil.close( docStream );
84                  }
85              }
86          }
87  
88          return expressionDocumentation;
89      }
90  
91      /**
92       * <expressions>
93       *   <expression>
94       *     <syntax>project.distributionManagementArtifactRepository</syntax>
95       *     <origin><![CDATA[
96       *   <distributionManagement>
97       *     <repository>
98       *       <id>some-repo</id>
99       *       <url>scp://host/path</url>
100      *     </repository>
101      *     <snapshotRepository>
102      *       <id>some-snap-repo</id>
103      *       <url>scp://host/snapshot-path</url>
104      *     </snapshotRepository>
105      *   </distributionManagement>
106      *   ]]></origin>
107      *     <usage><![CDATA[
108      *   The repositories onto which artifacts should be deployed.
109      *   One is for releases, the other for snapshots.
110      *   ]]></usage>
111      *   </expression>
112      * <expressions>
113      * @throws IOException 
114      * @throws XmlPullParserException 
115      */
116     private static Map parseExpressionDocumentation( InputStream docStream )
117         throws IOException, XmlPullParserException
118     {
119         Reader reader = new BufferedReader( ReaderFactory.newXmlReader( docStream ) );
120 
121         ParamdocXpp3Reader paramdocReader = new ParamdocXpp3Reader();
122 
123         ExpressionDocumentation documentation = paramdocReader.read( reader, true );
124 
125         List expressions = documentation.getExpressions();
126 
127         Map bySyntax = new HashMap();
128 
129         if ( expressions != null && !expressions.isEmpty() )
130         {
131             for ( Iterator it = expressions.iterator(); it.hasNext(); )
132             {
133                 Expression expr = (Expression) it.next();
134 
135                 bySyntax.put( expr.getSyntax(), expr );
136             }
137         }
138 
139         return bySyntax;
140     }
141 
142     private static ClassLoader initializeDocLoader()
143         throws ExpressionDocumentationException
144     {
145         String myResourcePath = ExpressionDocumenter.class.getName().replace( '.', '/' ) + ".class";
146 
147         URL myResource = ExpressionDocumenter.class.getClassLoader().getResource( myResourcePath );
148 
149         String myClasspathEntry = myResource.getPath();
150 
151         myClasspathEntry = myClasspathEntry.substring( 0, myClasspathEntry.length() - ( myResourcePath.length() + 2 ) );
152 
153         if ( myClasspathEntry.startsWith( "file:" ) )
154         {
155             myClasspathEntry = myClasspathEntry.substring( "file:".length() );
156         }
157 
158         URL docResource;
159         try
160         {
161             docResource = new File( myClasspathEntry ).toURL();
162         }
163         catch ( MalformedURLException e )
164         {
165             throw new ExpressionDocumentationException(
166                                                         "Cannot construct expression documentation classpath resource base.",
167                                                         e );
168         }
169 
170         return new URLClassLoader( new URL[] { docResource } );
171     }
172 
173 }