source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.archiva.repository.project.writers;
   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.commons.collections.CollectionUtils;
  23 import org.apache.commons.io.IOUtils;
  24 import org.apache.commons.lang.StringUtils;
  25 import org.apache.maven.archiva.model.ArchivaProjectModel;
  26 import org.apache.maven.archiva.model.ArtifactReference;
  27 import org.apache.maven.archiva.model.CiManagement;
  28 import org.apache.maven.archiva.model.Dependency;
  29 import org.apache.maven.archiva.model.Exclusion;
  30 import org.apache.maven.archiva.model.Individual;
  31 import org.apache.maven.archiva.model.IssueManagement;
  32 import org.apache.maven.archiva.model.License;
  33 import org.apache.maven.archiva.model.MailingList;
  34 import org.apache.maven.archiva.model.Organization;
  35 import org.apache.maven.archiva.model.ProjectRepository;
  36 import org.apache.maven.archiva.model.Scm;
  37 import org.apache.maven.archiva.model.VersionedReference;
  38 import org.apache.maven.archiva.repository.project.ProjectModelException;
  39 import org.apache.maven.archiva.repository.project.ProjectModelWriter;
  40 import org.apache.maven.archiva.xml.XMLException;
  41 import org.apache.maven.archiva.xml.XMLWriter;
  42 import org.dom4j.Document;
  43 import org.dom4j.DocumentHelper;
  44 import org.dom4j.Element;
  45 import org.dom4j.Namespace;
  46 import org.dom4j.Node;
  47 import org.dom4j.QName;
  48
  49 import java.io.File;
  50 import java.io.FileWriter;
  51 import java.io.IOException;
  52 import java.io.Writer;
  53 import java.util.Iterator;
  54 import java.util.List;
  55
  56 /**
  57  * ProjectModel400Writer for Maven 2 project model v4.0.0 pom files.
  58  *
  59  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  60  * @version $Id$
  61  *
  62  * @plexus.component
  63  *      role="org.apache.maven.archiva.repository.project.ProjectModelWriter"
  64  *      role-hint="model400"
  65  */
  66 public class ProjectModel400Writer
  67     implements ProjectModelWriter
  68 {
  69     private static final Namespace DEFAULT_NAMESPACE = Namespace.get( "", "http://maven.apache.org/POM/4.0.0" );
  70
  71     public void write( ArchivaProjectModel model, File pomFile )
  72         throws ProjectModelException, IOException
  73     {
  74         FileWriter writer = null;
  75         try
  76         {
  77             writer = new FileWriter( pomFile );
  78             write( model, writer );
  79             writer.flush();
  80         }
  81         finally
  82         {
  83             IOUtils.closeQuietly( writer );
  84         }
  85     }
  86
  87     public void write( ArchivaProjectModel model, Writer writer )
  88         throws ProjectModelException, IOException
  89     {
  90         Document doc = DocumentHelper.createDocument();
  91
  92         Element root = DocumentHelper.createElement( "project" );
  93
  94         root.add( DEFAULT_NAMESPACE );
  95         root.addNamespace( "xsi", "http://www.w3.org/2001/XMLSchema-instance" );
  96         root.addAttribute( "xsi:schemaLocation",
  97                            "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd" );
  98
  99         doc.setRootElement( root );
 100
 101         root.addElement( "modelVersion" ).setText( "4.0.0" );
 102
 103         addParent( root, model.getParentProject() );
 104
 105         addChildElement( root, "groupId", model.getGroupId() );
 106         root.addElement( "artifactId" ).setText( model.getArtifactId() );
 107
 108         addChildElement( root, "version", model.getVersion() );
 109
 110         addChildElement( root, "packaging", model.getPackaging() );
 111         addChildElement( root, "name", model.getName() );
 112         addChildElement( root, "description", model.getDescription() );
 113         addChildElement( root, "url", model.getUrl() );
 114         // TODO: add inceptionYear to ArchivaProjectModel
 115
 116         addOrganization( root, model.getOrganization() );
 117
 118         addIssueManagement( root, model.getIssueManagement() );
 119         addCiManagement( root, model.getCiManagement() );
 120         addMailingLists( root, model.getMailingLists() );
 121         addDevelopersAndContributors( root, model.getIndividuals() );
 122         // TODO: add distribution management to ArchivaProjectModel
 123
 124         addLicenses( root, model.getLicenses() );
 125         addRepositories( root, model.getRepositories() );
 126         addDependencyManagement( root, model.getDependencyManagement() );
 127         addDependencies( root, model.getDependencies() );
 128
 129         addReporting( root, model.getReports() );
 130         addScm( root, model.getScm() );
 131
 132         // <build> element
 133         addPlugins( root, model.getPlugins() );
 134         addBuildExtensions( root, model.getBuildExtensions() );
 135
 136         // <distributionManagement>
 137         addRelocation( root, model.getRelocation() );
 138
 139         fixDefaultNamespace( root );
 140
 141         try
 142         {
 143             XMLWriter.write( doc, writer );
 144         }
 145         catch ( XMLException e )
 146         {
 147             throw new ProjectModelException( "Unable to write xml contents to writer: " + e.getMessage(), e );
 148         }
 149     }
 150
 151     private void addArtifactReference( Element elem, ArtifactReference ref, String defaultType )
 152     {
 153         addChildElement( elem, "groupId", ref.getGroupId() );
 154         addChildElement( elem, "artifactId", ref.getArtifactId() );
 155         addChildElement( elem, "version", ref.getVersion() );
 156         addChildElement( elem, "classifier", ref.getClassifier() );
 157
 158         if ( !StringUtils.equals( defaultType, ref.getType() ) )
 159         {
 160             addChildElement( elem, "type", ref.getType() );
 161         }
 162     }
 163
 164     private void addBuildExtensions( Element root, List<ArtifactReference> buildExtensions )
 165     {
 166         if ( CollectionUtils.isEmpty( buildExtensions ) )
 167         {
 168             return;
 169         }
 170
 171         Element build = root.element( "build" );
 172         if ( build == null )
 173         {
 174             build = root.addElement( "build" );
 175         }
 176
 177         Element elemExtensions = build.addElement( "extensions" );
 178
 179         for ( ArtifactReference extension : buildExtensions )
 180         {
 181             Element elem = elemExtensions.addElement( "extension" );
 182
 183             addArtifactReference( elem, extension, "jar" );
 184         }
 185     }
 186
 187     private void addCiManagement( Element root, CiManagement ciManagement )
 188     {
 189         if ( ciManagement == null )
 190         {
 191             return;
 192         }
 193
 194         Element elem = root.addElement( "ciManagement" );
 195         addChildElement( elem, "system", ciManagement.getSystem() );
 196         addChildElement( elem, "url", ciManagement.getUrl() );
 197         // TODO: Add notifiers into ArchivaProjectModel
 198     }
 199
 200     private void addDependencies( Element root, List<Dependency> dependencies )
 201     {
 202         if ( CollectionUtils.isEmpty( dependencies ) )
 203         {
 204             return;
 205         }
 206
 207         addDependencyList( root, dependencies );
 208     }
 209
 210     private void addDependencyList( Element elemParent, List<Dependency> dependencies )
 211     {
 212         if ( CollectionUtils.isEmpty( dependencies ) )
 213         {
 214             return;
 215         }
 216
 217         Element elemDeps = elemParent.addElement( "dependencies" );
 218
 219         for ( Dependency dep : dependencies )
 220         {
 221             Element elem = elemDeps.addElement( "dependency" );
 222
 223             addChildElement( elem, "groupId", dep.getGroupId() );
 224             addChildElement( elem, "artifactId", dep.getArtifactId() );
 225             addChildElement( elem, "version", dep.getVersion() );
 226             addChildElement( elem, "classifier", dep.getClassifier() );
 227             addChildElement( elem, "type", dep.getType() );
 228             addChildElement( elem, "scope", dep.getScope() );
 229             addChildElement( elem, "systemPath", dep.getSystemPath() );
 230
 231             addExclusions( elem, dep.getExclusions() );
 232         }
 233     }
 234
 235     private void addDependencyManagement( Element root, List<Dependency> dependencyManagement )
 236     {
 237         if ( CollectionUtils.isEmpty( dependencyManagement ) )
 238         {
 239             return;
 240         }
 241
 242         Element elemDepMgmt = root.addElement( "dependencyManagement" );
 243         addDependencyList( elemDepMgmt, dependencyManagement );
 244     }
 245
 246     private void addDevelopersAndContributors( Element root, List<Individual> individuals )
 247     {
 248         if ( CollectionUtils.isEmpty( individuals ) )
 249         {
 250             return;
 251         }
 252
 253         Element developers = null;
 254         Element contributors = null;
 255
 256         for ( Individual individual : individuals )
 257         {
 258             if ( individual.isCommitor() )
 259             {
 260                 if ( developers == null )
 261                 {
 262                     developers = root.addElement( "developers" );
 263                 }
 264
 265                 Element developer = developers.addElement( "developer" );
 266                 addChildElement( developer, "id", individual.getPrincipal() );
 267                 addIndividual( developer, individual );
 268             }
 269             else
 270             {
 271                 if ( contributors == null )
 272                 {
 273                     contributors = root.addElement( "contributors" );
 274                 }
 275
 276                 Element contributor = contributors.addElement( "contributor" );
 277                 addIndividual( contributor, individual );
 278             }
 279         }
 280     }
 281
 282     private void addExclusions( Element elemParent, List<Exclusion> exclusions )
 283     {
 284         if ( CollectionUtils.isEmpty( exclusions ) )
 285         {
 286             return;
 287         }
 288
 289         Element elemExclusions = elemParent.addElement( "exclusions" );
 290
 291         for ( Exclusion exclusion : exclusions )
 292         {
 293             Element elem = elemExclusions.addElement( "exclusion" );
 294
 295             addChildElement( elem, "groupId", exclusion.getGroupId() );
 296             addChildElement( elem, "artifactId", exclusion.getArtifactId() );
 297         }
 298     }
 299
 300     private void addIndividual( Element elem, Individual individual )
 301     {
 302         addChildElement( elem, "name", individual.getName() );
 303         addChildElement( elem, "email", individual.getEmail() );
 304         addChildElement( elem, "organization", individual.getOrganization() );
 305         addChildElement( elem, "organizationUrl", individual.getOrganizationUrl() );
 306         addChildElement( elem, "timezone", individual.getTimezone() );
 307
 308         if ( CollectionUtils.isNotEmpty( individual.getRoles() ) )
 309         {
 310             Element roles = elem.addElement( "roles" );
 311             List<String> roleList = individual.getRoles();
 312             for ( String roleName : roleList )
 313             {
 314                 addChildElement( roles, "role", roleName );
 315             }
 316         }
 317     }
 318
 319     private void addIssueManagement( Element root, IssueManagement issueManagement )
 320     {
 321         if ( issueManagement == null )
 322         {
 323             return;
 324         }
 325
 326         Element elem = root.addElement( "issueManagement" );
 327         addChildElement( elem, "system", issueManagement.getSystem() );
 328         addChildElement( elem, "url", issueManagement.getUrl() );
 329     }
 330
 331     private void addLicenses( Element root, List<License> licenses )
 332     {
 333         if ( CollectionUtils.isEmpty( licenses ) )
 334         {
 335             return;
 336         }
 337
 338         Element elemLicenses = root.addElement( "licenses" );
 339
 340         for ( License license : licenses )
 341         {
 342             Element elem = elemLicenses.addElement( "license" );
 343             addChildElement( elem, "name", license.getName() );
 344             addChildElement( elem, "url", license.getUrl() );
 345             // TODO: research if we need <distribution> subelement.
 346         }
 347     }
 348
 349     private void addMailingLists( Element root, List<MailingList> mailingLists )
 350     {
 351         if ( CollectionUtils.isEmpty( mailingLists ) )
 352         {
 353             return;
 354         }
 355
 356         Element mlists = root.addElement( "mailingLists" );
 357
 358         for ( MailingList mailingList : mailingLists )
 359         {
 360             Element mlist = mlists.addElement( "mailingList" );
 361             addChildElement( mlist, "name", mailingList.getName() );
 362             addChildElement( mlist, "post", mailingList.getPostAddress() );
 363             addChildElement( mlist, "subscribe", mailingList.getSubscribeAddress() );
 364             addChildElement( mlist, "unsubscribe", mailingList.getUnsubscribeAddress() );
 365             addChildElement( mlist, "archive", mailingList.getMainArchiveUrl() );
 366
 367             addOtherArchives( mlist, mailingList.getOtherArchives() );
 368         }
 369     }
 370
 371     private void addOtherArchives( Element mlist, List<String> otherArchives )
 372     {
 373         if ( CollectionUtils.isEmpty( otherArchives ) )
 374         {
 375             return;
 376         }
 377
 378         Element elemOtherArchives = mlist.addElement( "otherArchives" );
 379
 380         for ( String archive : otherArchives )
 381         {
 382             addChildElement( elemOtherArchives, "otherArchive", archive );
 383         }
 384     }
 385
 386     private void addOrganization( Element root, Organization organization )
 387     {
 388         if ( organization == null )
 389         {
 390             return;
 391         }
 392
 393         Element elem = root.addElement( "organization" );
 394
 395         addChildElement( elem, "name", organization.getName() );
 396         addChildElement( elem, "url", organization.getUrl() );
 397     }
 398
 399     private void addParent( Element root, VersionedReference parentProject )
 400     {
 401         if ( parentProject == null )
 402         {
 403             return;
 404         }
 405
 406         Element parent = root.addElement( "parent" );
 407         parent.addElement( "groupId" ).setText( parentProject.getGroupId() );
 408         parent.addElement( "artifactId" ).setText( parentProject.getArtifactId() );
 409         parent.addElement( "version" ).setText( parentProject.getVersion() );
 410     }
 411
 412     private void addPlugins( Element root, List<ArtifactReference> plugins )
 413     {
 414         if ( CollectionUtils.isEmpty( plugins ) )
 415         {
 416             return;
 417         }
 418
 419         Element build = root.element( "build" );
 420         if ( build == null )
 421         {
 422             build = root.addElement( "build" );
 423         }
 424
 425         Element elemPlugins = build.addElement( "plugins" );
 426
 427         for ( ArtifactReference plugin : plugins )
 428         {
 429             Element elem = elemPlugins.addElement( "plugin" );
 430
 431             addArtifactReference( elem, plugin, "maven-plugin" );
 432         }
 433     }
 434
 435     private void addRelocation( Element root, VersionedReference relocation )
 436     {
 437         if ( relocation == null )
 438         {
 439             return;
 440         }
 441
 442         Element distribManagement = root.element( "distributionManagement" );
 443
 444         if ( distribManagement == null )
 445         {
 446             distribManagement = root.addElement( "distributionManagement" );
 447         }
 448
 449         Element elem = distribManagement.addElement( "relocation" );
 450         addChildElement( elem, "groupId", relocation.getGroupId() );
 451         addChildElement( elem, "artifactId", relocation.getArtifactId() );
 452         addChildElement( elem, "version", relocation.getVersion() );
 453     }
 454
 455     private void addReporting( Element root, List<ArtifactReference> reports )
 456     {
 457         if ( CollectionUtils.isEmpty( reports ) )
 458         {
 459             return;
 460         }
 461
 462         Element reporting = root.addElement( "reporting" );
 463         Element plugins = reporting.addElement( "plugins" );
 464
 465         for ( ArtifactReference reference : reports )
 466         {
 467             Element plugin = plugins.addElement( "plugin" );
 468             addChildElement( plugin, "groupId", reference.getGroupId() );
 469             addChildElement( plugin, "artifactId", reference.getArtifactId() );
 470             addChildElement( plugin, "version", reference.getVersion() );
 471         }
 472     }
 473
 474     private void addRepositories( Element root, List<ProjectRepository> repositories )
 475     {
 476         if ( CollectionUtils.isEmpty( repositories ) )
 477         {
 478             return;
 479         }
 480
 481         Element elemRepos = root.addElement( "repositories" );
 482         for ( ProjectRepository repository : repositories )
 483         {
 484             Element elem = elemRepos.addElement( "repository" );
 485             addChildElement( elem, "id", repository.getId() );
 486             addChildElement( elem, "name", repository.getName() );
 487             addChildElement( elem, "url", repository.getUrl() );
 488
 489             if ( !StringUtils.equals( "default", repository.getLayout() ) )
 490             {
 491                 addChildElement( elem, "layout", repository.getLayout() );
 492             }
 493         }
 494     }
 495
 496     private void addScm( Element root, Scm scm )
 497     {
 498         if ( scm == null )
 499         {
 500             return;
 501         }
 502
 503         Element elem = root.addElement( "scm" );
 504
 505         addChildElement( elem, "connection", scm.getConnection() );
 506         addChildElement( elem, "developerConnection", scm.getDeveloperConnection() );
 507         addChildElement( elem, "url", scm.getUrl() );
 508     }
 509
 510     /**
 511      * Fix the default namespace on all elements recursively.
 512      */
 513     private void fixDefaultNamespace( Element elem )
 514     {
 515         elem.remove( elem.getNamespace() );
 516         elem.setQName( QName.get( elem.getName(), DEFAULT_NAMESPACE, elem.getQualifiedName() ) );
 517
 518         Node n;
 519
 520         Iterator<Node> it = elem.elementIterator();
 521         while ( it.hasNext() )
 522         {
 523             n = it.next();
 524
 525             switch ( n.getNodeType() )
 526             {
 527                 case Node.ELEMENT_NODE:
 528                     fixDefaultNamespace( (Element) n );
 529                     break;
 530             }
 531         }
 532     }
 533
 534     private static void addChildElement( Element elem, String elemName, String text )
 535     {
 536         if ( StringUtils.isBlank( text ) )
 537         {
 538             return;
 539         }
 540
 541         elem.addElement( elemName ).setText( text );
 542     }
 543 }