package org.apache.maven.shared.jar.classes;

 /*

  * 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 org.apache.bcel.classfile.ConstantClass;

 import org.apache.bcel.classfile.ConstantUtf8;

 import org.apache.bcel.classfile.EmptyVisitor;

 import org.apache.bcel.classfile.JavaClass;

 import org.apache.commons.collections.list.SetUniqueList;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 /**

  * Implementation of a BCEL class visitor that analyzes a class and collects imports.

  */

 public class ImportVisitor

     extends EmptyVisitor

 {

     /**

      * The list of imports discovered.

      */

     private List imports;

     /**

      * The Java class that is being analyzed.

      */

     private JavaClass javaClass;

     /**

      * Pattern to detect if the import is qualified and allows retrieval of the actual import name from the string via the group 1.

      */

     private static final Pattern QUALIFIED_IMPORT_PATTERN = Pattern.compile( "L([a-zA-Z][a-zA-Z0-9\\.]+);" );

     /**

      * Pattern that checks whether a string is valid UTF-8. Imports that are not are ignored.

      */

     private static final Pattern VALID_UTF8_PATTERN = Pattern.compile( "^[\\(\\)\\[A-Za-z0-9;/]+$" );

     /**

      * Create an Import visitor.

      *

      * @param javaClass the javaclass to work from

      */

     public ImportVisitor( JavaClass javaClass )

     {

         this.javaClass = javaClass;

         // Create a list that is guaranteed to be unique while retaining it's list qualities (LinkedHashSet does not

         // expose the list interface even if natural ordering is retained)  

         this.imports = SetUniqueList.decorate( new ArrayList() );

     }

     /**

      * Get the list of discovered imports.

      *

      * @return Returns the imports.

      */

     public List getImports()

     {

         return imports;

     }

     /**

      * Find any formally declared import in the Constant Pool.

      *

      * @see org.apache.bcel.classfile.EmptyVisitor#visitConstantClass(org.apache.bcel.classfile.ConstantClass)

      */

     public void visitConstantClass( ConstantClass constantClass )

     {

         String name = constantClass.getBytes( javaClass.getConstantPool() );

         // only strings with '/' character are to be considered.

         if ( name.indexOf( '/' ) == -1 )

         {

             return;

         }

         name = name.replace( '/', '.' );

         if ( name.endsWith( ".class" ) )

         {

             name = name.substring( 0, name.length() - 6 );

         }

         Matcher mat = QUALIFIED_IMPORT_PATTERN.matcher( name );

         if ( mat.find() )

         {

             this.imports.add( mat.group( 1 ) );

         }

         else

         {

             this.imports.add( name );

         }

     }

     /**

      * Find any package class Strings in the UTF8 String Pool.

      *

      * @see org.apache.bcel.classfile.EmptyVisitor#visitConstantUtf8(org.apache.bcel.classfile.ConstantUtf8)

      */

     public void visitConstantUtf8( ConstantUtf8 constantUtf8 )

     {

         String ret = constantUtf8.getBytes().trim();

         // empty strings are not class names.

         if ( ret.length() <= 0 )

         {

             return;

         }

         // Only valid characters please.

         if ( !VALID_UTF8_PATTERN.matcher( ret ).matches() )

         {

             return;

         }

         // only strings with '/' character are to be considered.

         if ( ret.indexOf( '/' ) == -1 )

         {

             return;

         }

         // Strings that start with '/' are bad too

         // Seen when Pool has regex patterns.

         if ( ret.charAt( 0 ) == '/' )

         {

             return;

         }

         // Make string more class-like.

         ret = ret.replace( '/', '.' );

         // Double ".." indicates a bad class fail-fast.

         // Seen when ConstantUTF8 Pool has regex patterns.

         if ( ret.indexOf( ".." ) != -1 )

         {

             return;

         }

         Matcher mat = QUALIFIED_IMPORT_PATTERN.matcher( ret );

         char prefix = ret.charAt( 0 );

         if ( prefix == '(' )

         {

             // A Method Declaration.

             // Loop for each Qualified Class found.

             while ( mat.find() )

             {

                 this.imports.add( mat.group( 1 ) );

             }

         }

         else

         {

             // A Variable Declaration.

             if ( mat.find() )

             {

                 // Add a UTF8 Qualified Class reference.

                 this.imports.add( mat.group( 1 ) );

             }

             else

             {

                 // Add a simple Class reference.

                 this.imports.add( ret );

             }

         }

     }

 }