unit tests coverage

Coverage report

%line %branch

org.apache.commons.validator.ValidatorResources$1
9%

50%

1
/*

2
* Licensed to the Apache Software Foundation (ASF) under one or more

3
* contributor license agreements. See the NOTICE file distributed with

4
* this work for additional information regarding copyright ownership.

5
* The ASF licenses this file to You under the Apache License, Version 2.0

6
* (the "License"); you may not use this file except in compliance with

7
* the License. You may obtain a copy of the License at

8
*

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

10
*

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

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

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

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

15
* limitations under the License.

16
*/

17
package org.apache.commons.validator;

18

19
import java.io.IOException;

20
import java.io.InputStream;

21
import java.io.Serializable;

22
import java.net.URL;

23
import java.util.Collections;

24
import java.util.Iterator;

25
import java.util.Locale;

26
import java.util.Map;

27

28
import org.apache.commons.collections.FastHashMap;

29
import org.apache.commons.digester.Digester;

30
import org.apache.commons.digester.Rule;

31
import org.apache.commons.digester.xmlrules.DigesterLoader;

32
import org.apache.commons.logging.Log;

33
import org.apache.commons.logging.LogFactory;

34
import org.xml.sax.SAXException;

35
import org.xml.sax.Attributes;

36

37
/**

38
* 

39
* General purpose class for storing <code>FormSet</code> objects based

40
* on their associated <code>Locale</code>. Instances of this class are usually

41
* configured through a validation.xml file that is parsed in a constructor.

42
* 

43
*

44
* Note - Classes that extend this class

45
* must be Serializable so that instances may be used in distributable

46
* application server environments.

47
*

48
* 

49
* The use of FastHashMap is deprecated and will be replaced in a future

50
* release.

51
* 

52
*

53
* @version $Revision: 478473 $ $Date: 2006-11-23 05:42:30 +0000 (Thu, 23 Nov 2006) $

54
*/

55
public class ValidatorResources implements Serializable {

56

57
/** Name of the digester validator rules file */

58
private static final String VALIDATOR_RULES = "digester-rules.xml";

59

60
/**

61
* The set of public identifiers, and corresponding resource names, for

62
* the versions of the configuration file DTDs that we know about. There

63
* MUST be an even number of Strings in this list!

64
*/

65
private static final String REGISTRATIONS[] = {

66
"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0//EN",

67
"/org/apache/commons/validator/resources/validator_1_0.dtd",

68
"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0.1//EN",

69
"/org/apache/commons/validator/resources/validator_1_0_1.dtd",

70
"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1//EN",

71
"/org/apache/commons/validator/resources/validator_1_1.dtd",

72
"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1.3//EN",

73
"/org/apache/commons/validator/resources/validator_1_1_3.dtd",

74
"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.2.0//EN",

75
"/org/apache/commons/validator/resources/validator_1_2_0.dtd",

76
"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.3.0//EN",

77
"/org/apache/commons/validator/resources/validator_1_3_0.dtd"

78
};

79

80
private transient Log log = LogFactory.getLog(ValidatorResources.class);

81

82
/**

83
* <code>Map</code> of <code>FormSet</code>s stored under

84
* a <code>Locale</code> key.

85
* @deprecated Subclasses should use getFormSets() instead.

86
*/

87
protected FastHashMap hFormSets = new FastHashMap();

88

89
/**

90
* <code>Map</code> of global constant values with

91
* the name of the constant as the key.

92
* @deprecated Subclasses should use getConstants() instead.

93
*/

94
protected FastHashMap hConstants = new FastHashMap();

95

96
/**

97
* <code>Map</code> of <code>ValidatorAction</code>s with

98
* the name of the <code>ValidatorAction</code> as the key.

99
* @deprecated Subclasses should use getActions() instead.

100
*/

101
protected FastHashMap hActions = new FastHashMap();

102

103
/**

104
* The default locale on our server.

105
*/

106
protected static Locale defaultLocale = Locale.getDefault();

107

108
/**

109
* Create an empty ValidatorResources object.

110
*/

111
public ValidatorResources() {

112
super();

113
}

114

115
/**

116
* This is the default <code>FormSet</code> (without locale). (We probably don't need

117
* the defaultLocale anymore.)

118
*/

119
protected FormSet defaultFormSet;

120

121
/**

122
* Create a ValidatorResources object from an InputStream.

123
*

124
* @param in InputStream to a validation.xml configuration file. It's the client's

125
* responsibility to close this stream.

126
* @throws IOException

127
* @throws SAXException if the validation XML files are not valid or well

128
* formed.

129
* @throws IOException if an I/O error occurs processing the XML files

130
* @since Validator 1.1

131
*/

132
public ValidatorResources(InputStream in) throws IOException, SAXException {

133
this(new InputStream[]{in});

134
}

135

136
/**

137
* Create a ValidatorResources object from an InputStream.

138
*

139
* @param streams An array of InputStreams to several validation.xml

140
* configuration files that will be read in order and merged into this object.

141
* It's the client's responsibility to close these streams.

142
* @throws IOException

143
* @throws SAXException if the validation XML files are not valid or well

144
* formed.

145
* @throws IOException if an I/O error occurs processing the XML files

146
* @since Validator 1.1

147
*/

148
public ValidatorResources(InputStream[] streams)

149
throws IOException, SAXException {

150

151
super();

152

153
Digester digester = initDigester();

154
for (int i = 0; i < streams.length; i++) {

155
digester.push(this);

156
digester.parse(streams[i]);

157
}

158

159
this.process();

160
}

161

162
/**

163
* Create a ValidatorResources object from an uri

164
*

165
* @param uri The location of a validation.xml configuration file.

166
* @throws IOException

167
* @throws SAXException if the validation XML files are not valid or well

168
* formed.

169
* @throws IOException if an I/O error occurs processing the XML files

170
* @since Validator 1.2

171
*/

172
public ValidatorResources(String uri) throws IOException, SAXException {

173
this(new String[]{uri});

174
}

175

176
/**

177
* Create a ValidatorResources object from several uris

178
*

179
* @param uris An array of uris to several validation.xml

180
* configuration files that will be read in order and merged into this object.

181
* @throws IOException

182
* @throws SAXException if the validation XML files are not valid or well

183
* formed.

184
* @throws IOException if an I/O error occurs processing the XML files

185
* @since Validator 1.2

186
*/

187
public ValidatorResources(String[] uris)

188
throws IOException, SAXException {

189

190
super();

191

192
Digester digester = initDigester();

193
for (int i = 0; i < uris.length; i++) {

194
digester.push(this);

195
digester.parse(uris[i]);

196
}

197

198
this.process();

199
}

200

201
/**

202
* Create a ValidatorResources object from a URL.

203
*

204
* @param url The URL for the validation.xml

205
* configuration file that will be read into this object.

206
* @throws IOException

207
* @throws SAXException if the validation XML file are not valid or well

208
* formed.

209
* @throws IOException if an I/O error occurs processing the XML files

210
* @since Validator 1.3.1

211
*/

212
public ValidatorResources(URL url)

213
throws IOException, SAXException {

214
this(new URL[]{url});

215
}

216

217
/**

218
* Create a ValidatorResources object from several URL.

219
*

220
* @param urls An array of URL to several validation.xml

221
* configuration files that will be read in order and merged into this object.

222
* @throws IOException

223
* @throws SAXException if the validation XML files are not valid or well

224
* formed.

225
* @throws IOException if an I/O error occurs processing the XML files

226
* @since Validator 1.3.1

227
*/

228
public ValidatorResources(URL[] urls)

229
throws IOException, SAXException {

230

231
super();

232

233
Digester digester = initDigester();

234
for (int i = 0; i < urls.length; i++) {

235
digester.push(this);

236
InputStream stream = null;

237
try {

238
stream = urls[i].openStream();

239
org.xml.sax.InputSource source =

240
new org.xml.sax.InputSource(urls[i].toExternalForm());

241
source.setByteStream(stream);

242
digester.parse(source);

243
} finally {

244
if (stream != null) {

245
try {

246
stream.close();

247
} catch (IOException e) {

248
// ignore problem closing

249
}

250
}

251
}

252
}

253

254
this.process();

255
}

256

257
/**

258
* Initialize the digester.

259
*/

260
private Digester initDigester() {

261
URL rulesUrl = this.getClass().getResource(VALIDATOR_RULES);

262
if (rulesUrl == null) {

263
// Fix for Issue# VALIDATOR-195

264
rulesUrl = ValidatorResources.class.getResource(VALIDATOR_RULES);

265
}

266
if (getLog().isDebugEnabled()) {

267
getLog().debug("Loading rules from '" + rulesUrl + "'");

268
}

269
Digester digester = DigesterLoader.createDigester(rulesUrl);

270
digester.setNamespaceAware(true);

271
digester.setValidating(true);

272
digester.setUseContextClassLoader(true);

273

274
// Add rules for arg0-arg3 elements

275
addOldArgRules(digester);

276

277
// register DTDs

278
for (int i = 0; i < REGISTRATIONS.length; i += 2) {

279
URL url = this.getClass().getResource(REGISTRATIONS[i + 1]);

280
if (url != null) {

281
digester.register(REGISTRATIONS[i], url.toString());

282
}

283
}

284
return digester;

285
}

286

287
private static final String ARGS_PATTERN

288
= "form-validation/formset/form/field/arg";

289

290
/**

291
* Create a <code>Rule</code> to handle <code>arg0-arg3</code>

292
* elements. This will allow validation.xml files that use the

293
* versions of the DTD prior to Validator 1.2.0 to continue

294
* working.

295
*/

296
private void addOldArgRules(Digester digester) {

297

298
// Create a new rule to process args elements

299
Rule rule = new Rule() {

300 98
public void begin(String namespace, String name,

301
Attributes attributes) throws Exception {

302
// Create the Arg

303 0
Arg arg = new Arg();

304 0
arg.setKey(attributes.getValue("key"));

305 0
arg.setName(attributes.getValue("name"));

306 0
if ("false".equalsIgnoreCase(attributes.getValue("resource"))) {

307 0
arg.setResource(false);

308
}

309
try {

310 0
arg.setPosition(Integer.parseInt(name.substring(3)));

311 0
} catch (Exception ex) {

312 0
getLog().error("Error parsing Arg position: "

313
+ name + " " + arg + " " + ex);

314
}

315

316
// Add the arg to the parent field

317 0
((Field)getDigester().peek(0)).addArg(arg);

318 0
}

319
};

320

321
// Add the rule for each of the arg elements

322
digester.addRule(ARGS_PATTERN + "0", rule);

323
digester.addRule(ARGS_PATTERN + "1", rule);

324
digester.addRule(ARGS_PATTERN + "2", rule);

325
digester.addRule(ARGS_PATTERN + "3", rule);

326

327
}

328

329
/**

330
* Add a <code>FormSet</code> to this <code>ValidatorResources</code>

331
* object. It will be associated with the <code>Locale</code> of the

332
* <code>FormSet</code>.

333
* @param fs The form set to add.

334
* @since Validator 1.1

335
*/

336
public void addFormSet(FormSet fs) {

337
String key = this.buildKey(fs);

338
if (key.length() == 0) {// there can only be one default formset

339
if (getLog().isWarnEnabled() && defaultFormSet != null) {

340
// warn the user he might not get the expected results

341
getLog().warn("Overriding default FormSet definition.");

342
}

343
defaultFormSet = fs;

344
} else {

345
FormSet formset = (FormSet) hFormSets.get(key);

346
if (formset == null) {// it hasn't been included yet

347
if (getLog().isDebugEnabled()) {

348
getLog().debug("Adding FormSet '" + fs.toString() + "'.");

349
}

350
} else if (getLog().isWarnEnabled()) {// warn the user he might not

351
// get the expected results

352
getLog()

353
.warn("Overriding FormSet definition. Duplicate for locale: "

354
+ key);

355
}

356
hFormSets.put(key, fs);

357
}

358
}

359

360
/**

361
* Add a global constant to the resource.

362
* @param name The constant name.

363
* @param value The constant value.

364
*/

365
public void addConstant(String name, String value) {

366
if (getLog().isDebugEnabled()) {

367
getLog().debug("Adding Global Constant: " + name + "," + value);

368
}

369

370
this.hConstants.put(name, value);

371
}

372

373
/**

374
* Add a <code>ValidatorAction</code> to the resource. It also creates an

375
* instance of the class based on the <code>ValidatorAction</code>s

376
* classname and retrieves the <code>Method</code> instance and sets them

377
* in the <code>ValidatorAction</code>.

378
* @param va The validator action.

379
*/

380
public void addValidatorAction(ValidatorAction va) {

381
va.init();

382

383
this.hActions.put(va.getName(), va);

384

385
if (getLog().isDebugEnabled()) {

386
getLog().debug("Add ValidatorAction: " + va.getName() + "," + va.getClassname());

387
}

388
}

389

390
/**

391
* Get a <code>ValidatorAction</code> based on it's name.

392
* @param key The validator action key.

393
* @return The validator action.

394
*/

395
public ValidatorAction getValidatorAction(String key) {

396
return (ValidatorAction) hActions.get(key);

397
}

398

399
/**

400
* Get an unmodifiable <code>Map</code> of the <code>ValidatorAction</code>s.

401
* @return Map of validator actions.

402
*/

403
public Map getValidatorActions() {

404
return Collections.unmodifiableMap(hActions);

405
}

406

407
/**

408
* Builds a key to store the <code>FormSet</code> under based on it's

409
* language, country, and variant values.

410
* @param fs The Form Set.

411
* @return generated key for a formset.

412
*/

413
protected String buildKey(FormSet fs) {

414
return

415
this.buildLocale(fs.getLanguage(), fs.getCountry(), fs.getVariant());

416
}

417

418
/**

419
* Assembles a Locale code from the given parts.

420
*/

421
private String buildLocale(String lang, String country, String variant) {

422
String key = ((lang != null && lang.length() > 0) ? lang : "");

423
key += ((country != null && country.length() > 0) ? "_" + country : "");

424
key += ((variant != null && variant.length() > 0) ? "_" + variant : "");

425
return key;

426
}

427

428
/**

429
* Gets a <code>Form</code> based on the name of the form and the

430
* <code>Locale</code> that most closely matches the <code>Locale</code>

431
* passed in. The order of <code>Locale</code> matching is:

432
* <ol>

433
* <li>language + country + variant</li>

434
* <li>language + country</li>

435
* <li>language</li>

436
* <li>default locale</li>

437
* </ol>

438
* @param locale The Locale.

439
* @param formKey The key for the Form.

440
* @return The validator Form.

441
* @since Validator 1.1

442
*/

443
public Form getForm(Locale locale, String formKey) {

444
return this.getForm(locale.getLanguage(), locale.getCountry(), locale

445
.getVariant(), formKey);

446
}

447

448
/**

449
* Gets a <code>Form</code> based on the name of the form and the

450
* <code>Locale</code> that most closely matches the <code>Locale</code>

451
* passed in. The order of <code>Locale</code> matching is:

452
* <ol>

453
* <li>language + country + variant</li>

454
* <li>language + country</li>

455
* <li>language</li>

456
* <li>default locale</li>

457
* </ol>

458
* @param language The locale's language.

459
* @param country The locale's country.

460
* @param variant The locale's language variant.

461
* @param formKey The key for the Form.

462
* @return The validator Form.

463
* @since Validator 1.1

464
*/

465
public Form getForm(String language, String country, String variant,

466
String formKey) {

467

468
Form form = null;

469

470
// Try language/country/variant

471
String key = this.buildLocale(language, country, variant);

472
if (key.length() > 0) {

473
FormSet formSet = (FormSet)hFormSets.get(key);

474
if (formSet != null) {

475
form = formSet.getForm(formKey);

476
}

477
}

478
String localeKey = key;

479

480

481
// Try language/country

482
if (form == null) {

483
key = buildLocale(language, country, null);

484
if (key.length() > 0) {

485
FormSet formSet = (FormSet)hFormSets.get(key);

486
if (formSet != null) {

487
form = formSet.getForm(formKey);

488
}

489
}

490
}

491

492
// Try language

493
if (form == null) {

494
key = buildLocale(language, null, class="keyword">null);

495
if (key.length() > 0) {

496
FormSet formSet = (FormSet)hFormSets.get(key);

497
if (formSet != null) {

498
form = formSet.getForm(formKey);

499
}

500
}

501
}

502

503
// Try default formset

504
if (form == null) {

505
form = defaultFormSet.getForm(formKey);

506
key = "default";

507
}

508

509
if (form == null) {

510
if (getLog().isWarnEnabled()) {

511
getLog().warn("Form '" + formKey + "' not found for locale '" +

512
localeKey + "'");

513
}

514
} else {

515
if (getLog().isDebugEnabled()) {

516
getLog().debug("Form '" + formKey + "' found in formset '" +

517
key + "' for locale '" + localeKey + "'");

518
}

519
}

520

521
return form;

522

523
}

524

525
/**

526
* Process the <code>ValidatorResources</code> object. Currently sets the

527
* <code>FastHashMap</code> s to the 'fast' mode and call the processes

528
* all other resources. Note : The framework calls this

529
* automatically when ValidatorResources is created from an XML file. If you

530
* create an instance of this class by hand you must call

531
* this method when finished.

532
*/

533
public void process() {

534
hFormSets.setFast(true);

535
hConstants.setFast(true);

536
hActions.setFast(true);

537

538
this.processForms();

539
}

540

541
/**

542
* Process the <code>Form</code> objects. This clones the <code>Field</code>s

543
* that don't exist in a <code>FormSet</code> compared to its parent

544
* <code>FormSet</code>.

545
*/

546
private void processForms() {

547
if (defaultFormSet == null) {// it isn't mandatory to have a

548
// default formset

549
defaultFormSet = new FormSet();

550
}

551
defaultFormSet.process(hConstants);

552
// Loop through FormSets and merge if necessary

553
for (Iterator i = hFormSets.keySet().iterator(); i.hasNext();) {

554
String key = (String) i.next();

555
FormSet fs = (FormSet) hFormSets.get(key);

556
fs.merge(getParent(fs));

557
}

558

559
// Process Fully Constructed FormSets

560
for (Iterator i = hFormSets.values().iterator(); i.hasNext();) {

561
FormSet fs = (FormSet) i.next();

562
if (!fs.isProcessed()) {

563
fs.process(hConstants);

564
}

565
}

566
}

567

568
/**

569
* Finds the given formSet's parent. ex: A formSet with locale en_UK_TEST1

570
* has a direct parent in the formSet with locale en_UK. If it doesn't

571
* exist, find the formSet with locale en, if no found get the

572
* defaultFormSet.

573
*

574
* @param fs

575
* the formSet we want to get the parent from

576
* @return fs's parent

577
*/

578
private FormSet getParent(FormSet fs) {

579

580
FormSet parent = null;

581
if (fs.getType() == FormSet.LANGUAGE_FORMSET) {

582
parent = defaultFormSet;

583
} else if (fs.getType() == FormSet.COUNTRY_FORMSET) {

584
parent = (FormSet) hFormSets.get(buildLocale(fs.getLanguage(),

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

586
if (parent == null) {

587
parent = defaultFormSet;

588
}

589
} else if (fs.getType() == FormSet.VARIANT_FORMSET) {

590
parent = (FormSet) hFormSets.get(buildLocale(fs.getLanguage(), fs

591
.getCountry(), null));

592
if (parent == null) {

593
parent = (FormSet) hFormSets.get(buildLocale(fs.getLanguage(),

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

595
if (parent == null) {

596
parent = defaultFormSet;

597
}

598
}

599
}

600
return parent;

601
}

602

603
/**

604
* Gets a <code>FormSet</code> based on the language, country

605
* and variant.

606
* @param language The locale's language.

607
* @param country The locale's country.

608
* @param variant The locale's language variant.

609
* @return The FormSet for a locale.

610
* @since Validator 1.2

611
*/

612
FormSet getFormSet(String language, String country, String variant) {

613

614
String key = buildLocale(language, country, variant);

615

616
if (key.length() == 0) {

617
return defaultFormSet;

618
}

619

620
return (FormSet)hFormSets.get(key);

621
}

622

623
/**

624
* Returns a Map of String locale keys to Lists of their FormSets.

625
* @return Map of Form sets

626
* @since Validator 1.2.0

627
*/

628
protected Map getFormSets() {

629
return hFormSets;

630
}

631

632
/**

633
* Returns a Map of String constant names to their String values.

634
* @return Map of Constants

635
* @since Validator 1.2.0

636
*/

637
protected Map getConstants() {

638
return hConstants;

639
}

640

641
/**

642
* Returns a Map of String ValidatorAction names to their ValidatorAction.

643
* @return Map of Validator Actions

644
* @since Validator 1.2.0

645
*/

646
protected Map getActions() {

647
return hActions;

648
}

649

650
/**

651
* Accessor method for Log instance.

652
*

653
* The Log instance variable is transient and

654
* accessing it through this method ensures it

655
* is re-initialized when this instance is

656
* de-serialized.

657
*

658
* @return The Log instance.

659
*/

660
private Log getLog() {

661
if (log == null) {

662
log = LogFactory.getLog(ValidatorResources.class);

663
}

664
return log;

665
}

666

667
}

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