Coverage Report

Coverage Report - org.apache.maven.plugin.dependency.utils.markers.SourcesFileMarkerHandler

Classes in this File

Line Coverage

Branch Coverage

Complexity

SourcesFileMarkerHandler

100 %

40/40

100 %

28/28

2,1

 package org.apache.maven.plugin.dependency.utils.markers;
 
 /*
  * 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.File;
 import java.io.IOException;
 
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.plugin.MojoExecutionException;
 
 /**
  * @author <a href="mailto:brianf@apache.org">Brian Fox</a>
  * @version $Id: SourcesFileMarkerHandler.java 1367274 2012-07-30 20:32:05Z hboutemy $
  */
 public class SourcesFileMarkerHandler
     extends DefaultFileMarkerHandler
 {
 
     boolean resolved;
 
     public SourcesFileMarkerHandler( File markerFilesDirectory )
     {
         super( markerFilesDirectory );
     }
 
     public SourcesFileMarkerHandler( Artifact artifact, File markerFilesDirectory, boolean isResolved )
     {
         super( artifact, markerFilesDirectory );
         this.resolved = isResolved;
     }
 
     /**
      * Returns properly formatted File
      * 
      * @return File object for marker. The file is not guaranteed to exist.
      */
     public File getMarkerFile()
     {
         return getMarkerFile( this.resolved );
     }
 
     /**
      * Get MarkerFile, exposed for unit testing purposes
      * 
      * @param res
      *            resolved or not.
      * @return marker file for this artifact.
      */
     protected File getMarkerFile( boolean res )
     {
         String suffix;
         if ( res )
         {
             suffix = ".resolved";
         }
         else
         {
             suffix = ".unresolved";
         }
 
         return new File( this.markerFilesDirectory, this.artifact.getId().replace( ':', '-' ) + suffix );
     }
 
     /**
      * Tests whether the file or directory denoted by this abstract pathname
      * exists.
      * 
      * @return <code>true</code> if and only if the file or directory denoted
      *         by this abstract pathname exists; <code>false</code> otherwise
      * 
      * @throws MojoExecutionException
      *             If a security manager exists and its <code>{@link
      *          java.lang.SecurityManager#checkRead(java.lang.String)}</code>
      *             method denies read access to the file or directory
      */
     public boolean isMarkerSet()
         throws MojoExecutionException
     {
         File marker = getMarkerFile();
 
         File marker2 = getMarkerFile( !this.resolved );
 
         return marker.exists() || marker2.exists();
     }
 
     public boolean isMarkerOlder( Artifact theArtifact )
         throws MojoExecutionException
     {
         File marker = getMarkerFile();
         if ( marker.exists() )
         {
             return theArtifact.getFile().lastModified() > marker.lastModified();
         }
         else
         {
             marker = getMarkerFile( !this.resolved );
             if ( marker.exists() )
             {
                 return theArtifact.getFile().lastModified() > marker.lastModified();
             }
             else
             {
                 // if the marker doesn't exist, we want to copy so assume it is
                 // infinitely older
                 return true;
             }
         }
     }
 
     public void setMarker()
         throws MojoExecutionException
     {
         File marker = getMarkerFile();
 
         // get the other file if it exists.
         File clearMarker = getMarkerFile( !this.resolved );
         // create marker file
         try
         {
             marker.getParentFile().mkdirs();
         }
         catch ( NullPointerException e )
         {
             // parent is null, ignore it.
         }
 
         try
         {
             marker.createNewFile();
             // clear the other file if it exists.
             if ( clearMarker.exists() )
             {
                 clearMarker.delete();
             }
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( "Unable to create Marker: " + marker.getAbsolutePath(), e );
         }
     }
 
     /**
      * Deletes the file or directory denoted by this abstract pathname. If this
      * pathname denotes a directory, then the directory must be empty in order
      * to be deleted.
      * 
      * @return <code>true</code> if and only if the file or directory is
      *         successfully deleted; <code>false</code> otherwise
      * 
      * @throws SecurityException
      *             If a security manager exists and its <code>{@link
      *          java.lang.SecurityManager#checkDelete}</code>
      *             method denies delete access to the file
      */
     public boolean clearMarker()
         throws MojoExecutionException
     {
         File marker = getMarkerFile();
         File marker2 = getMarkerFile( !this.resolved );
         boolean markResult = marker.delete();
         boolean mark2Result = marker2.delete();
         return markResult || mark2Result;
     }
 
     /**
      * @return Returns the resolved.
      */
     public boolean isResolved()
     {
         return this.resolved;
     }
 
     /**
      * @param isResolved
      *            The resolved to set.
      */
     public void setResolved( boolean isResolved )
     {
         this.resolved = isResolved;
     }
 }

1		package org.apache.maven.plugin.dependency.utils.markers;
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.File;
23		import java.io.IOException;
24
25		import org.apache.maven.artifact.Artifact;
26		import org.apache.maven.plugin.MojoExecutionException;
27
28		/**
29		* @author <a href="mailto:brianf@apache.org">Brian Fox</a>
30		* @version $Id: SourcesFileMarkerHandler.java 1367274 2012-07-30 20:32:05Z hboutemy $
31		*/
32		public class SourcesFileMarkerHandler
33		extends DefaultFileMarkerHandler
34		{
35
36		boolean resolved;
37
38		public SourcesFileMarkerHandler( File markerFilesDirectory )
39		{
40	3	super( markerFilesDirectory );
41	3	}
42
43		public SourcesFileMarkerHandler( Artifact artifact, File markerFilesDirectory, boolean isResolved )
44		{
45	14	super( artifact, markerFilesDirectory );
46	14	this.resolved = isResolved;
47	14	}
48
49		/**
50		* Returns properly formatted File
51		*
52		* @return File object for marker. The file is not guaranteed to exist.
53		*/
54		public File getMarkerFile()
55		{
56	95	return getMarkerFile( this.resolved );
57		}
58
59		/**
60		* Get MarkerFile, exposed for unit testing purposes
61		*
62		* @param res
63		* resolved or not.
64		* @return marker file for this artifact.
65		*/
66		protected File getMarkerFile( boolean res )
67		{
68		String suffix;
69	180	if ( res )
70		{
71	90	suffix = ".resolved";
72		}
73		else
74		{
75	90	suffix = ".unresolved";
76		}
77
78	180	return new File( this.markerFilesDirectory, this.artifact.getId().replace( ':', '-' ) + suffix );
79		}
80
81		/**
82		* Tests whether the file or directory denoted by this abstract pathname
83		* exists.
84		*
85		* @return <code>true</code> if and only if the file or directory denoted
86		* by this abstract pathname exists; <code>false</code> otherwise
87		*
88		* @throws MojoExecutionException
89		* If a security manager exists and its <code>{@link
90		* java.lang.SecurityManager#checkRead(java.lang.String)}</code>
91		* method denies read access to the file or directory
92		*/
93		public boolean isMarkerSet()
94		throws MojoExecutionException
95		{
96	45	File marker = getMarkerFile();
97
98	45	File marker2 = getMarkerFile( !this.resolved );
99
100	45	return marker.exists() \|\| marker2.exists();
101		}
102
103		public boolean isMarkerOlder( Artifact theArtifact )
104		throws MojoExecutionException
105		{
106	16	File marker = getMarkerFile();
107	16	if ( marker.exists() )
108		{
109	6	return theArtifact.getFile().lastModified() > marker.lastModified();
110		}
111		else
112		{
113	10	marker = getMarkerFile( !this.resolved );
114	10	if ( marker.exists() )
115		{
116	6	return theArtifact.getFile().lastModified() > marker.lastModified();
117		}
118		else
119		{
120		// if the marker doesn't exist, we want to copy so assume it is
121		// infinitely older
122	4	return true;
123		}
124		}
125		}
126
127		public void setMarker()
128		throws MojoExecutionException
129		{
130	17	File marker = getMarkerFile();
131
132		// get the other file if it exists.
133	17	File clearMarker = getMarkerFile( !this.resolved );
134		// create marker file
135		try
136		{
137	17	marker.getParentFile().mkdirs();
138		}
139	2	catch ( NullPointerException e )
140		{
141		// parent is null, ignore it.
142	15	}
143
144		try
145		{
146	17	marker.createNewFile();
147		// clear the other file if it exists.
148	16	if ( clearMarker.exists() )
149		{
150	1	clearMarker.delete();
151		}
152		}
153	1	catch ( IOException e )
154		{
155	1	throw new MojoExecutionException( "Unable to create Marker: " + marker.getAbsolutePath(), e );
156	16	}
157	16	}
158
159		/**
160		* Deletes the file or directory denoted by this abstract pathname. If this
161		* pathname denotes a directory, then the directory must be empty in order
162		* to be deleted.
163		*
164		* @return <code>true</code> if and only if the file or directory is
165		* successfully deleted; <code>false</code> otherwise
166		*
167		* @throws SecurityException
168		* If a security manager exists and its <code>{@link
169		* java.lang.SecurityManager#checkDelete}</code>
170		* method denies delete access to the file
171		*/
172		public boolean clearMarker()
173		throws MojoExecutionException
174		{
175	15	File marker = getMarkerFile();
176	15	File marker2 = getMarkerFile( !this.resolved );
177	15	boolean markResult = marker.delete();
178	15	boolean mark2Result = marker2.delete();
179	15	return markResult \|\| mark2Result;
180		}
181
182		/**
183		* @return Returns the resolved.
184		*/
185		public boolean isResolved()
186		{
187	2	return this.resolved;
188		}
189
190		/**
191		* @param isResolved
192		* The resolved to set.
193		*/
194		public void setResolved( boolean isResolved )
195		{
196	1	this.resolved = isResolved;
197	1	}
198		}