Coverage Report

Coverage Report - org.apache.maven.plugin.assembly.utils.AssemblyFileUtils

Classes in this File

Line Coverage

Branch Coverage

Complexity

AssemblyFileUtils

67%

43/64

55%

21/38

3.625

 package org.apache.maven.plugin.assembly.utils;
 
 /*
  * 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 java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.io.Reader;
 import java.nio.channels.FileChannel;
 
 import org.apache.maven.plugin.assembly.archive.ArchiveExpansionException;
 import org.apache.maven.plugin.assembly.format.AssemblyFormattingException;
 import org.codehaus.plexus.archiver.ArchiverException;
 import org.codehaus.plexus.archiver.UnArchiver;
 import org.codehaus.plexus.archiver.manager.ArchiverManager;
 import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
 import org.codehaus.plexus.logging.Logger;
 import org.codehaus.plexus.util.IOUtil;
 
 /**
  * @version $Id: AssemblyFileUtils.java 782119 2009-06-05 19:55:15Z jdcasey $
  */
 public final class AssemblyFileUtils
 {
 
     public static final String LINE_ENDING_KEEP = "keep";
     public static final String LINE_ENDING_DOS = "dos";
     public static final String LINE_ENDING_UNIX = "unix";
     public static final String LINE_ENDING_CRLF = "crlf";
     public static final String LINE_ENDING_LF = "lf";
 
     private AssemblyFileUtils()
     {
     }
     
     public static String makePathRelativeTo( String path, final File basedir )
     {
         if ( basedir == null )
         {
             return path;
         }
 
         if ( path == null )
         {
             return null;
         }
 
         path = path.trim();
 
         String base = basedir.getAbsolutePath();
         if ( path.startsWith( base ) )
         {
             path = path.substring( base.length() );
             if ( path.length() > 0 )
             {
                 if ( path.startsWith( "/" ) || path.startsWith( "\\" ) )
                 {
                     path = path.substring( 1 );
                 }
             }
             
             if ( path.length() == 0 )
             {
                 path = ".";
             }
         }
 
         if ( !new File( path ).isAbsolute() )
         {
             path = path.replace( '\\', '/' );
         }
 
         return path;
     }
 
     public static void verifyTempDirectoryAvailability( final File tempDir, final Logger logger )
     {
         if (!tempDir.exists())
         {
             tempDir.mkdirs();
         }
     }
 
     /**
      * Unpacks the archive file.
      *
      * @param source
      *            File to be unpacked.
      * @param destDir
      *            Location where to put the unpacked files.
      */
     public static void unpack( File source, File destDir, ArchiverManager archiverManager )
         throws ArchiveExpansionException, NoSuchArchiverException
     {
         try
         {
             UnArchiver unArchiver = archiverManager.getUnArchiver( source );
 
             unArchiver.setSourceFile( source );
 
             unArchiver.setDestDirectory( destDir );
 
             unArchiver.extract();
         }
         catch ( ArchiverException e )
         {
             throw new ArchiveExpansionException( "Error unpacking file: " + source + "to: " + destDir, e );
         }
     }
 
     /**
      * NOTE: It is the responsibility of the caller to close the source Reader instance.
      * The file content is written using platform encoding.
      * @param lineEndings This is the result of the getLineEndingChars(..) method in this utility class; the actual
      *   line-ending characters.
      */
     public static void convertLineEndings( Reader source, File dest, String lineEndings )
         throws IOException
     {
         BufferedWriter out = null;
         BufferedReader bufferedSource = null;
         try
         {
             if ( source instanceof BufferedReader )
             {
                 bufferedSource = (BufferedReader) source;
             }
             else
             {
                 bufferedSource = new BufferedReader( source );
             }
 
             out = new BufferedWriter( new FileWriter( dest ) ); // platform encoding
 
             String line;
 
             do
             {
                 line = bufferedSource.readLine();
                 if ( line != null )
                 {
                     out.write( line );
                     out.write( lineEndings );
                 }
             } while ( line != null );
 
             out.flush();
         }
         finally
         {
             IOUtil.close( out );
         }
     }
 
     public static String getLineEndingCharacters( String lineEnding )
         throws AssemblyFormattingException
     {
         String value = lineEnding;
         if ( lineEnding != null )
         {
             if ( LINE_ENDING_KEEP.equals( lineEnding ) )
             {
                 value = null;
             }
             else if ( LINE_ENDING_DOS.equals( lineEnding ) || LINE_ENDING_CRLF.equals( lineEnding ) )
             {
                 value = "\r\n";
             }
             else if ( LINE_ENDING_UNIX.equals( lineEnding ) || LINE_ENDING_LF.equals( lineEnding ) )
             {
                 value = "\n";
             }
             else
             {
                 throw new AssemblyFormattingException( "Illlegal lineEnding specified: '" + lineEnding + "'" );
             }
         }
 
         return value;
     }
 
     public static void copyFile( File src, File dst ) throws IOException
     {
         FileChannel c1 = new RandomAccessFile( src, "r" ).getChannel();
         FileChannel c2 = new RandomAccessFile( dst, "rw" ).getChannel();
 
         long tCount = 0, size = c1.size();
         while ( ( tCount += c2.transferFrom( c1, 0, size - tCount ) ) < size )
             ;
 
         c1.close();
         c2.force( true );
         c2.close();
     }
 
     public static String normalizePath( String path )
     {
         return path.replace( '\\', '/' );
     }
 
 }

1		package org.apache.maven.plugin.assembly.utils;
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 java.io.BufferedReader;
23		import java.io.BufferedWriter;
24		import java.io.File;
25		import java.io.FileWriter;
26		import java.io.IOException;
27		import java.io.RandomAccessFile;
28		import java.io.Reader;
29		import java.nio.channels.FileChannel;
30
31		import org.apache.maven.plugin.assembly.archive.ArchiveExpansionException;
32		import org.apache.maven.plugin.assembly.format.AssemblyFormattingException;
33		import org.codehaus.plexus.archiver.ArchiverException;
34		import org.codehaus.plexus.archiver.UnArchiver;
35		import org.codehaus.plexus.archiver.manager.ArchiverManager;
36		import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
37		import org.codehaus.plexus.logging.Logger;
38		import org.codehaus.plexus.util.IOUtil;
39
40		/**
41		* @version $Id: AssemblyFileUtils.java 782119 2009-06-05 19:55:15Z jdcasey $
42		*/
43		public final class AssemblyFileUtils
44		{
45
46		public static final String LINE_ENDING_KEEP = "keep";
47		public static final String LINE_ENDING_DOS = "dos";
48		public static final String LINE_ENDING_UNIX = "unix";
49		public static final String LINE_ENDING_CRLF = "crlf";
50		public static final String LINE_ENDING_LF = "lf";
51
52		private AssemblyFileUtils()
53	0	{
54	0	}
55
56		public static String makePathRelativeTo( String path, final File basedir )
57		{
58	10	if ( basedir == null )
59		{
60	10	return path;
61		}
62
63	0	if ( path == null )
64		{
65	0	return null;
66		}
67
68	0	path = path.trim();
69
70	0	String base = basedir.getAbsolutePath();
71	0	if ( path.startsWith( base ) )
72		{
73	0	path = path.substring( base.length() );
74	0	if ( path.length() > 0 )
75		{
76	0	if ( path.startsWith( "/" ) \|\| path.startsWith( "\\" ) )
77		{
78	0	path = path.substring( 1 );
79		}
80		}
81
82	0	if ( path.length() == 0 )
83		{
84	0	path = ".";
85		}
86		}
87
88	0	if ( !new File( path ).isAbsolute() )
89		{
90	0	path = path.replace( '\\', '/' );
91		}
92
93	0	return path;
94		}
95
96		public static void verifyTempDirectoryAvailability( final File tempDir, final Logger logger )
97		{
98	33	if (!tempDir.exists())
99		{
100	2	tempDir.mkdirs();
101		}
102	33	}
103
104		/**
105		* Unpacks the archive file.
106		*
107		* @param source
108		* File to be unpacked.
109		* @param destDir
110		* Location where to put the unpacked files.
111		*/
112		public static void unpack( File source, File destDir, ArchiverManager archiverManager )
113		throws ArchiveExpansionException, NoSuchArchiverException
114		{
115		try
116		{
117	1	UnArchiver unArchiver = archiverManager.getUnArchiver( source );
118
119	1	unArchiver.setSourceFile( source );
120
121	1	unArchiver.setDestDirectory( destDir );
122
123	1	unArchiver.extract();
124		}
125	0	catch ( ArchiverException e )
126		{
127	0	throw new ArchiveExpansionException( "Error unpacking file: " + source + "to: " + destDir, e );
128	1	}
129	1	}
130
131		/**
132		* NOTE: It is the responsibility of the caller to close the source Reader instance.
133		* The file content is written using platform encoding.
134		* @param lineEndings This is the result of the getLineEndingChars(..) method in this utility class; the actual
135		* line-ending characters.
136		*/
137		public static void convertLineEndings( Reader source, File dest, String lineEndings )
138		throws IOException
139		{
140	12	BufferedWriter out = null;
141	12	BufferedReader bufferedSource = null;
142		try
143		{
144	12	if ( source instanceof BufferedReader )
145		{
146	0	bufferedSource = (BufferedReader) source;
147		}
148		else
149		{
150	12	bufferedSource = new BufferedReader( source );
151		}
152
153	12	out = new BufferedWriter( new FileWriter( dest ) ); // platform encoding
154
155		String line;
156
157		do
158		{
159	36	line = bufferedSource.readLine();
160	36	if ( line != null )
161		{
162	24	out.write( line );
163	24	out.write( lineEndings );
164		}
165	36	} while ( line != null );
166
167	12	out.flush();
168		}
169		finally
170		{
171	12	IOUtil.close( out );
172	12	}
173	12	}
174
175		public static String getLineEndingCharacters( String lineEnding )
176		throws AssemblyFormattingException
177		{
178	48	String value = lineEnding;
179	48	if ( lineEnding != null )
180		{
181	31	if ( LINE_ENDING_KEEP.equals( lineEnding ) )
182		{
183	13	value = null;
184		}
185	18	else if ( LINE_ENDING_DOS.equals( lineEnding ) \|\| LINE_ENDING_CRLF.equals( lineEnding ) )
186		{
187	13	value = "\r\n";
188		}
189	5	else if ( LINE_ENDING_UNIX.equals( lineEnding ) \|\| LINE_ENDING_LF.equals( lineEnding ) )
190		{
191	4	value = "\n";
192		}
193		else
194		{
195	1	throw new AssemblyFormattingException( "Illlegal lineEnding specified: '" + lineEnding + "'" );
196		}
197		}
198
199	47	return value;
200		}
201
202		public static void copyFile( File src, File dst ) throws IOException
203		{
204	7	FileChannel c1 = new RandomAccessFile( src, "r" ).getChannel();
205	7	FileChannel c2 = new RandomAccessFile( dst, "rw" ).getChannel();
206
207	7	long tCount = 0, size = c1.size();
208	7	while ( ( tCount += c2.transferFrom( c1, 0, size - tCount ) ) < size )
209	0	;
210
211	7	c1.close();
212	7	c2.force( true );
213	7	c2.close();
214	7	}
215
216		public static String normalizePath( String path )
217		{
218	0	return path.replace( '\\', '/' );
219		}
220
221		}