Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.ftp.parser.FTPTimestampParserImpl |
87% |
100% |

1 |  |
     /*
2 |  |
      * Copyright 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 |  |
18 |  |
     import java.text.DateFormatSymbols;
19 |  |
     import java.text.ParseException;
20 |  |
     import java.text.ParsePosition;
21 |  |
     import java.text.SimpleDateFormat;
22 |  |
     import java.util.Calendar;
23 |  |
     import java.util.Date;
24 |  |
     import java.util.TimeZone;
25 |  |
26 |  |
     import org.apache.commons.net.ftp.Configurable;
27 |  |
     import org.apache.commons.net.ftp.FTPClientConfig;
28 |  |
29 |  |
     /**
30 |  |
      * Default implementation of the {@link  FTPTimestampParser  FTPTimestampParser}
31 |  |
      * interface also implements the {@link  org.apache.commons.net.ftp.Configurable  Configurable}
32 |  |
      * interface to allow the parsing to be configured from the outside.
33 |  |
      *
34 |  |
      * @see ConfigurableFTPFileEntryParserImpl
35 |  |
      * @since 1.4
36 |  |
      */
37 |  |
     public class FTPTimestampParserImpl implements
38 |  |
     		FTPTimestampParser, Configurable
39 |  |
     {
40 |  |
41 |  |
42 |  |
     	private SimpleDateFormat defaultDateFormat;
43 |  |
     	private SimpleDateFormat recentDateFormat;
44 |  |
45 |  |
46 |  |
     	/**
47 |  |
     	 * The only constructor for this class.
48 |  |
     	 */
49 | 218 |
     	public FTPTimestampParserImpl() {
50 | 218 |
     		setDefaultDateFormat(DEFAULT_SDF);
51 | 218 |
     		setRecentDateFormat(DEFAULT_RECENT_SDF);
52 | 218 |
     	}
53 |  |
54 |  |
     	/**
55 |  |
     	 * Implements the one {@link  FTPTimestampParser#parseTimestamp(String)  method}
56 |  |
     	 * in the {@link  FTPTimestampParser  FTPTimestampParser} interface
57 |  |
     	 * according to this algorithm:
58 |  |
     	 *
59 |  |
     	 * If the recentDateFormat member has been defined, try to parse the
60 |  |
     	 * supplied string with that.  If that parse fails, or if the recentDateFormat
61 |  |
     	 * member has not been defined, attempt to parse with the defaultDateFormat
62 |  |
     	 * member.  If that fails, throw a ParseException.
63 |  |
     	 *
64 |  |
     	 * @see org.apache.commons.net.ftp.parser.FTPTimestampParser#parseTimestamp(java.lang.String)
65 |  |
     	 */
66 |  |
     	/* (non-Javadoc)
67 |  |
     	 *
68 |  |
     	 */
69 |  |
     	public Calendar parseTimestamp(String timestampStr) throws ParseException {
70 | 338 |
     		Calendar now = Calendar.getInstance();
71 | 338 |
     		now.setTimeZone(this.getServerTimeZone());
72 |  |
73 | 338 |
     		Calendar working = Calendar.getInstance();
74 | 338 |
     		working.setTimeZone(this.getServerTimeZone());
75 | 338 |
     		ParsePosition pp = new ParsePosition(0);
76 |  |
77 | 338 |
     		Date parsed = null;
78 | 338 |
     		if (this.recentDateFormat != null) {
79 | 130 |
     			parsed = recentDateFormat.parse(timestampStr, pp);
80 |  |
     		}
81 | 338 |
     		if (parsed != null && pp.getIndex() == timestampStr.length())
82 |  |
     		{
83 | 54 |
     			working.setTime(parsed);
84 | 54 |
     			working.set(Calendar.YEAR, now.get(Calendar.YEAR));
85 | 54 |
     			if (working.after(now)) {
86 | 16 |
     				working.add(Calendar.YEAR, -1);
87 |  |
     			}
88 |  |
     		} else {
89 | 284 |
     			pp = new ParsePosition(0);
90 | 284 |
     			parsed = defaultDateFormat.parse(timestampStr, pp);
91 |  |
     			// note, length checks are mandatory for us since
92 |  |
     			// SimpleDateFormat methods will succeed if less than
93 |  |
     			// full string is matched.  They will also accept,
94 |  |
     			// despite "leniency" setting, a two-digit number as
95 |  |
     			// a valid year (e.g. 22:04 will parse as 22 A.D.)
96 |  |
     			// so could mistakenly confuse an hour with a year,
97 |  |
     			// if we don't insist on full length parsing.
98 | 284 |
     			if (parsed != null && pp.getIndex() == timestampStr.length()) {
99 | 216 |
     				working.setTime(parsed);
100 |  |
     			} else {
101 | 68 |
     				throw new ParseException(
102 |  |
     					"Timestamp could not be parsed with older or recent DateFormat",
103 |  |
     					pp.getIndex());
104 |  |
     			}
105 |  |
     		}
106 | 270 |
     		return working;
107 |  |
     	}
108 |  |
109 |  |
     	/**
110 |  |
     	 * @return Returns the defaultDateFormat.
111 |  |
     	 */
112 |  |
     	public SimpleDateFormat getDefaultDateFormat() {
113 | 0 |
     		return defaultDateFormat;
114 |  |
     	}
115 |  |
     	/**
116 |  |
     	 * @return Returns the defaultDateFormat pattern string.
117 |  |
     	 */
118 |  |
     	public String getDefaultDateFormatString() {
119 | 0 |
     		return defaultDateFormat.toPattern();
120 |  |
     	}
121 |  |
     	/**
122 |  |
     	 * @param defaultDateFormat The defaultDateFormat to be set.
123 |  |
     	 */
124 |  |
     	private void setDefaultDateFormat(String format) {
125 | 218 |
     		if (format != null) {
126 | 218 |
     			this.defaultDateFormat = new SimpleDateFormat(format);
127 | 218 |
     			this.defaultDateFormat.setLenient(false);
128 |  |
     		}
129 | 218 |
     	}
130 |  |
     	/**
131 |  |
     	 * @return Returns the recentDateFormat.
132 |  |
     	 */
133 |  |
     	public SimpleDateFormat getRecentDateFormat() {
134 | 2 |
     		return recentDateFormat;
135 |  |
     	}
136 |  |
     	/**
137 |  |
     	 * @return Returns the recentDateFormat.
138 |  |
     	 */
139 |  |
     	public String getRecentDateFormatString() {
140 | 2 |
     		return recentDateFormat.toPattern();
141 |  |
     	}
142 |  |
     	/**
143 |  |
     	 * @param recentDateFormat The recentDateFormat to set.
144 |  |
     	 */
145 |  |
     	private void setRecentDateFormat(String format) {
146 | 218 |
     		if (format != null) {
147 | 218 |
     			this.recentDateFormat = new SimpleDateFormat(format);
148 | 218 |
     			this.recentDateFormat.setLenient(false);
149 |  |
     		}
150 | 218 |
     	}
151 |  |
152 |  |
     	/**
153 |  |
     	 * @return returns an array of 12 strings representing the short
154 |  |
     	 * month names used by this parse.
155 |  |
     	 */
156 |  |
     	public String[] getShortMonths() {
157 | 0 |
     		return defaultDateFormat.getDateFormatSymbols().getShortMonths();
158 |  |
     	}
159 |  |
160 |  |
161 |  |
     	/**
162 |  |
     	 * @return Returns the serverTimeZone used by this parser.
163 |  |
     	 */
164 |  |
     	public TimeZone getServerTimeZone() {
165 | 676 |
     		return this.defaultDateFormat.getTimeZone();
166 |  |
     	}
167 |  |
     	/**
168 |  |
     	 * sets a TimeZone represented by the supplied ID string into all
169 |  |
     	 * of the parsers used by this server.
170 |  |
     	 * @param serverTimeZone Time Id java.util.TimeZone id used by
171 |  |
     	 * the ftp server.  If null the client's local time zone is assumed.
172 |  |
     	 */
173 |  |
     	private void setServerTimeZone(String serverTimeZoneId) {
174 | 264 |
     		TimeZone serverTimeZone = TimeZone.getDefault();
175 | 264 |
     		if (serverTimeZoneId != null) {
176 | 2 |
     			serverTimeZone = TimeZone.getTimeZone(serverTimeZoneId);
177 |  |
     		}
178 | 264 |
     		this.defaultDateFormat.setTimeZone(serverTimeZone);
179 | 264 |
     		if (this.recentDateFormat != null) {
180 | 112 |
     			this.recentDateFormat.setTimeZone(serverTimeZone);
181 |  |
     		}
182 | 264 |
     	}
183 |  |
184 |  |
     	/**
185 |  |
     	 * Implementation of the {@link  Configurable  Configurable}
186 |  |
     	 * interface. Configures this <code>FTPTimestampParser</code> according
187 |  |
     	 * to the following logic:
188 |  |
     	 * <p>
189 |  |
     	 * Set up the {@link  FTPClientConfig#setDefaultDateFormatStr(java.lang.String) defaultDateFormat}
190 |  |
     	 * and optionally the {@link  FTPClientConfig#setRecentDateFormatStr(String) recentDateFormat}
191 |  |
     	 * to values supplied in the config based on month names configured as follows:
192 |  |
     	 * </p><p><ul>
193 |  |
     	 * <li>If a {@link  FTPClientConfig#setShortMonthNames(String) shortMonthString}
194 |  |
     	 * has been supplied in the <code>config</code>, use that to parse  parse timestamps.</li>
195 |  |
     	 * <li>Otherwise, if a {@link  FTPClientConfig#setServerLanguageCode(String) serverLanguageCode}
196 |  |
     	 * has been supplied in the <code>config</code>, use the month names represented
197 |  |
     	 * by that {@link  FTPClientConfig#lookupDateFormatSymbols(String) language}
198 |  |
     	 * to parse timestamps.</li>
199 |  |
     	 * <li>otherwise use default English month names</li>
200 |  |
     	 * </ul></p><p>
201 |  |
     	 * Finally if a {@link  org.apache.commons.net.ftp.FTPClientConfig#setServerTimeZoneId(String) serverTimeZoneId}
202 |  |
     	 * has been supplied via the config, set that into all date formats that have
203 |  |
     	 * been configured.
204 |  |
     	 * </p>
205 |  |
     	 */
206 |  |
     	public void configure(FTPClientConfig config) {
207 | 264 |
     		DateFormatSymbols dfs = null;
208 |  |
209 | 264 |
     		String languageCode = config.getServerLanguageCode();
210 | 264 |
     		String shortmonths = config.getShortMonthNames();
211 | 264 |
     		if (shortmonths != null) {
212 | 0 |
     			dfs = FTPClientConfig.getDateFormatSymbols(shortmonths);
213 | 264 |
     		} else if (languageCode != null) {
214 | 2 |
     			dfs = FTPClientConfig.lookupDateFormatSymbols(languageCode);
215 |  |
     		} else {
216 | 262 |
     			dfs = FTPClientConfig.lookupDateFormatSymbols("en");
217 |  |
     		}
218 |  |
219 |  |
220 | 264 |
     		String recentFormatString = config.getRecentDateFormatStr();
221 | 264 |
     		if (recentFormatString == null) {
222 | 152 |
     		    this.recentDateFormat = null;
223 |  |
     		} else {
224 | 112 |
     			this.recentDateFormat = new SimpleDateFormat(recentFormatString, dfs);
225 | 112 |
     			this.recentDateFormat.setLenient(false);
226 |  |
     		}
227 |  |
228 | 264 |
     		String defaultFormatString = config.getDefaultDateFormatStr();
229 | 264 |
     		if (defaultFormatString == null) {
230 | 0 |
     			throw new IllegalArgumentException("defaultFormatString cannot be null");
231 |  |
     		}
232 | 264 |
     		this.defaultDateFormat = new SimpleDateFormat(defaultFormatString, dfs);
233 | 264 |
     		this.defaultDateFormat.setLenient(false);
234 |  |
235 | 264 |
     		setServerTimeZone(config.getServerTimeZoneId());
236 | 264 |
     	}
237 |  |
     }

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