Added resolving of resource

krosenvold · krosenvold · commit b4e6875d7093 · 2014-10-28T23:22:47.000+01:00
diff --git a/pom.xml b/pom.xml
@@ -56,7 +56,7 @@
     <dependency>
       <groupId>org.codehaus.plexus</groupId>
       <artifactId>plexus-io</artifactId>
-      <version>2.3.2</version>
+      <version>2.3.3</version>
     </dependency>
     <dependency>
       <groupId>org.apache.commons</groupId>
diff --git a/src/main/java/org/codehaus/plexus/archiver/AbstractArchiver.java b/src/main/java/org/codehaus/plexus/archiver/AbstractArchiver.java
@@ -258,30 +258,30 @@ public void setIncludeEmptyDirs( final boolean includeEmptyDirs )
     public void addDirectory( @Nonnull final File directory )
         throws ArchiverException
     {
-        addFileSet( fileSet( directory ).prefixed( "" )
-            .includeExclude( null, null ).includeEmptyDirs( includeEmptyDirs ) );
+        addFileSet(
+            fileSet( directory ).prefixed( "" ).includeExclude( null, null ).includeEmptyDirs( includeEmptyDirs ) );
     }
 
     public void addDirectory( @Nonnull final File directory, final String prefix )
         throws ArchiverException
     {
-        addFileSet( fileSet( directory ).prefixed( prefix )
-            .includeExclude( null, null ).includeEmptyDirs( includeEmptyDirs ) );
+        addFileSet(
+            fileSet( directory ).prefixed( prefix ).includeExclude( null, null ).includeEmptyDirs( includeEmptyDirs ) );
     }
 
     public void addDirectory( @Nonnull final File directory, final String[] includes, final String[] excludes )
         throws ArchiverException
     {
-        addFileSet( fileSet( directory ).prefixed( "" )
-            .includeExclude( includes, excludes ).includeEmptyDirs( includeEmptyDirs ) );
+        addFileSet( fileSet( directory ).prefixed( "" ).includeExclude( includes, excludes ).includeEmptyDirs(
+            includeEmptyDirs ) );
     }
 
     public void addDirectory( @Nonnull final File directory, final String prefix, final String[] includes,
                               final String[] excludes )
         throws ArchiverException
     {
-        addFileSet( fileSet( directory ).prefixed( prefix )
-            .includeExclude( includes, excludes ).includeEmptyDirs( includeEmptyDirs ) );
+        addFileSet( fileSet( directory ).prefixed( prefix ).includeExclude( includes, excludes ).includeEmptyDirs(
+            includeEmptyDirs ) );
     }
 
     public void addFileSet( @Nonnull final FileSet fileSet )
@@ -300,7 +300,7 @@ public void addFileSet( @Nonnull final FileSet fileSet )
 
         // The PlexusIoFileResourceCollection contains platform-specific File.separatorChar which
         // is an interesting cause of grief, see PLXCOMP-192
-        final PlexusIoFileResourceCollection collection = new PlexusIoFileResourceCollection( );
+        final PlexusIoFileResourceCollection collection = new PlexusIoFileResourceCollection();
         collection.setFollowingSymLinks( !isSymlinkSupported() );
 
         collection.setIncludes( fileSet.getIncludes() );
@@ -328,8 +328,7 @@ public void addFileSet( @Nonnull final FileSet fileSet )
 
     private boolean isSymlinkSupported()
     {
-        return Os.isFamily( Os.FAMILY_UNIX )  &&
-        Java7Reflector.isAtLeastJava7();
+        return Os.isFamily( Os.FAMILY_UNIX ) && Java7Reflector.isAtLeastJava7();
     }
 
     public void addFile( @Nonnull final File inputFile, @Nonnull final String destFileName )
@@ -340,22 +339,22 @@ public void addFile( @Nonnull final File inputFile, @Nonnull final String destFi
         addFile( inputFile, destFileName, fileMode );
     }
 
-    public void addSymlink(String symlinkName, String symlinkDestination)
+    public void addSymlink( String symlinkName, String symlinkDestination )
         throws ArchiverException
     {
         final int fileMode = getOverrideFileMode();
 
-        addSymlink(symlinkName, fileMode, symlinkDestination);
+        addSymlink( symlinkName, fileMode, symlinkDestination );
     }
 
-    public void addSymlink(String symlinkName, int permissions, String symlinkDestination)
+    public void addSymlink( String symlinkName, int permissions, String symlinkDestination )
         throws ArchiverException
     {
         resources.add( ArchiveEntry.createSymlinkEntry( symlinkName, permissions, symlinkDestination ) );
     }
 
     protected ArchiveEntry asArchiveEntry( @Nonnull final PlexusIoResource resource, final String destFileName,
-                                           final int permissions,  PlexusIoResourceCollection collection)
+                                           final int permissions, PlexusIoResourceCollection collection )
         throws ArchiverException
     {
         if ( !resource.isExisting() )
@@ -377,27 +376,20 @@ protected ArchiveEntry asArchiveEntry( final PlexusIoResourceCollection collecti
                                            final PlexusIoResource resource )
         throws ArchiverException
     {
-        try
+        final String destFileName = collection.getName( resource );
+
+        int permissions = -1;
+        if ( resource instanceof PlexusIoResourceWithAttributes )
         {
-            final String destFileName = collection.getName( resource );
+            final PlexusIoResourceAttributes attrs = ( (PlexusIoResourceWithAttributes) resource ).getAttributes();
 
-            int permissions = -1;
-            if ( resource instanceof PlexusIoResourceWithAttributes )
+            if ( attrs != null )
             {
-                final PlexusIoResourceAttributes attrs = ( (PlexusIoResourceWithAttributes) resource ).getAttributes();
-
-                if ( attrs != null )
-                {
-                    permissions = attrs.getOctalMode();
-                }
+                permissions = attrs.getOctalMode();
             }
-
-            return asArchiveEntry( resource, destFileName, permissions, collection );
-        }
-        catch ( final IOException e )
-        {
-            throw new ArchiverException( e.getMessage(), e );
         }
+
+        return asArchiveEntry( resource, destFileName, permissions, collection );
     }
 
     public void addResource( final PlexusIoResource resource, final String destFileName, final int permissions )
@@ -457,7 +449,7 @@ public void addFile( @Nonnull final File inputFile, @Nonnull String destFileName
         }
     }
 
-	@Nonnull
+    @Nonnull
     public ResourceIterator getResources()
         throws ArchiverException
     {
@@ -559,8 +551,8 @@ else if ( Archiver.DUPLICATES_FAIL.equals( duplicateBehavior ) )
             private boolean throwIllegalResourceType( Object o )
             {
                 throw new IllegalStateException(
-                    "An invalid resource of type: " + o.getClass().getName()
-                        + " was added to archiver: " + getClass().getName() );
+                    "An invalid resource of type: " + o.getClass().getName() + " was added to archiver: "
+                        + getClass().getName() );
             }
 
             public ArchiveEntry next()
@@ -585,11 +577,11 @@ public void remove()
         };
     }
 
-    public Map<String,ArchiveEntry> getFiles()
+    public Map<String, ArchiveEntry> getFiles()
     {
         try
         {
-            final Map<String,ArchiveEntry> map = new HashMap<String,ArchiveEntry>();
+            final Map<String, ArchiveEntry> map = new HashMap<String, ArchiveEntry>();
             for ( final ResourceIterator iter = getResources(); iter.hasNext(); )
             {
                 final ArchiveEntry entry = iter.next();
@@ -685,10 +677,11 @@ protected PlexusIoResourceCollection asResourceCollection( final ArchivedFileSet
                                              + resources.getClass().getName() );
         }
 
-        if (resources instanceof AbstractPlexusIoResourceCollection ){
-            ((AbstractPlexusIoResourceCollection)resources).setStreamTransformer( fileSet.getStreamTransformer() );
+        if ( resources instanceof AbstractPlexusIoResourceCollection )
+        {
+            ( (AbstractPlexusIoResourceCollection) resources ).setStreamTransformer( fileSet.getStreamTransformer() );
         }
-        final PlexusIoProxyResourceCollection proxy = new PlexusIoProxyResourceCollection(resources);
+        final PlexusIoProxyResourceCollection proxy = new PlexusIoProxyResourceCollection( resources );
 
         proxy.setExcludes( fileSet.getExcludes() );
         proxy.setIncludes( fileSet.getIncludes() );
@@ -718,7 +711,7 @@ protected PlexusIoResourceCollection asResourceCollection( final ArchivedFileSet
     public void addResources( final PlexusIoResourceCollection collection )
         throws ArchiverException
     {
-        resources.add(collection);
+        resources.add( collection );
     }
 
     public void addArchivedFileSet( final ArchivedFileSet fileSet )
@@ -736,10 +729,8 @@ public void addArchivedFileSet( @Nonnull final File archiveFile, final String pr
         throws ArchiverException
     {
         addArchivedFileSet(
-            archivedFileSet( archiveFile )
-                .prefixed( prefix )
-                .includeExclude( includes, excludes )
-                .includeEmptyDirs( includeEmptyDirs ) );
+            archivedFileSet( archiveFile ).prefixed( prefix ).includeExclude( includes, excludes ).includeEmptyDirs(
+                includeEmptyDirs ) );
     }
 
     /**
@@ -748,10 +739,7 @@ public void addArchivedFileSet( @Nonnull final File archiveFile, final String pr
     public void addArchivedFileSet( @Nonnull final File archiveFile, final String prefix )
         throws ArchiverException
     {
-        addArchivedFileSet(
-            archivedFileSet( archiveFile )
-                .prefixed( prefix )
-                .includeEmptyDirs( includeEmptyDirs ) );
+        addArchivedFileSet( archivedFileSet( archiveFile ).prefixed( prefix ).includeEmptyDirs( includeEmptyDirs ) );
     }
 
     /**
@@ -761,9 +749,7 @@ public void addArchivedFileSet( @Nonnull final File archiveFile, final String[]
         throws ArchiverException
     {
         addArchivedFileSet(
-            archivedFileSet( archiveFile )
-                .includeExclude( includes, excludes )
-                .includeEmptyDirs( includeEmptyDirs ) );
+            archivedFileSet( archiveFile ).includeExclude( includes, excludes ).includeEmptyDirs( includeEmptyDirs ) );
     }
 
     /**
@@ -804,7 +790,7 @@ public void setForced( final boolean forced )
         this.forced = forced;
     }
 
-    public void setArchiveFilters(final List filters)
+    public void setArchiveFilters( final List filters )
     {
         filterSupport = new FilterSupport( filters, getLogger() );
     }
@@ -913,9 +899,10 @@ protected void runArchiveFinalizers()
     {
         if ( finalizers != null )
         {
-			for (final ArchiveFinalizer finalizer : finalizers) {
-				finalizer.finalizeArchiveCreation(this);
-			}
+            for ( final ArchiveFinalizer finalizer : finalizers )
+            {
+                finalizer.finalizeArchiveCreation( this );
+            }
         }
     }
 
@@ -969,13 +956,15 @@ protected boolean hasVirtualFiles()
     {
         if ( finalizers != null )
         {
-			for (final ArchiveFinalizer finalizer : finalizers) {
-				final List virtualFiles = finalizer.getVirtualFiles();
+            for ( final ArchiveFinalizer finalizer : finalizers )
+            {
+                final List virtualFiles = finalizer.getVirtualFiles();
 
-				if ((virtualFiles != null) && !virtualFiles.isEmpty()) {
-					return true;
-				}
-			}
+                if ( ( virtualFiles != null ) && !virtualFiles.isEmpty() )
+                {
+                    return true;
+                }
+            }
         }
         return false;
     }
@@ -1000,10 +989,14 @@ protected void cleanUp()
     {
         for ( Object resource : resources )
         {
-            if (resource instanceof  PlexusIoProxyResourceCollection){
+            if ( resource instanceof PlexusIoProxyResourceCollection )
+            {
                 resource = ( (PlexusIoProxyResourceCollection) resource ).getSrc();
             }
-            if (resource instanceof Closeable ) ((Closeable)resource).close();
+            if ( resource instanceof Closeable )
+            {
+                ( (Closeable) resource ).close();
+            }
         }
         resources.clear();
     }
diff --git a/src/main/java/org/codehaus/plexus/archiver/ArchiveEntry.java b/src/main/java/org/codehaus/plexus/archiver/ArchiveEntry.java
@@ -69,8 +69,12 @@ private ArchiveEntry( String name, @Nonnull PlexusIoResource resource, int type,
                           PlexusIoResourceCollection collection )
     {
         this.name = name;
-        this.resource = resource;
         this.collection = collection;
+        try {
+            this.resource = collection != null ? collection.resolve(resource) : resource;
+        } catch (IOException e) {
+            throw new   ArchiverException("Error resolving resource " + resource.getName(), e);
+        }
         this.attributes = ( resource instanceof PlexusIoResourceWithAttributes )
             ? ( (PlexusIoResourceWithAttributes) resource ).getAttributes() : null;
         this.type = type;
@@ -115,7 +119,7 @@ public File getFile()
     public InputStream getInputStream()
         throws IOException
     {
-        return collection != null ? collection.getInputStream( resource ) : resource.getContents();
+        return resource.getContents();
     }
     
     /**
diff --git a/src/main/java/org/codehaus/plexus/archiver/bzip2/PlexusIoBzip2ResourceCollection.java b/src/main/java/org/codehaus/plexus/archiver/bzip2/PlexusIoBzip2ResourceCollection.java
@@ -13,6 +13,7 @@
 import org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection;
 import org.codehaus.plexus.util.IOUtil;
 
+import javax.annotation.Nonnull;
 import javax.annotation.WillNotClose;
 
 
@@ -23,6 +24,7 @@
 public class PlexusIoBzip2ResourceCollection
     extends PlexusIoCompressedFileResourceCollection
 {
+    @Nonnull
     protected @WillNotClose InputStream getInputStream( File file )
         throws IOException
     {
diff --git a/src/main/java/org/codehaus/plexus/archiver/gzip/PlexusIoGzipResourceCollection.java b/src/main/java/org/codehaus/plexus/archiver/gzip/PlexusIoGzipResourceCollection.java
@@ -12,6 +12,8 @@
 import org.codehaus.plexus.components.io.resources.PlexusIoCompressedFileResourceCollection;
 import org.codehaus.plexus.util.IOUtil;
 
+import javax.annotation.Nonnull;
+
 
 /**
  * Abstract base class for compressed files, aka singleton
@@ -25,6 +27,7 @@ protected String getDefaultExtension()
         return ".gz";
     }
 
+    @Nonnull
     protected InputStream getInputStream( File file )
         throws IOException
     {
diff --git a/src/main/java/org/codehaus/plexus/archiver/tar/TarArchiver.java b/src/main/java/org/codehaus/plexus/archiver/tar/TarArchiver.java
@@ -328,15 +328,19 @@ else if ( longFileMode.isFailMode() )
 
             tOut.putArchiveEntry(te);
 
-            if ( entry.getResource().isFile() && !(entry.getType() == ArchiveEntry.SYMLINK))
-            {
-                fIn = entry.getInputStream();
+            try {
+                if (entry.getResource().isFile() && !(entry.getType() == ArchiveEntry.SYMLINK)) {
+                    fIn = entry.getInputStream();
 
-                Streams.copyFullyDontCloseOutput( fIn, tOut, "xAR" );
-            }
+                    Streams.copyFullyDontCloseOutput(fIn, tOut, "xAR");
+                }
 
-            tOut.closeArchiveEntry();
-        }
+            } catch (Throwable e){
+                getLogger().warn("When creating tar entry", e);
+            } finally {
+                tOut.closeArchiveEntry();
+            }
+    }
         finally
         {
             IOUtil.close( fIn );

Original file line number	Diff line number	Diff line change
`@@ -258,30 +258,30 @@ public void setIncludeEmptyDirs( final boolean includeEmptyDirs )`
`258`	`258`	`public void addDirectory( @Nonnull final File directory )`
`259`	`259`	`throws ArchiverException`
`260`	`260`	`{`
`261`		`- addFileSet( fileSet( directory ).prefixed( "" )`
`262`		`- .includeExclude( null, null ).includeEmptyDirs( includeEmptyDirs ) );`
	`261`	`+ addFileSet(`
	`262`	`+ fileSet( directory ).prefixed( "" ).includeExclude( null, null ).includeEmptyDirs( includeEmptyDirs ) );`
`263`	`263`	`}`
`264`	`264`
`265`	`265`	`public void addDirectory( @Nonnull final File directory, final String prefix )`
`266`	`266`	`throws ArchiverException`
`267`	`267`	`{`
`268`		`- addFileSet( fileSet( directory ).prefixed( prefix )`
`269`		`- .includeExclude( null, null ).includeEmptyDirs( includeEmptyDirs ) );`
	`268`	`+ addFileSet(`
	`269`	`+ fileSet( directory ).prefixed( prefix ).includeExclude( null, null ).includeEmptyDirs( includeEmptyDirs ) );`
`270`	`270`	`}`
`271`	`271`
`272`	`272`	`public void addDirectory( @Nonnull final File directory, final String[] includes, final String[] excludes )`
`273`	`273`	`throws ArchiverException`
`274`	`274`	`{`
`275`		`- addFileSet( fileSet( directory ).prefixed( "" )`
`276`		`- .includeExclude( includes, excludes ).includeEmptyDirs( includeEmptyDirs ) );`
	`275`	`+ addFileSet( fileSet( directory ).prefixed( "" ).includeExclude( includes, excludes ).includeEmptyDirs(`
	`276`	`+ includeEmptyDirs ) );`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`public void addDirectory( @Nonnull final File directory, final String prefix, final String[] includes,`
`280`	`280`	`final String[] excludes )`
`281`	`281`	`throws ArchiverException`
`282`	`282`	`{`
`283`		`- addFileSet( fileSet( directory ).prefixed( prefix )`
`284`		`- .includeExclude( includes, excludes ).includeEmptyDirs( includeEmptyDirs ) );`
	`283`	`+ addFileSet( fileSet( directory ).prefixed( prefix ).includeExclude( includes, excludes ).includeEmptyDirs(`
	`284`	`+ includeEmptyDirs ) );`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`public void addFileSet( @Nonnull final FileSet fileSet )`
`@@ -300,7 +300,7 @@ public void addFileSet( @Nonnull final FileSet fileSet )`
`300`	`300`
`301`	`301`	`// The PlexusIoFileResourceCollection contains platform-specific File.separatorChar which`
`302`	`302`	`// is an interesting cause of grief, see PLXCOMP-192`
`303`		`- final PlexusIoFileResourceCollection collection = new PlexusIoFileResourceCollection( );`
	`303`	`+ final PlexusIoFileResourceCollection collection = new PlexusIoFileResourceCollection();`
`304`	`304`	`collection.setFollowingSymLinks( !isSymlinkSupported() );`
`305`	`305`
`306`	`306`	`collection.setIncludes( fileSet.getIncludes() );`
`@@ -328,8 +328,7 @@ public void addFileSet( @Nonnull final FileSet fileSet )`
`328`	`328`
`329`	`329`	`private boolean isSymlinkSupported()`
`330`	`330`	`{`
`331`		`- return Os.isFamily( Os.FAMILY_UNIX ) &&`
`332`		`- Java7Reflector.isAtLeastJava7();`
	`331`	`+ return Os.isFamily( Os.FAMILY_UNIX ) && Java7Reflector.isAtLeastJava7();`
`333`	`332`	`}`
`334`	`333`
`335`	`334`	`public void addFile( @Nonnull final File inputFile, @Nonnull final String destFileName )`
`@@ -340,22 +339,22 @@ public void addFile( @Nonnull final File inputFile, @Nonnull final String destFi`
`340`	`339`	`addFile( inputFile, destFileName, fileMode );`
`341`	`340`	`}`
`342`	`341`
`343`		`- public void addSymlink(String symlinkName, String symlinkDestination)`
	`342`	`+ public void addSymlink( String symlinkName, String symlinkDestination )`
`344`	`343`	`throws ArchiverException`
`345`	`344`	`{`
`346`	`345`	`final int fileMode = getOverrideFileMode();`
`347`	`346`
`348`		`- addSymlink(symlinkName, fileMode, symlinkDestination);`
	`347`	`+ addSymlink( symlinkName, fileMode, symlinkDestination );`
`349`	`348`	`}`
`350`	`349`
`351`		`- public void addSymlink(String symlinkName, int permissions, String symlinkDestination)`
	`350`	`+ public void addSymlink( String symlinkName, int permissions, String symlinkDestination )`
`352`	`351`	`throws ArchiverException`
`353`	`352`	`{`
`354`	`353`	`resources.add( ArchiveEntry.createSymlinkEntry( symlinkName, permissions, symlinkDestination ) );`
`355`	`354`	`}`
`356`	`355`
`357`	`356`	`protected ArchiveEntry asArchiveEntry( @Nonnull final PlexusIoResource resource, final String destFileName,`
`358`		`- final int permissions, PlexusIoResourceCollection collection)`
	`357`	`+ final int permissions, PlexusIoResourceCollection collection )`
`359`	`358`	`throws ArchiverException`
`360`	`359`	`{`
`361`	`360`	`if ( !resource.isExisting() )`
`@@ -377,27 +376,20 @@ protected ArchiveEntry asArchiveEntry( final PlexusIoResourceCollection collecti`
`377`	`376`	`final PlexusIoResource resource )`
`378`	`377`	`throws ArchiverException`
`379`	`378`	`{`
`380`		`- try`
	`379`	`+ final String destFileName = collection.getName( resource );`
	`380`	`+`
	`381`	`+ int permissions = -1;`
	`382`	`+ if ( resource instanceof PlexusIoResourceWithAttributes )`
`381`	`383`	`{`
`382`		`- final String destFileName = collection.getName( resource );`
	`384`	`+ final PlexusIoResourceAttributes attrs = ( (PlexusIoResourceWithAttributes) resource ).getAttributes();`
`383`	`385`
`384`		`- int permissions = -1;`
`385`		`- if ( resource instanceof PlexusIoResourceWithAttributes )`
	`386`	`+ if ( attrs != null )`
`386`	`387`	`{`
`387`		`- final PlexusIoResourceAttributes attrs = ( (PlexusIoResourceWithAttributes) resource ).getAttributes();`
`388`		`-`
`389`		`- if ( attrs != null )`
`390`		`- {`
`391`		`- permissions = attrs.getOctalMode();`
`392`		`- }`
	`388`	`+ permissions = attrs.getOctalMode();`
`393`	`389`	`}`
`394`		`-`
`395`		`- return asArchiveEntry( resource, destFileName, permissions, collection );`
`396`		`- }`
`397`		`- catch ( final IOException e )`
`398`		`- {`
`399`		`- throw new ArchiverException( e.getMessage(), e );`
`400`	`390`	`}`
	`391`	`+`
	`392`	`+ return asArchiveEntry( resource, destFileName, permissions, collection );`
`401`	`393`	`}`
`402`	`394`
`403`	`395`	`public void addResource( final PlexusIoResource resource, final String destFileName, final int permissions )`
`@@ -457,7 +449,7 @@ public void addFile( @Nonnull final File inputFile, @Nonnull String destFileName`
`457`	`449`	`}`
`458`	`450`	`}`
`459`	`451`
`460`		`- @Nonnull`
	`452`	`+ @Nonnull`
`461`	`453`	`public ResourceIterator getResources()`
`462`	`454`	`throws ArchiverException`
`463`	`455`	`{`
`@@ -559,8 +551,8 @@ else if ( Archiver.DUPLICATES_FAIL.equals( duplicateBehavior ) )`
`559`	`551`	`private boolean throwIllegalResourceType( Object o )`
`560`	`552`	`{`
`561`	`553`	`throw new IllegalStateException(`
`562`		`- "An invalid resource of type: " + o.getClass().getName()`
`563`		`- + " was added to archiver: " + getClass().getName() );`
	`554`	`+ "An invalid resource of type: " + o.getClass().getName() + " was added to archiver: "`
	`555`	`+ + getClass().getName() );`
`564`	`556`	`}`
`565`	`557`
`566`	`558`	`public ArchiveEntry next()`
`@@ -585,11 +577,11 @@ public void remove()`
`585`	`577`	`};`
`586`	`578`	`}`
`587`	`579`
`588`		`- public Map<String,ArchiveEntry> getFiles()`
	`580`	`+ public Map<String, ArchiveEntry> getFiles()`
`589`	`581`	`{`
`590`	`582`	`try`
`591`	`583`	`{`
`592`		`- final Map<String,ArchiveEntry> map = new HashMap<String,ArchiveEntry>();`
	`584`	`+ final Map<String, ArchiveEntry> map = new HashMap<String, ArchiveEntry>();`
`593`	`585`	`for ( final ResourceIterator iter = getResources(); iter.hasNext(); )`
`594`	`586`	`{`
`595`	`587`	`final ArchiveEntry entry = iter.next();`
`@@ -685,10 +677,11 @@ protected PlexusIoResourceCollection asResourceCollection( final ArchivedFileSet`
`685`	`677`	`+ resources.getClass().getName() );`
`686`	`678`	`}`
`687`	`679`
`688`		`- if (resources instanceof AbstractPlexusIoResourceCollection ){`
`689`		`- ((AbstractPlexusIoResourceCollection)resources).setStreamTransformer( fileSet.getStreamTransformer() );`
	`680`	`+ if ( resources instanceof AbstractPlexusIoResourceCollection )`
	`681`	`+ {`
	`682`	`+ ( (AbstractPlexusIoResourceCollection) resources ).setStreamTransformer( fileSet.getStreamTransformer() );`
`690`	`683`	`}`
`691`		`- final PlexusIoProxyResourceCollection proxy = new PlexusIoProxyResourceCollection(resources);`
	`684`	`+ final PlexusIoProxyResourceCollection proxy = new PlexusIoProxyResourceCollection( resources );`
`692`	`685`
`693`	`686`	`proxy.setExcludes( fileSet.getExcludes() );`
`694`	`687`	`proxy.setIncludes( fileSet.getIncludes() );`
`@@ -718,7 +711,7 @@ protected PlexusIoResourceCollection asResourceCollection( final ArchivedFileSet`
`718`	`711`	`public void addResources( final PlexusIoResourceCollection collection )`
`719`	`712`	`throws ArchiverException`
`720`	`713`	`{`
`721`		`- resources.add(collection);`
	`714`	`+ resources.add( collection );`
`722`	`715`	`}`
`723`	`716`
`724`	`717`	`public void addArchivedFileSet( final ArchivedFileSet fileSet )`
`@@ -736,10 +729,8 @@ public void addArchivedFileSet( @Nonnull final File archiveFile, final String pr`
`736`	`729`	`throws ArchiverException`
`737`	`730`	`{`
`738`	`731`	`addArchivedFileSet(`
`739`		`- archivedFileSet( archiveFile )`
`740`		`- .prefixed( prefix )`
`741`		`- .includeExclude( includes, excludes )`
`742`		`- .includeEmptyDirs( includeEmptyDirs ) );`
	`732`	`+ archivedFileSet( archiveFile ).prefixed( prefix ).includeExclude( includes, excludes ).includeEmptyDirs(`
	`733`	`+ includeEmptyDirs ) );`
`743`	`734`	`}`
`744`	`735`
`745`	`736`	`/**`
`@@ -748,10 +739,7 @@ public void addArchivedFileSet( @Nonnull final File archiveFile, final String pr`
`748`	`739`	`public void addArchivedFileSet( @Nonnull final File archiveFile, final String prefix )`
`749`	`740`	`throws ArchiverException`
`750`	`741`	`{`
`751`		`- addArchivedFileSet(`
`752`		`- archivedFileSet( archiveFile )`
`753`		`- .prefixed( prefix )`
`754`		`- .includeEmptyDirs( includeEmptyDirs ) );`
	`742`	`+ addArchivedFileSet( archivedFileSet( archiveFile ).prefixed( prefix ).includeEmptyDirs( includeEmptyDirs ) );`
`755`	`743`	`}`
`756`	`744`
`757`	`745`	`/**`
`@@ -761,9 +749,7 @@ public void addArchivedFileSet( @Nonnull final File archiveFile, final String[]`
`761`	`749`	`throws ArchiverException`
`762`	`750`	`{`
`763`	`751`	`addArchivedFileSet(`
`764`		`- archivedFileSet( archiveFile )`
`765`		`- .includeExclude( includes, excludes )`
`766`		`- .includeEmptyDirs( includeEmptyDirs ) );`
	`752`	`+ archivedFileSet( archiveFile ).includeExclude( includes, excludes ).includeEmptyDirs( includeEmptyDirs ) );`
`767`	`753`	`}`
`768`	`754`
`769`	`755`	`/**`
`@@ -804,7 +790,7 @@ public void setForced( final boolean forced )`
`804`	`790`	`this.forced = forced;`
`805`	`791`	`}`
`806`	`792`
`807`		`- public void setArchiveFilters(final List filters)`
	`793`	`+ public void setArchiveFilters( final List filters )`
`808`	`794`	`{`
`809`	`795`	`filterSupport = new FilterSupport( filters, getLogger() );`
`810`	`796`	`}`
`@@ -913,9 +899,10 @@ protected void runArchiveFinalizers()`
`913`	`899`	`{`
`914`	`900`	`if ( finalizers != null )`
`915`	`901`	`{`
`916`		`- for (final ArchiveFinalizer finalizer : finalizers) {`
`917`		`- finalizer.finalizeArchiveCreation(this);`
`918`		`- }`
	`902`	`+ for ( final ArchiveFinalizer finalizer : finalizers )`
	`903`	`+ {`
	`904`	`+ finalizer.finalizeArchiveCreation( this );`
	`905`	`+ }`
`919`	`906`	`}`
`920`	`907`	`}`
`921`	`908`
`@@ -969,13 +956,15 @@ protected boolean hasVirtualFiles()`
`969`	`956`	`{`
`970`	`957`	`if ( finalizers != null )`
`971`	`958`	`{`
`972`		`- for (final ArchiveFinalizer finalizer : finalizers) {`
`973`		`- final List virtualFiles = finalizer.getVirtualFiles();`
	`959`	`+ for ( final ArchiveFinalizer finalizer : finalizers )`
	`960`	`+ {`
	`961`	`+ final List virtualFiles = finalizer.getVirtualFiles();`
`974`	`962`
`975`		`- if ((virtualFiles != null) && !virtualFiles.isEmpty()) {`
`976`		`- return true;`
`977`		`- }`
`978`		`- }`
	`963`	`+ if ( ( virtualFiles != null ) && !virtualFiles.isEmpty() )`
	`964`	`+ {`
	`965`	`+ return true;`
	`966`	`+ }`
	`967`	`+ }`
`979`	`968`	`}`
`980`	`969`	`return false;`
`981`	`970`	`}`
`@@ -1000,10 +989,14 @@ protected void cleanUp()`
`1000`	`989`	`{`
`1001`	`990`	`for ( Object resource : resources )`
`1002`	`991`	`{`
`1003`		`- if (resource instanceof PlexusIoProxyResourceCollection){`
	`992`	`+ if ( resource instanceof PlexusIoProxyResourceCollection )`
	`993`	`+ {`
`1004`	`994`	`resource = ( (PlexusIoProxyResourceCollection) resource ).getSrc();`
`1005`	`995`	`}`
`1006`		`- if (resource instanceof Closeable ) ((Closeable)resource).close();`
	`996`	`+ if ( resource instanceof Closeable )`
	`997`	`+ {`
	`998`	`+ ( (Closeable) resource ).close();`
	`999`	`+ }`
`1007`	`1000`	`}`
`1008`	`1001`	`resources.clear();`
`1009`	`1002`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@`
`13`	`13`	`import org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection;`
`14`	`14`	`import org.codehaus.plexus.util.IOUtil;`
`15`	`15`
	`16`	`+import javax.annotation.Nonnull;`
`16`	`17`	`import javax.annotation.WillNotClose;`
`17`	`18`
`18`	`19`
`@@ -23,6 +24,7 @@`
`23`	`24`	`public class PlexusIoBzip2ResourceCollection`
`24`	`25`	`extends PlexusIoCompressedFileResourceCollection`
`25`	`26`	`{`
	`27`	`+ @Nonnull`
`26`	`28`	`protected @WillNotClose InputStream getInputStream( File file )`
`27`	`29`	`throws IOException`
`28`	`30`	`{`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@`
`12`	`12`	`import org.codehaus.plexus.components.io.resources.PlexusIoCompressedFileResourceCollection;`
`13`	`13`	`import org.codehaus.plexus.util.IOUtil;`
`14`	`14`
	`15`	`+import javax.annotation.Nonnull;`
	`16`	`+`
`15`	`17`
`16`	`18`	`/**`
`17`	`19`	`* Abstract base class for compressed files, aka singleton`
`@@ -25,6 +27,7 @@ protected String getDefaultExtension()`
`25`	`27`	`return ".gz";`
`26`	`28`	`}`
`27`	`29`
	`30`	`+ @Nonnull`
`28`	`31`	`protected InputStream getInputStream( File file )`
`29`	`32`	`throws IOException`
`30`	`33`	`{`