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: "
76                          + EXPRESSION_ROOTS[i], e );
77                  }
78                  catch ( XmlPullParserException e )
79                  {
80                      throw new ExpressionDocumentationException( "Failed to parse documentation for expression root: "
81                          + EXPRESSION_ROOTS[i], e );
82                  }
83                  finally
84                  {
85                      IOUtil.close( docStream );
86                  }
87              }
88          }
89  
90          return expressionDocumentation;
91      }
92  
93      /**
94       * <expressions>
95       *   <expression>
96       *     <syntax>project.distributionManagementArtifactRepository</syntax>
97       *     <origin><![CDATA[
98       *   <distributionManagement>
99       *     <repository>
100      *       <id>some-repo</id>
101      *       <url>scp://host/path</url>
102      *     </repository>
103      *     <snapshotRepository>
104      *       <id>some-snap-repo</id>
105      *       <url>scp://host/snapshot-path</url>
106      *     </snapshotRepository>
107      *   </distributionManagement>
108      *   ]]></origin>
109      *     <usage><![CDATA[
110      *   The repositories onto which artifacts should be deployed.
111      *   One is for releases, the other for snapshots.
112      *   ]]></usage>
113      *   </expression>
114      * <expressions>
115      * @throws IOException
116      * @throws XmlPullParserException
117      */
118     private static Map parseExpressionDocumentation( InputStream docStream )
119         throws IOException, XmlPullParserException
120     {
121         Reader reader = new BufferedReader( ReaderFactory.newXmlReader( docStream ) );
122 
123         ParamdocXpp3Reader paramdocReader = new ParamdocXpp3Reader();
124 
125         ExpressionDocumentation documentation = paramdocReader.read( reader, true );
126 
127         List expressions = documentation.getExpressions();
128 
129         Map bySyntax = new HashMap();
130 
131         if ( expressions != null && !expressions.isEmpty() )
132         {
133             for ( Iterator it = expressions.iterator(); it.hasNext(); )
134             {
135                 Expression expr = (Expression) it.next();
136 
137                 bySyntax.put( expr.getSyntax(), expr );
138             }
139         }
140 
141         return bySyntax;
142     }
143 
144     private static ClassLoader initializeDocLoader()
145         throws ExpressionDocumentationException
146     {
147         String myResourcePath = ExpressionDocumenter.class.getName().replace( '.', '/' ) + ".class";
148 
149         URL myResource = ExpressionDocumenter.class.getClassLoader().getResource( myResourcePath );
150 
151         String myClasspathEntry = myResource.getPath();
152 
153         myClasspathEntry = myClasspathEntry.substring( 0, myClasspathEntry.length() - ( myResourcePath.length() + 2 ) );
154 
155         if ( myClasspathEntry.startsWith( "file:" ) )
156         {
157             myClasspathEntry = myClasspathEntry.substring( "file:".length() );
158         }
159 
160         URL docResource;
161         try
162         {
163             docResource = new File( myClasspathEntry ).toURL();
164         }
165         catch ( MalformedURLException e )
166         {
167             throw new ExpressionDocumentationException(
168                                                         "Cannot construct expression documentation classpath resource base.",
169                                                         e );
170         }
171 
172         return new URLClassLoader( new URL[] { docResource } );
173     }
174 
175 }