1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// Copyright (C) 2009 Red Hat, Inc.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package net.sourceforge.jnlp.util;
import java.io.File;
import java.io.IOException;
import net.sourceforge.jnlp.runtime.JNLPRuntime;
/**
* This class contains a few file-related utility functions.
*
* @author Omair Majid
*/
public final class FileUtils {
/**
* list of characters not allowed in filenames
*/
private static final char INVALID_CHARS[] = { '\\', '/', ':', '*', '?', '"', '<', '>', '|' };
private static final char SANITIZED_CHAR = '_';
/**
* Clean up a string by removing characters that can't appear in a local
* file name.
*
* @param path
* the path to sanitize
* @return a sanitized version of the input which is suitable for using as a
* file path
*/
public static String sanitizePath(String path) {
for (int i = 0; i < INVALID_CHARS.length; i++)
if (INVALID_CHARS[i] != File.separatorChar)
if (-1 != path.indexOf(INVALID_CHARS[i]))
path = path.replace(INVALID_CHARS[i], SANITIZED_CHAR);
return path;
}
/**
* Given an input, return a sanitized form of the input suitable for use as
* a file/directory name
*
* @param input
* @return a sanitized version of the input
*/
public static String sanitizeFileName(String filename) {
for (int i = 0; i < INVALID_CHARS.length; i++)
if (-1 != filename.indexOf(INVALID_CHARS[i]))
filename = filename.replace(INVALID_CHARS[i], SANITIZED_CHAR);
return filename;
}
/**
* Returns a String that is suitable for using in GUI elements for
* displaying (long) paths to users.
*
* @param path a path that should be shortened
* @return a shortened path suitable for displaying to the user
*/
public static String displayablePath(String path) {
final int DEFAULT_LENGTH = 40;
return displayablePath(path, DEFAULT_LENGTH);
}
/**
* Return a String that is suitable for using in GUI elements for displaying
* paths to users. If the path is longer than visibleChars, it is truncated
* in a display-friendly way
*
* @param path a path that should be shorted
* @param visibleChars the maximum number of characters that path should fit
* into. Also the length of the returned string
* @return a shortened path that contains limited number of chars
*/
public static String displayablePath(String path, int visibleChars) {
/*
* use a very simple method: prefix + "..." + suffix
*
* where prefix is the beginning part of path (as much as we can squeeze in)
* and suffix is the end path of path
*/
if (path == null || path.length() <= visibleChars) {
return path;
}
final String OMITTED = "...";
final int OMITTED_LENGTH = OMITTED.length();
final int MIN_PREFIX_LENGTH = 4;
final int MIN_SUFFIX_LENGTH = 4;
/*
* we want to show things other than OMITTED. if we have too few for
* suffix and prefix, then just return as much as we can of the filename
*/
if (visibleChars < (OMITTED_LENGTH + MIN_PREFIX_LENGTH + MIN_SUFFIX_LENGTH)) {
return path.substring(path.length() - visibleChars);
}
int affixLength = (visibleChars - OMITTED_LENGTH)/2;
String prefix = path.substring(0, affixLength);
String suffix = path.substring(path.length() - affixLength);
return prefix + OMITTED + suffix;
}
/**
* Recursively delete everything under a directory. Works on either files or
* directories
*
* @param file the file object representing what to delete. Can be either a
* file or a directory.
* @param base the directory under which the file and its subdirectories must be located
* @throws IOException on an io exception or if trying to delete something
* outside the base
*/
public static void recursiveDelete(File file, File base) throws IOException {
if (JNLPRuntime.isDebug()) {
System.err.println("Deleting: " + file);
}
if (!(file.getCanonicalPath().startsWith(base.getCanonicalPath()))) {
throw new IOException("Trying to delete a file outside Netx's basedir: "
+ file.getCanonicalPath());
}
if (file.isDirectory()) {
File[] children = file.listFiles();
for (int i = 0; i < children.length; i++) {
recursiveDelete(children[i], base);
}
}
if (!file.delete()) {
throw new IOException("Unable to delete file: " + file);
}
}
}
|
