package org.apache.maven.plugin.version;
   
   /*
    * 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.maven.artifact.Artifact;
  import org.apache.maven.artifact.ArtifactUtils;
  import org.apache.maven.artifact.factory.ArtifactFactory;
  import org.apache.maven.artifact.metadata.ArtifactMetadataRetrievalException;
  import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
  import org.apache.maven.artifact.metadata.ResolutionGroup;
  import org.apache.maven.artifact.repository.ArtifactRepository;
  import org.apache.maven.artifact.versioning.ArtifactVersion;
  import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
  import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
  import org.apache.maven.artifact.versioning.VersionRange;
  import org.apache.maven.execution.RuntimeInformation;
  import org.apache.maven.model.Plugin;
  import org.apache.maven.model.ReportPlugin;
  import org.apache.maven.plugin.InvalidPluginException;
  import org.apache.maven.plugin.registry.MavenPluginRegistryBuilder;
  import org.apache.maven.plugin.registry.PluginRegistry;
  import org.apache.maven.plugin.registry.PluginRegistryUtils;
  import org.apache.maven.plugin.registry.TrackableBase;
  import org.apache.maven.plugin.registry.io.xpp3.PluginRegistryXpp3Writer;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.MavenProjectBuilder;
  import org.apache.maven.project.ProjectBuildingException;
  import org.apache.maven.settings.RuntimeInfo;
  import org.apache.maven.settings.Settings;
  import org.codehaus.plexus.components.interactivity.InputHandler;
  import org.codehaus.plexus.logging.AbstractLogEnabled;
  import org.codehaus.plexus.util.IOUtil;
  import org.codehaus.plexus.util.StringUtils;
  import org.codehaus.plexus.util.WriterFactory;
  import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.Writer;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  public class DefaultPluginVersionManager
      extends AbstractLogEnabled
      implements PluginVersionManager
  {
      private MavenPluginRegistryBuilder mavenPluginRegistryBuilder;
  
      private ArtifactFactory artifactFactory;
  
      private InputHandler inputHandler;
  
      private ArtifactMetadataSource artifactMetadataSource;
  
      // TODO: [jc] Revisit to remove this piece of state. PLUGIN REGISTRY MAY BE UPDATED ON DISK OUT-OF-PROCESS!
      private PluginRegistry pluginRegistry;
  
      private MavenProjectBuilder mavenProjectBuilder;
  
      private RuntimeInformation runtimeInformation;
  
      // TODO: Revisit to remove this piece of state. PLUGIN REGISTRY MAY BE UPDATED ON DISK OUT-OF-PROCESS!
      private Map resolvedMetaVersions = new HashMap();
  
      public String resolvePluginVersion( String groupId, String artifactId, MavenProject project, Settings settings,
                                          ArtifactRepository localRepository )
          throws PluginVersionResolutionException, InvalidPluginException, PluginVersionNotFoundException
      {
          return resolvePluginVersion( groupId, artifactId, project, settings, localRepository, false );
      }
  
      public String resolveReportPluginVersion( String groupId, String artifactId, MavenProject project,
                                                Settings settings, ArtifactRepository localRepository )
          throws PluginVersionResolutionException, InvalidPluginException, PluginVersionNotFoundException
      {
          return resolvePluginVersion( groupId, artifactId, project, settings, localRepository, true );
      }
 
     private String resolvePluginVersion( String groupId, String artifactId, MavenProject project, Settings settings,
                                          ArtifactRepository localRepository, boolean resolveAsReportPlugin )
         throws PluginVersionResolutionException, InvalidPluginException, PluginVersionNotFoundException
     {
         // first pass...if the plugin is specified in the pom, try to retrieve the version from there.
         String version = getVersionFromPluginConfig( groupId, artifactId, project, resolveAsReportPlugin );
 
         // NOTE: We CANNOT check the current project version here, so delay it until later.
         // It will prevent plugins from building themselves, if they are part of the lifecycle mapping.
 
         // if there was no explicit version, try for one in the reactor
         if ( version == null )
         {
             if ( project.getProjectReferences() != null )
             {
                 String refId = ArtifactUtils.versionlessKey( groupId, artifactId );
                 MavenProject ref = (MavenProject) project.getProjectReferences().get( refId );
                 if ( ref != null )
                 {
                     version = ref.getVersion();
                 }
             }
         }
 
         // we're NEVER going to persist POM-derived plugin versions.
         String updatedVersion = null;
 
         // we're not going to prompt the user to accept a plugin update until we find one.
         boolean promptToPersist = false;
 
         RuntimeInfo settingsRTInfo = settings.getRuntimeInfo();
 
         // determine the behavior WRT prompting the user and installing plugin updates.
         Boolean pluginUpdateOverride = settingsRTInfo.getPluginUpdateOverride();
 
         // second pass...if we're using the plugin registry, and the plugin is listed in the plugin-registry.xml, use
         // the version from <useVersion/>.
         if ( StringUtils.isEmpty( version ) && settings.isUsePluginRegistry() )
         {
             // resolve existing useVersion.
             version = resolveExistingFromPluginRegistry( groupId, artifactId );
 
             if ( StringUtils.isNotEmpty( version ) )
             {
                 // 2. check for updates. Determine whether this is the right time to attempt to update the version.
                 // Only check for plugin updates if:
                 //
                 //  a. the CLI switch to force plugin updates is set, OR BOTH OF THE FOLLOWING:
                 //  b. the CLI switch to suppress plugin updates is NOT set, AND
                 //  c. the update interval for the plugin has triggered an update check.
                 if ( Boolean.TRUE.equals( pluginUpdateOverride ) ||
                     ( !Boolean.FALSE.equals( pluginUpdateOverride ) && shouldCheckForUpdates( groupId, artifactId ) ) )
                 {
                     updatedVersion =
                         resolveMetaVersion( groupId, artifactId, project, localRepository, Artifact.LATEST_VERSION );
 
                     if ( StringUtils.isNotEmpty( updatedVersion ) && !updatedVersion.equals( version ) )
                     {
                         // see if this version we've resolved is on our previously rejected list.
                         boolean isRejected = checkForRejectedStatus( groupId, artifactId, updatedVersion );
 
                         // we should only prompt to use this version if the user has not previously rejected it.
                         promptToPersist = !isRejected;
 
                         // if we've rejected this version previously, forget about updating.
                         if ( isRejected )
                         {
                             updatedVersion = null;
                         }
                         else
                         {
                             getLogger().info(
                                 "Plugin \'" + constructPluginKey( groupId, artifactId ) + "\' has updates." );
                         }
                     }
                 }
             }
         }
 
         boolean forcePersist = false;
 
         // third pass...we're always checking for latest install/deploy, so retrieve the version for LATEST metadata and
         // also set that resolved version as the <useVersion/> in settings.xml.
         if ( StringUtils.isEmpty( version ) )
         {
             // 1. resolve the version to be used
             version = resolveMetaVersion( groupId, artifactId, project, localRepository, Artifact.LATEST_VERSION );
 
             if ( version != null )
             {
                 // 2. Set the updatedVersion so the user will be prompted whether to make this version permanent.
                 updatedVersion = version;
 
                 // 3. Persist this version without prompting.
                 forcePersist = true;
                 promptToPersist = false;
             }
         }
 
         // final pass...retrieve the version for RELEASE and also set that resolved version as the <useVersion/>
         // in settings.xml.
         if ( StringUtils.isEmpty( version ) )
         {
             // 1. resolve the version to be used
             version = resolveMetaVersion( groupId, artifactId, project, localRepository, Artifact.RELEASE_VERSION );
 
             if ( version != null )
             {
                 // 2. Set the updatedVersion so the user will be prompted whether to make this version permanent.
                 updatedVersion = version;
 
                 // 3. Persist this version without prompting.
                 forcePersist = true;
                 promptToPersist = false;
             }
         }
 
         // if we're still empty here, and the current project matches the plugin in question, use the current project's
         // version, I guess...
         if ( StringUtils.isEmpty( version ) && project.getGroupId().equals( groupId ) &&
             project.getArtifactId().equals( artifactId ) )
         {
             version = project.getVersion();
         }
 
         // if we still haven't found a version, then fail early before we get into the update goop.
         if ( StringUtils.isEmpty( version ) )
         {
             throw new PluginVersionNotFoundException( groupId, artifactId );
         }
 
         // if the plugin registry is inactive, then the rest of this goop is useless...
         if ( settings.isUsePluginRegistry() )
         {
             // determine whether this build is running in interactive mode
             // If it's not, then we'll defer to the autoUpdate setting from the registry
             // for a decision on updating the plugin in the registry...rather than prompting
             // the user.
             boolean inInteractiveMode = settings.isInteractiveMode();
 
             // determines what should be done if we're in non-interactive mode.
             // if true, then just update the registry with the new versions.
             String s = getPluginRegistry( groupId, artifactId ).getAutoUpdate();
             boolean autoUpdate = true;
             if ( s != null )
             {
                 autoUpdate = Boolean.valueOf( s ).booleanValue();
             }
 
             // We should persist by default if:
             //
             // 0. RELEASE or LATEST was used to resolve the plugin version (it's not in the registry)
             //
             // -OR-
             //
             // 1. we detected a change in the plugin version from what was in the registry, or
             //      a. the plugin is not registered
             // 2. the pluginUpdateOverride flag has NOT been set to Boolean.FALSE (suppression mode)
             // 3. we're in interactive mode, or
             //      a. the registry is declared to be in autoUpdate mode
             //
             // NOTE: This is only the default value; it may be changed as the result of prompting the user.
             boolean persistUpdate = forcePersist || ( promptToPersist &&
                 !Boolean.FALSE.equals( pluginUpdateOverride ) && ( inInteractiveMode || autoUpdate ) );
 
             // retrieve the apply-to-all flag, if it's been set previously.
             Boolean applyToAll = settings.getRuntimeInfo().getApplyToAllPluginUpdates();
 
             // Incorporate interactive-mode CLI overrides, and previous decisions on apply-to-all, if appropriate.
             //
             // don't prompt if RELEASE or LATEST was used to resolve the plugin version
             // don't prompt if not in interactive mode.
             // don't prompt if the CLI pluginUpdateOverride is set (either suppression or force mode will stop prompting)
             // don't prompt if the user has selected ALL/NONE previously in this session
             //
             // NOTE: We're incorporating here, to make the usages of this check more consistent and 
             // resistant to change.
             promptToPersist =
                 promptToPersist && pluginUpdateOverride == null && applyToAll == null && inInteractiveMode;
 
             if ( promptToPersist )
             {
                 persistUpdate = promptToPersistPluginUpdate( version, updatedVersion, groupId, artifactId, settings );
             }
 
             // if it is determined that we should use this version, persist it as useVersion.
             // cases where this version will be persisted:
             // 1. the user is prompted and answers yes or all
             // 2. the user has previously answered all in this session
             // 3. the build is running in non-interactive mode, and the registry setting is for auto-update
             if ( !Boolean.FALSE.equals( applyToAll ) && persistUpdate )
             {
                 updatePluginVersionInRegistry( groupId, artifactId, updatedVersion );
 
                 // we're using the updated version of the plugin in this session as well.
                 version = updatedVersion;
             }
             // otherwise, if we prompted the user to update, we should treat this as a rejectedVersion, and
             // persist it iff the plugin pre-exists and is in the user-level registry.
             else if ( promptToPersist )
             {
                 addNewVersionToRejectedListInExisting( groupId, artifactId, updatedVersion );
             }
         }
 
         return version;
     }
 
     private boolean shouldCheckForUpdates( String groupId, String artifactId )
         throws PluginVersionResolutionException
     {
         PluginRegistry pluginRegistry = getPluginRegistry( groupId, artifactId );
 
         org.apache.maven.plugin.registry.Plugin plugin = getPlugin( groupId, artifactId, pluginRegistry );
 
         if ( plugin == null )
         {
             return true;
         }
         else
         {
             String lastChecked = plugin.getLastChecked();
 
             if ( StringUtils.isEmpty( lastChecked ) )
             {
                 return true;
             }
             else
             {
                 SimpleDateFormat format =
                     new SimpleDateFormat( org.apache.maven.plugin.registry.Plugin.LAST_CHECKED_DATE_FORMAT );
 
                 try
                 {
                     Date lastCheckedDate = format.parse( lastChecked );
 
                     return IntervalUtils.isExpired( pluginRegistry.getUpdateInterval(), lastCheckedDate );
                 }
                 catch ( ParseException e )
                 {
                     getLogger().warn( "Last-checked date for plugin {" + constructPluginKey( groupId, artifactId ) +
                         "} is invalid. Checking for updates." );
 
                     return true;
                 }
             }
         }
     }
 
     private boolean checkForRejectedStatus( String groupId, String artifactId, String version )
         throws PluginVersionResolutionException
     {
         PluginRegistry pluginRegistry = getPluginRegistry( groupId, artifactId );
 
         org.apache.maven.plugin.registry.Plugin plugin = getPlugin( groupId, artifactId, pluginRegistry );
 
         return plugin.getRejectedVersions().contains( version );
     }
 
     private boolean promptToPersistPluginUpdate( String version, String updatedVersion, String groupId,
                                                  String artifactId, Settings settings )
         throws PluginVersionResolutionException
     {
         try
         {
             StringBuffer message = new StringBuffer();
 
             // this means that the plugin is not registered.
             if ( version != null && version.equals( updatedVersion ) )
             {
                 message.append( "Unregistered plugin detected.\n\n" );
             }
             else
             {
                 message.append( "New plugin version detected.\n\n" );
             }
 
             message.append( "Group ID: " ).append( groupId ).append( "\n" );
             message.append( "Artifact ID: " ).append( artifactId ).append( "\n" );
             message.append( "\n" );
 
             // this means that we've detected a new, non-rejected plugin version.
             if ( version != null && !version.equals( updatedVersion ) )
             {
                 message.append( "Registered Version: " ).append( version ).append( "\n" );
             }
 
             message.append( "Detected plugin version: " ).append( updatedVersion ).append( "\n" );
             message.append( "\n" );
             message.append( "Would you like to use this new version from now on? ( [Y]es, [n]o, [a]ll, n[o]ne ) " );
 
             // TODO: check the GUI-friendliness of this approach to collecting input.
             // If we can't port this prompt into a GUI, IDE-integration will not work well.
             getLogger().info( message.toString() );
 
             String persistAnswer = inputHandler.readLine();
 
             boolean shouldPersist = true;
 
             if ( !StringUtils.isEmpty( persistAnswer ) )
             {
                 persistAnswer = persistAnswer.toLowerCase();
 
                 if ( persistAnswer.startsWith( "y" ) )
                 {
                     shouldPersist = true;
                 }
                 else if ( persistAnswer.startsWith( "a" ) )
                 {
                     shouldPersist = true;
 
                     settings.getRuntimeInfo().setApplyToAllPluginUpdates( Boolean.TRUE );
                 }
                 else if ( persistAnswer.indexOf( "o" ) > -1 )
                 {
                     settings.getRuntimeInfo().setApplyToAllPluginUpdates( Boolean.FALSE );
                 }
                 else if ( persistAnswer.startsWith( "n" ) )
                 {
                     shouldPersist = false;
                 }
                 else
                 {
                     // default to yes.
                     shouldPersist = true;
                 }
             }
 
             if ( shouldPersist )
             {
                 getLogger().info( "Updating plugin version to " + updatedVersion );
             }
             else
             {
                 getLogger().info( "NOT updating plugin version to " + updatedVersion );
             }
 
             return shouldPersist;
 
         }
         catch ( IOException e )
         {
             throw new PluginVersionResolutionException( groupId, artifactId, "Can't read user input.", e );
         }
     }
 
     private void addNewVersionToRejectedListInExisting( String groupId, String artifactId, String rejectedVersion )
         throws PluginVersionResolutionException
     {
         PluginRegistry pluginRegistry = getPluginRegistry( groupId, artifactId );
 
         org.apache.maven.plugin.registry.Plugin plugin = getPlugin( groupId, artifactId, pluginRegistry );
 
         String pluginKey = constructPluginKey( groupId, artifactId );
 
         if ( plugin != null && !TrackableBase.GLOBAL_LEVEL.equals( plugin.getSourceLevel() ) )
         {
             plugin.addRejectedVersion( rejectedVersion );
 
             writeUserRegistry( groupId, artifactId, pluginRegistry );
 
             getLogger().warn( "Plugin version: " + rejectedVersion + " added to your rejectedVersions list.\n" +
                 "You will not be prompted for this version again.\n\nPlugin: " + pluginKey );
         }
         else
         {
             getLogger().warn(
                 "Cannot add rejectedVersion entry for: " + rejectedVersion + ".\n\nPlugin: " + pluginKey );
         }
     }
 
     private String resolveExistingFromPluginRegistry( String groupId, String artifactId )
         throws PluginVersionResolutionException
     {
         PluginRegistry pluginRegistry = getPluginRegistry( groupId, artifactId );
 
         org.apache.maven.plugin.registry.Plugin plugin = getPlugin( groupId, artifactId, pluginRegistry );
 
         String version = null;
 
         if ( plugin != null )
         {
             version = plugin.getUseVersion();
         }
 
         return version;
     }
 
     private org.apache.maven.plugin.registry.Plugin getPlugin( String groupId, String artifactId,
                                                                PluginRegistry pluginRegistry )
     {
         Map pluginsByKey;
 
         if ( pluginRegistry != null )
         {
             pluginsByKey = pluginRegistry.getPluginsByKey();
         }
         else
         {
             pluginsByKey = new HashMap();
         }
 
         String pluginKey = constructPluginKey( groupId, artifactId );
 
         return (org.apache.maven.plugin.registry.Plugin) pluginsByKey.get( pluginKey );
     }
 
     private String constructPluginKey( String groupId, String artifactId )
     {
         return groupId + ":" + artifactId;
     }
 
     private String getVersionFromPluginConfig( String groupId, String artifactId, MavenProject project,
                                                boolean resolveAsReportPlugin )
     {
         String version = null;
 
         if ( resolveAsReportPlugin )
         {
             if ( project.getReportPlugins() != null )
             {
                 for ( Iterator it = project.getReportPlugins().iterator(); it.hasNext() && version == null; )
                 {
                     ReportPlugin plugin = (ReportPlugin) it.next();
 
                     if ( groupId.equals( plugin.getGroupId() ) && artifactId.equals( plugin.getArtifactId() ) )
                     {
                         version = plugin.getVersion();
                     }
                 }
             }
         }
         else
         {
             if ( project.getBuildPlugins() != null )
             {
                 for ( Iterator it = project.getBuildPlugins().iterator(); it.hasNext() && version == null; )
                 {
                     Plugin plugin = (Plugin) it.next();
 
                     if ( groupId.equals( plugin.getGroupId() ) && artifactId.equals( plugin.getArtifactId() ) )
                     {
                         version = plugin.getVersion();
                     }
                 }
             }
         }
 
         return version;
     }
 
     private void updatePluginVersionInRegistry( String groupId, String artifactId, String version )
         throws PluginVersionResolutionException
     {
         PluginRegistry pluginRegistry = getPluginRegistry( groupId, artifactId );
 
         org.apache.maven.plugin.registry.Plugin plugin = getPlugin( groupId, artifactId, pluginRegistry );
 
         // if we can find the plugin, but we've gotten here, the useVersion must be missing; fill it in.
         if ( plugin != null )
         {
             if ( PluginRegistry.GLOBAL_LEVEL.equals( plugin.getSourceLevel() ) )
             {
                 // do nothing. We don't rewrite the globals, under any circumstances.
                 getLogger().warn( "Cannot update registered version for plugin {" + groupId + ":" + artifactId +
                     "}; it is specified in the global registry." );
             }
             else
             {
                 plugin.setUseVersion( version );
 
                 SimpleDateFormat format =
                     new SimpleDateFormat( org.apache.maven.plugin.registry.Plugin.LAST_CHECKED_DATE_FORMAT );
 
                 plugin.setLastChecked( format.format( new Date() ) );
             }
         }
         else
         {
             plugin = new org.apache.maven.plugin.registry.Plugin();
 
             plugin.setGroupId( groupId );
             plugin.setArtifactId( artifactId );
             plugin.setUseVersion( version );
 
             pluginRegistry.addPlugin( plugin );
 
             pluginRegistry.flushPluginsByKey();
         }
 
         writeUserRegistry( groupId, artifactId, pluginRegistry );
     }
 
     private void writeUserRegistry( String groupId, String artifactId, PluginRegistry pluginRegistry )
     {
         File pluginRegistryFile = pluginRegistry.getRuntimeInfo().getFile();
 
         PluginRegistry extractedUserRegistry = PluginRegistryUtils.extractUserPluginRegistry( pluginRegistry );
 
         // only rewrite the user-level registry if one existed before, or if we've created user-level data here.
         if ( extractedUserRegistry != null )
         {
             Writer fWriter = null;
 
             try
             {
                 pluginRegistryFile.getParentFile().mkdirs();
                 fWriter = WriterFactory.newXmlWriter( pluginRegistryFile );
 
                 PluginRegistryXpp3Writer writer = new PluginRegistryXpp3Writer();
 
                 writer.write( fWriter, extractedUserRegistry );
             }
             catch ( IOException e )
             {
                 getLogger().warn(
                     "Cannot rewrite user-level plugin-registry.xml with new plugin version of plugin: \'" + groupId +
                         ":" + artifactId + "\'.", e );
             }
             finally
             {
                 IOUtil.close( fWriter );
             }
         }
     }
 
     private PluginRegistry getPluginRegistry( String groupId, String artifactId )
         throws PluginVersionResolutionException
     {
         if ( pluginRegistry == null )
         {
             try
             {
                 pluginRegistry = mavenPluginRegistryBuilder.buildPluginRegistry();
             }
             catch ( IOException e )
             {
                 throw new PluginVersionResolutionException( groupId, artifactId,
                                                             "Error reading plugin registry: " + e.getMessage(), e );
             }
             catch ( XmlPullParserException e )
             {
                 throw new PluginVersionResolutionException( groupId, artifactId,
                                                             "Error parsing plugin registry: " + e.getMessage(), e );
             }
 
             if ( pluginRegistry == null )
             {
                 pluginRegistry = mavenPluginRegistryBuilder.createUserPluginRegistry();
             }
         }
 
         return pluginRegistry;
     }
 
     private String resolveMetaVersion( String groupId, String artifactId, MavenProject project,
                                        ArtifactRepository localRepository, String metaVersionId )
         throws PluginVersionResolutionException, InvalidPluginException
     {
         Artifact artifact = artifactFactory.createProjectArtifact( groupId, artifactId, metaVersionId );
 
         String key = artifact.getDependencyConflictId();
         if ( resolvedMetaVersions.containsKey( key ) )
         {
             return (String) resolvedMetaVersions.get( key );
         }
 
         String version = null;
 
         // This takes the spec version and resolves a real version
         try
         {
             ResolutionGroup resolutionGroup =
                 artifactMetadataSource.retrieve( artifact, localRepository, project.getPluginArtifactRepositories() );
 
             // switching this out with the actual resolved artifact instance, since the MMSource re-creates the pom
             // artifact.
             artifact = resolutionGroup.getPomArtifact();
         }
         catch ( ArtifactMetadataRetrievalException e )
         {
             throw new PluginVersionResolutionException( groupId, artifactId, e.getMessage(), e );
         }
 
         String artifactVersion = artifact.getVersion();
 
         // make sure this artifact was actually resolved to a file in the repo...
         if ( artifact.getFile() != null )
         {
             boolean pluginValid = false;
 
             while ( !pluginValid && artifactVersion != null )
             {
                 pluginValid = true;
                 MavenProject pluginProject;
                 try
                 {
                     artifact = artifactFactory.createProjectArtifact( groupId, artifactId, artifactVersion );
                     pluginProject = mavenProjectBuilder.buildFromRepository( artifact,
                                                                              project.getPluginArtifactRepositories(),
                                                                              localRepository, false );
                 }
                 catch ( ProjectBuildingException e )
                 {
                     throw new InvalidPluginException( "Unable to build project information for plugin '" +
                         ArtifactUtils.versionlessKey( groupId, artifactId ) + "': " + e.getMessage(), e );
                 }
 
                 // if we don't have the required Maven version, then ignore an update
                 if ( pluginProject.getPrerequisites() != null && pluginProject.getPrerequisites().getMaven() != null )
                 {
                     DefaultArtifactVersion requiredVersion =
                         new DefaultArtifactVersion( pluginProject.getPrerequisites().getMaven() );
 
                     if ( runtimeInformation.getApplicationVersion().compareTo( requiredVersion ) < 0 )
                     {
                         getLogger().info( "Ignoring available plugin update: " + artifactVersion +
                             " as it requires Maven version " + requiredVersion );
 
                         VersionRange vr;
                         try
                         {
                             vr = VersionRange.createFromVersionSpec( "(," + artifactVersion + ")" );
                         }
                         catch ( InvalidVersionSpecificationException e )
                         {
                             throw new PluginVersionResolutionException( groupId, artifactId,
                                                                         "Error getting available plugin versions: " +
                                                                             e.getMessage(), e );
                         }
 
                         getLogger().debug( "Trying " + vr );
                         try
                         {
                             List versions = artifactMetadataSource.retrieveAvailableVersions( artifact, localRepository,
                                                                                               project.getPluginArtifactRepositories() );
                             ArtifactVersion v = vr.matchVersion( versions );
                             artifactVersion = v != null ? v.toString() : null;
                         }
                         catch ( ArtifactMetadataRetrievalException e )
                         {
                             throw new PluginVersionResolutionException( groupId, artifactId,
                                                                         "Error getting available plugin versions: " +
                                                                             e.getMessage(), e );
                         }
 
                         if ( artifactVersion != null )
                         {
                             getLogger().debug( "Found " + artifactVersion );
                             pluginValid = false;
                         }
                     }
                 }
             }
         }
 
         if ( !metaVersionId.equals( artifactVersion ) )
         {
             version = artifactVersion;
             resolvedMetaVersions.put( key, version );
         }
 
         return version;
     }
 
 }