unit tests coverage

Coverage report

%line %branch

org.apache.commons.net.ftp.parser.UnixFTPEntryParser
88%

100%

1
/*

2
* Copyright 2001-2005 The Apache Software Foundation

3
*

4
* Licensed under the Apache License, Version 2.0 (the "License");

5
* you may not use this file except in compliance with the License.

6
* You may obtain a copy of the License at

7
*

8
* http://www.apache.org/licenses/LICENSE-2.0

9
*

10
* Unless required by applicable law or agreed to in writing, software

11
* distributed under the License is distributed on an "AS IS" BASIS,

12
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

13
* See the License for the specific language governing permissions and

14
* limitations under the License.

15
*/

16
package org.apache.commons.net.ftp.parser;

17
import java.text.ParseException;

18

19
import org.apache.commons.net.ftp.FTPClientConfig;

20
import org.apache.commons.net.ftp.FTPFile;

21

22
/**

23
* Implementation FTPFileEntryParser and FTPFileListParser for standard

24
* Unix Systems.

25
*

26
* This class is based on the logic of Daniel Savarese's

27
* DefaultFTPListParser, but adapted to use regular expressions and to fit the

28
* new FTPFileEntryParser interface.

29
* @version $Id: UnixFTPEntryParser.java 161712 2005-04-18 02:57:04Z scohen $

30
* @see org.apache.commons.net.ftp.FTPFileEntryParser FTPFileEntryParser (for usage instructions)

31
*/

32
public class UnixFTPEntryParser extends ConfigurableFTPFileEntryParserImpl

33
{

34
/**

35
* months abbreviations looked for by this parser. Also used

36
* to determine which month is matched by the parser

37
*/

38
private static final String DEFAULT_MONTHS =

39
"(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)";

40

41
static final String DEFAULT_DATE_FORMAT

42
= "MMM d yyyy"; //Nov 9 2001

43

44
static final String DEFAULT_RECENT_DATE_FORMAT

45
= "MMM d HH:mm"; //Nov 9 20:06

46

47
static final String NUMERIC_DATE_FORMAT

48
= "yyyy-MM-dd HH:mm"; //2001-11-09 20:06

49

50
/**

51
* Some Linux distributions are now shipping an FTP server which formats

52
* file listing dates in an all-numeric format:

53
* <code>"yyyy-MM-dd HH:mm</code>.

54
* This is a very welcome development, and hopefully it will soon become

55
* the standard. However, since it is so new, for now, and possibly

56
* forever, we merely accomodate it, but do not make it the default.

57
* <p>

58
* For now end users may specify this format only via

59
* <code>UnixFTPEntryParser(FTPClientConfig)</code>.

60
* Steve Cohen - 2005-04-17

61
*/

62 10
public static final FTPClientConfig NUMERIC_DATE_CONFIG =

63
new FTPClientConfig(

64
FTPClientConfig.SYST_UNIX,

65
NUMERIC_DATE_FORMAT,

66
null, class="keyword">null, class="keyword">null, class="keyword">null);

67

68
/**

69
* this is the regular expression used by this parser.

70
*

71
* Permissions:

72
* r the file is readable

73
* w the file is writable

74
* x the file is executable

75
* - the indicated permission is not granted

76
* L mandatory locking occurs during access (the set-group-ID bit is

77
* on and the group execution bit is off)

78
* s the set-user-ID or set-group-ID bit is on, and the corresponding

79
* user or group execution bit is also on

80
* S undefined bit-state (the set-user-ID bit is on and the user

81
* execution bit is off)

82
* t the 1000 (octal) bit, or sticky bit, is on [see chmod(1)], and

83
* execution is on

84
* T the 1000 bit is turned on, and execution is off (undefined bit-

85
* state)

86
*/

87
private static final String REGEX =

88
"([bcdlfmpSs-])"

89
+"(((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-])))\\+?\\s+"

90
+ "(\\d+)\\s+"

91
+ "(\\S+)\\s+"

92
+ "(?:(\\S+)\\s+)?"

93
+ "(\\d+)\\s+"

94

95
/*

96
numeric or standard format date

97
*/

98
+ "((?:\\d+[-/]\\d+[-/]\\d+)|(?:\\S+\\s+\\S+))\\s+"

99

100
/*

101
year (for non-recent standard format)

102
or time (for numeric or recent standard format

103
*/

104
+ "(\\d+(?::\\d+)?)\\s+"

105

106
+ "(\\S*)(\\s*.*)";

107

108

109
/**

110
* The default constructor for a UnixFTPEntryParser object.

111
*

112
* @exception IllegalArgumentException

113
* Thrown if the regular expression is unparseable. Should not be seen

114
* under normal conditions. It it is seen, this is a sign that

115
* <code>REGEX</code> is not a valid regular expression.

116
*/

117
public UnixFTPEntryParser()

118
{

119 92
this(null);

120 92
}

121

122
/**

123
* This constructor allows the creation of a UnixFTPEntryParser object with

124
* something other than the default configuration.

125
*

126
* @param config The {@link FTPClientConfig configuration} object used to

127
* configure this parser.

128
* @exception IllegalArgumentException

129
* Thrown if the regular expression is unparseable. Should not be seen

130
* under normal conditions. It it is seen, this is a sign that

131
* <code>REGEX</code> is not a valid regular expression.

132
* @since 1.4

133
*/

134
public UnixFTPEntryParser(FTPClientConfig config)

135
{

136 94
super(REGEX);

137 94
configure(config);

138 94
}

139

140

141
/**

142
* Parses a line of a unix (standard) FTP server file listing and converts

143
* it into a usable format in the form of an <code> FTPFile </code>

144
* instance. If the file listing line doesn't describe a file,

145
* <code> null </code> is returned, otherwise a <code> FTPFile </code>

146
* instance representing the files in the directory is returned.

147
* <p>

148
* @param entry A line of text from the file listing

149
* @return An FTPFile instance corresponding to the supplied entry

150
*/

151
public FTPFile parseFTPEntry(String entry) {

152 154
FTPFile file = new FTPFile();

153 154
file.setRawListing(entry);

154
int type;

155 154
boolean isDevice = false;

156

157 154
if (matches(entry))

158
{

159 106
String typeStr = group(1);

160 106
String hardLinkCount = group(15);

161 106
String usr = group(16);

162 106
String grp = group(17);

163 106
String filesize = group(18);

164 106
String datestr = group(19) + " " + group(20);

165 106
String name = group(21);

166 106
String endtoken = group(22);

167

168
try

169
{

170 106
file.setTimestamp(super.parseTimestamp(datestr));

171
}

172 18
catch (ParseException e)

173
{

174 18
return null; // this is a parsing failure too.

175 88
}

176

177

178
// bcdlfmpSs-

179 88
switch (typeStr.charAt(0))

180
{

181
case 'd':

182 18
type = FTPFile.DIRECTORY_TYPE;

183 18
break;

184
case 'l':

185 8
type = FTPFile.SYMBOLIC_LINK_TYPE;

186 8
break;

187
case 'b':

188
case 'c':

189 4
isDevice = true;

190
// break; - fall through

191
case 'f':

192
case '-':

193 62
type = FTPFile.FILE_TYPE;

194 62
break;

195
default:

196 0
type = FTPFile.UNKNOWN_TYPE;

197
}

198

199 88
file.setType(type);

200

201 88
int g = 4;

202 352
for (int access = 0; access < 3; access++, g += 4)

203
{

204
// Use != '-' to avoid having to check for suid and sticky bits

205 264
file.setPermission(access, FTPFile.READ_PERMISSION,

206
(!group(g).equals("-")));

207 264
file.setPermission(access, FTPFile.WRITE_PERMISSION,

208
(!group(g + 1).equals("-")));

209

210 264
String execPerm = group(g + 2);

211 264
if (!execPerm.equals("-") && !Character.isUpperCase(execPerm.charAt(0)))

212
{

213 116
file.setPermission(access, FTPFile.EXECUTE_PERMISSION, true);

214
}

215
else

216
{

217 148
file.setPermission(access, FTPFile.EXECUTE_PERMISSION, false);

218
}

219
}

220

221 88
if (!isDevice)

222
{

223
try

224
{

225 84
file.setHardLinkCount(Integer.parseInt(hardLinkCount));

226
}

227 0
catch (NumberFormatException e)

228
{

229
// intentionally do nothing

230 84
}

231
}

232

233 88
file.setUser(usr);

234 88
file.setGroup(grp);

235

236
try

237
{

238 88
file.setSize(Long.parseLong(filesize));

239
}

240 0
catch (NumberFormatException e)

241
{

242
// intentionally do nothing

243 88
}

244

245 88
if (null == endtoken)

246
{

247 0
file.setName(name);

248
}

249
else

250
{

251
// oddball cases like symbolic links, file names

252
// with spaces in them.

253 88
name += endtoken;

254 88
if (type == FTPFile.SYMBOLIC_LINK_TYPE)

255
{

256

257 8
int end = name.indexOf(" -> ");

258
// Give up if no link indicator is present

259 8
if (end == -1)

260
{

261 4
file.setName(name);

262
}

263
else

264
{

265 4
file.setName(name.substring(0, end));

266 4
file.setLink(name.substring(end + 4));

267
}

268

269
}

270
else

271
{

272 80
file.setName(name);

273
}

274
}

275 88
return file;

276
}

277 48
return null;

278
}

279

280
/**

281
* Defines a default configuration to be used when this class is

282
* instantiated without a {@link FTPClientConfig FTPClientConfig}

283
* parameter being specified.

284
* @return the default configuration for this parser.

285
*/

286
protected FTPClientConfig getDefaultConfiguration() {

287 108
return new FTPClientConfig(

288
FTPClientConfig.SYST_UNIX,

289
DEFAULT_DATE_FORMAT,

290
DEFAULT_RECENT_DATE_FORMAT,

291
null, class="keyword">null, class="keyword">null);

292
}

293

294

295

296

297
}

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.

1		/*
2		* Copyright 2001-2005 The Apache Software Foundation
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.apache.commons.net.ftp.parser;
17		import java.text.ParseException;
18
19		import org.apache.commons.net.ftp.FTPClientConfig;
20		import org.apache.commons.net.ftp.FTPFile;
21
22		/**
23		* Implementation FTPFileEntryParser and FTPFileListParser for standard
24		* Unix Systems.
25		*
26		* This class is based on the logic of Daniel Savarese's
27		* DefaultFTPListParser, but adapted to use regular expressions and to fit the
28		* new FTPFileEntryParser interface.
29		* @version $Id: UnixFTPEntryParser.java 161712 2005-04-18 02:57:04Z scohen $
30		* @see org.apache.commons.net.ftp.FTPFileEntryParser FTPFileEntryParser (for usage instructions)
31		*/
32		public class UnixFTPEntryParser extends ConfigurableFTPFileEntryParserImpl
33		{
34		/**
35		* months abbreviations looked for by this parser. Also used
36		* to determine which month is matched by the parser
37		*/
38		private static final String DEFAULT_MONTHS =
39		"(Jan\|Feb\|Mar\|Apr\|May\|Jun\|Jul\|Aug\|Sep\|Oct\|Nov\|Dec)";
40
41		static final String DEFAULT_DATE_FORMAT
42		= "MMM d yyyy"; //Nov 9 2001
43
44		static final String DEFAULT_RECENT_DATE_FORMAT
45		= "MMM d HH:mm"; //Nov 9 20:06
46
47		static final String NUMERIC_DATE_FORMAT
48		= "yyyy-MM-dd HH:mm"; //2001-11-09 20:06
49
50		/**
51		* Some Linux distributions are now shipping an FTP server which formats
52		* file listing dates in an all-numeric format:
53		* <code>"yyyy-MM-dd HH:mm</code>.
54		* This is a very welcome development, and hopefully it will soon become
55		* the standard. However, since it is so new, for now, and possibly
56		* forever, we merely accomodate it, but do not make it the default.
57		* <p>
58		* For now end users may specify this format only via
59		* <code>UnixFTPEntryParser(FTPClientConfig)</code>.
60		* Steve Cohen - 2005-04-17
61		*/
62	10	public static final FTPClientConfig NUMERIC_DATE_CONFIG =
63		new FTPClientConfig(
64		FTPClientConfig.SYST_UNIX,
65		NUMERIC_DATE_FORMAT,
66		null, class="keyword">null, class="keyword">null, class="keyword">null);
67
68		/**
69		* this is the regular expression used by this parser.
70		*
71		* Permissions:
72		* r the file is readable
73		* w the file is writable
74		* x the file is executable
75		* - the indicated permission is not granted
76		* L mandatory locking occurs during access (the set-group-ID bit is
77		* on and the group execution bit is off)
78		* s the set-user-ID or set-group-ID bit is on, and the corresponding
79		* user or group execution bit is also on
80		* S undefined bit-state (the set-user-ID bit is on and the user
81		* execution bit is off)
82		* t the 1000 (octal) bit, or sticky bit, is on [see chmod(1)], and
83		* execution is on
84		* T the 1000 bit is turned on, and execution is off (undefined bit-
85		* state)
86		*/
87		private static final String REGEX =
88		"([bcdlfmpSs-])"
89		+"(((r\|-)(w\|-)([xsStTL-]))((r\|-)(w\|-)([xsStTL-]))((r\|-)(w\|-)([xsStTL-])))\\+?\\s+"
90		+ "(\\d+)\\s+"
91		+ "(\\S+)\\s+"
92		+ "(?:(\\S+)\\s+)?"
93		+ "(\\d+)\\s+"
94
95		/*
96		numeric or standard format date
97		*/
98		+ "((?:\\d+[-/]\\d+[-/]\\d+)\|(?:\\S+\\s+\\S+))\\s+"
99
100		/*
101		year (for non-recent standard format)
102		or time (for numeric or recent standard format
103		*/
104		+ "(\\d+(?::\\d+)?)\\s+"
105
106		+ "(\\S)(\\s.*)";
107
108
109		/**
110		* The default constructor for a UnixFTPEntryParser object.
111		*
112		* @exception IllegalArgumentException
113		* Thrown if the regular expression is unparseable. Should not be seen
114		* under normal conditions. It it is seen, this is a sign that
115		* <code>REGEX</code> is not a valid regular expression.
116		*/
117		public UnixFTPEntryParser()
118		{
119	92	this(null);
120	92	}
121
122		/**
123		* This constructor allows the creation of a UnixFTPEntryParser object with
124		* something other than the default configuration.
125		*
126		* @param config The {@link FTPClientConfig configuration} object used to
127		* configure this parser.
128		* @exception IllegalArgumentException
129		* Thrown if the regular expression is unparseable. Should not be seen
130		* under normal conditions. It it is seen, this is a sign that
131		* <code>REGEX</code> is not a valid regular expression.
132		* @since 1.4
133		*/
134		public UnixFTPEntryParser(FTPClientConfig config)
135		{
136	94	super(REGEX);
137	94	configure(config);
138	94	}
139
140
141		/**
142		* Parses a line of a unix (standard) FTP server file listing and converts
143		* it into a usable format in the form of an <code> FTPFile </code>
144		* instance. If the file listing line doesn't describe a file,
145		* <code> null </code> is returned, otherwise a <code> FTPFile </code>
146		* instance representing the files in the directory is returned.
147		* <p>
148		* @param entry A line of text from the file listing
149		* @return An FTPFile instance corresponding to the supplied entry
150		*/
151		public FTPFile parseFTPEntry(String entry) {
152	154	FTPFile file = new FTPFile();
153	154	file.setRawListing(entry);
154		int type;
155	154	boolean isDevice = false;
156
157	154	if (matches(entry))
158		{
159	106	String typeStr = group(1);
160	106	String hardLinkCount = group(15);
161	106	String usr = group(16);
162	106	String grp = group(17);
163	106	String filesize = group(18);
164	106	String datestr = group(19) + " " + group(20);
165	106	String name = group(21);
166	106	String endtoken = group(22);
167
168		try
169		{
170	106	file.setTimestamp(super.parseTimestamp(datestr));
171		}
172	18	catch (ParseException e)
173		{
174	18	return null; // this is a parsing failure too.
175	88	}
176
177
178		// bcdlfmpSs-
179	88	switch (typeStr.charAt(0))
180		{
181		case 'd':
182	18	type = FTPFile.DIRECTORY_TYPE;
183	18	break;
184		case 'l':
185	8	type = FTPFile.SYMBOLIC_LINK_TYPE;
186	8	break;
187		case 'b':
188		case 'c':
189	4	isDevice = true;
190		// break; - fall through
191		case 'f':
192		case '-':
193	62	type = FTPFile.FILE_TYPE;
194	62	break;
195		default:
196	0	type = FTPFile.UNKNOWN_TYPE;
197		}
198
199	88	file.setType(type);
200
201	88	int g = 4;
202	352	for (int access = 0; access < 3; access++, g += 4)
203		{
204		// Use != '-' to avoid having to check for suid and sticky bits
205	264	file.setPermission(access, FTPFile.READ_PERMISSION,
206		(!group(g).equals("-")));
207	264	file.setPermission(access, FTPFile.WRITE_PERMISSION,
208		(!group(g + 1).equals("-")));
209
210	264	String execPerm = group(g + 2);
211	264	if (!execPerm.equals("-") && !Character.isUpperCase(execPerm.charAt(0)))
212		{
213	116	file.setPermission(access, FTPFile.EXECUTE_PERMISSION, true);
214		}
215		else
216		{
217	148	file.setPermission(access, FTPFile.EXECUTE_PERMISSION, false);
218		}
219		}
220
221	88	if (!isDevice)
222		{
223		try
224		{
225	84	file.setHardLinkCount(Integer.parseInt(hardLinkCount));
226		}
227	0	catch (NumberFormatException e)
228		{
229		// intentionally do nothing
230	84	}
231		}
232
233	88	file.setUser(usr);
234	88	file.setGroup(grp);
235
236		try
237		{
238	88	file.setSize(Long.parseLong(filesize));
239		}
240	0	catch (NumberFormatException e)
241		{
242		// intentionally do nothing
243	88	}
244
245	88	if (null == endtoken)
246		{
247	0	file.setName(name);
248		}
249		else
250		{
251		// oddball cases like symbolic links, file names
252		// with spaces in them.
253	88	name += endtoken;
254	88	if (type == FTPFile.SYMBOLIC_LINK_TYPE)
255		{
256
257	8	int end = name.indexOf(" -> ");
258		// Give up if no link indicator is present
259	8	if (end == -1)
260		{
261	4	file.setName(name);
262		}
263		else
264		{
265	4	file.setName(name.substring(0, end));
266	4	file.setLink(name.substring(end + 4));
267		}
268
269		}
270		else
271		{
272	80	file.setName(name);
273		}
274		}
275	88	return file;
276		}
277	48	return null;
278		}
279
280		/**
281		* Defines a default configuration to be used when this class is
282		* instantiated without a {@link FTPClientConfig FTPClientConfig}
283		* parameter being specified.
284		* @return the default configuration for this parser.
285		*/
286		protected FTPClientConfig getDefaultConfiguration() {
287	108	return new FTPClientConfig(
288		FTPClientConfig.SYST_UNIX,
289		DEFAULT_DATE_FORMAT,
290		DEFAULT_RECENT_DATE_FORMAT,
291		null, class="keyword">null, class="keyword">null);
292		}
293
294
295
296
297		}