001    package org.apache.maven.usability.plugin;
002    
003    /*
004     * Licensed to the Apache Software Foundation (ASF) under one
005     * or more contributor license agreements.  See the NOTICE file
006     * distributed with this work for additional information
007     * regarding copyright ownership.  The ASF licenses this file
008     * to you under the Apache License, Version 2.0 (the
009     * "License"); you may not use this file except in compliance
010     * with the License.  You may obtain a copy of the License at
011     *
012     *  http://www.apache.org/licenses/LICENSE-2.0
013     *
014     * Unless required by applicable law or agreed to in writing,
015     * software distributed under the License is distributed on an
016     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017     * KIND, either express or implied.  See the License for the
018     * specific language governing permissions and limitations
019     * under the License.
020     */
021    
022    import org.apache.maven.usability.plugin.io.xpp3.ParamdocXpp3Reader;
023    import org.codehaus.plexus.util.IOUtil;
024    import org.codehaus.plexus.util.ReaderFactory;
025    import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
026    
027    import java.io.BufferedReader;
028    import java.io.File;
029    import java.io.IOException;
030    import java.io.InputStream;
031    import java.io.Reader;
032    import java.net.MalformedURLException;
033    import java.net.URL;
034    import java.net.URLClassLoader;
035    import java.util.HashMap;
036    import java.util.Iterator;
037    import java.util.List;
038    import java.util.Map;
039    
040    public class ExpressionDocumenter
041    {
042    
043        private static final String[] EXPRESSION_ROOTS = { "project", "settings", "session", "plugin", "rootless" };
044    
045        private static final String EXPRESSION_DOCO_ROOTPATH = "META-INF/maven/plugin-expressions/";
046    
047        private static Map expressionDocumentation;
048    
049        public static Map load()
050            throws ExpressionDocumentationException
051        {
052            if ( expressionDocumentation == null )
053            {
054                expressionDocumentation = new HashMap();
055    
056                ClassLoader docLoader = initializeDocLoader();
057    
058                for ( int i = 0; i < EXPRESSION_ROOTS.length; i++ )
059                {
060                    InputStream docStream = null;
061                    try
062                    {
063                        docStream = docLoader
064                            .getResourceAsStream( EXPRESSION_DOCO_ROOTPATH + EXPRESSION_ROOTS[i] + ".paramdoc.xml" );
065    
066                        if ( docStream != null )
067                        {
068                            Map doco = parseExpressionDocumentation( docStream );
069    
070                            expressionDocumentation.putAll( doco );
071                        }
072                    }
073                    catch ( IOException e )
074                    {
075                        throw new ExpressionDocumentationException( "Failed to read documentation for expression root: "
076                            + EXPRESSION_ROOTS[i], e );
077                    }
078                    catch ( XmlPullParserException e )
079                    {
080                        throw new ExpressionDocumentationException( "Failed to parse documentation for expression root: "
081                            + EXPRESSION_ROOTS[i], e );
082                    }
083                    finally
084                    {
085                        IOUtil.close( docStream );
086                    }
087                }
088            }
089    
090            return expressionDocumentation;
091        }
092    
093        /**
094         * <expressions>
095         *   <expression>
096         *     <syntax>project.distributionManagementArtifactRepository</syntax>
097         *     <origin><![CDATA[
098         *   <distributionManagement>
099         *     <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    }