Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
ProjectResourceLoader |
|
| 5.0;5 |
1 | package org.apache.maven.plugin.resource.loader; | |
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.BufferedInputStream; | |
23 | import java.io.File; | |
24 | import java.io.FileInputStream; | |
25 | import java.io.FileNotFoundException; | |
26 | import java.io.InputStream; | |
27 | import java.util.Hashtable; | |
28 | import java.util.Vector; | |
29 | ||
30 | import org.apache.commons.collections.ExtendedProperties; | |
31 | import org.apache.velocity.exception.ResourceNotFoundException; | |
32 | import org.apache.velocity.runtime.resource.Resource; | |
33 | import org.apache.velocity.runtime.resource.loader.ResourceLoader; | |
34 | import org.apache.velocity.util.StringUtils; | |
35 | ||
36 | /** | |
37 | * Resource Loader for external projects. | |
38 | * | |
39 | * @version $Id: org.apache.maven.plugin.resource.loader.ProjectResourceLoader.html 816584 2012-05-08 12:33:35Z hboutemy $ | |
40 | */ | |
41 | 0 | public class ProjectResourceLoader |
42 | extends ResourceLoader | |
43 | { | |
44 | /** | |
45 | * The paths to search for templates. | |
46 | */ | |
47 | 0 | private Vector paths = null; |
48 | ||
49 | /** | |
50 | * Used to map the path that a template was found on | |
51 | * so that we can properly check the modification | |
52 | * times of the files. | |
53 | */ | |
54 | 0 | private Hashtable templatePaths = new Hashtable(); |
55 | ||
56 | public void init( ExtendedProperties configuration ) | |
57 | { | |
58 | 0 | rsvc.info( "ProjectResourceLoader : initialization starting." ); |
59 | ||
60 | 0 | String separator = System.getProperty( "file.separator" ); |
61 | ||
62 | 0 | String path = System.getProperty( "user.dir" ) + separator + "src" + separator + "main" + separator |
63 | + "resources" + separator; | |
64 | ||
65 | 0 | rsvc.info( "path :" + path ); |
66 | ||
67 | 0 | paths = new Vector(); |
68 | ||
69 | 0 | paths.add( path ); |
70 | ||
71 | 0 | int sz = paths.size(); |
72 | ||
73 | 0 | for ( int i = 0; i < sz; i++ ) |
74 | { | |
75 | 0 | rsvc.info( "ProjectResourceLoader : adding path '" + (String) paths.get( i ) + "'" ); |
76 | } | |
77 | 0 | rsvc.info( "ProjectResourceLoader : initialization complete." ); |
78 | 0 | } |
79 | ||
80 | /** | |
81 | * Get an InputStream so that the Runtime can build a | |
82 | * template with it. | |
83 | * | |
84 | * @param templateName name of template to get | |
85 | * @return InputStream containing the template | |
86 | * @throws ResourceNotFoundException if template not found | |
87 | * in the file template path. | |
88 | */ | |
89 | public synchronized InputStream getResourceStream( String templateName ) | |
90 | throws ResourceNotFoundException | |
91 | { | |
92 | /* | |
93 | * Make sure we have a valid templateName. | |
94 | */ | |
95 | 0 | if ( templateName == null || templateName.length() == 0 ) |
96 | { | |
97 | /* | |
98 | * If we don't get a properly formed templateName then | |
99 | * there's not much we can do. So we'll forget about | |
100 | * trying to search any more paths for the template. | |
101 | */ | |
102 | 0 | throw new ResourceNotFoundException( "Need to specify a file name or file path!" ); |
103 | } | |
104 | ||
105 | 0 | String template = StringUtils.normalizePath( templateName ); |
106 | 0 | if ( template == null || template.length() == 0 ) |
107 | { | |
108 | 0 | String msg = "Project Resource loader error : argument " + template |
109 | + " contains .. and may be trying to access " + "content outside of template root. Rejected."; | |
110 | ||
111 | 0 | rsvc.error( "ProjectResourceLoader : " + msg ); |
112 | ||
113 | 0 | throw new ResourceNotFoundException( msg ); |
114 | } | |
115 | ||
116 | /* | |
117 | * if a / leads off, then just nip that :) | |
118 | */ | |
119 | 0 | if ( template.startsWith( "/" ) ) |
120 | { | |
121 | 0 | template = template.substring( 1 ); |
122 | } | |
123 | ||
124 | 0 | int size = paths.size(); |
125 | 0 | for ( int i = 0; i < size; i++ ) |
126 | { | |
127 | 0 | String path = (String) paths.get( i ); |
128 | 0 | InputStream inputStream = findTemplate( path, template ); |
129 | ||
130 | 0 | if ( inputStream != null ) |
131 | { | |
132 | /* | |
133 | * Store the path that this template came | |
134 | * from so that we can check its modification | |
135 | * time. | |
136 | */ | |
137 | ||
138 | 0 | templatePaths.put( templateName, path ); |
139 | 0 | return inputStream; |
140 | } | |
141 | } | |
142 | ||
143 | /* | |
144 | * We have now searched all the paths for | |
145 | * templates and we didn't find anything so | |
146 | * throw an exception. | |
147 | */ | |
148 | 0 | String msg = "ProjectResourceLoader Error: cannot find resource " + template; |
149 | ||
150 | 0 | throw new ResourceNotFoundException( msg ); |
151 | } | |
152 | ||
153 | /** | |
154 | * Try to find a template given a normalized path. | |
155 | * | |
156 | * @param path a normalized path | |
157 | * @return InputStream input stream that will be parsed | |
158 | * | |
159 | */ | |
160 | private InputStream findTemplate( String path, String template ) | |
161 | { | |
162 | try | |
163 | { | |
164 | 0 | File file = new File( path, template ); |
165 | ||
166 | 0 | if ( file.canRead() ) |
167 | { | |
168 | 0 | return new BufferedInputStream( new FileInputStream( file.getAbsolutePath() ) ); |
169 | } | |
170 | else | |
171 | { | |
172 | 0 | return null; |
173 | } | |
174 | } | |
175 | 0 | catch ( FileNotFoundException fnfe ) |
176 | { | |
177 | /* | |
178 | * log and convert to a general Velocity ResourceNotFoundException | |
179 | */ | |
180 | 0 | return null; |
181 | } | |
182 | } | |
183 | ||
184 | /** | |
185 | * How to keep track of all the modified times | |
186 | * across the paths. Note that a file might have | |
187 | * appeared in a directory which is earlier in the | |
188 | * path; so we should search the path and see if | |
189 | * the file we find that way is the same as the one | |
190 | * that we have cached. | |
191 | */ | |
192 | public boolean isSourceModified( Resource resource ) | |
193 | { | |
194 | /* | |
195 | * we assume that the file needs to be reloaded; | |
196 | * if we find the original file and it's unchanged, | |
197 | * then we'll flip this. | |
198 | */ | |
199 | 0 | boolean modified = true; |
200 | ||
201 | 0 | String fileName = resource.getName(); |
202 | 0 | String path = (String) templatePaths.get( fileName ); |
203 | 0 | File currentFile = null; |
204 | ||
205 | 0 | for ( int i = 0; currentFile == null && i < paths.size(); i++ ) |
206 | { | |
207 | 0 | String testPath = (String) paths.get( i ); |
208 | 0 | File testFile = new File( testPath, fileName ); |
209 | 0 | if ( testFile.canRead() ) |
210 | { | |
211 | 0 | currentFile = testFile; |
212 | } | |
213 | } | |
214 | 0 | File file = new File( path, fileName ); |
215 | 0 | if ( currentFile == null || !file.exists() ) |
216 | 0 | { |
217 | /* | |
218 | * noop: if the file is missing now (either the cached | |
219 | * file is gone, or the file can no longer be found) | |
220 | * then we leave modified alone (it's set to true); a | |
221 | * reload attempt will be done, which will either use | |
222 | * a new template or fail with an appropriate message | |
223 | * about how the file couldn't be found. | |
224 | */ | |
225 | } | |
226 | 0 | else if ( currentFile.equals( file ) && file.canRead() ) |
227 | { | |
228 | /* | |
229 | * if only if currentFile is the same as file and | |
230 | * file.lastModified() is the same as | |
231 | * resource.getLastModified(), then we should use the | |
232 | * cached version. | |
233 | */ | |
234 | 0 | modified = ( file.lastModified() != resource.getLastModified() ); |
235 | } | |
236 | ||
237 | /* | |
238 | * rsvc.debug("isSourceModified for " + fileName + ": " + modified); | |
239 | */ | |
240 | 0 | return modified; |
241 | } | |
242 | ||
243 | public long getLastModified( Resource resource ) | |
244 | { | |
245 | 0 | String path = (String) templatePaths.get( resource.getName() ); |
246 | 0 | File file = new File( path, resource.getName() ); |
247 | ||
248 | 0 | if ( file.canRead() ) |
249 | { | |
250 | 0 | return file.lastModified(); |
251 | } | |
252 | else | |
253 | { | |
254 | 0 | return 0; |
255 | } | |
256 | } | |
257 | } |