Apache Commons Digester is hosted on the Apache subversion repository.
The project URL is:
http://svn.apache.org/repos/asf/commons/proper/digester/trunk
The best way to view the repository is via the subversion viewer.
The alternative is to use the native subversion display.
We recommend you use a mirror to download our release builds, but you must verify the integrity of the downloaded files using signatures downloaded from our main distribution directories. Recent releases (48 hours) may not yet be available from the mirrors.
You are currently using [preferred]. If you
encounter a problem with this mirror, please select another
mirror. If all mirrors are failing, there are backup
mirrors (at the end of the mirrors list) that should be
available.
[if-any logo][end]
The KEYS link links to the code signing keys used to sign the product.
The PGP link downloads the OpenPGP compatible signature from our main site.
The MD5 link downloads the checksum from the main site.
For more information concerning Commons Digester, see the Commons Digester web site.
- Binary
- Source
- browse download area
- archives...
Commons Digester uses ASF JIRA for tracking issues. See the Commons Digester JIRA project page.
To use JIRA you may need to create an account (if you have previously created/updated Commons issues using Bugzilla an account will have been automatically created and you can use the Forgot Password page to get a new password).
If you would like to report a bug, or raise an enhancement request with Commons Digester please do the following:
- Search existing open bugs. If you find your issue listed then please add a comment with your details.
- Search the mailing list archive(s). You may find your issue or idea has already been discussed.
- Decide if your issue is a bug or an enhancement.
- Submit either a bug report or enhancement request.
Please also remember these points:
- the more information you provide, the better we can help you
- test cases are vital, particularly for any proposed enhancements
- the developers of Commons Digester are all unpaid volunteers
For more information on subversion and creating patches see the Apache Contributors Guide.
You may also find these links useful:
Runs standard tests for RulesBase as well as tests of extensions.
*
* @author Robert Burrell Donkin This should be overriden by subclasses.
*
* @return the matching rules to be tested.
*/
protected Rules createMatchingRulesForTest() {
return new ExtendedBaseRules();
}
/**
* Return the tests included in this test suite.
*/
public static Test suite() {
return (new TestSuite(EBRTestCase.class));
}
/**
* Basic test of parent matching rules.
* A parent match matches any child of a particular kind of parent.
* A wild parent has a wildcard prefix.
* This method tests non-universal wildcards.
*/
public void testBasicParentMatch() {
// clear any existing rules
digester.getRules().clear();
assertEquals("Initial rules list is empty",
0, digester.getRules().rules().size());
// Set up rules
// since these are all NON-UNIVERSAL matches
// only expect one match at each stage
digester.addRule("alpha/beta/gamma/delta", new TestRule("exact"));
digester.addRule("*/beta/gamma/epsilon", new TestRule("wild_child"));
digester.addRule("alpha/beta/gamma/?", new TestRule("exact_parent"));
digester.addRule("*/beta/gamma/?", new TestRule("wild_parent"));
List list = null;
Iterator it = null;
// this should match just the exact since this has presidence
list = digester.getRules().match(null, "alpha/beta/gamma/delta");
// all three rules should match
assertEquals("Testing basic parent mismatch (A)", 1, list.size());
it = list.iterator();
assertEquals("Testing basic parent mismatch (B)", "exact", ((TestRule) it.next()).getIdentifier());
// we don't have an exact match for this child so we should get the exact parent
list = digester.getRules().match(null, "alpha/beta/gamma/epsilon");
// all three rules should match
assertEquals("Testing basic parent mismatch (C)", 1, list.size());
it = list.iterator();
assertEquals("Testing basic parent mismatch (D)", "exact_parent", ((TestRule) it.next()).getIdentifier());
// wild child overrides wild parent
list = digester.getRules().match(null, "alpha/omega/beta/gamma/epsilon");
// all three rules should match
assertEquals("Testing basic parent mismatch (E)", 1, list.size());
it = list.iterator();
assertEquals("Testing basic parent mismatch (F)", "wild_child", ((TestRule) it.next()).getIdentifier());
// nothing else matches so return wild parent
list = digester.getRules().match(null, "alpha/omega/beta/gamma/zeta");
// all three rules should match
assertEquals("Testing basic parent mismatch (G)", 1, list.size());
it = list.iterator();
assertEquals("Testing basic parent mismatch (H)", "wild_parent", ((TestRule) it.next()).getIdentifier());
// clean up
digester.getRules().clear();
}
/**
* Basic test of universal matching rules.
* Universal rules act independent.
*/
public void testBasicUniversal() {
// clear any existing rules
digester.getRules().clear();
assertEquals("Initial rules list is empty",
0, digester.getRules().rules().size());
// Set up rules
// set up universal matches against non-universal ones
digester.addRule("alpha/beta/gamma", new TestRule("exact"));
digester.addRule("*/beta/gamma", new TestRule("non_wild_head"));
digester.addRule("!*/beta/gamma", new TestRule("universal_wild_head"));
digester.addRule("!alpha/beta/gamma/?", new TestRule("universal_wild_child"));
digester.addRule("alpha/beta/gamma/?", new TestRule("non_wild_child"));
digester.addRule("alpha/beta/gamma/epsilon", new TestRule("exact2"));
digester.addRule("alpha/epsilon/beta/gamma/zeta", new TestRule("exact3"));
digester.addRule("*/gamma/?", new TestRule("non_wildhead_child"));
digester.addRule("!*/epsilon/beta/gamma/?", new TestRule("universal_wildhead_child"));
List list = null;
Iterator it = null;
// test universal wild head
list = digester.getRules().match(null, "alpha/beta/gamma");
assertEquals("Testing universal wildcard mismatch (A)", 2, list.size());
it = list.iterator();
assertEquals("Testing universal wildcard mismatch (B)", "exact", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing universal wildcard mismatch (C)", "universal_wild_head", ((TestRule) it.next()).getIdentifier());
// test universal parent
list = digester.getRules().match(null, "alpha/beta/gamma/epsilon");
assertEquals("Testing universal wildcard mismatch (D)", 2, list.size());
it = list.iterator();
assertEquals("Testing universal wildcard mismatch (E)", "universal_wild_child", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing universal wildcard mismatch (F)", "exact2", ((TestRule) it.next()).getIdentifier());
// test universal parent
list = digester.getRules().match(null, "alpha/beta/gamma/zeta");
assertEquals("Testing universal wildcard mismatch (G)", 2, list.size());
it = list.iterator();
assertEquals("Testing universal wildcard mismatch (H)", "universal_wild_child", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing universal wildcard mismatch (I)", "non_wild_child", ((TestRule) it.next()).getIdentifier());
// test wildcard universal parent
list = digester.getRules().match(null, "alpha/epsilon/beta/gamma/alpha");
assertEquals("Testing universal wildcard mismatch (J)", 2, list.size());
it = list.iterator();
assertEquals("Testing universal wildcard mismatch (K)", "non_wildhead_child", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing universal wildcard mismatch (L)", "universal_wildhead_child", ((TestRule) it.next()).getIdentifier());
// test wildcard universal parent
list = digester.getRules().match(null, "alpha/epsilon/beta/gamma/zeta");
assertEquals("Testing universal wildcard mismatch (M)", 2, list.size());
it = list.iterator();
assertEquals("Testing universal wildcard mismatch (M)", "exact3", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing universal wildcard mismatch (O)", "universal_wildhead_child", ((TestRule) it.next()).getIdentifier());
// clean up
digester.getRules().clear();
}
/**
* Basic test of wild matches.
* A universal will match matches anything!
* A non-universal will match matches anything not matched by something else.
* This method tests non-universal and universal wild matches.
*/
public void testWildMatch() {
// clear any existing rules
digester.getRules().clear();
assertEquals("Initial rules list is empty",
0, digester.getRules().rules().size());
// Set up rules
// The combinations a little large to test everything but we'll pick a couple and try them.
digester.addRule("*", new TestRule("basic_wild"));
digester.addRule("!*", new TestRule("universal_wild"));
digester.addRule("alpha/beta/gamma/delta", new TestRule("exact"));
digester.addRule("*/beta/gamma/?", new TestRule("wild_parent"));
List list = null;
Iterator it = null;
// The universal wild will always match whatever else does
list = digester.getRules().match(null, "alpha/beta/gamma/delta");
// all three rules should match
assertEquals("Testing wild mismatch (A)", 2, list.size());
it = list.iterator();
assertEquals("Testing wild mismatch (B)", "universal_wild", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing wild mismatch (C)", "exact", ((TestRule) it.next()).getIdentifier());
// The universal wild will always match whatever else does
list = digester.getRules().match(null, "alpha/beta/gamma/epsilon");
assertEquals("Testing wild mismatch (D)", 2, list.size());
it = list.iterator();
assertEquals("Testing wild mismatch (E)", "universal_wild", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing wild mismatch (F)", "wild_parent", ((TestRule) it.next()).getIdentifier());
// The universal wild will always match whatever else does
// we have no other non-universal matching so this will match the non-universal wild as well
list = digester.getRules().match(null, "alpha/gamma");
assertEquals("Testing wild mismatch (G)", 2, list.size());
it = list.iterator();
assertEquals("Testing wild mismatch (H)", "basic_wild", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing wild mismatch (I)", "universal_wild", ((TestRule) it.next()).getIdentifier());
// clean up
digester.getRules().clear();
}
/**
* Basic test of wild matches.
* A universal will match matches anything!
* A non-universal will match matches anything not matched by something else.
* This method tests non-universal and universal wild matches.
*/
public void testRootTailMatch() {
// clear any existing rules
digester.getRules().clear();
assertEquals("Initial rules list is empty",
0, digester.getRules().rules().size());
// Set up rules
// The combinations a little large to test everything but we'll pick a couple and try them.
digester.addRule("*/a", new TestRule("a_tail"));
List list = null;
list = digester.getRules().match(null, "a");
assertEquals("Testing tail wrong size (A)", 1, list.size());
assertEquals("Testing tail mismatch (B)", "a_tail", ((TestRule) list.get(0)).getIdentifier());
list = digester.getRules().match(null, "beta/a");
assertEquals("Testing tail wrong size (C)", 1, list.size());
assertEquals("Testing tail mismatch (D)", "a_tail", ((TestRule) list.get(0)).getIdentifier());
list = digester.getRules().match(null, "be/aaa");
assertEquals("Testing tail no matches (E)", 0, list.size());
list = digester.getRules().match(null, "aaa");
assertEquals("Testing tail no matches (F)", 0, list.size());
list = digester.getRules().match(null, "a/beta");
assertEquals("Testing tail no matches (G)", 0, list.size());
// clean up
digester.getRules().clear();
}
public void testAncesterMatch() throws Exception {
// test fixed root ancester
digester.getRules().clear();
digester.addRule("!a/b/*", new TestRule("uni-a-b-star"));
digester.addRule("a/b/*", new TestRule("a-b-star"));
digester.addRule("a/b/c", new TestRule("a-b-c"));
digester.addRule("a/b/?", new TestRule("a-b-child"));
List
list = digester.getRules().match(null, "a/b/c");
assertEquals("Simple ancester matches (1)", 2, list.size());
assertEquals("Univeral ancester mismatch (1)", "uni-a-b-star" , ((TestRule) list.get(0)).getIdentifier());
assertEquals("Parent precedence failure", "a-b-c" , ((TestRule) list.get(1)).getIdentifier());
list = digester.getRules().match(null, "a/b/b");
assertEquals("Simple ancester matches (2)", 2, list.size());
assertEquals("Univeral ancester mismatch (2)", "uni-a-b-star" , ((TestRule) list.get(0)).getIdentifier());
assertEquals("Child precedence failure", "a-b-child" , ((TestRule) list.get(1)).getIdentifier());
list = digester.getRules().match(null, "a/b/d");
assertEquals("Simple ancester matches (3)", 2, list.size());
assertEquals("Univeral ancester mismatch (3)", "uni-a-b-star" , ((TestRule) list.get(0)).getIdentifier());
assertEquals("Ancester mismatch (1)", "a-b-child" , ((TestRule) list.get(1)).getIdentifier());
list = digester.getRules().match(null, "a/b/d/e/f");
assertEquals("Simple ancester matches (4)", 2, list.size());
assertEquals("Univeral ancester mismatch (4)", "uni-a-b-star" , ((TestRule) list.get(0)).getIdentifier());
assertEquals("Ancester mismatch (2)", "a-b-star" , ((TestRule) list.get(1)).getIdentifier());
// test wild root ancester
digester.getRules().clear();
digester.addRule("!*/a/b/*", new TestRule("uni-star-a-b-star"));
digester.addRule("*/b/c/*", new TestRule("star-b-c-star"));
digester.addRule("*/b/c/d", new TestRule("star-b-c-d"));
digester.addRule("a/b/c", new TestRule("a-b-c"));
list = digester.getRules().match(null, "a/b/c");
assertEquals("Wild ancester match (1)", 2, list.size());
assertEquals(
"Univeral ancester mismatch (5)",
"uni-star-a-b-star" ,
((TestRule) list.get(0)).getIdentifier());
assertEquals("Match missed (1)", "a-b-c" , ((TestRule) list.get(1)).getIdentifier());
list = digester.getRules().match(null, "b/c");
assertEquals("Wild ancester match (2)", 1, list.size());
assertEquals("Match missed (2)", "star-b-c-star" , ((TestRule) list.get(0)).getIdentifier());
list = digester.getRules().match(null, "a/b/c/d");
assertEquals("Wild ancester match (3)", 2, list.size());
assertEquals("Match missed (3)", "uni-star-a-b-star" , ((TestRule) list.get(0)).getIdentifier());
assertEquals("Match missed (4)", "star-b-c-d" , ((TestRule) list.get(1)).getIdentifier());
list = digester.getRules().match(null, "b/b/c/e/d");
assertEquals("Wild ancester match (2)", 1, list.size());
assertEquals("Match missed (5)", "star-b-c-star" , ((TestRule) list.get(0)).getIdentifier());
}
public void testLongMatch() {
digester.getRules().clear();
digester.addRule("a/b/c/d/*", new TestRule("a-b-c-d-star"));
List list = digester.getRules().match(null, "a/b/c/d/e");
assertEquals("Long match (1)", 1, list.size());
assertEquals("Match missed (1)", "a-b-c-d-star" , ((TestRule) list.get(0)).getIdentifier());
list = digester.getRules().match(null, "a/b/c/d/e/f");
assertEquals("Long match (2)", 1, list.size());
assertEquals("Match missed (2)", "a-b-c-d-star" , ((TestRule) list.get(0)).getIdentifier());
list = digester.getRules().match(null, "a/b/c/d/e/f/g");
assertEquals("Long match (3)", 1, list.size());
assertEquals("Match missed (3)", "a-b-c-d-star" , ((TestRule) list.get(0)).getIdentifier());
list = digester.getRules().match(null, "a/b/c/d");
assertEquals("Long match (4)", 0, list.size());
}
public void testInstructors() {
digester.getRules().clear();
digester.addRule("!instructors/*", new TestRule("instructors"));
digester.addRule("!instructor/*", new TestRule("instructor"));
List list = digester.getRules().match(null, "instructors");
assertEquals("Only expect to match instructors", 1, list.size());
assertEquals("Instructors expected", "instructors" , ((TestRule) list.get(0)).getIdentifier());
}
public void testMiddleInstructors() {
digester.getRules().clear();
digester.addRule("!instructors/*", new TestRule("instructors"));
List list = digester.getRules().match(null, "/tosh/instructors/fiddlesticks");
assertEquals("No matches expected", 0, list.size());
}
}
libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/Test8.xml 0000644 0001750 0001750 00000001660 11226450007 030073 0 ustar twerner twerner
Test Case for the variable expansion facility in Digester.
*
* @author Simon Kitching
* @version $Revision: 471661 $ $Date: 2006-11-06 03:09:25 -0500 (Mon, 06 Nov 2006) $
*/
public class VariableExpansionTestCase extends TestCase {
// ----------------------------------------------------------- Constructors
/**
* Construct a new instance of this test case.
*
* @param name Name of the test case
*/
public VariableExpansionTestCase(String name) {
super(name);
}
// --------------------------------------------------- Overall Test Methods
/**
* Set up instance variables required by this test case.
*/
public void setUp() {
}
/**
* Return the tests included in this test suite.
*/
public static Test suite() {
return (new TestSuite(VariableExpansionTestCase.class));
}
/**
* Tear down instance variables required by this test case.
*/
public void tearDown() {
}
// method used in tests4
private LinkedList simpleTestBeans = new LinkedList();
public void addSimpleTestBean(SimpleTestBean bean) {
simpleTestBeans.add(bean);
}
// implementation of source shared by the variable expander and
// is updatable during digesting via an Ant-like property element
private HashMap mutableSource=new HashMap();
/**
* Used in test case "testExpansionWithMutableSource", where the
* set of variables available to be substituted into the xml is
* updated as the xml is parsed.
*/
public void addProperty(String key, String value) {
mutableSource.put(key, value);
}
/**
* Creates a Digester configured to show Ant-like capability.
*
* @return a Digester with rules and variable substitutor
*/
private Digester createDigesterThatCanDoAnt() {
Digester digester = new Digester();
MultiVariableExpander expander = new MultiVariableExpander();
expander.addSource("$", mutableSource);
digester.setSubstitutor(new VariableSubstitutor(expander));
int useRootObj = -1;
Class[] callerArgTypes = new Class[] {String.class, String.class};
CallMethodRule caller = new CallMethodRule(useRootObj, "addProperty",
callerArgTypes.length, callerArgTypes);
digester.addRule("root/property", caller);
digester.addCallParam("root/property", 0, "name");
digester.addCallParam("root/property", 1, "value");
digester.addObjectCreate("root/bean", SimpleTestBean.class);
digester.addSetProperties("root/bean");
digester.addSetNext("root/bean", "addSimpleTestBean");
return digester;
}
// ------------------------------------------------ Individual Test Methods
/**
* Test that by default no expansion occurs.
*/
public void testNoExpansion() throws SAXException, IOException {
String xml = " Tests for the Test Case for the Digester class. These tests exercise the individual
* methods of a Digester, but do not attempt to process complete documents.
* Test matching rules in {@link RulesBase}. Tests: Test Case for the RulesBase matching rules.
* Most of this material was original contained in the digester test case
* but was moved into this class so that extensions of the basic matching rules
* behaviour can extend this test case.
* This should be overriden by subclasses.
*
* @return the matching rules to be tested.
*/
protected Rules createMatchingRulesForTest() {
return new RulesBase();
}
/**
* Return the tests included in this test suite.
*/
public static Test suite() {
return (new TestSuite(RulesBaseTestCase.class));
}
/**
* Tear down instance variables required by this test case.
*/
public void tearDown() {
digester = null;
}
// ------------------------------------------------ Individual Test Methods
/**
* Basic test for rule creation and matching.
*/
public void testRules() {
// clear any existing rules
digester.getRules().clear();
// perform tests
assertEquals("Initial rules list is empty",
0, digester.getRules().match("a").size());
digester.addSetProperties("a");
assertEquals("Add a matching rule",
1, digester.getRules().match(null, "a").size());
digester.addSetProperties("b");
assertEquals("Add a non-matching rule",
1, digester.getRules().match(null, "a").size());
digester.addSetProperties("a/b");
assertEquals("Add a non-matching nested rule",
1, digester.getRules().match(null, "a").size());
digester.addSetProperties("a/b");
assertEquals("Add a second matching rule",
2, digester.getRules().match(null, "a/b").size());
// clean up
digester.getRules().clear();
}
/**
* Test matching rules in {@link RulesBase}. Tests: This rule implementation is intended to help test digester.
* The idea is that you can test which rule matches by looking
* at the identifier. Tests for the
* The current implementation of CallMethodRule ensures this works by
* firing only at the end of the tag that CallMethodRule triggered on.
*/
public void testOrderNestedPartA() throws Exception {
// Configure the digester as required
// Here, we use the "grandchild element name" as a parameter to
// the created element, to ensure that all the params aren't
// avaiable to the CallMethodRule until some other rules have fired,
// in particular an ObjectCreateRule. The CallMethodRule should still
// function correctly in this scenario.
digester.addObjectCreate("toplevel/element", NamedBean.class);
digester.addCallMethod("toplevel/element", "setName", 1);
digester.addCallParam("toplevel/element/element/element", 0, "name");
digester.addObjectCreate("toplevel/element/element", NamedBean.class);
// Parse our test input
NamedBean root1 = null;
try {
// an exception will be thrown if the method can't be found
root1 = (NamedBean) digester.parse(getInputStream("Test8.xml"));
} catch (Throwable t) {
// this means that the method can't be found and so the test fails
fail("Digester threw Exception: " + t);
}
// if the CallMethodRule were to incorrectly invoke the method call
// on the second-created NamedBean instance, then the root one would
// have a null name. If it works correctly, the target element will
// be the first-created (root) one, despite the fact that a second
// object instance was created between the firing of the
// CallMethodRule and its associated CallParamRule.
assertEquals("Wrong method call order", "C", root1.getName());
}
/**
* Test nested CallMethod rules.
*
* The current implementation of CallMethodRule, in which the method is
* invoked in its end() method, causes behaviour which some users find
* non-intuitive. In this test it can be seen to "reverse" the order of
* data processed. However this is the way CallMethodRule has always
* behaved, and it is expected that apps out there rely on this call order
* so this test is present to ensure that no-one changes this behaviour.
*/
public void testOrderNestedPartB() throws Exception {
// Configure the digester as required
StringBuffer word = new StringBuffer();
digester.push(word);
digester.addCallMethod("*/element", "append", 1);
digester.addCallParam("*/element", 0, "name");
// Parse our test input
Object root1 = null;
try {
// an exception will be thrown if the method can't be found
root1 = digester.parse(getInputStream("Test8.xml"));
assertNotNull(root1);
} catch (Throwable t) {
// this means that the method can't be found and so the test fails
fail("Digester threw Exception: " + t);
}
assertEquals("Wrong method call order", "CBA", word.toString());
}
public void testPrimitiveReading() throws Exception {
StringReader reader = new StringReader(
" Unit tests that exercise the new (in 1.8) methods for passing in
* Public identifier of the Digester Rules DTD. System identifier of the Digester Rules DTD. System identifier for the Digester Rules file that we will parse. The Test Case for the Digester class. These tests perform parsing of
* XML documents to exercise the built-in rules. Test case for
* See bugzilla entry 31393.
*/
public void testRecursiveNestedProperties()
throws SAXException, IOException {
String testXml =
"" +
" As it's name suggests just a simple bean used for testing.
*/
public class SimpleTestBean {
private String alpha;
private String beta;
private String gamma;
private String delta;
public String getAlpha() {
return alpha;
}
public void setAlpha(String alpha) {
this.alpha = alpha;
}
public String getBeta() {
return beta;
}
public void setBeta(String beta) {
this.beta = beta;
}
public String getGamma() {
return gamma;
}
public void setGamma(String gamma) {
this.gamma = gamma;
}
public String getDeltaValue() { // Retrieves "write only" value
return delta;
}
public void setDelta(String delta) { // "delta" is a write-only property
this.delta = delta;
}
public void setAlphaBeta(String alpha, String beta) {
setAlpha(alpha);
setBeta(beta);
}
public String toString() {
StringBuffer sb = new StringBuffer("[SimpleTestBean]");
sb.append(" alpha=");
sb.append(alpha);
sb.append(" beta=");
sb.append(beta);
sb.append(" gamma=");
sb.append(gamma);
sb.append(" delta=");
sb.append(delta);
return sb.toString();
}
}
libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/RegexRulesTestCase.java 0000644 0001750 0001750 00000023635 11226450007 032734 0 ustar twerner twerner /* $Id: RegexRulesTestCase.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.util.List;
import junit.framework.TestCase;
/**
* Test case for RegexRules
*
* @author Robert Burrell Donkin
* @version $Revision: 471661 $ $Date: 2006-11-06 03:09:25 -0500 (Mon, 06 Nov 2006) $
*/
public class RegexRulesTestCase extends TestCase {
/** Base constructor */
public RegexRulesTestCase(String name) {
super(name);
}
/** Test regex that matches everything */
public void testMatchAll() {
// set up which should match every rule
RegexRules rules = new RegexRules(
new RegexMatcher() {
public boolean match(String pathPattern, String rulePattern) {
return true;
}
});
rules.add("/a/b/b", new TestRule("alpha"));
rules.add("/a/d", new TestRule("beta"));
rules.add("/b", new TestRule("gamma"));
// now test a few patterns
// check that all are return in the order which they were added
List matches = rules.match("", "x/g/e");
assertEquals("Wrong number of rules returned (1)", 3, matches.size());
assertEquals("Rule Out Of Order (1)", "alpha", ((TestRule) matches.get(0)).getIdentifier());
assertEquals("Rule Out Of Order (2)", "beta", ((TestRule) matches.get(1)).getIdentifier());
assertEquals("Rule Out Of Order (3)", "gamma", ((TestRule) matches.get(2)).getIdentifier());
matches = rules.match("", "/a");
assertEquals("Wrong number of rules returned (2)", 3, matches.size());
assertEquals("Rule Out Of Order (4)", "alpha", ((TestRule) matches.get(0)).getIdentifier());
assertEquals("Rule Out Of Order (5)", "beta", ((TestRule) matches.get(1)).getIdentifier());
assertEquals("Rule Out Of Order (6)", "gamma", ((TestRule) matches.get(2)).getIdentifier());
}
/** Test regex matcher that matches nothing */
public void testMatchNothing() {
// set up which should match every rule
RegexRules rules = new RegexRules(
new RegexMatcher() {
public boolean match(String pathPattern, String rulePattern) {
return false;
}
});
rules.add("/b/c/f", new TestRule("alpha"));
rules.add("/c/f", new TestRule("beta"));
rules.add("/b", new TestRule("gamma"));
// now test a few patterns
// check that all are return in the order which they were added
List matches = rules.match("", "/b/c");
assertEquals("Wrong number of rules returned (1)", 0, matches.size());
matches = rules.match("", "/b/c/f");
assertEquals("Wrong number of rules returned (2)", 0, matches.size());
}
/** Test a mixed regex - in other words, one that sometimes returns true and sometimes false */
public void testMatchMixed() {
// set up which should match every rule
RegexRules rules = new RegexRules(
new RegexMatcher() {
public boolean match(String pathPattern, String rulePattern) {
return (rulePattern.equals("/match/me"));
}
});
rules.add("/match", new TestRule("alpha"));
rules.add("/match/me", new TestRule("beta"));
rules.add("/match", new TestRule("gamma"));
// now test a few patterns
// check that all are return in the order which they were added
List matches = rules.match("", "/match");
assertEquals("Wrong number of rules returned (1)", 1, matches.size());
assertEquals("Wrong Rule (1)", "beta", ((TestRule) matches.get(0)).getIdentifier());
matches = rules.match("", "/a/match");
assertEquals("Wrong Rule (2)", "beta", ((TestRule) matches.get(0)).getIdentifier());
}
/** Test rules and clear methods */
public void testClear() {
// set up which should match every rule
RegexRules rules = new RegexRules(
new RegexMatcher() {
public boolean match(String pathPattern, String rulePattern) {
return true;
}
});
rules.add("/abba", new TestRule("alpha"));
rules.add("/ad/ma", new TestRule("beta"));
rules.add("/gamma", new TestRule("gamma"));
// check that rules returns all rules in the order which they were added
List matches = rules.rules();
assertEquals("Wrong number of rules returned (1)", 3, matches.size());
assertEquals("Rule Out Of Order (1)", "alpha", ((TestRule) matches.get(0)).getIdentifier());
assertEquals("Rule Out Of Order (2)", "beta", ((TestRule) matches.get(1)).getIdentifier());
assertEquals("Rule Out Of Order (3)", "gamma", ((TestRule) matches.get(2)).getIdentifier());
matches = rules.match("", "/eggs");
assertEquals("Wrong number of rules returned (2)", 3, matches.size());
assertEquals("Rule Out Of Order (4)", "alpha", ((TestRule) matches.get(0)).getIdentifier());
assertEquals("Rule Out Of Order (5)", "beta", ((TestRule) matches.get(1)).getIdentifier());
assertEquals("Rule Out Of Order (6)", "gamma", ((TestRule) matches.get(2)).getIdentifier());
rules.clear();
matches = rules.rules();
assertEquals("Wrong number of rules returned (3)", 0, matches.size());
matches = rules.match("", "/eggs");
assertEquals("Wrong number of rules returned (4)", 0, matches.size());
}
public void testSimpleRegexMatch() {
SimpleRegexMatcher matcher = new SimpleRegexMatcher();
// SimpleLog log = new SimpleLog("{testSimpleRegexMatch:SimpleRegexMatcher]");
// log.setLevel(SimpleLog.LOG_LEVEL_TRACE);
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '/alpha/beta/gamma' ",
true,
matcher.match("/alpha/beta/gamma", "/alpha/beta/gamma"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '/alpha/beta/gamma/epsilon' ",
false,
matcher.match("/alpha/beta/gamma", "/alpha/beta/gamma/epsilon"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '/alpha/*' ",
true,
matcher.match("/alpha/beta/gamma", "/alpha/*"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '/alpha/*/gamma' ",
true,
matcher.match("/alpha/beta/gamma", "/alpha/*/gamma"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '/alpha/*me' ",
false,
matcher.match("/alpha/beta/gamma", "/alpha/*me"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '*/beta/gamma' ",
true,
matcher.match("/alpha/beta/gamma", "*/beta/gamma"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '*/alpha/beta/gamma' ",
true,
matcher.match("/alpha/beta/gamma", "*/alpha/beta/gamma"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '*/bet/gamma' ",
false,
matcher.match("/alpha/beta/gamma", "*/bet/gamma"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to 'alph?/beta/gamma' ",
true,
matcher.match("/alpha/beta/gamma", "/alph?/beta/gamma"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '/?lpha/beta/gamma' ",
true,
matcher.match("/alpha/beta/gamma", "/?lpha/beta/gamma"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '/alpha/?beta/gamma' ",
false,
matcher.match("/alpha/beta/gamma", "/alpha/?beta/gamma"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '/alpha/?eta/*' ",
true,
matcher.match("/alpha/beta/gamma", "/alpha/?eta/*"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '/alpha/?eta/*e' ",
false,
matcher.match("/alpha/beta/gamma", "/alpha/?eta/*e"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma' to '*/?et?/?amma' ",
true,
matcher.match("/alpha/beta/gamma", "*/?et?/?amma"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma/beta/epsilon/beta/gamma/epsilon' to "
+ " '*/beta/gamma/?p*n' ",
true,
matcher.match("/alpha/beta/gamma/beta/epsilon/beta/gamma/epsilon", "*/beta/gamma/?p*n"));
assertEquals(
"Simple Regex Match '/alpha/beta/gamma/beta/epsilon/beta/gamma/epsilon' to "
+ " '*/beta/gamma/?p*no' ",
false,
matcher.match("/alpha/beta/gamma", "*/beta/gamma/?p*no"));
}
}
libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/Test7.xml 0000644 0001750 0001750 00000002117 11226450007 030070 0 ustar twerner twerner
Test case for Test case for Test case for the Tests for situations where CallMethodRule instances and their
* parameters overlap each other.
* The following sequence always fails:
*
* One solution is for CallParamRule objects to know which CallMethodRule
* they are associated with. Even this might fail in corner cases where
* the same rule is associated with multiple patterns, or with wildcard
* patterns which cause a rule to fire in a "recursive" manner. However
* implementing this is not possible with the current digester design.
*/
public void testItem4() throws SAXException, IOException {
StringBuffer input = new StringBuffer();
input.append(" Test case for
* See the readme file included with this example for more information.
*/
public class Main {
/** The input xml to be parsed by this example. */
String in = " Hi, this is an example of some bold text.
* See the readme file included with this example for more information.
*/
public class MarkupDigester extends Digester {
/** See equivalent constructor in Digester class. */
public MarkupDigester() {
}
/** See equivalent constructor in Digester class. */
public MarkupDigester(SAXParser parser) {
super(parser);
}
/** See equivalent constructor in Digester class. */
public MarkupDigester(XMLReader reader) {
super(reader);
}
//===================================================================
/**
* The text found in the current element since the last child element.
*/
protected StringBuffer currTextSegment = new StringBuffer();
/**
* Process notification of character data received from the body of
* an XML element.
*
* @param buffer The characters from the XML document
* @param start Starting offset into the buffer
* @param length Number of characters from the buffer
*
* @exception SAXException if a parsing error is to be reported
*/
public void characters(char buffer[], int start, int length)
throws SAXException {
super.characters(buffer, start, length);
currTextSegment.append(buffer, start, length);
}
/**
* Process notification of the start of an XML element being reached.
*
* @param namespaceURI The Namespace URI, or the empty string if the element
* has no Namespace URI or if Namespace processing is not being performed.
* @param localName The local name (without prefix), or the empty
* string if Namespace processing is not being performed.
* @param qName The qualified name (with prefix), or the empty
* string if qualified names are not available.
* @param list The attributes attached to the element. If there are
* no attributes, it shall be an empty Attributes object.
* @exception SAXException if a parsing error is to be reported
*/
public void startElement(String namespaceURI, String localName,
String qName, Attributes list)
throws SAXException {
handleTextSegments();
// Unlike bodyText, which accumulates despite intervening child
// elements, currTextSegment gets cleared here. This means that
// we don't need to save it on a stack either.
currTextSegment.setLength(0);
super.startElement(namespaceURI, localName, qName, list);
}
/**
* Process notification of the end of an XML element being reached.
*
* @param namespaceURI - The Namespace URI, or the empty string if the
* element has no Namespace URI or if Namespace processing is not
* being performed.
* @param localName - The local name (without prefix), or the empty
* string if Namespace processing is not being performed.
* @param qName - The qualified XML 1.0 name (with prefix), or the
* empty string if qualified names are not available.
* @exception SAXException if a parsing error is to be reported
*/
public void endElement(String namespaceURI, String localName,
String qName) throws SAXException {
handleTextSegments();
currTextSegment.setLength(0);
super.endElement(namespaceURI, localName, qName);
}
/**
* Iterate over the list of rules most recently matched, and
* if any of them implement the TextSegmentHandler interface then
* invoke that rule's textSegment method passing the current
* segment of text from the xml element body.
*/
private void handleTextSegments() throws SAXException {
if (currTextSegment.length() > 0) {
String segment = currTextSegment.toString();
List parentMatches = (List) matches.peek();
int len = parentMatches.size();
for(int i=0; i
* This code will parse the provided "example.xml" file, and immediately
* insert the processed data into a database as each row tag is parsed,
* instead of building up an in-memory representation. Actually, in order
* to keep this example simple and easy to run, sql insert statements are
* printed out rather than actually performing database inserts, but the
* principle remains.
*
* Very verbose comments are included here, as this class is intended
* as a tutorial; if you look closely at method "addRules", you will
* see that the amount of code required to use the Digester is actually
* quite low.
*
* Usage: java Main example.xml
*/
public class Main {
/**
* Main method : entry point for running this example program.
*
* Usage: java Main example.xml
*/
public static void main(String[] args) {
if (args.length != 1) {
usage();
System.exit(-1);
}
String filename = args[0];
// Create a Digester instance
Digester d = new Digester();
// Here you would establish a real connection.
// There would also be a finally clause to ensure it is
// closed after parsing terminates, etc.
java.sql.Connection connection = null;
// Add rules to the digester that will be triggered while
// parsing occurs.
addRules(d, connection);
// Process the input file.
System.out.println("Parsing commencing...");
try {
java.io.File srcfile = new java.io.File(filename);
d.parse(srcfile);
}
catch(java.io.IOException ioe) {
System.out.println("Error reading input file:" + ioe.getMessage());
System.exit(-1);
}
catch(org.xml.sax.SAXException se) {
System.out.println("Error parsing input file:" + se.getMessage());
System.exit(-1);
}
// And here there is nothing to do. The digester rules have
// (deliberately) not built a representation of the input, but
// instead processed the data as it was read.
System.out.println("Parsing complete.");
}
private static void addRules(Digester d, java.sql.Connection conn) {
//--------------------------------------------------
// when we encounter a "table" tag, do the following:
// Create a new instance of class Table, and push that
// object onto the digester stack of objects. We only need
// this so that when a row is inserted, it can find out what
// the enclosing tablename was.
//
// Note that the object is popped off the stack at the end of the
// "table" tag (normal behaviour for ObjectCreateRule). Because we
// never added the table object to some parent object, when it is
// popped off the digester stack it becomes garbage-collected. That
// is fine in this situation; we've done all the necessary work and
// don't need the table object any more.
d.addObjectCreate("database/table", Table.class);
// Map *any* attributes on the table tag to appropriate
// setter-methods on the top object on the stack (the Table
// instance created by the preceeding rule). We only expect one
// attribute, though: a 'name' attribute specifying what table
// we are inserting rows into.
d.addSetProperties("database/table");
//--------------------------------------------------
// When we encounter a "row" tag, invoke methods on the provided
// RowInserterRule instance.
//
// This rule creates a Row instance and pushes it on the digester
// object stack, rather like ObjectCreateRule, so that the column
// tags have somewhere to store their information. And when the
// end tag is found, the rule will trigger to remove this
// object from the stack, and also do an actual database insert.
//
// Note that the rule instance we are passing to the digester has
// been initialised with some useful data (the SQL connection).
//
// Note also that in this case we are not using the digester's
// factory methods to create the rule instance; that's just a
// convenience - and obviously not an option for Rule classes
// that are not part of the digester core implementation.
RowInserterRule rowInserterRule = new RowInserterRule(conn);
d.addRule("database/table/row", rowInserterRule);
//--------------------------------------------------
// when we encounter a "column" tag, call setColumn on the top
// object on the stack, passing two parameters: the "name"
// attribute, and the text within the tag body.
d.addCallMethod("database/table/row/column", "addColumn", 2);
d.addCallParam("database/table/row/column", 0, "name");
d.addCallParam("database/table/row/column", 1);
}
private static void usage() {
System.out.println("Usage: java Main example.xml");
}
} libcommons-digester-java-1.8.1.orig/src/examples/api/dbinsert/RowInserterRule.java 0000644 0001750 0001750 00000007436 11226450007 030260 0 ustar twerner twerner /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.Map;
import java.util.Iterator;
/**
* See Main.java.
*/
public class RowInserterRule extends org.apache.commons.digester.Rule {
private java.sql.Connection conn;
public RowInserterRule(java.sql.Connection conn) {
this.conn = conn;
}
/**
* This method is invoked when the start tag for an xml element representing
* a database row is encountered. It pushes a new Row instance onto the
* digester stack (rather like an ObjectCreateRule) so that column data
* can be stored on it.
*/
public void begin(String namespace, String name, org.xml.sax.Attributes attrs) {
digester.push(new Row());
}
/**
* This method is invoked when the end tag for an xml element representing
* a database row is encountered. It pops a fully-configured Row instance
* off the digester stack, accesses the object below it on the stack (a
* Table object) to get the tablename, then does an SQL insert). Actually,
* here we just print out text rather than do the sql insert, but the
* real implementation should be fairly simple.
*
* Note that after this rule completes, the row/column information is
* discarded, ie this rule performs actions as the input is
* parsed. This contrasts with the more usual way digester is used,
* which is to build trees of objects for later use. But it's a perfectly
* valid use of Digester.
*/
public void end(String namespace, String name) {
Row row = (Row) digester.pop();
Table table = (Table) digester.peek();
// Obviously, all this would be replaced by code like:
// stmt = conn.prepareStatement();
// stmt.setString(n, value);
//
// Many improvements can then be implemented, such as using the
// PreparedStatement.getParameterMetaData method to retrieve
// retrieve parameter types, etc.
StringBuffer colnames = new StringBuffer();
StringBuffer colvalues = new StringBuffer();
for(Iterator i = row.getColumns().iterator(); i.hasNext();)
{
Row.Column column = (Row.Column) i.next();
if (colnames.length() > 0)
{
colnames.append(", ");
colvalues.append(", ");
}
colnames.append("'");
colnames.append(column.getName());
colnames.append("'");
colvalues.append("'");
colvalues.append(column.getValue());
colvalues.append("'");
}
StringBuffer buf = new StringBuffer();
buf.append("insert into ");
buf.append(table.getName());
buf.append(" (");
buf.append(colnames.toString());
buf.append(") values (");
buf.append(colvalues.toString());
buf.append(")");
// here the prepared statement would be executed....
System.out.println(buf.toString());
}
}
libcommons-digester-java-1.8.1.orig/src/examples/api/dbinsert/readme.txt 0000644 0001750 0001750 00000003133 11226450007 026266 0 ustar twerner twerner #########################################################################
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#########################################################################
== overview
The files in this directory are intended as an example of how to use
the Apache Digester's basic functionality via its java interface.
Topics covered:
* how to write a custom Rule class.
* How to use digester to perform actions during parsing, rather
than just build in-memory models of the input.
== compiling and running
First rename the build.properties.sample file in the parent directory
to build.properties and edit it to suit your environment. Then in this
directory:
* to compile:
ant compile
* to run:
ant run
Alternatively, you can set up your CLASSPATH appropriately, and
run the example directly. See the build.properties and build.xml
files for details.
libcommons-digester-java-1.8.1.orig/src/examples/api/dbinsert/build.xml 0000644 0001750 0001750 00000011327 11226450007 026115 0 ustar twerner twerner
* This code will parse the provided "example.xml" file to build a tree
* of java objects, then cause those objects to print out their values
* to demonstrate that the input file has been processed correctly.
*
* As with all code, there are many ways of achieving the same goal;
* the solution here is only one possible solution to the problem.
*
* Very verbose comments are included here, as this class is intended
* as a tutorial; if you look closely at method "addRules", you will
* see that the amount of code required to use the Digester is actually
* quite low.
*
* Usage: java Main example.xml
*/
public class Main {
/**
* Main method : entry point for running this example program.
*
* Usage: java Example example.xml
*/
public static void main(String[] args) {
if (args.length != 1) {
usage();
System.exit(-1);
}
String filename = args[0];
// Create a Digester instance
Digester d = new Digester();
// Prime the digester stack with an object for rules to
// operate on. Note that it is quite common for "this"
// to be the object pushed.
AddressBook book = new AddressBook();
d.push(book);
// Add rules to the digester that will be triggered while
// parsing occurs.
addRules(d);
// Process the input file.
try {
java.io.File srcfile = new java.io.File(filename);
d.parse(srcfile);
}
catch(java.io.IOException ioe) {
System.out.println("Error reading input file:" + ioe.getMessage());
System.exit(-1);
}
catch(org.xml.sax.SAXException se) {
System.out.println("Error parsing input file:" + se.getMessage());
System.exit(-1);
}
// Print out all the contents of the address book, as loaded from
// the input file.
book.print();
}
private static void addRules(Digester d) {
//--------------------------------------------------
// when we encounter a "person" tag, do the following:
// create a new instance of class Person, and push that
// object onto the digester stack of objects
d.addObjectCreate("address-book/person", Person.class);
// map *any* attributes on the tag to appropriate
// setter-methods on the top object on the stack (the Person
// instance created by the preceeding rule).
//
// For example:
// if attribute "id" exists on the xml tag, and method setId
// with one parameter exists on the object that is on top of
// the digester object stack, then a call will be made to that
// method. The value will be type-converted from string to
// whatever type the target method declares (where possible),
// using the commons ConvertUtils functionality.
//
// Attributes on the xml tag for which no setter methods exist
// on the top object on the stack are just ignored.
d.addSetProperties("address-book/person");
// call the addPerson method on the second-to-top object on
// the stack (the AddressBook object), passing the top object
// on the stack (the recently created Person object).
d.addSetNext("address-book/person", "addPerson");
//--------------------------------------------------
// when we encounter a "name" tag, call setName on the top
// object on the stack, passing the text contained within the
// body of that name element [specifying a zero parameter count
// implies one actual parameter, being the body text].
// The top object on the stack will be a person object, because
// the pattern address-book/person always triggers the
// ObjectCreateRule we added previously.
d.addCallMethod("address-book/person/name", "setName", 0);
//--------------------------------------------------
// when we encounter an "email" tag, call addEmail on the top
// object on the stack, passing two parameters: the "type"
// attribute, and the text within the tag body.
d.addCallMethod("address-book/person/email", "addEmail", 2);
d.addCallParam("address-book/person/email", 0, "type");
d.addCallParam("address-book/person/email", 1);
//--------------------------------------------------
// When we encounter an "address" tag, create an instance of class
// Address and push it on the digester stack of objects. After
// doing that, call addAddress on the second-to-top object on the
// digester stack (a "Person" object), passing the top object on
// the digester stack (the "Address" object). And also set things
// up so that for each child xml element encountered between the start
// of the address tag and the end of the address tag, the text
// contained in that element is passed to a setXXX method on the
// Address object where XXX is the name of the xml element found.
d.addObjectCreate("address-book/person/address", Address.class);
d.addSetNext("address-book/person/address", "addAddress");
d.addSetNestedProperties("address-book/person/address");
}
private static void usage() {
System.out.println("Usage: java Main example.xml");
}
} libcommons-digester-java-1.8.1.orig/src/examples/api/addressbook/Address.java 0000644 0001750 0001750 00000007252 11226450007 027214 0 ustar twerner twerner /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.HashMap;
import java.util.Iterator;
/**
* See Main.java.
*/
public class Address {
private String type;
private String street;
private String city;
private String state;
private String zip;
private String country;
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append( " address (type "+ type + ")\n");
sb.append( " " + street + "\n");
sb.append( " " + city + " " + state + " " + zip + "\n");
sb.append( " " + country + "\n");
return sb.toString();
}
public void print(java.io.PrintStream out, int indentAmount) {
StringBuffer indentStr = new StringBuffer(indentAmount);
for(; indentAmount > 0; --indentAmount) {
indentStr.append(' ');
}
out.print(indentStr);
out.print("address type: ");
out.println(type);
out.print(indentStr);
out.println(" " + street);
out.print(indentStr);
out.println(" " + city + " " + state + " " + zip);
out.print(indentStr);
out.println(" " + country);
}
/**
* Returns the value of street.
*/
public String getStreet()
{
return street;
}
/**
* Sets the value of street.
* @param street The value to assign to street.
*/
public void setStreet(String street)
{
this.street = street;
}
/**
* Returns the value of city.
*/
public String getCity()
{
return city;
}
/**
* Sets the value of city.
* @param city The value to assign to city.
*/
public void setCity(String city)
{
this.city = city;
}
/**
* Returns the value of state.
*/
public String getState()
{
return state;
}
/**
* Sets the value of state.
* @param state The value to assign to state.
*/
public void setState(String state)
{
this.state = state;
}
/**
* Returns the value of zip.
*/
public String getZip()
{
return zip;
}
/**
* Sets the value of zip.
* @param zip The value to assign to zip.
*/
public void setZip(String zip)
{
this.zip = zip;
}
/**
* Returns the value of country.
*/
public String getCountry()
{
return country;
}
/**
* Sets the value of country.
* @param country The value to assign to country.
*/
public void setCountry(String country)
{
this.country = country;
}
/**
* Returns the value of type.
*/
public String getType()
{
return type;
}
/**
* Sets the value of type.
* @param type The value to assign to type.
*/
public void setType(String type)
{
this.type = type;
}
}
libcommons-digester-java-1.8.1.orig/src/examples/api/addressbook/Person.java 0000644 0001750 0001750 00000004323 11226450007 027071 0 ustar twerner twerner /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
/**
* See Main.java.
*/
public class Person {
private int id;
private String category;
private String name;
private HashMap emails = new HashMap();
private List addresses = new ArrayList();
/**
* A unique id for this person. Note that the Digester automatically
* converts the id to an integer.
*/
public void setId(int id) {
this.id = id;
}
public void setCategory(String category) {
this.category = category;
}
public void setName(String name) {
this.name = name;
}
/** we assume only one email of each type... */
public void addEmail(String type, String address) {
emails.put(type, address);
}
public void addAddress( Address addr ) {
addresses.add( addr );
}
public void print() {
System.out.println("Person #" + id);
System.out.println(" category=" + category);
System.out.println(" name=" + name);
for(Iterator i = emails.keySet().iterator(); i.hasNext(); ) {
String type = (String) i.next();
String address = (String) emails.get(type);
System.out.println(" email (type " + type + ") : " + address);
}
for(Iterator i = addresses.iterator(); i.hasNext(); ) {
Address addr = (Address) i.next();
addr.print(System.out, 2);
}
}
}
libcommons-digester-java-1.8.1.orig/src/examples/api/addressbook/readme.txt 0000644 0001750 0001750 00000003704 11226450007 026760 0 ustar twerner twerner #########################################################################
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#########################################################################
== overview
The files in this directory are intended as an example of how to use
the Apache Digester's basic functionality via its java interface.
Topics covered:
* how to create a digester instance
* how to parse a file
* how to use the "object create" rule to create java objects
* how to use the "set properties" rule (basic usage) to map xml attributes
to java bean properties.
* how to use the "set next" rule to build trees of java objects.
* how to use the "call method rule" (basic usage)
* how to use the "call parameter rule" to process the text contained
in a tag's body
* how to use the "call parameter rule" to process the contents of an
xml attribute.
== compiling and running
First rename the build.properties.sample file in the parent directory
to build.properties and edit it to suit your environment. Then in this
directory:
* to compile:
ant compile
* to run:
ant run
Alternatively, you can set up your CLASSPATH appropriately, and
run the example directly. See the build.properties and build.xml
files for details.
libcommons-digester-java-1.8.1.orig/src/examples/api/addressbook/build.xml 0000644 0001750 0001750 00000011327 11226450007 026603 0 ustar twerner twerner
* This code will parse the provided "example.xml" file to build a tree
* of java objects, then cause those objects to print out their values
* to demonstrate that the input file has been processed correctly. The
* input file represents a catalog of items in a library.
*
* As with all code, there are many ways of achieving the same goal;
* the solution here is only one possible implementation.
*
* Very verbose comments are included here, as this class is intended
* as a tutorial; if you look closely at method "addRules", you will
* see that the amount of code required to use the Digester is actually
* quite low.
*
* Usage: java Main example.xml
*/
public class Main {
/**
* Main method : entry point for running this example program.
*
* Usage: java CatalogDigester example.xml
*/
public static void main(String[] args) {
if (args.length != 1) {
usage();
System.exit(-1);
}
String filename = args[0];
// Create a Digester instance
Digester d = new Digester();
// Add rules to the digester that will be triggered while
// parsing occurs.
addRules(d);
// Process the input file.
try {
java.io.Reader reader = getInputData(filename);
d.parse(reader);
}
catch(java.io.IOException ioe) {
System.out.println("Error reading input file:" + ioe.getMessage());
System.exit(-1);
}
catch(org.xml.sax.SAXException se) {
System.out.println("Error parsing input file:" + se.getMessage());
System.exit(-1);
}
// Get the first object created by the digester's rules
// (the "root" object). Note that this is exactly the same object
// returned by the Digester.parse method; either approach works.
Catalog catalog = (Catalog) d.getRoot();
// Print out all the contents of the catalog, as loaded from
// the input file.
catalog.print();
}
private static void addRules(Digester d) {
//--------------------------------------------------
// when we encounter the root "catalog" tag, create an
// instance of the Catalog class.
//
// Note that this approach is different from the approach taken in
// the AddressBook example, where an initial "root" object was
// explicitly created and pushed onto the digester stack before
// parsing started instead
//
// Either approach is fine.
d.addObjectCreate("catalog", Catalog.class);
//--------------------------------------------------
// when we encounter a book tag, we want to create a Book
// instance. However the Book class doesn't have a default
// constructor (one with no arguments), so we can't use
// the ObjectCreateRule. Instead, we use the FactoryCreateRule.
BookFactory factory = new BookFactory();
d.addFactoryCreate("catalog/book", factory);
// and add the book to the parent catalog object (which is
// the next-to-top object on the digester object stack).
d.addSetNext("catalog/book", "addItem");
// we want each subtag of book to map the text contents of
// the tag into a bean property with the same name as the tag.
// eg
* This method exists just to demonstrate that the input to the
* digester doesn't need to be from a file; for example, xml could
* be read from a database or generated dynamically; any old buffer
* in memory can be processed by the digester.
*
* Clearly, if the data is always coming from a file, then calling
* the Digester.parse method that takes a File object would be
* more sensible (see AddressBook example).
*/
private static java.io.Reader getInputData(String filename)
throws java.io.IOException {
java.io.File srcfile = new java.io.File(filename);
java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream(1000);
byte[] buf = new byte[100];
java.io.FileInputStream fis = new java.io.FileInputStream(srcfile);
for(;;) {
int nread = fis.read(buf);
if (nread == -1) {
break;
}
baos.write(buf, 0, nread);
}
fis.close();
return new java.io.StringReader( baos.toString() );
}
private static void usage() {
System.out.println("Usage: java Main example.xml");
}
} libcommons-digester-java-1.8.1.orig/src/examples/api/catalog/Book.java 0000644 0001750 0001750 00000002721 11226450007 025627 0 ustar twerner twerner /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* See Main.java.
*/
public class Book implements Item {
private String isbn;
private String title;
private String author;
private String desc;
public Book(String isbn) {
this.isbn = isbn;
}
public void setTitle(String title) {
this.title = title;
}
public void setAuthor(String author) {
this.author = author;
}
public void setDesc(String desc) {
this.desc = desc;
}
public void print() {
System.out.println("Book:");
System.out.println(" isbn=" + isbn);
System.out.println(" title=" + title);
System.out.println(" author=" + author);
System.out.println(" desc=" + desc);
}
}
libcommons-digester-java-1.8.1.orig/src/examples/api/catalog/readme.txt 0000644 0001750 0001750 00000004171 11226450007 026071 0 ustar twerner twerner #########################################################################
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#########################################################################
== overview
The files in this directory are intended as an example of how to use
the Apache Digester's basic functionality via its java interface.
Topics covered:
* how to read xml from a string (instead of a file)
* how to use Digester.getRoot() to retrieve the "root" object
created when parsing an input file.
* how to use the "factory create" rule to create java objects which
do not have default (no-argument) constructors.
* how to use the "set properties" rule (advanced usage) to map xml attributes
to java bean properties with names different from the xml attribute name.
* how to use the SetPropertyRule.
* how to use the ObjectParamRule to pass a constant string to a method.
If you haven't read the "addressbook" example, it is recommended that
you start there first. This example demonstrates more advanced features
of the digester.
== compiling and running
First rename the build.properties.sample file in the parent directory
to build.properties and edit it to suit your environment. Then in this
directory:
* to compile:
ant compile
* to run:
ant run
Alternatively, you can set up your CLASSPATH appropriately, and
run the example directly. See the build.properties and build.xml
files for details.
libcommons-digester-java-1.8.1.orig/src/examples/api/catalog/build.xml 0000644 0001750 0001750 00000011316 11226450007 025713 0 ustar twerner twerner
* To resolve this issue, the FactoryCreateRule can be used in
* conjunction with an appropriate factory class, like this one.
* The "createObject" method of the factory is invoked to generate
* object instances when required.
*
* The factory object can access any xml attributes, plus of course
* any values set up within it before digester parsing starts (like
* JNDI references, database connections, etc) that it may in the
* process of generating an appropriate object.
*
* Note that it is not possible for any data to be extracted
* from the body or subelements of the xml element that caused the
* createObject method on this factory to be invoked. For example:
*
* Note that even if the class to be created does have a default constructor,
* you may wish to use a factory class, in order to initialise the created
* object in specific ways, or insert created objects into a central
* register, etc.
*
* And don't forget, either, that factories may be implemented as
* inner classes or anonymous classes if appropriate, reducing the
* overhead of using this functionality in many cases.
*/
public class BookFactory extends AbstractObjectCreationFactory {
public Object createObject(org.xml.sax.Attributes attributes)
throws Exception {
String isbn = attributes.getValue("isbn");
if (isbn == null) {
throw new Exception(
"Mandatory isbn attribute not present on book tag.");
}
return new Book(isbn);
}
}
libcommons-digester-java-1.8.1.orig/src/examples/rss/ 0000755 0001750 0001750 00000000000 11226450007 022514 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/examples/rss/LICENSE.txt 0000644 0001750 0001750 00000026136 11226450007 024347 0 ustar twerner twerner
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
libcommons-digester-java-1.8.1.orig/src/examples/rss/readme.txt 0000644 0001750 0001750 00000002771 11226450007 024521 0 ustar twerner twerner #########################################################################
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#########################################################################
This directory contains the example code for parsing RSS (Really Simple
Syndication) newsfeeds, which was originally included directly in the
commons-digester.jar file, in package "org.apache.commons.digester.rss".
The package name has not been changed, so the only impact on applications
relying on these classes will be the need to include an additional JAR
file (commons-digester-rss.jar) in their classpath.
A packaged distribution can be created by using ant:
1 Copy build.properties.sample to build.properties and edit the properties to
match those on your local system
2 run ant dist
libcommons-digester-java-1.8.1.orig/src/examples/rss/src/ 0000755 0001750 0001750 00000000000 11126627040 023305 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/ 0000755 0001750 0001750 00000000000 11126627037 024234 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/org/ 0000755 0001750 0001750 00000000000 11126627037 025023 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/org/apache/ 0000755 0001750 0001750 00000000000 11126627037 026244 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/org/apache/commons/ 0000755 0001750 0001750 00000000000 11126627037 027717 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/org/apache/commons/digester/ 0000755 0001750 0001750 00000000000 11126627037 031525 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/org/apache/commons/digester/rss/ 0000755 0001750 0001750 00000000000 11226450007 032324 5 ustar twerner twerner ././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/org/apache/commons/digester/rss/Item.java libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/org/apache/commons/digester/rss/Item.j0000644 0001750 0001750 00000005327 11226450007 033404 0 ustar twerner twerner /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.rss;
import java.io.PrintWriter;
import java.io.Serializable;
/**
* Implementation object representing an item in the
* Rich Site Summary DTD, version 0.91. This class may be subclassed
* to further specialize its behavior. Implementation object representing a channel in the
* Rich Site Summary DTD, version 0.91. This class may be subclassed
* to further specialize its behavior. Implementation of org.apache.commons.digester.Digester
* designed to process input streams that conform to the Rich Site
* Summary DTD, version 0.91. For more information about this format,
* see the My Netscape site. The default implementation object returned by calling
* Example usage of Digester to parse XML documents compatible with the
Rich Site Summary format used by many newsfeeds. Implementation object representing an image in the
* Rich Site Summary DTD, version 0.91. This class may be subclassed
* to further specialize its behavior. Implementation object representing a textinput in the
* Rich Site Summary DTD, version 0.91. This class may be subclassed
* to further specialize its behavior.
* This code will parse the provided "example.xml" file to build a tree
* of java objects, then cause those objects to print out their values
* to demonstrate that the input file has been processed correctly.
*
* Unlike the "addressbook" example in the "api" section, this implementation
* has no parsing rules hard-wired into the code in this class. Instead, the
* parsing rules are loaded from an external file at runtime. This allows
* the parsing rules to be modified without compiling the code, and
* potentially makes it somewhat easier to review the parsing rules.
*
* Note, however, that there is tyically quite a tight coupling between
* the parsing rules and the purpose of the application which means
* that it may not be all that common for parsing rules to be altered
* without the application code also being altered, so only in some cases
* will this prove of benefit. As with all software, it must be determined
* whether this feature provides a true benefit in the context of the
* application it is being applied to.
*
* Usage: java Main xmlrules.xml example.xml
*/
public class Main {
/**
* Main method : entry point for running this example program.
*
* Usage: java Example example.xml
*/
public static void main(String[] args) throws Exception {
if (args.length != 2) {
usage();
System.exit(-1);
}
String rulesfileName = args[0];
String datafileName = args[1];
// Create a Digester instance which has been initialised with
// rules loaded from the specified file.
URL rulesURL = ClassLoader.getSystemResource(rulesfileName);
if (rulesURL == null) {
System.out.println("Unable to find rules file.");
System.exit(-1);
}
Digester d = DigesterLoader.createDigester(rulesURL);
// Prime the digester stack with an object for rules to
// operate on. Note that it is quite common for "this"
// to be the object pushed.
AddressBook book = new AddressBook();
d.push(book);
// Process the input file.
try {
java.io.File srcfile = new java.io.File(datafileName);
d.parse(srcfile);
}
catch(java.io.IOException ioe) {
System.out.println("Error reading input file:" + ioe.getMessage());
System.exit(-1);
}
catch(org.xml.sax.SAXException se) {
System.out.println("Error parsing input file:" + se.getMessage());
System.exit(-1);
}
// Print out all the contents of the address book, as loaded from
// the input file.
book.print();
}
private static void usage() {
System.out.println("Usage: java Main xmlrules.xml example.xml");
}
} libcommons-digester-java-1.8.1.orig/src/examples/xmlrules/addressbook/Address.java 0000644 0001750 0001750 00000007252 11226450007 030316 0 ustar twerner twerner /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.HashMap;
import java.util.Iterator;
/**
* See Main.java.
*/
public class Address {
private String type;
private String street;
private String city;
private String state;
private String zip;
private String country;
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append( " address (type "+ type + ")\n");
sb.append( " " + street + "\n");
sb.append( " " + city + " " + state + " " + zip + "\n");
sb.append( " " + country + "\n");
return sb.toString();
}
public void print(java.io.PrintStream out, int indentAmount) {
StringBuffer indentStr = new StringBuffer(indentAmount);
for(; indentAmount > 0; --indentAmount) {
indentStr.append(' ');
}
out.print(indentStr);
out.print("address type: ");
out.println(type);
out.print(indentStr);
out.println(" " + street);
out.print(indentStr);
out.println(" " + city + " " + state + " " + zip);
out.print(indentStr);
out.println(" " + country);
}
/**
* Returns the value of street.
*/
public String getStreet()
{
return street;
}
/**
* Sets the value of street.
* @param street The value to assign to street.
*/
public void setStreet(String street)
{
this.street = street;
}
/**
* Returns the value of city.
*/
public String getCity()
{
return city;
}
/**
* Sets the value of city.
* @param city The value to assign to city.
*/
public void setCity(String city)
{
this.city = city;
}
/**
* Returns the value of state.
*/
public String getState()
{
return state;
}
/**
* Sets the value of state.
* @param state The value to assign to state.
*/
public void setState(String state)
{
this.state = state;
}
/**
* Returns the value of zip.
*/
public String getZip()
{
return zip;
}
/**
* Sets the value of zip.
* @param zip The value to assign to zip.
*/
public void setZip(String zip)
{
this.zip = zip;
}
/**
* Returns the value of country.
*/
public String getCountry()
{
return country;
}
/**
* Sets the value of country.
* @param country The value to assign to country.
*/
public void setCountry(String country)
{
this.country = country;
}
/**
* Returns the value of type.
*/
public String getType()
{
return type;
}
/**
* Sets the value of type.
* @param type The value to assign to type.
*/
public void setType(String type)
{
this.type = type;
}
}
libcommons-digester-java-1.8.1.orig/src/examples/xmlrules/addressbook/Person.java 0000644 0001750 0001750 00000004323 11226450007 030173 0 ustar twerner twerner /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
/**
* See Main.java.
*/
public class Person {
private int id;
private String category;
private String name;
private HashMap emails = new HashMap();
private List addresses = new ArrayList();
/**
* A unique id for this person. Note that the Digester automatically
* converts the id to an integer.
*/
public void setId(int id) {
this.id = id;
}
public void setCategory(String category) {
this.category = category;
}
public void setName(String name) {
this.name = name;
}
/** we assume only one email of each type... */
public void addEmail(String type, String address) {
emails.put(type, address);
}
public void addAddress( Address addr ) {
addresses.add( addr );
}
public void print() {
System.out.println("Person #" + id);
System.out.println(" category=" + category);
System.out.println(" name=" + name);
for(Iterator i = emails.keySet().iterator(); i.hasNext(); ) {
String type = (String) i.next();
String address = (String) emails.get(type);
System.out.println(" email (type " + type + ") : " + address);
}
for(Iterator i = addresses.iterator(); i.hasNext(); ) {
Address addr = (Address) i.next();
addr.print(System.out, 2);
}
}
}
libcommons-digester-java-1.8.1.orig/src/examples/xmlrules/addressbook/readme.txt 0000644 0001750 0001750 00000004156 11226450007 030064 0 ustar twerner twerner #########################################################################
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#########################################################################
== overview
The files in this directory are intended as an example of how to use
the Apache Digester's basic functionality via its xmlrules interface.
Topics covered:
* how to create a digester instance initialised with
rules specified in an external file.
* how to parse a file
* how to use the "object create" rule to create java objects
* how to use the "set properties" rule (basic usage) to map xml attributes
to java bean properties.
* how to use the "set nested properties" rule (basic usage) to map nested
elements to java bean properties.
* how to use the "set next" rule to build trees of java objects.
* how to use the "call method rule" (basic usage)
* how to use the "call parameter rule" to process the text contained
in a tag's body
* how to use the "call parameter rule" to process the contents of an
xml attribute.
== compiling and running
First rename the build.properties.sample file in the parent directory
to build.properties and edit it to suit your environment. Then in this
directory:
* to compile:
ant compile
* to run:
ant run
Alternatively, you can set up your CLASSPATH appropriately, and
run the example directly. See the build.properties and build.xml
files for details.
libcommons-digester-java-1.8.1.orig/src/examples/xmlrules/addressbook/build.xml 0000644 0001750 0001750 00000011367 11226450007 027711 0 ustar twerner twerner
* This demonstrates that a plugged-in class can itself define plugin-points
* for user-defined classes if it wishes.
*/
public class CompoundTransform implements Transform {
private LinkedList transforms = new LinkedList();
public void addTransform(Transform transform) {
transforms.add(transform);
}
public String transform(String s) {
for(Iterator i = transforms.iterator(); i.hasNext(); ) {
Transform t = (Transform) i.next();
s = t.transform(s);
}
return s;
}
public static void addRules(Digester d, String patternPrefix) {
PluginCreateRule pcr = new PluginCreateRule(Transform.class);
d.addRule(patternPrefix+"/subtransform", pcr);
d.addSetNext(patternPrefix+"/subtransform", "addTransform");
}
}
libcommons-digester-java-1.8.1.orig/src/examples/plugins/pipeline/Pipeline.java 0000644 0001750 0001750 00000010300 11226450007 027575 0 ustar twerner twerner /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.PluginRules;
import org.apache.commons.digester.plugins.PluginCreateRule;
import java.io.*;
/**
* This is the "main" class for this example.
*
* It can be run via
* The specified config file is parsed using the Apache Commons Digester.
* This config file specifies an input file to be read, a number of
* user-defined transform classes to be instantiated and configured from
* the config file, and an output file.
*
* The contents of the input file is then passed to the transform objects,
* and the output written to the output file.
*
* Why not try writing your own transform classes, and plugging them in.
* Note that they can configure themselves from the main config file in
* any manner the Digester supports, without changing a line of this
* application.
*/
public class Pipeline {
private String source;
private String dest;
private Transform transformer;
public static void main(String[] args) {
if (args.length != 1) {
System.err.println("usage: pipeline config-file");
System.exit(-1);
}
String configFile = args[0];
Digester digester = new Digester();
PluginRules rc = new PluginRules();
digester.setRules(rc);
digester.addObjectCreate("pipeline", Pipeline.class);
digester.addCallMethod("pipeline/source", "setSource", 1);
digester.addCallParam("pipeline/source", 0, "file");
PluginCreateRule pcr = new PluginCreateRule(Transform.class);
digester.addRule("pipeline/transform", pcr);
digester.addSetNext("pipeline/transform", "setTransform");
digester.addCallMethod("pipeline/destination", "setDest", 1);
digester.addCallParam("pipeline/destination", 0, "file");
Pipeline pipeline = null;
try {
pipeline = (Pipeline) digester.parse(configFile);
}
catch(Exception e) {
System.err.println("oops exception occurred during parse.");
e.printStackTrace();
System.exit(-1);
}
try {
pipeline.execute();
}
catch (Exception e) {
System.err.println("oops exception occurred during pipeline execution.");
e.printStackTrace();
System.exit(-1);
}
}
public void setSource(String source) {
this.source = source;
}
public void setDest(String dest) {
this.dest = dest;
}
public void setTransform(Transform transformer) {
this.transformer = transformer;
}
private void execute() throws IOException {
FileReader inRaw = new FileReader(source);
FileWriter out = new FileWriter(dest);
BufferedReader in = new BufferedReader(inRaw);
while(true) {
String inStr = in.readLine();
if (inStr==null)
break;
String outStr = transformer.transform(inStr);
out.write(outStr);
out.write('\n');
}
inRaw.close();
out.close();
System.out.println(
"Contents of file " + source + " have been transformed, and"
+ " written to file " + dest + ".");
}
}
libcommons-digester-java-1.8.1.orig/src/examples/plugins/pipeline/SubstituteTransform.java 0000644 0001750 0001750 00000004077 11226450007 032115 0 ustar twerner twerner /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import org.apache.commons.digester.Digester;
/**
* An implementation of the Transform interface which replaces all occurrences
* of a specified string with a different string.
*
* Because this class wishes to configure instances via nested "from" and
* "to" tags, it needs to define an addRules method to add rules to the
* Digester dynamically. Note that there are different ways of defining the
* rules though; for example they can be defined in a separate
* SubstituteTransformRuleInfo class.
*/
public class SubstituteTransform implements Transform {
private String from;
private String to;
public void setFrom(String from) {
this.from = from;
}
public void setTo(String to) {
this.to = to;
}
public String transform(String s) {
StringBuffer buf = new StringBuffer(s);
while (true) {
int idx = buf.indexOf(from);
if (idx == -1)
break;
StringBuffer buf2 = buf.replace(idx, idx+from.length(), to);
}
return buf.toString();
}
public static void addRules(Digester d, String patternPrefix) {
d.addCallMethod(patternPrefix+"/from", "setFrom", 0);
d.addCallMethod(patternPrefix+"/to", "setTo", 0);
}
}
libcommons-digester-java-1.8.1.orig/src/examples/plugins/pipeline/input.txt 0000644 0001750 0001750 00000000537 11226450007 027100 0 ustar twerner twerner This is a test input file
for the pipeline demo.
It has multiple lines of text, which
are transformed one-by-one using
plugin classes.
HERE IS SOME ALL-UPPERCASE TEXT and here some lowercase text
which demonstrates the Case Transform plugin.
Here are some lines to demonstrate the substitution plugin:
changeme 1
and changeme2
and changeme again.
libcommons-digester-java-1.8.1.orig/src/examples/plugins/pipeline/substitute.xml 0000644 0001750 0001750 00000002052 11226450007 030127 0 ustar twerner twerner
* Note that because it doesn't use any nested tags for configuration,
* just xml attributes which map 1:1 onto bean property-setter methods,
* there is no need to define any custom addRules method to use this
* as a Digester plugin class.
*/
public class CaseTransform implements Transform {
private boolean toLower = true;
public void setCase(String caseType) {
if (caseType.equalsIgnoreCase("upper"))
toLower = false;
else
toLower = true;
}
public String transform(String s) {
if (toLower)
return s.toLowerCase();
else
return s.toUpperCase();
}
}
libcommons-digester-java-1.8.1.orig/src/examples/plugins/pipeline/compound.xml 0000644 0001750 0001750 00000002220 11226450007 027535 0 ustar twerner twerner
See the
Package Description for the Rule implementation that calls a "set parent" method on the top (child)
* object, passing the (top-1) (parent) object as an argument. This rule now supports more flexible method matching by default.
* It is possible that this may break (some) code
* written against release 1.1.1 or earlier.
* See {@link #isExactMatch()} for more details. Is exact matching being used. This rule uses When exact matching is disabled, The default setting is to disable exact matches. Set whether exact matching is enabled. See {@link #isExactMatch()}. Rule implementation that saves a parameter for use by a surrounding
* This parameter may be:
* Digester instance, associating them with
* our namespace URI (if any). This method should only be called
* by a Digester instance.
*
* @param digester Digester instance to which the new Rule instances
* should be added.
*/
public void addRuleInstances(Digester digester) {
digester.addObjectCreate(prefix + "employee", Employee.class);
digester.addSetProperties(prefix + "employee");
digester.addObjectCreate("employee/address",
"org.apache.commons.digester.Address");
digester.addSetProperties(prefix + "employee/address");
digester.addSetNext(prefix + "employee/address",
"addAddress");
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/document-with-relative-dtd.xml libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/document-with-relative-dtd.0000644 0001750 0001750 00000001560 11226450007 033513 0 ustar twerner twerner
ObjectParamRuleTestCase
*
* @author Mark Huisman
*/
public class ObjectParamRuleTestCase extends TestCase {
// ----------------------------------------------------- Instance Variables
/**
* The digester instance we will be processing.
*/
protected Digester digester = null;
// ----------------------------------------------------------- Constructors
/**
* Construct a new instance of this test case.
*
* @param name Name of the test case
*/
public ObjectParamRuleTestCase(String name) {
super(name);
}
public static void main(String[] args){
// so we can run standalone
junit.textui.TestRunner.run(suite());
}
// --------------------------------------------------- Overall Test Methods
/**
* Set up instance variables required by this test case.
*/
public void setUp() {
digester = new Digester();
}
/**
* Return the tests included in this test suite.
*/
public static Test suite() {
return (new TestSuite(ObjectParamRuleTestCase.class));
}
/**
* Tear down instance variables required by this test case.
*/
public void tearDown() {
digester = null;
}
// ------------------------------------------------ Individual Test Methods
private StringBuffer sb = new StringBuffer().
append("null parsing.
* (should lead to IllegalArgumentExceptions)
*/
public void testNullFileParse() throws Exception {
try {
digester.parse((File) null);
fail("Expected IllegalArgumentException with null argument");
} catch (IllegalArgumentException e) {
// expected
}
}
public void testNullInputSourceParse() throws Exception {
try {
digester.parse((InputSource) null);
fail("Expected IllegalArgumentException with null argument");
} catch (IllegalArgumentException e) {
// expected
}
}
public void testNullInputStreamParse() throws Exception {
try {
digester.parse((InputStream) null);
fail("Expected IllegalArgumentException with null argument");
} catch (IllegalArgumentException e) {
// expected
}
}
public void testNullReaderParse() throws Exception {
try {
digester.parse((Reader) null);
fail("Expected IllegalArgumentException with null argument");
} catch (IllegalArgumentException e) {
// expected
}
}
public void testNullStringParse() throws Exception {
try {
digester.parse((String) null);
fail("Expected IllegalArgumentException with null argument");
} catch (IllegalArgumentException e) {
// expected
}
}
public void testNullURLParse() throws Exception {
try {
digester.parse((URL) null);
fail("Expected IllegalArgumentException with null argument");
} catch (IllegalArgumentException e) {
// expected
}
}
/**
* Test the basic property getters and setters.
*/
public void testProperties() {
assertNull("Initial error handler is null",
digester.getErrorHandler());
digester.setErrorHandler((ErrorHandler) digester);
assertTrue("Set error handler is digester",
digester.getErrorHandler() == digester);
digester.setErrorHandler(null);
assertNull("Reset error handler is null",
digester.getErrorHandler());
assertTrue("Initial namespace aware is false",
!digester.getNamespaceAware());
digester.setNamespaceAware(true);
assertTrue("Set namespace aware is true",
digester.getNamespaceAware());
digester.setNamespaceAware(false);
assertTrue("Reset namespace aware is false",
!digester.getNamespaceAware());
assertTrue("Initial validating is false",
!digester.getValidating());
digester.setValidating(true);
assertTrue("Set validating is true",
digester.getValidating());
digester.setValidating(false);
assertTrue("Reset validating is false",
!digester.getValidating());
}
/**
* Test registration of URLs for specified public identifiers.
*/
public void testRegistrations() {
Map map = digester.getRegistrations();
assertEquals("Initially zero registrations", 0, map.size());
int n = 0;
for (int i = 0; i < registrations.length; i += 2) {
URL url = this.getClass().getResource(registrations[i + 1]);
if (url != null) {
digester.register(registrations[i], url);
n++;
}
}
map = digester.getRegistrations();
assertEquals("Registered two URLs", n, map.size());
int count[] = new int[n];
for (int i = 0; i < n; i++)
count[i] = 0;
Iterator keys = map.keySet().iterator();
while (keys.hasNext()) {
String key = (String) keys.next();
for (int i = 0; i < n; i++) {
if (key.equals(registrations[i * 2])) {
count[i]++;
break;
}
}
}
for (int i = 0; i < n; i++)
assertEquals("Count for key " + registrations[i * 2],
1, count[i]);
}
/**
* Basic test for rule creation and matching.
*/
public void testRules() {
assertEquals("Initial rules list is empty",
0, digester.getRules().match(null, "a").size());
digester.addSetProperties("a");
assertEquals("Add a matching rule",
1, digester.getRules().match(null, "a").size());
digester.addSetProperties("b");
assertEquals("Add a non-matching rule",
1, digester.getRules().match(null, "a").size());
digester.addSetProperties("a/b");
assertEquals("Add a non-matching nested rule",
1, digester.getRules().match(null, "a").size());
digester.addSetProperties("a/b");
assertEquals("Add a second matching rule",
2, digester.getRules().match(null, "a/b").size());
}
/**
*
*
*/
public void testRulesBase() {
assertEquals("Initial rules list is empty",
0, digester.getRules().rules().size());
// We're going to set up
digester.addRule("a/b/c/d", new TestRule("a/b/c/d"));
digester.addRule("*/d", new TestRule("*/d"));
digester.addRule("*/c/d", new TestRule("*/c/d"));
// Test exact match
assertEquals("Exact match takes precedence 1",
1, digester.getRules().match(null, "a/b/c/d").size());
assertEquals("Exact match takes precedence 2",
"a/b/c/d",
((TestRule) digester.getRules().match(null, "a/b/c/d").iterator().next()).getIdentifier());
// Test wildcard tail matching
assertEquals("Wildcard tail matching rule 1",
1, digester.getRules().match(null, "a/b/d").size());
assertEquals("Wildcard tail matching rule 2",
"*/d",
((TestRule) digester.getRules().match(null, "a/b/d").iterator().next()).getIdentifier());
// Test the longest matching pattern rule
assertEquals("Longest tail rule 1",
1, digester.getRules().match(null, "x/c/d").size());
assertEquals("Longest tail rule 2",
"*/c/d",
((TestRule) digester.getRules().match(null, "x/c/d").iterator().next()).getIdentifier());
}
/**
* Test the basic stack mechanisms.
*/
public void testStackMethods() {
Object value = null;
// New stack must be empty
assertEquals("New stack is empty", 0, digester.getCount());
value = digester.peek();
assertNull("New stack peek() returns null", value);
value = digester.pop();
assertNull("New stack pop() returns null", value);
// Test pushing and popping activities
digester.push("First Item");
assertEquals("Pushed one item size", 1, digester.getCount());
value = digester.peek();
assertNotNull("Peeked first item is not null", value);
assertEquals("Peeked first item value", "First Item", (String) value);
digester.push("Second Item");
assertEquals("Pushed two items size", 2, digester.getCount());
value = digester.peek();
assertNotNull("Peeked second item is not null", value);
assertEquals("Peeked second item value", "Second Item", (String) value);
value = digester.pop();
assertEquals("Popped stack size", 1, digester.getCount());
assertNotNull("Popped second item is not null", value);
assertEquals("Popped second item value", "Second Item", (String) value);
value = digester.peek();
assertNotNull("Remaining item is not null", value);
assertEquals("Remaining item value", "First Item", (String) value);
assertEquals("Remaining stack size", 1, digester.getCount());
// Cleared stack is empty
digester.push("Dummy Item");
digester.clear();
assertEquals("Cleared stack is empty", 0, digester.getCount());
value = digester.peek();
assertNull("Cleared stack peek() returns null", value);
value = digester.pop();
assertNull("Cleared stack pop() returns null", value);
}
public void testOnceAndOnceOnly() throws Exception {
class TestConfigureDigester extends Digester {
public int called=0;
public TestConfigureDigester() {}
protected void initialize() {
called++;
}
}
TestConfigureDigester digester = new TestConfigureDigester();
String xml = "
*
*/
public void testRulesBase() {
// clear any existing rules
digester.getRules().clear();
assertEquals("Initial rules list is empty",
0, digester.getRules().rules().size());
// We're going to set up
digester.addRule("a/b/c/d", new TestRule("a/b/c/d"));
digester.addRule("*/d", new TestRule("*/d"));
digester.addRule("*/c/d", new TestRule("*/c/d"));
// Test exact match
assertEquals("Exact match takes precedence 1",
1, digester.getRules().match(null, "a/b/c/d").size());
assertEquals("Exact match takes precedence 2",
"a/b/c/d",
((TestRule) digester.getRules().match(null, "a/b/c/d").iterator().next()).getIdentifier());
// Test wildcard tail matching
assertEquals("Wildcard tail matching rule 1",
1, digester.getRules().match(null, "a/b/d").size());
assertEquals("Wildcard tail matching rule 2",
"*/d",
((TestRule) digester.getRules().match(null, "a/b/d").iterator().next()).getIdentifier());
// Test the longest matching pattern rule
assertEquals("Longest tail rule 1",
1, digester.getRules().match(null, "x/c/d").size());
assertEquals("Longest tail rule 2",
"*/c/d",
((TestRule) digester.getRules().match(null, "x/c/d").iterator().next()).getIdentifier());
// Test wildcard tail matching at the top level,
// i.e. the wildcard is nothing
digester.addRule("*/a", new TestRule("*/a"));
assertEquals("Wildcard tail matching rule 3",
1,
digester.getRules().match(null,"a").size());
assertEquals("Wildcard tail matching rule 3 (match too much)",
0,
digester.getRules().match(null,"aa").size());
// clean up
digester.getRules().clear();
}
/**
* Test basic matchings involving namespaces.
*/
public void testBasicNamespaceMatching() {
List list = null;
Iterator it = null;
// clear any existing rules
digester.getRules().clear();
assertEquals("Initial rules list is empty",
0, digester.getRules().rules().size());
// Set up rules
digester.addRule("alpha/beta/gamma", new TestRule("No-Namespace"));
digester.addRule("alpha/beta/gamma", new TestRule("Euclidean-Namespace", "euclidean"));
list = digester.getRules().rules();
// test that matching null namespace brings back namespace and non-namespace rules
list = digester.getRules().match(null, "alpha/beta/gamma");
assertEquals("Null namespace match (A)", 2, list.size());
it = list.iterator();
assertEquals("Null namespace match (B)", "No-Namespace", ((TestRule) it.next()).getIdentifier());
assertEquals("Null namespace match (C)", "Euclidean-Namespace", ((TestRule) it.next()).getIdentifier());
// test that matching euclid namespace brings back namespace and non-namespace rules
list = digester.getRules().match("euclidean", "alpha/beta/gamma");
assertEquals("Matching namespace match (A)", 2, list.size());
it = list.iterator();
assertEquals("Matching namespace match (B)", "No-Namespace", ((TestRule) it.next()).getIdentifier());
assertEquals("Matching namespace match (C)", "Euclidean-Namespace", ((TestRule) it.next()).getIdentifier());
// test that matching another namespace brings back only non-namespace rule
list = digester.getRules().match("hyperbolic", "alpha/beta/gamma");
assertEquals("Non matching namespace match (A)", 1, list.size());
it = list.iterator();
assertEquals("Non matching namespace match (B)", "No-Namespace", ((TestRule) it.next()).getIdentifier());
// clean up
digester.getRules().clear();
}
/**
* Rules must always be returned in the correct order.
*/
public void testOrdering() {
// clear any existing rules
digester.getRules().clear();
assertEquals("Initial rules list is empty",
0, digester.getRules().rules().size());
// Set up rules
digester.addRule("alpha/beta/gamma", new TestRule("one"));
digester.addRule("alpha/beta/gamma", new TestRule("two"));
digester.addRule("alpha/beta/gamma", new TestRule("three"));
// test that rules are returned in set order
List list = digester.getRules().match(null, "alpha/beta/gamma");
assertEquals("Testing ordering mismatch (A)", 3, list.size());
Iterator it = list.iterator();
assertEquals("Testing ordering mismatch (B)", "one", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing ordering mismatch (C)", "two", ((TestRule) it.next()).getIdentifier());
assertEquals("Testing ordering mismatch (D)", "three", ((TestRule) it.next()).getIdentifier());
// clean up
digester.getRules().clear();
}
/** Tests the behaviour when a rule is added with a trailing slash*/
public void testTrailingSlash() {
// clear any existing rules
digester.getRules().clear();
assertEquals("Initial rules list is empty",
0, digester.getRules().rules().size());
// Set up rules
digester.addRule("alpha/beta/gamma/", new TestRule("one"));
digester.addRule("alpha/beta/", new TestRule("two"));
digester.addRule("beta/gamma/alpha", new TestRule("three"));
// test that rules are returned in set order
List list = digester.getRules().match(null, "alpha/beta/gamma");
assertEquals("Testing number of matches", 1, list.size());
Iterator it = list.iterator();
assertEquals("Testing ordering (A)", "one", ((TestRule) it.next()).getIdentifier());
// clean up
digester.getRules().clear();
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/LocationTrackerTestCase.java libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/LocationTrackerTestCase.jav0000644 0001750 0001750 00000006262 11226450007 033567 0 ustar twerner twerner /* $Id: LocationTrackerTestCase.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.io.StringReader;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;
import org.xml.sax.Locator;
/**
* Tests that StackAction can be used to track the source location
* of objects created from input xml stream.
*/
public class LocationTrackerTestCase extends TestCase {
private static class LocationTracker implements StackAction {
public Map locations = new HashMap();
public Object onPush(Digester d, String stackName, Object o) {
if (stackName == null) {
// we only care about the real object stack
// note that a Locator object can also provide
// publicId and systemId info.
Locator l = d.getDocumentLocator();
StringBuffer locn = new StringBuffer();
locn.append("line=");
locn.append(l.getLineNumber());
locations.put(o, locn.toString());
}
return o;
}
public Object onPop(Digester d, String stackName, Object o) {
return o;
}
}
public void testAll() throws Exception {
final String TEST_XML =
"\n"
+ "TestRule */
private String identifier;
/** Used when testing body text */
private String bodyText;
/** Used when testing call orders */
private List order;
// ----------------------------------------------------------- Constructors
/**
* Base constructor.
*
* @param identifier Used to tell which TestRule is which
*/
public TestRule(String identifier) {
this.identifier = identifier;
}
/**
* Constructor sets namespace URI.
*
* @param identifier Used to tell which TestRule is which
* @param namespaceURI Set rule namespace
*/
public TestRule(
String identifier,
String namespaceURI) {
this.identifier = identifier;
setNamespaceURI(namespaceURI);
}
// ------------------------------------------------ Rule Implementation
/**
* 'Begin' call.
*/
public void begin(Attributes attributes) {
appendCall();
}
/**
* 'Body' call.
*/
public void body(String text) {
this.bodyText = text;
appendCall();
}
/**
* 'End' call.
*/
public void end() {
appendCall();
}
// ------------------------------------------------ Methods
/**
* If a list has been set, append this to the list.
*/
protected void appendCall() {
if (order != null)
order.add(this);
}
/**
* Get the body text that was set.
*/
public String getBodyText() {
return bodyText;
}
/**
* Get the identifier associated with this test.
*/
public String getIdentifier() {
return identifier;
}
/**
* Get call order list.
*/
public List getOrder() {
return order;
}
/**
* Set call order list
*/
public void setOrder(List order) {
this.order = order;
}
/**
* Return the identifier.
*/
public String toString() {
return identifier;
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/NamespaceSnapshotTestCase.java libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/NamespaceSnapshotTestCase.j0000644 0001750 0001750 00000011100 11226450007 033553 0 ustar twerner twerner /* $Id: NamespaceSnapshotTestCase.java 561583 2007-07-31 22:48:00Z dennisl $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;
import org.xml.sax.Attributes;
/**
* Tests namespace snapshotting.
*/
public class NamespaceSnapshotTestCase extends TestCase {
/**
* A test case specific helper rule.
*/
static class NamespaceSnapshotRule extends Rule {
/**
* @see Rule#begin(String, String, Attributes)
*/
public final void begin(final String namespace, final String name,
final Attributes attributes) {
Digester d = getDigester();
Map namespaces = d.getCurrentNamespaces();
((NamespacedBox) d.peek()).setNamespaces(namespaces);
}
}
/**
* Namespace snapshot test case.
*/
public void testNamespaceSnapshots() throws Exception {
Digester digester = new Digester();
digester.setNamespaceAware(true);
digester.addObjectCreate("box", NamespacedBox.class);
digester.addSetProperties("box");
digester.addRule("box", new NamespaceSnapshotRule());
digester.addObjectCreate("box/subBox", NamespacedBox.class);
digester.addSetProperties("box/subBox");
digester.addRule("box/subBox", new NamespaceSnapshotRule());
digester.addSetNext("box/subBox", "addChild");
Object result = digester.parse(getInputStream("Test11.xml"));
assertNotNull(result);
NamespacedBox root = (NamespacedBox) result;
Map nsmap = root.getNamespaces();
assertEquals(3, nsmap.size());
assertEquals("", nsmap.get(""));
assertEquals("http://commons.apache.org/digester/Foo", nsmap.get("foo"));
assertEquals("http://commons.apache.org/digester/Bar", nsmap.get("bar"));
List children = root.getChildren();
assertEquals(3, children.size());
NamespacedBox child1 = (NamespacedBox) children.get(0);
nsmap = child1.getNamespaces();
assertEquals(3, nsmap.size());
assertEquals("", nsmap.get(""));
assertEquals("http://commons.apache.org/digester/Foo1", nsmap.get("foo"));
assertEquals("http://commons.apache.org/digester/Bar1", nsmap.get("bar"));
NamespacedBox child2 = (NamespacedBox) children.get(1);
nsmap = child2.getNamespaces();
assertEquals(5, nsmap.size());
assertEquals("", nsmap.get(""));
assertEquals("http://commons.apache.org/digester/Foo", nsmap.get("foo"));
assertEquals("http://commons.apache.org/digester/Bar", nsmap.get("bar"));
assertEquals("http://commons.apache.org/digester/Alpha", nsmap.get("alpha"));
assertEquals("http://commons.apache.org/digester/Beta", nsmap.get("beta"));
NamespacedBox child3 = (NamespacedBox) children.get(2);
nsmap = child3.getNamespaces();
assertEquals(4, nsmap.size());
assertEquals("", nsmap.get(""));
assertEquals("http://commons.apache.org/digester/Foo3", nsmap.get("foo"));
assertEquals("http://commons.apache.org/digester/Alpha", nsmap.get("alpha"));
assertEquals("http://commons.apache.org/digester/Bar", nsmap.get("bar"));
}
// ------------------------------------------------ Utility Support Methods
/**
* Return an appropriate InputStream for the specified test file (which
* must be inside our current package.
*
* @param name Name of the test file we want
*
* @exception IOException if an input/output error occurs
*/
protected InputStream getInputStream(String name) throws IOException {
return (this.getClass().getResourceAsStream
("/org/apache/commons/digester/" + name));
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/CallMethodRuleTestCase.java libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/CallMethodRuleTestCase.java0000644 0001750 0001750 00000066300 11226450007 033507 0 ustar twerner twerner /* $Id: CallMethodRuleTestCase.java 472840 2006-11-09 10:18:34Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.xml.sax.SAXException;
//import org.apache.commons.logging.impl.SimpleLog;
/**
* CallMethodRule and associated
* CallParamRule.
*
* @author Christopher Lenz
*/
public class CallMethodRuleTestCase extends TestCase {
// ----------------------------------------------------- Instance Variables
/**
* The digester instance we will be processing.
*/
protected Digester digester = null;
// ----------------------------------------------------------- Constructors
/**
* Construct a new instance of this test case.
*
* @param name Name of the test case
*/
public CallMethodRuleTestCase(String name) {
super(name);
}
// --------------------------------------------------- Overall Test Methods
/**
* Set up instance variables required by this test case.
*/
public void setUp() {
digester = new Digester();
}
/**
* Return the tests included in this test suite.
*/
public static Test suite() {
return (new TestSuite(CallMethodRuleTestCase.class));
}
/**
* Tear down instance variables required by this test case.
*/
public void tearDown() {
digester = null;
}
// ------------------------------------------------ Individual Test Methods
/**
* Test method calls with the CallMethodRule rule. It should be possible
* to call a method with no arguments using several rule syntaxes.
*/
public void testBasic() throws SAXException, IOException {
// Configure the digester as required
digester.addObjectCreate("employee", Employee.class);
// try all syntax permutations
digester.addCallMethod("employee", "toString", 0, (Class[])null);
digester.addCallMethod("employee", "toString", 0, (String[])null);
digester.addCallMethod("employee", "toString", 0, new Class[] {});
digester.addCallMethod("employee", "toString", 0, new String[] {});
digester.addCallMethod("employee", "toString");
// Parse our test input.
// An exception will be thrown if the method can't be found
Object root1 = digester.parse(getInputStream("Test5.xml"));
assertNotNull(root1);
}
/**
* Test method calls with the CallMethodRule reading from the element
* body, with no CallParamMethod rules added.
*/
public void testCallMethodOnly() throws Exception {
// Configure the digester as required
digester.addObjectCreate("employee", Employee.class);
digester.addCallMethod("employee/firstName", "setFirstName", 0);
digester.addCallMethod("employee/lastName", "setLastName", 0);
// Parse our test input
Employee employee = (Employee)
digester.parse(getInputStream("Test9.xml"));
assertNotNull("parsed an employee", employee);
// Validate that the property setters were called
assertEquals("Set first name", "First Name", employee.getFirstName());
assertEquals("Set last name", "Last Name", employee.getLastName());
}
/**
* Test CallMethodRule variants which specify the classes of the
* parameters to target methods. String, int, boolean, float should all
* be acceptable as parameter types.
*/
public void testSettingProperties() throws SAXException, IOException {
// Configure the digester as required
digester.addObjectCreate("employee", Employee.class);
// try all syntax permutations
digester.addCallMethod("employee", "setLastName", 1,
new String[] {"java.lang.String"});
digester.addCallParam("employee/lastName", 0);
// Parse our test input
Object root1 = null;
// an exception will be thrown if the method can't be found
root1 = digester.parse(getInputStream("Test5.xml"));
Employee employee = (Employee) root1;
assertEquals("Failed to call Employee.setLastName",
"Last Name", employee.getLastName());
digester = new Digester();
// Configure the digester as required
digester.addObjectCreate("employee", Employee.class);
// try out primitive convertion
digester.addCallMethod("employee", "setAge", 1,
new Class[] {int.class});
digester.addCallParam("employee/age", 0);
// Parse our test input
root1 = null;
// an exception will be thrown if the method can't be found
root1 = digester.parse(getInputStream("Test5.xml"));
employee = (Employee) root1;
assertEquals("Failed to call Employee.setAge", 21, employee.getAge());
digester = new Digester();
// Configure the digester as required
digester.addObjectCreate("employee", Employee.class);
digester.addCallMethod("employee", "setActive", 1,
new Class[] {boolean.class});
digester.addCallParam("employee/active", 0);
// Parse our test input
root1 = null;
// an exception will be thrown if the method can't be found
root1 = digester.parse(getInputStream("Test5.xml"));
employee = (Employee) root1;
assertEquals("Failed to call Employee.setActive",
true, employee.isActive());
digester = new Digester();
// Configure the digester as required
digester.addObjectCreate("employee", Employee.class);
digester.addCallMethod("employee", "setSalary", 1,
new Class[] {float.class});
digester.addCallParam("employee/salary", 0);
// Parse our test input
root1 = null;
// an exception will be thrown if the method can't be found
root1 = digester.parse(getInputStream("Test5.xml"));
employee = (Employee) root1;
assertEquals("Failed to call Employee.setSalary",
1000000.0f, employee.getSalary(), 0.1f);
}
/**
* This tests the call methods params enhancement that provides
* for more complex stack-based calls.
*/
public void testParamsFromStack() throws SAXException, IOException {
StringBuffer xml = new StringBuffer().
append("").
append("");
digester.addObjectCreate("map", HashMap.class);
digester.addCallMethod("map", "put", 2);
digester.addObjectCreate("map/key", AlphaBean.class);
digester.addSetProperties("map/key");
digester.addCallParam("map/key", 0, true);
digester.addObjectCreate("map/value", BetaBean.class);
digester.addSetProperties("map/value");
digester.addCallParam("map/value", 1, true);
Map map = (Map) digester.parse(new StringReader(xml.toString()));
assertNotNull(map);
assertEquals(1, map.size());
assertEquals("The key",
((AlphaBean)map.keySet().iterator().next()).getName());
assertEquals("The value",
((BetaBean)map.values().iterator().next()).getName());
}
/**
* Test that the target object for a CallMethodRule is the object that was
* on top of the object stack when the CallMethodRule fired, even when other
* rules fire between the CallMethodRule and its associated CallParamRules.
* URL arguments instead of strings.Digester instance under test.testRuleSet1 except using a single namespace.
*/
public void testRuleSet2() throws SAXException, IOException {
// Configure the digester as required
digester.setNamespaceAware(true);
RuleSet rs = new TestRuleSet(null,
"http://commons.apache.org/digester/Foo");
digester.addRuleSet(rs);
// Parse our test input.
Object root = null;
root = digester.parse(getInputStream("Test2.xml"));
assertNotNull("Digester returned an object", root);
assertTrue("Digester returned an Employee",
root instanceof Employee);
Employee employee = (Employee) root;
assertEquals("First name is correct",
"First Name",
employee.getFirstName());
assertEquals("Last name is correct",
"Last Name",
employee.getLastName());
assertNotNull("Can retrieve home address",
employee.getAddress("home"));
assertNotNull("Can retrieve office address",
employee.getAddress("office"));
}
/**
* Same as testRuleSet2 except using a namespace
* for employee that we should recognize, and a namespace for
* address that we should skip.
*/
public void testRuleSet3() throws SAXException, IOException {
// Configure the digester as required
digester.setNamespaceAware(true);
RuleSet rs = new TestRuleSet(null,
"http://commons.apache.org/digester/Foo");
digester.addRuleSet(rs);
// Parse our test input.
Object root = null;
root = digester.parse(getInputStream("Test3.xml"));
assertNotNull("Digester returned an object", root);
assertTrue("Digester returned an Employee",
root instanceof Employee);
Employee employee = (Employee) root;
assertEquals("First name is correct",
"First Name",
employee.getFirstName());
assertEquals("Last name is correct",
"Last Name",
employee.getLastName());
assertNull("Can not retrieve home address",
employee.getAddress("home"));
assertNull("Can not retrieve office address",
employee.getAddress("office"));
}
/**
* Test the two argument version of the SetTopRule rule. This test is
* based on testObjectCreate3 and should result in the same tree of
* objects. Instead of using the SetNextRule rule which results in
* a method invocation on the (top-1) (parent) object with the top
* object (child) as an argument, this test uses the SetTopRule rule
* which results in a method invocation on the top object (child)
* with the top-1 (parent) object as an argument. The three argument
* form is tested in testSetTopRule2.
*/
public void testSetTopRule1() throws SAXException, IOException {
// Configure the digester as required
digester.addObjectCreate("employee",
"org.apache.commons.digester.Employee");
digester.addSetProperties("employee");
digester.addObjectCreate("employee/address",
"org.apache.commons.digester.Address");
digester.addSetProperties("employee/address");
digester.addSetTop("employee/address", "setEmployee");
// Parse our test input.
Object root = null;
root = digester.parse(getInputStream("Test1.xml"));
validateObjectCreate3(root);
}
/**
* Same as testSetTopRule1 except using the three argument
* form of the SetTopRule rule.
*/
public void testSetTopRule2() throws SAXException, IOException {
// Configure the digester as required
digester.addObjectCreate("employee",
"org.apache.commons.digester.Employee");
digester.addSetProperties("employee");
digester.addObjectCreate("employee/address",
"org.apache.commons.digester.Address");
digester.addSetProperties("employee/address");
digester.addSetTop("employee/address", "setEmployee",
"org.apache.commons.digester.Employee");
// Parse our test input.
Object root = null;
root = digester.parse(getInputStream("Test1.xml"));
validateObjectCreate3(root);
}
/**
* Test rule addition - this boils down to making sure that
* digester is set properly on rule addition.
*/
public void testAddRule() {
Digester digester = new Digester();
TestRule rule = new TestRule("Test");
digester.addRule("/root", rule);
assertEquals("Digester is not properly on rule addition.",
digester, rule.getDigester());
}
public void testSetNext() throws SAXException, IOException {
Digester digester = new Digester();
digester.setRules(new ExtendedBaseRules());
digester.setValidating(false);
digester.addObjectCreate("!*/b", BetaBean.class);
digester.addObjectCreate("!*/a", AlphaBean.class);
digester.addObjectCreate("root", ArrayList.class);
digester.addSetProperties("!*");
digester.addSetNext("!*/b/?", "setChild");
digester.addSetNext("!*/a/?", "setChild");
digester.addSetNext("!root/?", "add");
ArrayList root =
(ArrayList) digester.parse(getInputStream("Test4.xml"));
assertEquals("Wrong array size", 2, root.size());
AlphaBean one = (AlphaBean) root.get(0);
assertTrue(one.getChild() instanceof BetaBean);
BetaBean two = (BetaBean) one.getChild();
assertEquals("Wrong name (1)", two.getName() , "TWO");
assertTrue(two.getChild() instanceof AlphaBean);
AlphaBean three = (AlphaBean) two.getChild();
assertEquals("Wrong name (2)", three.getName() , "THREE");
BetaBean four = (BetaBean) root.get(1);
assertEquals("Wrong name (3)", four.getName() , "FOUR");
assertTrue(four.getChild() instanceof BetaBean);
BetaBean five = (BetaBean) four.getChild();
assertEquals("Wrong name (4)", five.getName() , "FIVE");
}
public void testSetTop() throws SAXException, IOException {
Digester digester = new Digester();
digester.setRules(new ExtendedBaseRules());
digester.setValidating(false);
digester.addObjectCreate("!*/b", BetaBean.class);
digester.addObjectCreate("!*/a", AlphaBean.class);
digester.addObjectCreate("root", ArrayList.class);
digester.addSetProperties("!*");
digester.addSetTop("!*/b/?", "setParent");
digester.addSetTop("!*/a/?", "setParent");
digester.addSetRoot("!*/a", "add");
digester.addSetRoot("!*/b", "add");
ArrayList root =
(ArrayList) digester.parse(getInputStream("Test4.xml"));
assertEquals("Wrong array size", 5, root.size());
// note that the array is in popped order (rather than pushed)
Object obj = root.get(1);
assertTrue("TWO should be a BetaBean", obj instanceof BetaBean);
BetaBean two = (BetaBean) obj;
assertNotNull("Two's parent should not be null", two.getParent());
assertEquals("Wrong name (1)", "TWO", two.getName());
assertEquals("Wrong name (2)", "ONE", two.getParent().getName() );
obj = root.get(0);
assertTrue("THREE should be an AlphaBean", obj instanceof AlphaBean);
AlphaBean three = (AlphaBean) obj;
assertNotNull("Three's parent should not be null", three.getParent());
assertEquals("Wrong name (3)", "THREE", three.getName());
assertEquals("Wrong name (4)", "TWO", three.getParent().getName());
obj = root.get(3);
assertTrue("FIVE should be a BetaBean", obj instanceof BetaBean);
BetaBean five = (BetaBean) obj;
assertNotNull("Five's parent should not be null", five.getParent());
assertEquals("Wrong name (5)", "FIVE", five.getName());
assertEquals("Wrong name (6)", "FOUR", five.getParent().getName());
}
/**
*/
public void testSetCustomProperties() throws SAXException, IOException {
Digester digester = new Digester();
digester.setValidating(false);
digester.addObjectCreate("toplevel", ArrayList.class);
digester.addObjectCreate("toplevel/one", Address.class);
digester.addSetNext("toplevel/one", "add");
digester.addObjectCreate("toplevel/two", Address.class);
digester.addSetNext("toplevel/two", "add");
digester.addObjectCreate("toplevel/three", Address.class);
digester.addSetNext("toplevel/three", "add");
digester.addObjectCreate("toplevel/four", Address.class);
digester.addSetNext("toplevel/four", "add");
digester.addSetProperties("toplevel/one");
digester.addSetProperties(
"toplevel/two",
new String[] {"alt-street", "alt-city", "alt-state"},
new String[] {"street", "city", "state"});
digester.addSetProperties(
"toplevel/three",
new String[] {"aCity", "state"},
new String[] {"city"});
digester.addSetProperties("toplevel/four", "alt-city", "city");
ArrayList root =
(ArrayList) digester.parse(getInputStream("Test7.xml"));
assertEquals("Wrong array size", 4, root.size());
// note that the array is in popped order (rather than pushed)
Object
obj = root.get(0);
assertTrue("(1) Should be an Address ", obj instanceof Address);
Address addressOne = (Address) obj;
assertEquals("(1) Street attribute", "New Street",
addressOne.getStreet());
assertEquals("(1) City attribute", "Las Vegas", addressOne.getCity());
assertEquals("(1) State attribute", "Nevada", addressOne.getState());
obj = root.get(1);
assertTrue("(2) Should be an Address ", obj instanceof Address);
Address addressTwo = (Address) obj;
assertEquals("(2) Street attribute", "Old Street",
addressTwo.getStreet());
assertEquals("(2) City attribute", "Portland", addressTwo.getCity());
assertEquals("(2) State attribute", "Oregon", addressTwo.getState());
obj = root.get(2);
assertTrue("(3) Should be an Address ", obj instanceof Address);
Address addressThree = (Address) obj;
assertEquals("(3) Street attribute", "4th Street",
addressThree.getStreet());
assertEquals("(3) City attribute", "Dayton", addressThree.getCity());
assertEquals("(3) State attribute", "US" , addressThree.getState());
obj = root.get(3);
assertTrue("(4) Should be an Address ", obj instanceof Address);
Address addressFour = (Address) obj;
assertEquals("(4) Street attribute", "6th Street",
addressFour.getStreet());
assertEquals("(4) City attribute", "Cleveland", addressFour.getCity());
assertEquals("(4) State attribute", "Ohio", addressFour.getState());
}
// ------------------------------------------------ Utility Support Methods
/**
* Return an appropriate InputStream for the specified test file (which
* must be inside our current package.
*
* @param name Name of the test file we want
*
* @exception IOException if an input/output error occurs
*/
protected InputStream getInputStream(String name) throws IOException {
return (this.getClass().getResourceAsStream
("/org/apache/commons/digester/" + name));
}
/**
* Validate the assertions for ObjectCreateRule3.
*
* @param root Root object returned by digester.parse()
*/
protected void validateObjectCreate3(Object root) {
// Validate the retrieved Employee
assertNotNull("Digester returned an object", root);
assertTrue("Digester returned an Employee",
root instanceof Employee);
Employee employee = (Employee) root;
assertEquals("First name is correct",
"First Name",
employee.getFirstName());
assertEquals("Last name is correct",
"Last Name",
employee.getLastName());
// Validate the corresponding "home" Address
Address home = employee.getAddress("home");
assertNotNull("Retrieved home address", home);
assertEquals("Home street", "Home Street",
home.getStreet());
assertEquals("Home city", "Home City",
home.getCity());
assertEquals("Home state", "HS",
home.getState());
assertEquals("Home zip", "HmZip",
home.getZipCode());
// Validate the corresponding "office" Address
Address office = employee.getAddress("office");
assertNotNull("Retrieved office address", office);
assertEquals("Office street", "Office Street",
office.getStreet());
assertEquals("Office city", "Office City",
office.getCity());
assertEquals("Office state", "OS",
office.getState());
assertEquals("Office zip", "OfZip",
office.getZipCode());
}
}
libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/xmlrules/ 0000755 0001750 0001750 00000000000 11226450007 030212 5 ustar twerner twerner ././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/xmlrules/test-node-create-rules.xml libcommons-digester-java-1.8.1.orig/src/test/org/apache/commons/digester/xmlrules/test-node-create-r0000644 0001750 0001750 00000002166 11226450007 033544 0 ustar twerner twerner
SetNestedPropertiesRule.
* This contains tests for the main applications of the rule
* and two more general tests of digester functionality used by this rule.
*/
public class SetNestedPropertiesRuleTestCase extends TestCase {
// ----------------------------------------------------- Instance Variables
/**
* Simple test xml document used in the tests.
*/
protected final static String TEST_XML =
"" +
"
*
*/
public void testMultiRuleMatch()
throws SAXException, IOException {
String testXml =
"" +
"BeanPropertySetterRule.
* This contains tests for the main applications of the rule
* and two more general tests of digester functionality used by this rule.
*/
public class BeanPropertySetterRuleTestCase extends TestCase {
// ----------------------------------------------------- Instance Variables
/**
* Simple test xml document used in the tests.
*/
protected final static String TEST_XML =
"" +
"SetPropertiesRule.NodeCreateRule.
*
* @author Christopher Lenz
* @version $Revision: 730332 $ $Date: 2008-12-31 02:09:35 -0500 (Wed, 31 Dec 2008) $
*/
public class NodeCreateRuleTestCase extends TestCase {
// ----------------------------------------------------- Instance Variables
/**
* Simple test xml document used in the tests.
*/
protected final static String TEST_XML =
"
*
* The result is that method "b" appears to work ok, but method "a"
* loses its input parameters.
* SetPropertyRule.
* [book isdn="12345"]
*
* is fine; the isdn value can be accessed during the createObject method.
* However, given the xml:
*
* [book]
* [isdn]12345[/isdn]
* ...
*
* it is not possible to access the isdn number until after the
* Book instance has been created.
* null
* for no declaration
*
* @exception UnsupportedEncodingException if the named encoding
* is not supported
*/
public void render(OutputStream stream, String encoding)
throws UnsupportedEncodingException {
PrintWriter pw = null;
if (encoding == null) {
pw = new PrintWriter(stream);
} else {
pw = new PrintWriter(new OutputStreamWriter(stream, encoding));
}
render(pw, encoding);
pw.flush();
}
/**
* Render this channel as XML conforming to the RSS 0.91 specification,
* to the specified writer, with no indication of character encoding.
*
* @param writer The writer to render output to
*/
public void render(Writer writer) {
render(writer, null);
}
/**
* Render this channel as XML conforming to the RSS 0.91 specification,
* to the specified writer, indicating the specified character encoding.
*
* @param writer The writer to render output to
* @param encoding The character encoding to declare, or null
* for no declaration
*/
public void render(Writer writer, String encoding) {
PrintWriter pw = new PrintWriter(writer);
render(pw, encoding);
pw.flush();
}
/**
* Render this channel as XML conforming to the RSS 0.91 specification,
* to the specified writer, with no indication of character encoding.
*
* @param writer The writer to render output to
*/
public void render(PrintWriter writer) {
render(writer, null);
}
/**
* Render this channel as XML conforming to the RSS 0.91 specification,
* to the specified writer, indicating the specified character encoding.
*
* @param writer The writer to render output to
* @param encoding The character encoding to declare, or null
* for no declaration
*/
public void render(PrintWriter writer, String encoding) {
writer.print("");
writer.println();
writer.println("");
writer.println();
writer.println("parse() (an instance of
* org.apache.commons.digester.rss.Channel)
* knows how to render itself in XML format via the render()
* method. See the test main() method below for an
* example of using these classes.Channel
* implementation class.
*/
protected String channelClass = "org.apache.commons.digester.rss.Channel";
public String getChannelClass() {
return (this.channelClass);
}
public void setChannelClass(String channelClass) {
this.channelClass = channelClass;
}
/**
* The fully qualified class name of the Image
* implementation class.
*/
protected String imageClass = "org.apache.commons.digester.rss.Image";
public String getImageClass() {
return (this.imageClass);
}
public void setImageClass(String imageClass) {
this.imageClass = imageClass;
}
/**
* The fully qualified class name of the Item
* implementation class.
*/
protected String itemClass = "org.apache.commons.digester.rss.Item";
public String getItemClass() {
return (this.itemClass);
}
public void setItemClass(String itemClass) {
this.itemClass = itemClass;
}
/**
* The fully qualified class name of the TextInput
* implementation class.
*/
protected String textInputClass =
"org.apache.commons.digester.rss.TextInput";
public String getTextInputClass() {
return (this.textInputClass);
}
public void setTextInputClass(String textInputClass) {
this.textInputClass = textInputClass;
}
// --------------------------------------------------------- Public Methods
/**
* Parse the content of the specified file using this Digester. Returns
* the root element from the object stack (which will be the Channel).
*
* @param file File containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*/
public Object parse(File file) throws IOException, SAXException {
configure();
return (super.parse(file));
}
/**
* Parse the content of the specified input source using this Digester.
* Returns the root element from the object stack (which will be the
* Channel).
*
* @param input Input source containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*/
public Object parse(InputSource input) throws IOException, SAXException {
configure();
return (super.parse(input));
}
/**
* Parse the content of the specified input stream using this Digester.
* Returns the root element from the object stack (which will be
* the Channel).
*
* @param input Input stream containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*/
public Object parse(InputStream input) throws IOException, SAXException {
configure();
return (super.parse(input));
}
/**
* Parse the content of the specified URI using this Digester.
* Returns the root element from the object stack (which will be
* the Channel).
*
* @param uri URI containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*/
public Object parse(String uri) throws IOException, SAXException {
configure();
return (super.parse(uri));
}
// -------------------------------------------------------- Package Methods
// ------------------------------------------------------ Protected Methods
/**
* Configure the parsing rules that will be used to process RSS input.
*/
protected void configure() {
if (configured) {
return;
}
// Register local copies of the DTDs we understand
for (int i = 0; i < registrations.length; i += 2) {
URL url = this.getClass().getResource(registrations[i + 1]);
if (url != null) {
register(registrations[i], url.toString());
}
}
// FIXME - validate the "version" attribute of the rss element?
// Add the rules for the Channel object
addObjectCreate("rss/channel", channelClass);
addCallMethod("rss/channel/copyright", "setCopyright", 0);
addCallMethod("rss/channel/description", "setDescription", 0);
addCallMethod("rss/channel/docs", "setDocs", 0);
addCallMethod("rss/channel/language", "setLanguage", 0);
addCallMethod("rss/channel/lastBuildDate", "setLastBuildDate", 0);
addCallMethod("rss/channel/link", "setLink", 0);
addCallMethod("rss/channel/managingEditor", "setManagingEditor", 0);
addCallMethod("rss/channel/pubDate", "setPubDate", 0);
addCallMethod("rss/channel/rating", "setRating", 0);
addCallMethod("rss/channel/skipDays/day", "addSkipDay", 0);
addCallMethod("rss/channel/skipHours/hour", "addSkipHour", 0);
addCallMethod("rss/channel/title", "setTitle", 0);
addCallMethod("rss/channel/webMaster", "setWebMaster", 0);
// Add the rules for the Image object
addObjectCreate("rss/channel/image", imageClass);
addSetNext("rss/channel/image", "setImage",
"org.apache.commons.digester.rss.Image");
addCallMethod("rss/channel/image/description", "setDescription", 0);
addCallMethod("rss/channel/image/height", "setHeight", 0,
new Class[]{ Integer.TYPE });
addCallMethod("rss/channel/image/link", "setLink", 0);
addCallMethod("rss/channel/image/title", "setTitle", 0);
addCallMethod("rss/channel/image/url", "setURL", 0);
addCallMethod("rss/channel/image/width", "setWidth", 0,
new Class[]{ Integer.TYPE });
// Add the rules for the Item object
addObjectCreate("rss/channel/item", itemClass);
addSetNext("rss/channel/item", "addItem",
"org.apache.commons.digester.rss.Item");
addCallMethod("rss/channel/item/description", "setDescription", 0);
addCallMethod("rss/channel/item/link", "setLink", 0);
addCallMethod("rss/channel/item/title", "setTitle", 0);
// Add the rules for the TextInput object
addObjectCreate("rss/channel/textinput", textInputClass);
addSetNext("rss/channel/textinput", "setTextInput",
"org.apache.commons.digester.rss.TextInput");
addCallMethod("rss/channel/textinput/description",
"setDescription", 0);
addCallMethod("rss/channel/textinput/link", "setLink", 0);
addCallMethod("rss/channel/textinput/name", "setName", 0);
addCallMethod("rss/channel/textinput/title", "setTitle", 0);
// Mark this digester as having been configured
configured = true;
}
// ------------------------------------------------------ Test Main Program
/**
* Test main program that parses the channel description included in this
* package as a static resource.
*
* @param args The command line arguments (ignored)
*/
public static void main(String args[]) {
try {
System.out.println("RSSDigester Test Program");
System.out.println("Opening input stream ...");
InputStream is = RSSDigester.class.getResourceAsStream
("/org/apache/commons/digester/rss/rss-example.xml");
System.out.println("Creating new digester ...");
RSSDigester digester = new RSSDigester();
if ((args.length > 0) && (args[0].equals("-debug"))) {
digester.setLogger(LogFactory.getLog("RSSDigester"));
}
System.out.println("Parsing input stream ...");
Channel channel = (Channel) digester.parse(is);
System.out.println("Closing input stream ...");
is.close();
System.out.println("Dumping channel info ...");
channel.render(System.out);
} catch (Exception e) {
System.out.println("-->Exception");
e.printStackTrace(System.out);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/org/apache/commons/digester/rss/package.html libcommons-digester-java-1.8.1.orig/src/examples/rss/src/java/org/apache/commons/digester/rss/packag0000644 0001750 0001750 00000002064 11226450007 033477 0 ustar twerner twerner
java Pipeline config-file-name.
* org.apache.commons.digester
package for more information.java.lang.Boolean
* for a boolean parameter)
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #SetTopRule(String methodName, String paramType)} instead.
*/
public SetTopRule(Digester digester, String methodName,
String paramType) {
this(methodName, paramType);
}
/**
* Construct a "set parent" rule with the specified method name. The
* "set parent" method's argument type is assumed to be the class of the
* parent object.
*
* @param methodName Method name of the "set parent" method to call
*/
public SetTopRule(String methodName) {
this(methodName, null);
}
/**
* Construct a "set parent" rule with the specified method name.
*
* @param methodName Method name of the "set parent" method to call
* @param paramType Java class of the "set parent" method's argument
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
*/
public SetTopRule(String methodName,
String paramType) {
this.methodName = methodName;
this.paramType = paramType;
}
// ----------------------------------------------------- Instance Variables
/**
* The method name to call on the child object.
*/
protected String methodName = null;
/**
* The Java class name of the parameter type expected by the method.
*/
protected String paramType = null;
/**
* Should we use exact matching. Default is no.
*/
protected boolean useExactMatch = false;
// --------------------------------------------------------- Public Methods
/**
* org.apache.commons.beanutils.MethodUtils
* to introspect the relevent objects so that the right method can be called.
* Originally, MethodUtils.invokeExactMethod was used.
* This matches methods very strictly
* and so may not find a matching method when one exists.
* This is still the behaviour when exact matching is enabled.MethodUtils.invokeMethod is used.
* This method finds more methods but is less precise when there are several methods
* with correct signatures.
* So, if you want to choose an exact signature you might need to enable this property.CallMethodRule.
*
* Rule).
* See {@link PathCallParamRule}
*
Note that if the element is empty the an empty string is * passed to the target method, not null. And if automatic type conversion * is being applied (ie if the target function takes something other than * a string as a parameter) then the conversion will fail if the converter * class does not accept an empty string as valid input.
* * @param digester The associated Digester * @param paramIndex The zero-relative parameter number * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #CallParamRule(int paramIndex)} instead. */ public CallParamRule(Digester digester, int paramIndex) { this(paramIndex); } /** * Construct a "call parameter" rule that will save the value of the * specified attribute as the parameter value. * * @param digester The associated Digester * @param paramIndex The zero-relative parameter number * @param attributeName The name of the attribute to save * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #CallParamRule(int paramIndex, String attributeName)} instead. */ public CallParamRule(Digester digester, int paramIndex, String attributeName) { this(paramIndex, attributeName); } /** * Construct a "call parameter" rule that will save the body text of this * element as the parameter value. * *Note that if the element is empty the an empty string is * passed to the target method, not null. And if automatic type conversion * is being applied (ie if the target function takes something other than * a string as a parameter) then the conversion will fail if the converter * class does not accept an empty string as valid input.
* * @param paramIndex The zero-relative parameter number */ public CallParamRule(int paramIndex) { this(paramIndex, null); } /** * Construct a "call parameter" rule that will save the value of the * specified attribute as the parameter value. * * @param paramIndex The zero-relative parameter number * @param attributeName The name of the attribute to save */ public CallParamRule(int paramIndex, String attributeName) { this.paramIndex = paramIndex; this.attributeName = attributeName; } /** * Construct a "call parameter" rule. * * @param paramIndex The zero-relative parameter number * @param fromStack should this parameter be taken from the top of the stack? */ public CallParamRule(int paramIndex, boolean fromStack) { this.paramIndex = paramIndex; this.fromStack = fromStack; } /** * Constructs a "call parameter" rule which sets a parameter from the stack. * If the stack contains too few objects, then the parameter will be set to null. * * @param paramIndex The zero-relative parameter number * @param stackIndex the index of the object which will be passed as a parameter. * The zeroth object is the top of the stack, 1 is the next object down and so on. */ public CallParamRule(int paramIndex, int stackIndex) { this.paramIndex = paramIndex; this.fromStack = true; this.stackIndex = stackIndex; } // ----------------------------------------------------- Instance Variables /** * The attribute from which to save the parameter value */ protected String attributeName = null; /** * The zero-relative index of the parameter we are saving. */ protected int paramIndex = 0; /** * Is the parameter to be set from the stack? */ protected boolean fromStack = false; /** * The position of the object from the top of the stack */ protected int stackIndex = 0; /** * Stack is used to allow nested body text to be processed. * Lazy creation. */ protected ArrayStack bodyTextStack; // --------------------------------------------------------- Public Methods /** * Process the start of this element. * * @param attributes The attribute list for this element */ public void begin(Attributes attributes) throws Exception { Object param = null; if (attributeName != null) { param = attributes.getValue(attributeName); } else if(fromStack) { param = digester.peek(stackIndex); if (digester.log.isDebugEnabled()) { StringBuffer sb = new StringBuffer("[CallParamRule]{"); sb.append(digester.match); sb.append("} Save from stack; from stack?").append(fromStack); sb.append("; object=").append(param); digester.log.debug(sb.toString()); } } // Have to save the param object to the param stack frame here. // Can't wait until end(). Otherwise, the object will be lost. // We can't save the object as instance variables, as // the instance variables will be overwritten // if this CallParamRule is reused in subsequent nesting. if(param != null) { Object parameters[] = (Object[]) digester.peekParams(); parameters[paramIndex] = param; } } /** * Process the body text of this element. * * @param bodyText The body text of this element */ public void body(String bodyText) throws Exception { if (attributeName == null && !fromStack) { // We must wait to set the parameter until end // so that we can make sure that the right set of parameters // is at the top of the stack if (bodyTextStack == null) { bodyTextStack = new ArrayStack(); } bodyTextStack.push(bodyText.trim()); } } /** * Process any body texts now. */ public void end(String namespace, String name) { if (bodyTextStack != null && !bodyTextStack.empty()) { // what we do now is push one parameter onto the top set of parameters Object parameters[] = (Object[]) digester.peekParams(); parameters[paramIndex] = bodyTextStack.pop(); } } /** * Render a printable version of this Rule. */ public String toString() { StringBuffer sb = new StringBuffer("CallParamRule["); sb.append("paramIndex="); sb.append(paramIndex); sb.append(", attributeName="); sb.append(attributeName); sb.append(", from stack="); sb.append(fromStack); sb.append("]"); return (sb.toString()); } } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/StackAction.java 0000644 0001750 0001750 00000006427 11226450007 031360 0 ustar twerner twerner /* $Id: StackAction.java 476205 2006-11-17 16:43:10Z dennisl $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester; /** * An interface that can be implemented in order to get notifications of * objects being pushed onto a digester stack or popped from one. ** Because objects are pushed onto the main object stack when a rule * has created a new object, this gives the ability to intercept such * operations and perform modifications on created objects. *
* One use expected for this interface is to store information about the xml * line that a particular object was created from. An implementation of this * interface can detect whenever an object is pushed onto the digester object * stack, call Digester.getDocumentLocator() to get the location within the * current xml file, and store this either on the object on the stack (if it * supports some user-specific interface for this purpose), or build a map of * (object->locationinfo) separately. *
* It is recommended that objects implementing this interface provide * a method to set a "next" action, and invoke it from the callback * methods. This allows multiple actions to be "chained" together. *
* See also Digester.setStackAction. * * @since 1.8 */ public interface StackAction { /** * Invoked just before an object is to be pushed onto a digester stack. * * @param d is the digester instance. * * @param stackName is the name of the stack onto which the object * has been pushed. Null is passed to indicate the default stack. * * @param o is the object that has just been pushed. Calling peek on the * specified stack will return the same object. * * @return the object to be pushed. Normally, parameter o is returned * but this method could return an alternate object to be pushed * instead (eg a proxy for the provided object). */ public Object onPush(Digester d, String stackName, Object o); /** * Invoked just after an object has been popped from a digester stack. * * @param d is the digester instance. * * @param stackName is the name of the stack from which the object * has been popped. Null is passed to indicate the default stack. * * @param o is the object that has just been popped. * * @return the object to be returned to the called. Normally, parameter * o is returned but this method could return an alternate object. */ public Object onPop(Digester d, String stackName, Object o); } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/ 0000755 0001750 0001750 00000000000 11226450007 031055 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/package.html 0000644 0001750 0001750 00000004336 11226450007 033344 0 ustar twerner twerner
The class org.apache.commons.digester.Substitutor defines an abstract interface for mechanisms which manipulate xml attributes and body text. The Digester method setSubstitutor can be used to define a concrete substitutor that will be applied to the data before it is passed to the matching rules.
This package provides some useful concrete implementations of the abstract Substitutor class. In particular, it provides an implementation that allows the application to define "variables" which the input data can reference using a syntax such as "${user.name}".
Here's an example of setting up the VariableSubstitutor:
// set up the variables the input xml can reference
Map vars = new HashMap();
vars.put("user.name", "me");
vars.put("os", "Linux");
// map ${varname} to the entries in the var map
MultiVariableExpander expander = new MultiVariableExpander();
expander.addSource("$", vars);
// allow expansion in both xml attributes and element text
Substitutor substitutor = new VariableSubstitutor(expander);
Digester digester = new Digester();
digester.setSubstitutor(substitutor);
././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011567 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/VariableAttributes.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/VariableAttrib0000644 0001750 0001750 00000010215 11226450007 033672 0 ustar twerner twerner /* $Id: VariableAttributes.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.substitution;
import org.xml.sax.Attributes;
import java.util.ArrayList;
/**
* Wrapper for an org.xml.sax.Attributes object which expands any * "variables" referenced in the attribute value via ${foo} or similar. * This is only done when something actually asks for the attribute value, * thereby imposing no performance penalty if the attribute is not used.
* * @since 1.6 */ public class VariableAttributes implements Attributes { // list of mapped attributes. private ArrayList values = new ArrayList(10); private Attributes attrs; private VariableExpander expander; // ------------------- Public Methods /** * Specify which attributes class this object is a proxy for. */ public void init(Attributes attrs, VariableExpander expander) { this.attrs = attrs; this.expander = expander; // I hope this doesn't release the memory for this array; for // efficiency, this should just mark the array as being size 0. values.clear(); } public String getValue(int index) { if (index >= values.size()) { // Expand the values array with null elements, so the later // call to set(index, s) works ok. // // Unfortunately, there is no easy way to set the size of // an arraylist; we must repeatedly add null elements to it.. values.ensureCapacity(index+1); for(int i = values.size(); i<= index; ++i) { values.add(null); } } String s = (String) values.get(index); if (s == null) { // we have never been asked for this value before. // get the real attribute value and perform substitution // on it. s = attrs.getValue(index); if (s != null) { s = expander.expand(s); values.set(index, s); } } return s; } public String getValue(String qname) { int index = attrs.getIndex(qname); if (index == -1) { return null; } return getValue(index); } public String getValue(String uri, String localname) { int index = attrs.getIndex(uri, localname); if (index == -1) { return null; } return getValue(index); } // plain proxy methods follow : nothing interesting :-) public int getIndex(String qname) { return attrs.getIndex(qname); } public int getIndex(String uri, String localpart) { return attrs.getIndex(uri, localpart); } public int getLength() { return attrs.getLength(); } public String getLocalName(int index) { return attrs.getLocalName(index); } public String getQName(int index) { return attrs.getQName(index); } public String getType(int index) { return attrs.getType(index); } public String getType(String qname) { return attrs.getType(qname); } public String getType(String uri, String localname) { return attrs.getType(uri, localname); } public String getURI(int index) { return attrs.getURI(index); } } ././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/VariableExpander.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/VariableExpand0000644 0001750 0001750 00000002740 11226450007 033670 0 ustar twerner twerner /* $Id: VariableExpander.java 471661 2006-11-06 08:09:25Z skitching $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester.substitution; /** *An Interface describing a class capable of expanding strings which * may contain variable references. The exact syntax of the "reference", * and the mechanism for determining the corresponding value to be used * is up to the concrete implementation.
* * @since 1.6 */ public interface VariableExpander { /** * Return the input string with any variables replaced by their * corresponding value. If there are no variables in the string, * then the input parameter is returned unaltered. */ public String expand(String param); } ././@LongLink 0000000 0000000 0000000 00000000157 00000000000 011570 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/VariableSubstitutor.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/VariableSubsti0000644 0001750 0001750 00000007627 11226450007 033733 0 ustar twerner twerner /* $Id: VariableSubstitutor.java 471661 2006-11-06 08:09:25Z skitching $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester.substitution; import org.apache.commons.digester.Substitutor; import org.xml.sax.Attributes; /** * Substitutor implementation that support variable replacement * for both attributes and body text. * The actual expansion of variables into text is delegated to {@link VariableExpander} * implementations. * Supports setting an expander just for body text or just for attributes. * Also supported is setting no expanders for body text and for attributes. * * @since 1.6 */ public class VariableSubstitutor extends Substitutor { /** * The expander to be used to expand variables in the attributes. * Null when no expansion should be performed. */ private VariableExpander attributesExpander; /** * Attributes implementation that (lazily) performs variable substitution. * Will be lazily created when needed then reused. */ private VariableAttributes variableAttributes; /** * The expander to be used to expand variables in the body text. * Null when no expansion should be performed. */ private VariableExpander bodyTextExpander; /** * Constructs a Substitutor which uses the same VariableExpander for both * body text and attibutes. * @param expander VariableExpander implementation, * null if no substitutions are to be performed */ public VariableSubstitutor(VariableExpander expander) { this(expander, expander); } /** * Constructs a Substitutor. * @param attributesExpander VariableExpander implementation to be used for attributes, * null if no attribute substitutions are to be performed * @param bodyTextExpander VariableExpander implementation to be used for bodyTextExpander, * null if no attribute substitutions are to be performed */ public VariableSubstitutor(VariableExpander attributesExpander, VariableExpander bodyTextExpander) { this.attributesExpander = attributesExpander; this.bodyTextExpander = bodyTextExpander; variableAttributes = new VariableAttributes(); } /** * Substitutes the attributes (before they are passed to the *Rule implementations's)
*/
public Attributes substitute(Attributes attributes) {
Attributes results = attributes;
if (attributesExpander != null) {
variableAttributes.init(attributes, attributesExpander);
results = variableAttributes;
}
return results;
}
/**
* Substitutes for the body text.
* This method may substitute values into the body text of the
* elements that Digester parses.
*
* @param bodyText the body text (as passed to Digester)
* @return the body text to be passed to the Rule implementations
*/
public String substitute(String bodyText) {
String result = bodyText;
if (bodyTextExpander != null) {
result = bodyTextExpander.expand(bodyText);
}
return result;
}
}
././@LongLink 0000000 0000000 0000000 00000000161 00000000000 011563 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/MultiVariableExpander.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/substitution/MultiVariableE0000644 0001750 0001750 00000007450 11226450007 033653 0 ustar twerner twerner /* $Id: MultiVariableExpander.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.substitution;
import java.util.Map;
import java.util.ArrayList;
/**
* Expands variable references from multiple sources.
* * @since 1.6 */ public class MultiVariableExpander implements VariableExpander { private int nEntries = 0; private ArrayList markers = new ArrayList(2); private ArrayList sources = new ArrayList(2); public MultiVariableExpander() { } public void addSource(String marker, Map source) { ++nEntries; markers.add(marker); sources.add(source); } /* * Expands any variable declarations using any of the known * variable marker strings. * * @throws IllegalArgumentException if the input param references * a variable which is not known to the specified source. */ public String expand(String param) { for(int i=0; i* Returns the string after performing all substitutions. *
* If no substitutions were made, the input string object is * returned (not a copy). * * @throws IllegalArgumentException if the input param references * a variable which is not known to the specified source. */ public String expand(String str, String marker, Map source) { String startMark = marker + "{"; int markLen = startMark.length(); int index = 0; for(;;) { index = str.indexOf(startMark, index); if (index == -1) { return str; } int startIndex = index + markLen; if (startIndex > str.length()) { throw new IllegalArgumentException( "var expression starts at end of string"); } int endIndex = str.indexOf("}", index + markLen); if (endIndex == -1) { throw new IllegalArgumentException( "var expression starts but does not end"); } String key = str.substring(index+markLen, endIndex); Object value = source.get(key); if (value == null) { throw new IllegalArgumentException( "parameter [" + key + "] is not defined."); } String varValue = value.toString(); str = str.substring(0, index) + varValue + str.substring(endIndex+1); index += varValue.length(); } } } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/ExtendedBaseRules.java 0000644 0001750 0001750 00000044202 11226450007 032514 0 ustar twerner twerner /* $Id: ExtendedBaseRules.java 471661 2006-11-06 08:09:25Z skitching $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; /** *
Extension of {@link RulesBase} for complex schema.
* *This is an extension of the basic pattern matching scheme * intended to improve support for mapping complex xml-schema. * It is intended to be a minimal extension of the standard rules * big enough to support complex schema but without the full generality * offered by more exotic matching pattern rules.
* *When should you use this rather than the original?
* ** This pattern-matching engine is complex and slower than the basic * default RulesBase class, but offers more functionality: *
-
*
- Universal patterns allow patterns to be specified which will match * regardless of whether there are "better matching" patterns available. *
- Parent-match patterns (eg "a/b/?") allow matching for all direct * children of a specified element. *
- Ancestor-match patterns (eg "a/b/*") allow matching all elements * nested within a specified element to any nesting depth. *
- Completely-wild patterns ("*" or "!*") allow matching all elements. *
Universal Match Patterns
* *The default RulesBase pattern-matching engine always attempts to find * the "best matching pattern", and will ignore rules associated with other * patterns that match but are not "as good". As an example, if the pattern * "a/b/c" is associated with rules 1 and 2, and "*/c" is associated with * rules 3 and 4 then element "a/b/c" will cause only rules 1 and 2 to execute. * Rules 3 and 4 do have matching patterns, but because the patterns are shorter * and include wildcard characters they are regarded as being "not as good" as * a direct match. In general, exact patterns are better than wildcard patterns, * and among multiple patterns with wildcards, the longest is preferred. * See the RulesBase class for more information.
* *This feature of preferring "better" patterns can be a powerful tool. * However it also means that patterns can interact in unexpected ways.
* *When using the ExtendedBaseRules, any pattern prefixed with '!' bypasses * the "best match" feature. Even if there is an exact match or a longer * wildcard match, patterns prefixed by '!' will still be tested to see if * they match, and if so their associated Rule objects will be included in * the set of rules to be executed in the normal manner.
* *-
*
- Pattern
"!*/a/b"matches whenever an 'b' element * is inside an 'a'.
* - Pattern
"!a/b/?"matches any child of a parent * matching"a/b"(see "Parent Match Patterns").
* - Pattern
"!*/a/b/?"matches any child of a parent * matching"!*/a/b"(see "Parent Match Patterns").
* - Pattern
"!a/b/*"matches any element whose path * starts with "a" then "b" (see "Ancestor Match Patterns").
* - Pattern
"!*/a/b/*"matches any elements whose path * contains 'a/b' (see "Ancestor Match Patterns").
*
Parent Match Patterns
* ** These will match direct child elements of a particular parent element. *
-
*
-
*
"a/b/c/?"matches any child whose parent matches *"a/b/c". Exact parent rules take precedence over Ancestor * Match patterns. *
* -
*
"*/a/b/c/?"matches any child whose parent matches *"*/a/b/c". The longest matching still applies to parent * matches but the length excludes the '?', which effectively means * that standard wildcard matches with the same level of depth are * chosen in preference. *
*
Ancestor Match Patterns
* ** These will match elements whose parentage includes a particular sequence * of elements. *
-
*
-
*
"a/b/*"matches any element whose path starts with * 'a' then 'b'. Exact parent and parent match rules take precedence. * The longest ancestor match will take precedence. *
* -
*
"*/a/b/*"matches any elements whose path contains * an element 'a' followed by an element 'b'. The longest matching still * applies but the length excludes the '*' at the end. *
*
Completely Wild Patterns
* *Pattern "*" matches every pattern that isn't matched by
* any other basic rule.
Pattern "!*" matches every pattern.
Using The Extended Rules
* *By default, a Digester instance uses a {@link RulesBase} instance as * its pattern matching engine. To use an ExtendedBaseRules instance, call * the Digester.setRules method before adding any Rule objects to the digester * instance: *
* Digester digester = new Digester(); * digester.setRules( new ExtendedBaseRules() ); ** *
The most important thing to remember when using the extended rules is * that universal and non-universal patterns are completely independent. * Universal patterns are never affected by the addition of new patterns * or the removal of existing ones. Non-universal patterns are never affected * by the addition of new universal patterns or the removal of * existing universal patterns. As in the basic matching rules, * non-universal (basic) patterns can be affected by the * addition of new non-universal patterns or the removal of existing * non-universal patterns, because only rules associated with the * "best matching" pattern for each xml element are executed. * *
This means that you can use universal patterns to build up the simple * parts of your structure - for example defining universal creation and * property setting rules. More sophisticated and complex mapping will require * non-universal patterns and this might mean that some of the universal rules * will need to be replaced by a series of special cases using non-universal * rules. But by using universal rules as your backbone, these additions * should not break your existing rules.
*/ public class ExtendedBaseRules extends RulesBase { // ----------------------------------------------------- Instance Variables /** * Counts the entry number for the rules. */ private int counter = 0; /** * The decision algorithm used (unfortunately) doesn't preserve the entry * order. * This map is used by a comparator which orders the list of matches * before it's returned. * This map stores the entry number keyed by the rule. */ private Map order = new HashMap(); // --------------------------------------------------------- Public Methods /** * Register a new Rule instance matching the specified pattern. * * @param pattern Nesting pattern to be matched for this Rule * @param rule Rule instance to be registered */ public void add(String pattern, Rule rule) { super.add(pattern, rule); counter++; order.put(rule, new Integer(counter)); } /** * Return a List of all registered Rule instances that match the specified * nesting pattern, or a zero-length List if there are no matches. If more * than one Rule instance matches, they must be returned * in the order originally registered through theadd()
* method.
*
* @param pattern Nesting pattern to be matched
*/
public List match(String namespace, String pattern) {
// calculate the pattern of the parent
// (if the element has one)
String parentPattern = "";
int lastIndex = pattern.lastIndexOf('/');
boolean hasParent = true;
if (lastIndex == -1) {
// element has no parent
hasParent = false;
} else {
// calculate the pattern of the parent
parentPattern = pattern.substring(0, lastIndex);
}
// we keep the list of universal matches separate
List universalList = new ArrayList(counter);
// Universal all wildards ('!*')
// These are always matched so always add them
List tempList = (List) this.cache.get("!*");
if (tempList != null) {
universalList.addAll(tempList);
}
// Universal exact parent match
// need to get this now since only wildcards are considered later
tempList = (List) this.cache.get("!" + parentPattern + "/?");
if (tempList != null) {
universalList.addAll(tempList);
}
// base behaviour means that if we certain matches, we don't continue
// but we just have a single combined loop and so we have to set
// a variable
boolean ignoreBasicMatches = false;
// see if we have an exact basic pattern match
List rulesList = (List) this.cache.get(pattern);
if (rulesList != null) {
// we have a match!
// so ignore all basic matches from now on
ignoreBasicMatches = true;
} else {
// see if we have an exact child match
if (hasParent) {
// matching children takes preference
rulesList = (List) this.cache.get(parentPattern + "/?");
if (rulesList != null) {
// we have a match!
// so ignore all basic matches from now on
ignoreBasicMatches = true;
} else {
// we don't have a match yet - so try exact ancester
//
rulesList = findExactAncesterMatch(pattern);
if (rulesList != null) {
// we have a match!
// so ignore all basic matches from now on
ignoreBasicMatches = true;
}
}
}
}
// OK - we're ready for the big loop!
// Unlike the basic rules case,
// we have to go through for all those universal rules in all cases.
// Find the longest key, ie more discriminant
String longKey = "";
int longKeyLength = 0;
Iterator keys = this.cache.keySet().iterator();
while (keys.hasNext()) {
String key = (String) keys.next();
// find out if it's a univeral pattern
// set a flag
boolean isUniversal = key.startsWith("!");
if (isUniversal) {
// and find the underlying key
key = key.substring(1, key.length());
}
// don't need to check exact matches
boolean wildcardMatchStart = key.startsWith("*/");
boolean wildcardMatchEnd = key.endsWith("/*");
if (wildcardMatchStart || (isUniversal && wildcardMatchEnd)) {
boolean parentMatched = false;
boolean basicMatched = false;
boolean ancesterMatched = false;
boolean parentMatchEnd = key.endsWith("/?");
if (parentMatchEnd) {
// try for a parent match
parentMatched = parentMatch(key, pattern, parentPattern);
} else if (wildcardMatchEnd) {
// check for ancester match
if (wildcardMatchStart) {
String patternBody = key.substring(2, key.length() - 2);
if (pattern.endsWith(patternBody)) {
ancesterMatched = true;
} else {
ancesterMatched = (pattern.indexOf(patternBody + "/") > -1);
}
} else {
String bodyPattern = key.substring(0, key.length() - 2);
if (pattern.startsWith(bodyPattern))
{
if (pattern.length() == bodyPattern.length()) {
// exact match
ancesterMatched = true;
} else {
ancesterMatched = ( pattern.charAt(bodyPattern.length()) == '/' );
}
} else {
ancesterMatched = false;
}
}
} else {
// try for a base match
basicMatched = basicMatch(key, pattern);
}
if (parentMatched || basicMatched || ancesterMatched) {
if (isUniversal) {
// universal rules go straight in
// (no longest matching rule)
tempList = (List) this.cache.get("!" + key);
if (tempList != null) {
universalList.addAll(tempList);
}
} else {
if (!ignoreBasicMatches) {
// ensure that all parent matches are SHORTER
// than rules with same level of matching.
//
// the calculations below don't work for universal
// matching, but we don't care because in that case
// this if-stmt is not entered.
int keyLength = key.length();
if (wildcardMatchStart) {
--keyLength;
}
if (wildcardMatchEnd) {
--keyLength;
} else if (parentMatchEnd) {
--keyLength;
}
if (keyLength > longKeyLength) {
rulesList = (List) this.cache.get(key);
longKey = key;
longKeyLength = keyLength;
}
}
}
}
}
}
// '*' works in practice as a default matching
// (this is because anything is a deeper match!)
if (rulesList == null) {
rulesList = (List) this.cache.get("*");
}
// if we've matched a basic pattern, then add to the universal list
if (rulesList != null) {
universalList.addAll(rulesList);
}
// don't filter if namespace is null
if (namespace != null) {
// remove invalid namespaces
Iterator it = universalList.iterator();
while (it.hasNext()) {
Rule rule = (Rule) it.next();
String ns_uri = rule.getNamespaceURI();
if (ns_uri != null && !ns_uri.equals(namespace)) {
it.remove();
}
}
}
// need to make sure that the collection is sort in the order
// of addition. We use a custom comparator for this
Collections.sort(
universalList,
new Comparator() {
public int compare(Object o1, Object o2) throws ClassCastException {
// Get the entry order from the map
Integer i1 = (Integer) order.get(o1);
Integer i2 = (Integer) order.get(o2);
// and use that to perform the comparison
if (i1 == null) {
if (i2 == null) {
return 0;
} else {
return -1;
}
} else if (i2 == null) {
return 1;
}
return (i1.intValue() - i2.intValue());
}
});
return universalList;
}
/**
* Matching parent.
*/
private boolean parentMatch(String key, String pattern, String parentPattern) {
return parentPattern.endsWith(key.substring(1, key.length() - 2));
}
/**
* Standard match.
* Matches the end of the pattern to the key.
*/
private boolean basicMatch(String key, String pattern) {
return (pattern.equals(key.substring(2)) ||
pattern.endsWith(key.substring(1)));
}
/**
* Finds an exact ancester match for given pattern
*/
private List findExactAncesterMatch(String parentPattern) {
List matchingRules = null;
int lastIndex = parentPattern.length();
while (lastIndex-- > 0) {
lastIndex = parentPattern.lastIndexOf('/', lastIndex);
if (lastIndex > 0) {
matchingRules = (List) this.cache.get(parentPattern.substring(0, lastIndex) + "/*");
if (matchingRules != null) {
return matchingRules;
}
}
}
return null;
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/RulesBase.java 0000644 0001750 0001750 00000022302 11226450007 031030 0 ustar twerner twerner /* $Id: RulesBase.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
/**
* Default implementation of the Rules interface that supports
* the standard rule matching behavior. This class can also be used as a
* base class for specialized Rules implementations.
The matching policies implemented by this class support two different * types of pattern matching rules:
*-
*
- Exact Match - A pattern "a/b/c" exactly matches a
*
<c>element, nested inside a<b>* element, which is nested inside an<a>element.
* - Tail Match - A pattern "*/a/b" matches a
*
<b>element, nested inside an<a>* element, no matter how deeply the pair is nested.
*
Note that wildcard patterns are ignored if an explicit match can be found * (and when multiple wildcard patterns match, only the longest, ie most * explicit, pattern is considered a match).
* *See the package documentation for package org.apache.commons.digester * for more information.
*/ public class RulesBase implements Rules { // ----------------------------------------------------- Instance Variables /** * The set of registered Rule instances, keyed by the matching pattern. * Each value is a List containing the Rules for that pattern, in the * order that they were orginally registered. */ protected HashMap cache = new HashMap(); /** * The Digester instance with which this Rules instance is associated. */ protected Digester digester = null; /** * The namespace URI for which subsequently addedRule
* objects are relevant, or null for matching independent
* of namespaces.
*/
protected String namespaceURI = null;
/**
* The set of registered Rule instances, in the order that they were
* originally registered.
*/
protected ArrayList rules = new ArrayList();
// ------------------------------------------------------------- Properties
/**
* Return the Digester instance with which this Rules instance is
* associated.
*/
public Digester getDigester() {
return (this.digester);
}
/**
* Set the Digester instance with which this Rules instance is associated.
*
* @param digester The newly associated Digester instance
*/
public void setDigester(Digester digester) {
this.digester = digester;
Iterator items = rules.iterator();
while (items.hasNext()) {
Rule item = (Rule) items.next();
item.setDigester(digester);
}
}
/**
* Return the namespace URI that will be applied to all subsequently
* added Rule objects.
*/
public String getNamespaceURI() {
return (this.namespaceURI);
}
/**
* Set the namespace URI that will be applied to all subsequently
* added Rule objects.
*
* @param namespaceURI Namespace URI that must match on all
* subsequently added rules, or null for matching
* regardless of the current namespace URI
*/
public void setNamespaceURI(String namespaceURI) {
this.namespaceURI = namespaceURI;
}
// --------------------------------------------------------- Public Methods
/**
* Register a new Rule instance matching the specified pattern.
*
* @param pattern Nesting pattern to be matched for this Rule
* @param rule Rule instance to be registered
*/
public void add(String pattern, Rule rule) {
// to help users who accidently add '/' to the end of their patterns
int patternLength = pattern.length();
if (patternLength>1 && pattern.endsWith("/")) {
pattern = pattern.substring(0, patternLength-1);
}
List list = (List) cache.get(pattern);
if (list == null) {
list = new ArrayList();
cache.put(pattern, list);
}
list.add(rule);
rules.add(rule);
if (this.digester != null) {
rule.setDigester(this.digester);
}
if (this.namespaceURI != null) {
rule.setNamespaceURI(this.namespaceURI);
}
}
/**
* Clear all existing Rule instance registrations.
*/
public void clear() {
cache.clear();
rules.clear();
}
/**
* Return a List of all registered Rule instances that match the specified
* nesting pattern, or a zero-length List if there are no matches. If more
* than one Rule instance matches, they must be returned
* in the order originally registered through the add()
* method.
*
* @param pattern Nesting pattern to be matched
*
* @deprecated Call match(namespaceURI,pattern) instead.
*/
public List match(String pattern) {
return (match(null, pattern));
}
/**
* Return a List of all registered Rule instances that match the specified
* nesting pattern, or a zero-length List if there are no matches. If more
* than one Rule instance matches, they must be returned
* in the order originally registered through the add()
* method.
*
* @param namespaceURI Namespace URI for which to select matching rules,
* or null to match regardless of namespace URI
* @param pattern Nesting pattern to be matched
*/
public List match(String namespaceURI, String pattern) {
// List rulesList = (List) this.cache.get(pattern);
List rulesList = lookup(namespaceURI, pattern);
if ((rulesList == null) || (rulesList.size() < 1)) {
// Find the longest key, ie more discriminant
String longKey = "";
Iterator keys = this.cache.keySet().iterator();
while (keys.hasNext()) {
String key = (String) keys.next();
if (key.startsWith("*/")) {
if (pattern.equals(key.substring(2)) ||
pattern.endsWith(key.substring(1))) {
if (key.length() > longKey.length()) {
// rulesList = (List) this.cache.get(key);
rulesList = lookup(namespaceURI, key);
longKey = key;
}
}
}
}
}
if (rulesList == null) {
rulesList = new ArrayList();
}
return (rulesList);
}
/**
* Return a List of all registered Rule instances, or a zero-length List
* if there are no registered Rule instances. If more than one Rule
* instance has been registered, they must be returned
* in the order originally registered through the add()
* method.
*/
public List rules() {
return (this.rules);
}
// ------------------------------------------------------ Protected Methods
/**
* Return a List of Rule instances for the specified pattern that also
* match the specified namespace URI (if any). If there are no such
* rules, return null.
*
* @param namespaceURI Namespace URI to match, or null to
* select matching rules regardless of namespace URI
* @param pattern Pattern to be matched
*/
protected List lookup(String namespaceURI, String pattern) {
// Optimize when no namespace URI is specified
List list = (List) this.cache.get(pattern);
if (list == null) {
return (null);
}
if ((namespaceURI == null) || (namespaceURI.length() == 0)) {
return (list);
}
// Select only Rules that match on the specified namespace URI
ArrayList results = new ArrayList();
Iterator items = list.iterator();
while (items.hasNext()) {
Rule item = (Rule) items.next();
if ((namespaceURI.equals(item.getNamespaceURI())) ||
(item.getNamespaceURI() == null)) {
results.add(item);
}
}
return (results);
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/WithDefaultsRulesWrapper.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/WithDefaultsRulesWrapper.ja0000644 0001750 0001750 00000012660 11226450007 033601 0 ustar twerner twerner /* $Id: WithDefaultsRulesWrapper.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Rules Decorator that returns default rules
* when no matches are returned by the wrapped implementation.
This allows default Rule instances to be added to any
* existing Rules implementation. These default Rule
* instances will be returned for any match for which the wrapped
* implementation does not return any matches.
For example, *
* Rule alpha; * ... * WithDefaultsRulesWrapper rules = new WithDefaultsRulesWrapper(new BaseRules()); * rules.addDefault(alpha); * ... * digester.setRules(rules); * ... ** when a pattern does not match any other rule, then rule alpha will be called. * *
WithDefaultsRulesWrapper follows the Decorator pattern.
Rules implementation, not null
* @throws IllegalArgumentException when wrappedRules is null
*/
public WithDefaultsRulesWrapper(Rules wrappedRules) {
if (wrappedRules == null) {
throw new IllegalArgumentException("Wrapped rules must not be null");
}
this.wrappedRules = wrappedRules;
}
// --------------------------------------------------------- Properties
/** Gets digester using these Rules */
public Digester getDigester() {
return wrappedRules.getDigester();
}
/** Sets digeseter using these Rules */
public void setDigester(Digester digester) {
wrappedRules.setDigester(digester);
Iterator it = defaultRules.iterator();
while (it.hasNext()) {
Rule rule = (Rule) it.next();
rule.setDigester(digester);
}
}
/** Gets namespace to apply to Rule's added */
public String getNamespaceURI() {
return wrappedRules.getNamespaceURI();
}
/** Sets namespace to apply to Rule's added subsequently */
public void setNamespaceURI(String namespaceURI) {
wrappedRules.setNamespaceURI(namespaceURI);
}
/** Gets Rule's which will be fired when the wrapped implementation returns no matches */
public List getDefaults() {
return defaultRules;
}
// --------------------------------------------------------- Public Methods
public List match(String pattern) {
return match("", pattern);
}
/**
* Return list of rules matching given pattern.
* If wrapped implementation returns any matches return those.
* Otherwise, return default matches.
*/
public List match(String namespaceURI, String pattern) {
List matches = wrappedRules.match(namespaceURI, pattern);
if (matches == null || matches.isEmpty()) {
// a little bit of defensive programming
return new ArrayList(defaultRules);
}
// otherwise
return matches;
}
/** Adds a rule to be fired when wrapped implementation returns no matches */
public void addDefault(Rule rule) {
// set up rule
if (wrappedRules.getDigester() != null) {
rule.setDigester(wrappedRules.getDigester());
}
if (wrappedRules.getNamespaceURI() != null) {
rule.setNamespaceURI(wrappedRules.getNamespaceURI());
}
defaultRules.add(rule);
allRules.add(rule);
}
/** Gets all rules */
public List rules() {
return allRules;
}
/** Clears all Rule's */
public void clear() {
wrappedRules.clear();
allRules.clear();
defaultRules.clear();
}
/**
* Adds a Rule to be fired on given pattern.
* Pattern matching is delegated to wrapped implementation.
*/
public void add(String pattern, Rule rule) {
wrappedRules.add(pattern, rule);
allRules.add(rule);
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/SetNextRule.java 0000644 0001750 0001750 00000017303 11226450007 031372 0 ustar twerner twerner /* $Id: SetNextRule.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import org.apache.commons.beanutils.MethodUtils;
/**
* Rule implementation that calls a method on the (top-1) (parent) * object, passing the top object (child) as an argument. It is * commonly used to establish parent-child relationships.
* *This rule now supports more flexible method matching by default. * It is possible that this may break (some) code * written against release 1.1.1 or earlier. * See {@link #isExactMatch()} for more details.
* *Note that while CallMethodRule uses commons-beanutils' data-conversion * functionality (ConvertUtils class) to convert parameter values into * the appropriate type for the parameter to the called method, this * rule does not. Needing to use ConvertUtils functionality when building * parent-child relationships is expected to be very rare; however if you * do need this then instead of using this rule, create a CallMethodRule * specifying targetOffset of 1 in the constructor.
*/ public class SetNextRule extends Rule { // ----------------------------------------------------------- Constructors /** * Construct a "set next" rule with the specified method name. The * method's argument type is assumed to be the class of the * child object. * * @param digester The associated Digester * @param methodName Method name of the parent method to call * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #SetNextRule(String methodName)} instead. */ public SetNextRule(Digester digester, String methodName) { this(methodName); } /** * Construct a "set next" rule with the specified method name. * * @param digester The associated Digester * @param methodName Method name of the parent method to call * @param paramType Java class of the parent method's argument * (if you wish to use a primitive type, specify the corresonding * Java wrapper class instead, such asjava.lang.Boolean
* for a boolean parameter)
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #SetNextRule(String methodName,String paramType)} instead.
*/
public SetNextRule(Digester digester, String methodName,
String paramType) {
this(methodName, paramType);
}
/**
* Construct a "set next" rule with the specified method name. The
* method's argument type is assumed to be the class of the
* child object.
*
* @param methodName Method name of the parent method to call
*/
public SetNextRule(String methodName) {
this(methodName, null);
}
/**
* Construct a "set next" rule with the specified method name.
*
* @param methodName Method name of the parent method to call
* @param paramType Java class of the parent method's argument
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
*/
public SetNextRule(String methodName,
String paramType) {
this.methodName = methodName;
this.paramType = paramType;
}
// ----------------------------------------------------- Instance Variables
/**
* The method name to call on the parent object.
*/
protected String methodName = null;
/**
* The Java class name of the parameter type expected by the method.
*/
protected String paramType = null;
/**
* Should we use exact matching. Default is no.
*/
protected boolean useExactMatch = false;
// --------------------------------------------------------- Public Methods
/**
* Is exact matching being used.
* *This rule uses org.apache.commons.beanutils.MethodUtils
* to introspect the relevent objects so that the right method can be called.
* Originally, MethodUtils.invokeExactMethod was used.
* This matches methods very strictly
* and so may not find a matching method when one exists.
* This is still the behaviour when exact matching is enabled.
When exact matching is disabled, MethodUtils.invokeMethod is used.
* This method finds more methods but is less precise when there are several methods
* with correct signatures.
* So, if you want to choose an exact signature you might need to enable this property.
The default setting is to disable exact matches.
* * @return true iff exact matching is enabled * @since Digester Release 1.1.1 */ public boolean isExactMatch() { return useExactMatch; } /** *Set whether exact matching is enabled.
* *See {@link #isExactMatch()}.
* * @param useExactMatch should this rule use exact method matching * @since Digester Release 1.1.1 */ public void setExactMatch(boolean useExactMatch) { this.useExactMatch = useExactMatch; } /** * Process the end of this element. */ public void end() throws Exception { // Identify the objects to be used Object child = digester.peek(0); Object parent = digester.peek(1); if (digester.log.isDebugEnabled()) { if (parent == null) { digester.log.debug("[SetNextRule]{" + digester.match + "} Call [NULL PARENT]." + methodName + "(" + child + ")"); } else { digester.log.debug("[SetNextRule]{" + digester.match + "} Call " + parent.getClass().getName() + "." + methodName + "(" + child + ")"); } } // Call the specified method Class paramTypes[] = new Class[1]; if (paramType != null) { paramTypes[0] = digester.getClassLoader().loadClass(paramType); } else { paramTypes[0] = child.getClass(); } if (useExactMatch) { MethodUtils.invokeExactMethod(parent, methodName, new Object[]{ child }, paramTypes); } else { MethodUtils.invokeMethod(parent, methodName, new Object[]{ child }, paramTypes); } } /** * Render a printable version of this Rule. */ public String toString() { StringBuffer sb = new StringBuffer("SetNextRule["); sb.append("methodName="); sb.append(methodName); sb.append(", paramType="); sb.append(paramType); sb.append("]"); return (sb.toString()); } } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/SetRootRule.java 0000644 0001750 0001750 00000016330 11226450007 031376 0 ustar twerner twerner /* $Id: SetRootRule.java 471661 2006-11-06 08:09:25Z skitching $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester; import org.apache.commons.beanutils.MethodUtils; /** *Rule implementation that calls a method on the root object on the stack,
* passing the top object (child) as an argument.
* It is important to remember that this rule acts on end.
This rule now supports more flexible method matching by default. * It is possible that this may break (some) code * written against release 1.1.1 or earlier. * See {@link #isExactMatch()} for more details.
*/ public class SetRootRule extends Rule { // ----------------------------------------------------------- Constructors /** * Construct a "set root" rule with the specified method name. The * method's argument type is assumed to be the class of the * child object. * * @param digester The associated Digester * @param methodName Method name of the parent method to call * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #SetRootRule(String methodName)} instead. */ public SetRootRule(Digester digester, String methodName) { this(methodName); } /** * Construct a "set root" rule with the specified method name. * * @param digester The associated Digester * @param methodName Method name of the parent method to call * @param paramType Java class of the parent method's argument * (if you wish to use a primitive type, specify the corresonding * Java wrapper class instead, such asjava.lang.Boolean
* for a boolean parameter)
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #SetRootRule(String methodName,String paramType)} instead.
*/
public SetRootRule(Digester digester, String methodName,
String paramType) {
this(methodName, paramType);
}
/**
* Construct a "set root" rule with the specified method name. The
* method's argument type is assumed to be the class of the
* child object.
*
* @param methodName Method name of the parent method to call
*/
public SetRootRule(String methodName) {
this(methodName, null);
}
/**
* Construct a "set root" rule with the specified method name.
*
* @param methodName Method name of the parent method to call
* @param paramType Java class of the parent method's argument
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
*/
public SetRootRule(String methodName,
String paramType) {
this.methodName = methodName;
this.paramType = paramType;
}
// ----------------------------------------------------- Instance Variables
/**
* The method name to call on the parent object.
*/
protected String methodName = null;
/**
* The Java class name of the parameter type expected by the method.
*/
protected String paramType = null;
/**
* Should we use exact matching. Default is no.
*/
protected boolean useExactMatch = false;
// --------------------------------------------------------- Public Methods
/**
* Is exact matching being used.
* *This rule uses org.apache.commons.beanutils.MethodUtils
* to introspect the relevent objects so that the right method can be called.
* Originally, MethodUtils.invokeExactMethod was used.
* This matches methods very strictly
* and so may not find a matching method when one exists.
* This is still the behaviour when exact matching is enabled.
When exact matching is disabled, MethodUtils.invokeMethod is used.
* This method finds more methods but is less precise when there are several methods
* with correct signatures.
* So, if you want to choose an exact signature you might need to enable this property.
The default setting is to disable exact matches.
* * @return true iff exact matching is enabled * @since Digester Release 1.1.1 */ public boolean isExactMatch() { return useExactMatch; } /** *Set whether exact matching is enabled.
* *See {@link #isExactMatch()}.
* * @param useExactMatch should this rule use exact method matching * @since Digester Release 1.1.1 */ public void setExactMatch(boolean useExactMatch) { this.useExactMatch = useExactMatch; } /** * Process the end of this element. */ public void end() throws Exception { // Identify the objects to be used Object child = digester.peek(0); Object parent = digester.root; if (digester.log.isDebugEnabled()) { if (parent == null) { digester.log.debug("[SetRootRule]{" + digester.match + "} Call [NULL ROOT]." + methodName + "(" + child + ")"); } else { digester.log.debug("[SetRootRule]{" + digester.match + "} Call " + parent.getClass().getName() + "." + methodName + "(" + child + ")"); } } // Call the specified method Class paramTypes[] = new Class[1]; if (paramType != null) { paramTypes[0] = digester.getClassLoader().loadClass(paramType); } else { paramTypes[0] = child.getClass(); } if (useExactMatch) { MethodUtils.invokeExactMethod(parent, methodName, new Object[]{ child }, paramTypes); } else { MethodUtils.invokeMethod(parent, methodName, new Object[]{ child }, paramTypes); } } /** * Render a printable version of this Rule. */ public String toString() { StringBuffer sb = new StringBuffer("SetRootRule["); sb.append("methodName="); sb.append(methodName); sb.append(", paramType="); sb.append(paramType); sb.append("]"); return (sb.toString()); } } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/ObjectCreateRule.java 0000644 0001750 0001750 00000016001 11226450007 032324 0 ustar twerner twerner /* $Id: ObjectCreateRule.java 471661 2006-11-06 08:09:25Z skitching $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester; import org.xml.sax.Attributes; /** * Rule implementation that creates a new object and pushes it * onto the object stack. When the element is complete, the * object will be popped */ public class ObjectCreateRule extends Rule { // ----------------------------------------------------------- Constructors /** * Construct an object create rule with the specified class name. * * @param digester The associated Digester * @param className Java class name of the object to be created * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #ObjectCreateRule(String className)} instead. */ public ObjectCreateRule(Digester digester, String className) { this(className); } /** * Construct an object create rule with the specified class. * * @param digester The associated Digester * @param clazz Java class name of the object to be created * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #ObjectCreateRule(Class clazz)} instead. */ public ObjectCreateRule(Digester digester, Class clazz) { this(clazz); } /** * Construct an object create rule with the specified class name and an * optional attribute name containing an override. * * @param digester The associated Digester * @param className Java class name of the object to be created * @param attributeName Attribute name which, if present, contains an * override of the class name to create * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #ObjectCreateRule(String className, String attributeName)} instead. */ public ObjectCreateRule(Digester digester, String className, String attributeName) { this (className, attributeName); } /** * Construct an object create rule with the specified class and an * optional attribute name containing an override. * * @param digester The associated Digester * @param attributeName Attribute name which, if present, contains an * @param clazz Java class name of the object to be created * override of the class name to create * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #ObjectCreateRule(String attributeName, Class clazz)} instead. */ public ObjectCreateRule(Digester digester, String attributeName, Class clazz) { this(attributeName, clazz); } /** * Construct an object create rule with the specified class name. * * @param className Java class name of the object to be created */ public ObjectCreateRule(String className) { this(className, (String) null); } /** * Construct an object create rule with the specified class. * * @param clazz Java class name of the object to be created */ public ObjectCreateRule(Class clazz) { this(clazz.getName(), (String) null); } /** * Construct an object create rule with the specified class name and an * optional attribute name containing an override. * * @param className Java class name of the object to be created * @param attributeName Attribute name which, if present, contains an * override of the class name to create */ public ObjectCreateRule(String className, String attributeName) { this.className = className; this.attributeName = attributeName; } /** * Construct an object create rule with the specified class and an * optional attribute name containing an override. * * @param attributeName Attribute name which, if present, contains an * @param clazz Java class name of the object to be created * override of the class name to create */ public ObjectCreateRule(String attributeName, Class clazz) { this(clazz.getName(), attributeName); } // ----------------------------------------------------- Instance Variables /** * The attribute containing an override class name if it is present. */ protected String attributeName = null; /** * The Java class name of the object to be created. */ protected String className = null; // --------------------------------------------------------- Public Methods /** * Process the beginning of this element. * * @param attributes The attribute list of this element */ public void begin(Attributes attributes) throws Exception { // Identify the name of the class to instantiate String realClassName = className; if (attributeName != null) { String value = attributes.getValue(attributeName); if (value != null) { realClassName = value; } } if (digester.log.isDebugEnabled()) { digester.log.debug("[ObjectCreateRule]{" + digester.match + "}New " + realClassName); } // Instantiate the new object and push it on the context stack Class clazz = digester.getClassLoader().loadClass(realClassName); Object instance = clazz.newInstance(); digester.push(instance); } /** * Process the end of this element. */ public void end() throws Exception { Object top = digester.pop(); if (digester.log.isDebugEnabled()) { digester.log.debug("[ObjectCreateRule]{" + digester.match + "} Pop " + top.getClass().getName()); } } /** * Render a printable version of this Rule. */ public String toString() { StringBuffer sb = new StringBuffer("ObjectCreateRule["); sb.append("className="); sb.append(className); sb.append(", attributeName="); sb.append(attributeName); sb.append("]"); return (sb.toString()); } } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/package.html 0000644 0001750 0001750 00000200747 11226450007 030574 0 ustar twerner twerner
[Dependencies]
[Introduction]
[Configuration Properties]
[The Object Stack]
[Element Matching Patterns]
[Processing Rules]
[Logging]
[Usage Example]
[Namespace Aware Parsing]
[Pluggable Rules Processing]
[Encapsulated Rule Sets]
[Using Named Stacks For Inter-Rule Communication]
[Registering DTDs]
[Troubleshooting]
[FAQ]
[Extensions]
[Known Limitations]
External Dependencies
The Digester component is dependent upon implementations of the following standard libraries:
- XML Parser compatible with the JAXP/1.1 specification.
Examples compatible implementations include:
- JAXP/1.1 Reference Implementation
- Xerces (Version 1.3.1 or later)
It is also dependent on a compatible set of Apache Commons library components. The recommended dependency set is:
Recommended Dependency Set Digester +Logging 1.1.x +BeanUtils 1.8.0
Other compatible dependency sets include:
Compatible Dependency Sets Digester +Logging 1.1.x +BeanUtils 1.x +Collections 2.x Digester +Logging 1.1.x +BeanUtils 1.x +Collections 3.x
It is also possible to use Logging 1.0.x or BeanUtils 1.7.0 instead.
Introduction
In many application environments that deal with XML-formatted data, it is useful to be able to process an XML document in an "event driven" manner, where particular Java objects are created (or methods of existing objects are invoked) when particular patterns of nested XML elements have been recognized. Developers familiar with the Simple API for XML Parsing (SAX) approach to processing XML documents will recognize that the Digester provides a higher level, more developer-friendly interface to SAX events, because most of the details of navigating the XML element hierarchy are hidden -- allowing the developer to focus on the processing to be performed.
In order to use a Digester, the following basic steps are required:
- Create a new instance of the
org.apache.commons.digester.Digesterclass. Previously created Digester instances may be safely reused, as long as you have completed any previously requested parse, and you do not try to utilize a particular Digester instance from more than one thread at a time. - Set any desired configuration properties that will customize the operation of the Digester when you next initiate a parse operation.
- Optionally, push any desired initial object(s) onto the Digester's object stack.
- Register all of the element matching patterns for which you wish to have processing rules fired when this pattern is recognized in an input document. You may register as many rules as you like for any particular pattern. If there is more than one rule for a given pattern, the rules will be executed in the order that they were listed.
- Call the
digester.parse()method, passing a reference to the XML document to be parsed in one of a variety of forms. See the Digester.parse() documentation for details. Note that you will need to be prepared to catch anyIOExceptionorSAXExceptionthat is thrown by the parser, or any runtime expression that is thrown by one of the processing rules.
Alternatively a Digester may be used as a sax event hander, as follows:
- Create an instance of a sax parser (using the JAXP APIs or otherwise).
- Set any desired configuration properties on that parser object.
- Create an instance of
org.apache.commons.digester.Digester. - Optionally, push any desired initial object(s) onto the Digester's object stack.
- Register patterns and rules with the digester instance.
- Call parser.parse(inputSource, digester).
For example code, see the usage examples, and the FAQ .
Digester Configuration Properties
A org.apache.commons.digester.Digester instance contains several
configuration properties that can be used to customize its operation. These
properties must be configured before you call one of the
parse() variants, in order for them to take effect on that
parse.
Property Description classLoader You can optionally specify the class loader that will be used to load classes when required by the ObjectCreateRuleandFactoryCreateRulerules. If not specified, application classes will be loaded from the thread's context class loader (if theuseContextClassLoaderproperty is set totrue) or the same class loader that was used to load theDigesterclass itself.errorHandler You can optionally specify a SAX ErrorHandlerthat is notified when parsing errors occur. By default, any parsing errors that are encountered are logged, but Digester will continue processing as well.namespaceAware A boolean that is set to trueto perform parsing in a manner that is aware of XML namespaces. Among other things, this setting affects how elements are matched to processing rules. See Namespace Aware Parsing for more information.ruleNamespaceURI The public URI of the namespace for which all subsequently added rules are associated, or nullfor adding rules that are not associated with any namespace. See Namespace Aware Parsing for more information.rules The Rulescomponent that actually performs matching ofRuleinstances against the current element nesting pattern is pluggable. By default, Digester includes aRulesimplementation that behaves as described in this document. See Pluggable Rules Processing for more information.useContextClassLoader A boolean that is set to trueif you want application classes required byFactoryCreateRuleandObjectCreateRuleto be loaded from the context class loader of the current thread. By default, classes will be loaded from the class loader that loaded thisDigesterclass. NOTE - This property is ignored if you set a value for theclassLoaderproperty; that class loader will be used unconditionally.validating A boolean that is set to trueif you wish to validate the XML document against a Document Type Definition (DTD) that is specified in itsDOCTYPEdeclaration. The default value offalserequests a parse that only detects "well formed" XML documents, rather than "valid" ones.
In addition to the scalar properties defined above, you can also register
a local copy of a Document Type Definition (DTD) that is referenced in a
DOCTYPE declaration. Such a registration tells the XML parser
that, whenever it encounters a DOCTYPE declaration with the
specified public identifier, it should utilize the actual DTD content at the
registered system identifier (a URL), rather than the one in the
DOCTYPE declaration.
For example, the Struts framework controller servlet uses the following registration in order to tell Struts to use a local copy of the DTD for the Struts configuration file. This allows usage of Struts in environments that are not connected to the Internet, and speeds up processing even at Internet connected sites (because it avoids the need to go across the network).
URL url = new URL("/org/apache/struts/resources/struts-config_1_0.dtd");
digester.register
("-//Apache Software Foundation//DTD Struts Configuration 1.0//EN",
url.toString());
As a side note, the system identifier used in this example is the path
that would be passed to java.lang.ClassLoader.getResource()
or java.lang.ClassLoader.getResourceAsStream(). The actual DTD
resource is loaded through the same class loader that loads all of the Struts
classes -- typically from the struts.jar file.
The Object Stack
One very common use of org.apache.commons.digester.Digester
technology is to dynamically construct a tree of Java objects, whose internal
organization, as well as the details of property settings on these objects,
are configured based on the contents of the XML document. In fact, the
primary reason that the Digester package was created (it was originally part
of Struts, and then moved to the Commons project because it was recognized
as being generally useful) was to facilitate the
way that the Struts controller servlet configures itself based on the contents
of your application's struts-config.xml file.
To facilitate this usage, the Digester exposes a stack that can be manipulated by processing rules that are fired when element matching patterns are satisfied. The usual stack-related operations are made available, including the following:
- clear() - Clear the current contents of the object stack.
- peek() - Return a reference to the top object on the stack, without removing it.
- pop() - Remove the top object from the stack and return it.
- push() - Push a new object onto the top of the stack.
A typical design pattern, then, is to fire a rule that creates a new object and pushes it on the stack when the beginning of a particular XML element is encountered. The object will remain there while the nested content of this element is processed, and it will be popped off when the end of the element is encountered. As we will see, the standard "object create" processing rule supports exactly this functionalility in a very convenient way.
Several potential issues with this design pattern are addressed by other features of the Digester functionality:
- How do I relate the objects being created to each other? - The Digester supports standard processing rules that pass the top object on the stack as an argument to a named method on the next-to-top object on the stack (or vice versa). This rule makes it easy to establish parent-child relationships between these objects. One-to-one and one-to-many relationships are both easy to construct.
- How do I retain a reference to the first object that was created?
As you review the description of what the "object create" processing rule
does, it would appear that the first object you create (i.e. the object
created by the outermost XML element you process) will disappear from the
stack by the time that XML parsing is completed, because the end of the
element would have been encountered. However, Digester will maintain a
reference to the very first object ever pushed onto the object stack,
and will return it to you
as the return value from the
parse()call. Alternatively, you can push a reference to some application object onto the stack before callingparse(), and arrange that a parent-child relationship be created (by appropriate processing rules) between this manually pushed object and the ones that are dynamically created. In this way, the pushed object will retain a reference to the dynamically created objects (and therefore all of their children), and will be returned to you after the parse finishes as well.
Element Matching Patterns
A primary feature of the org.apache.commons.digester.Digester
parser is that the Digester automatically navigates the element hierarchy of
the XML document you are parsing for you, without requiring any developer
attention to this process. Instead, you focus on deciding what functions you
would like to have performed whenver a certain arrangement of nested elements
is encountered in the XML document being parsed. The mechanism for specifying
such arrangements are called element matching patterns.
The Digester can be configured to use different pattern-matching algorithms via the Digester.setRules method. However for the vast majority of cases, the default matching algorithm works fine. The default pattern matching behaviour is described below.
A very simple element matching pattern is a simple string like "a". This
pattern is matched whenever an <a> top-level element is
encountered in the XML document, no matter how many times it occurs. Note that
nested <a> elements will not match this
pattern -- we will describe means to support this kind of matching later.
The next step up in matching pattern complexity is "a/b". This pattern will
be matched when a <b> element is found nested inside a
top-level <a> element. Again, this match can occur as many
times as desired, depending on the content of the XML document being parsed.
You can use multiple slashes to define a hierarchy of any desired depth that
will be matched appropriately.
For example, assume you have registered processing rules that match patterns "a", "a/b", and "a/b/c". For an input XML document with the following contents, the indicated patterns will be matched when the corresponding element is parsed:
<a> -- Matches pattern "a"
<b> -- Matches pattern "a/b"
<c/> -- Matches pattern "a/b/c"
<c/> -- Matches pattern "a/b/c"
</b>
<b> -- Matches pattern "a/b"
<c/> -- Matches pattern "a/b/c"
<c/> -- Matches pattern "a/b/c"
<c/> -- Matches pattern "a/b/c"
</b>
</a>
It is also possible to match a particular XML element, no matter how it is
nested (or not nested) in the XML document, by using the "*" wildcard character
in your matching pattern strings. For example, an element matching pattern
of "*/a" will match an <a> element at any nesting position
within the document.
It is quite possible that, when a particular XML element is being parsed, the pattern for more than one registered processing rule will be matched because you registered more than one processing rule with the exact same matching pattern.
When this occurs, the corresponding processing rules will all be fired in
order. Rule methods begin (and body) are executed in
the order that the Rules were initially registered with the
Digester, whilst end method calls are executed in
reverse order. In other words - the order is first in, last out.
Note that wildcard patterns are ignored if an explicit match can be found (and when multiple wildcard patterns match, only the longest, ie most explicit, pattern is considered a match). The result is that rules can be added for "an <a> tag anywhere", but then for that behaviour to be explicitly overridden for specific cases, eg "but not an <a> that is a direct child of an <x>". Therefore if you have rules A and B registered for pattern "*/a" then want to add an additional rule C for pattern "x/a" only, then what you need to do is add *three* rules for "x/a": A, B and C. Note that by using:
Rule ruleA = new ObjectCreateRule();
Rule ruleB = new SetNextRule();
Rule ruleC = new SetPropertiesRule();
digester.addRule("*/a", ruleA);
digester.addRule("*/a", ruleB);
digester.addRule("x/a", ruleA);
digester.addRule("x/a", ruleB);
digester.addRule("x/a", ruleC);
you have associated the same rule instances A and B with multiple patterns,
thus avoiding creating extra rule object instances.
Processing Rules
The previous section documented how you identify when you wish to have certain actions take place. The purpose of processing rules is to define what should happen when the patterns are matched.
Formally, a processing rule is a Java class that subclasses the org.apache.commons.digester.Rule interface. Each Rule implements one or more of the following event methods that are called at well-defined times when the matching patterns corresponding to this rule trigger it:
- begin() - Called when the beginning of the matched XML element is encountered. A data structure containing all of the attributes corresponding to this element are passed as well.
- body() - Called when nested content (that is not itself XML elements) of the matched element is encountered. Any leading or trailing whitespace will have been removed as part of the parsing process.
- end() - Called when the ending of the matched XML element is encountered. If nested XML elements that matched other processing rules was included in the body of this element, the appropriate processing rules for the matched rules will have already been completed before this method is called.
- finish() - Called when the parse has been completed, to give each rule a chance to clean up any temporary data they might have created and cached.
As you are configuring your digester, you can call the
addRule() method to register a specific element matching pattern,
along with an instance of a Rule class that will have its event
handling methods called at the appropriate times, as described above. This
mechanism allows you to create Rule implementation classes
dynamically, to implement any desired application specific functionality.
In addition, a set of processing rule implementation classes are provided, which deal with many common programming scenarios. These classes include the following:
- ObjectCreateRule - When the
begin()method is called, this rule instantiates a new instance of a specified Java class, and pushes it on the stack. The class name to be used is defaulted according to a parameter passed to this rule's constructor, but can optionally be overridden by a classname passed via the specified attribute to the XML element being processed. When theend()method is called, the top object on the stack (presumably, the one we added in thebegin()method) will be popped, and any reference to it (within the Digester) will be discarded. - FactoryCreateRule - A variation of
ObjectCreateRulethat is useful when the Java class with which you wish to create an object instance does not have a no-arguments constructor, or where you wish to perform other setup processing before the object is handed over to the Digester. - SetPropertiesRule - When the
begin()method is called, the digester uses the standard Java Reflection API to identify any JavaBeans property setter methods (on the object at the top of the digester's stack) who have property names that match the attributes specified on this XML element, and then call them individually, passing the corresponding attribute values. These natural mappings can be overridden. This allows (for example) aclassattribute to be mapped correctly. It is recommended that this feature should not be overused - in most cases, it's better to use the standardBeanInfomechanism. A very common idiom is to define an object create rule, followed by a set properties rule, with the same element matching pattern. This causes the creation of a new Java object, followed by "configuration" of that object's properties based on the attributes of the same XML element that created this object. - SetPropertyRule - When the
begin()method is called, the digester calls a specified property setter (where the property itself is named by an attribute) with a specified value (where the value is named by another attribute), on the object at the top of the digester's stack. This is useful when your XML file conforms to a particular DTD, and you wish to configure a particular property that does not have a corresponding attribute in the DTD. - SetNextRule - When the
end()method is called, the digester analyzes the next-to-top element on the stack, looking for a property setter method for a specified property. It then calls this method, passing the object at the top of the stack as an argument. This rule is commonly used to establish one-to-many relationships between the two objects, with the method name commonly being something like "addChild". - SetTopRule - When the
end()method is called, the digester analyzes the top element on the stack, looking for a property setter method for a specified property. It then calls this method, passing the next-to-top object on the stack as an argument. This rule would be used as an alternative to a SetNextRule, with a typical method name "setParent", if the API supported by your object classes prefers this approach. - CallMethodRule - This rule sets up a
method call to a named method of the top object on the digester's stack,
which will actually take place when the
end()method is called. You configure this rule by specifying the name of the method to be called, the number of arguments it takes, and (optionally) the Java class name(s) defining the type(s) of the method's arguments. The actual parameter values, if any, will typically be accumulated from the body content of nested elements within the element that triggered this rule, using the CallParamRule discussed next. - CallParamRule - This rule identifies the source of a particular numbered (zero-relative) parameter for a CallMethodRule within which we are nested. You can specify that the parameter value be taken from a particular named attribute, or from the nested body content of this element.
- NodeCreateRule - A specialized rule
that converts part of the tree into a
DOM Nodeand then pushes it onto the stack.
You can create instances of the standard Rule classes and
register them by calling digester.addRule(), as described above.
However, because their usage is so common, shorthand registration methods are
defined for each of the standard rules, directly on the Digester
class. For example, the following code sequence:
Rule rule = new SetNextRule(digester, "addChild",
"com.mycompany.mypackage.MyChildClass");
digester.addRule("a/b/c", rule);
can be replaced by:
digester.addSetNext("a/b/c", "addChild",
"com.mycompany.mypackage.MyChildClass");
Logging
Logging is a vital tool for debugging Digester rulesets. Digester can log copious amounts of debugging information. So, you need to know how logging works before you start using Digester seriously.
Digester uses Apache Commons Logging. This component is not really a logging framework - rather an extensible, configurable bridge. It can be configured to swallow all log messages, to provide very basic logging by itself or to pass logging messages on to more sophisticated logging frameworks. Commons-Logging comes with connectors for many popular logging frameworks. Consult the commons-logging documentation for more information.
Two main logs are used by Digester:
- SAX-related messages are logged to
org.apache.commons.digester.Digester.sax. This log gives information about the basic SAX events received by Digester. org.apache.commons.digester.Digesteris used for everything else. You'll probably want to have this log turned up during debugging but turned down during production due to the high message volume.
Complete documentation of how to configure Commons-Logging can be found
in the Commons Logging package documentation. However, as a simple example,
let's assume that you want to use the SimpleLog implementation
that is included in Commons-Logging, and set up Digester to log events from
the Digester logger at the DEBUG level, while you want to log
events from the Digester.log logger at the INFO level. You can
accomplish this by creating a commons-logging.properties file
in your classpath (or setting corresponding system properties on the command
line that starts your application) with the following contents:
org.apache.commons.logging.Log=org.apache.commons.logging.impl.SimpleLog org.apache.commons.logging.simplelog.log.org.apache.commons.digester.Digester=debug org.apache.commons.logging.simplelog.log.org.apache.commons.digester.Digester.sax=info
Usage Examples
Creating a Simple Object Tree
Let's assume that you have two simple JavaBeans, Foo and
Bar, with the following method signatures:
package mypackage;
public class Foo {
public void addBar(Bar bar);
public Bar findBar(int id);
public Iterator getBars();
public String getName();
public void setName(String name);
}
package mypackage;
public class Bar {
public int getId();
public void setId(int id);
public String getTitle();
public void setTitle(String title);
}
and you wish to use Digester to parse the following XML document:
<foo name="The Parent">
<bar id="123" title="The First Child"/>
<bar id="456" title="The Second Child"/>
</foo>
A simple approach will be to use the following Digester in the following way to set up the parsing rules, and then process an input file containing this document:
Digester digester = new Digester();
digester.setValidating(false);
digester.addObjectCreate("foo", "mypackage.Foo");
digester.addSetProperties("foo");
digester.addObjectCreate("foo/bar", "mypackage.Bar");
digester.addSetProperties("foo/bar");
digester.addSetNext("foo/bar", "addBar", "mypackage.Bar");
Foo foo = (Foo) digester.parse();
In order, these rules do the following tasks:
- When the outermost
<foo>element is encountered, create a new instance ofmypackage.Fooand push it on to the object stack. At the end of the<foo>element, this object will be popped off of the stack. - Cause properties of the top object on the stack (i.e. the
Fooobject that was just created and pushed) to be set based on the values of the attributes of this XML element. - When a nested
<bar>element is encountered, create a new instance ofmypackage.Barand push it on to the object stack. At the end of the<bar>element, this object will be popped off of the stack (i.e. after the remaining rules matchingfoo/barare processed). - Cause properties of the top object on the stack (i.e. the
Barobject that was just created and pushed) to be set based on the values of the attributes of this XML element. Note that type conversions are automatically performed (such as String to int for theidproperty), for all converters registered with theConvertUtilsclass fromcommons-beanutilspackage. - Cause the
addBarmethod of the next-to-top element on the object stack (which is why this is called the "set next" rule) to be called, passing the element that is on the top of the stack, which must be of typemypackage.Bar. This is the rule that causes the parent/child relationship to be created.
Once the parse is completed, the first object that was ever pushed on to the
stack (the Foo object in this case) is returned to you. It will
have had its properties set, and all of its child Bar objects
created for you.
Processing A Struts Configuration File
As stated earlier, the primary reason that the
Digester package was created is because the
Struts controller servlet itself needed a robust, flexible, easy to extend
mechanism for processing the contents of the struts-config.xml
configuration that describes nearly every aspect of a Struts-based application.
Because of this, the controller servlet contains a comprehensive, real world,
example of how the Digester can be employed for this type of a use case.
See the initDigester() method of class
org.apache.struts.action.ActionServlet for the code that creates
and configures the Digester to be used, and the initMapping()
method for where the parsing actually takes place.
(Struts binary and source distributions can be acquired at http://struts.apache.org.)
The following discussion highlights a few of the matching patterns and processing rules that are configured, to illustrate the use of some of the Digester features. First, let's look at how the Digester instance is created and initialized:
Digester digester = new Digester();
digester.push(this); // Push controller servlet onto the stack
digester.setValidating(true);
We see that a new Digester instance is created, and is configured to use a validating parser. Validation will occur against the struts-config_1_0.dtd DTD that is included with Struts (as discussed earlier). In order to provide a means of tracking the configured objects, the controller servlet instance itself will be added to the digester's stack.
digester.addObjectCreate("struts-config/global-forwards/forward",
forwardClass, "className");
digester.addSetProperties("struts-config/global-forwards/forward");
digester.addSetNext("struts-config/global-forwards/forward",
"addForward",
"org.apache.struts.action.ActionForward");
digester.addSetProperty
("struts-config/global-forwards/forward/set-property",
"property", "value");
The rules created by these lines are used to process the global forward
declarations. When a <forward> element is encountered,
the following actions take place:
- A new object instance is created -- the
ActionForwardinstance that will represent this definition. The Java class name defaults to that specified as an initialization parameter (which we have stored in the String variableforwardClass), but can be overridden by using the "className" attribute (if it is present in the XML element we are currently parsing). The newActionForwardinstance is pushed onto the stack. - The properties of the
ActionForwardinstance (at the top of the stack) are configured based on the attributes of the<forward>element. - Nested occurrences of the
<set-property>element cause calls to additional property setter methods to occur. This is required only if you have provided a custom implementation of theActionForwardclass with additional properties that are not included in the DTD. - The
addForward()method of the next-to-top object on the stack (i.e. the controller servlet itself) will be called, passing the object at the top of the stack (i.e. theActionForwardinstance) as an argument. This causes the global forward to be registered, and as a result of this it will be remembered even after the stack is popped. - At the end of the
<forward>element, the top element (i.e. theActionForwardinstance) will be popped off the stack.
Later on, the digester is actually executed as follows:
InputStream input =
getServletContext().getResourceAsStream(config);
...
try {
digester.parse(input);
input.close();
} catch (SAXException e) {
... deal with the problem ...
}
As a result of the call to parse(), all of the configuration
information that was defined in the struts-config.xml file is
now represented as collections of objects cached within the Struts controller
servlet, as well as being exposed as servlet context attributes.
Parsing Body Text In XML Files
The Digester module also allows you to process the nested body text in an
XML file, not just the elements and attributes that are encountered. The
following example is based on an assumed need to parse the web application
deployment descriptor (/WEB-INF/web.xml) for the current web
application, and record the configuration information for a particular
servlet. To record this information, assume the existence of a bean class
with the following method signatures (among others):
package com.mycompany;
public class ServletBean {
public void setServletName(String servletName);
public void setServletClass(String servletClass);
public void addInitParam(String name, String value);
}
We are going to process the web.xml file that declares the
controller servlet in a typical Struts-based application (abridged for
brevity in this example):
<web-app>
...
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet<servlet-class>
<init-param>
<param-name>application</param-name>
<param-value>org.apache.struts.example.ApplicationResources<param-value>
</init-param>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml<param-value>
</init-param>
</servlet>
...
</web-app>
Next, lets define some Digester processing rules for this input file:
digester.addObjectCreate("web-app/servlet",
"com.mycompany.ServletBean");
digester.addCallMethod("web-app/servlet/servlet-name", "setServletName", 0);
digester.addCallMethod("web-app/servlet/servlet-class",
"setServletClass", 0);
digester.addCallMethod("web-app/servlet/init-param",
"addInitParam", 2);
digester.addCallParam("web-app/servlet/init-param/param-name", 0);
digester.addCallParam("web-app/servlet/init-param/param-value", 1);
Now, as elements are parsed, the following processing occurs:
- <servlet> - A new
com.mycompany.ServletBeanobject is created, and pushed on to the object stack. - <servlet-name> - The
setServletName()method of the top object on the stack (ourServletBean) is called, passing the body content of this element as a single parameter. - <servlet-class> - The
setServletClass()method of the top object on the stack (ourServletBean) is called, passing the body content of this element as a single parameter. - <init-param> - A call to the
addInitParammethod of the top object on the stack (ourServletBean) is set up, but it is not called yet. The call will be expecting twoStringparameters, which must be set up by subsequent call parameter rules. - <param-name> - The body content of this element is assigned as the first (zero-relative) argument to the call we are setting up.
- <param-value> - The body content of this element is assigned as the second (zero-relative) argument to the call we are setting up.
- </init-param> - The call to
addInitParam()that we have set up is now executed, which will cause a new name-value combination to be recorded in our bean. - <init-param> - The same set of processing rules are fired
again, causing a second call to
addInitParam()with the second parameter's name and value. - </servlet> - The element on the top of the object stack
(which should be the
ServletBeanwe pushed earlier) is popped off the object stack.
Namespace Aware Parsing
For digesting XML documents that do not use XML namespaces, the default
behavior of Digester, as described above, is generally sufficient.
However, if the document you are processing uses namespaces, it is often
convenient to have sets of Rule instances that are only
matched on elements that use the prefix of a particular namespace. This
approach, for example, makes it possible to deal with element names that are
the same in different namespaces, but where you want to perform different
processing for each namespace.
Digester does not provide full support for namespaces, but does provide sufficient to accomplish most tasks. Enabling digester's namespace support is done by following these steps:
- Tell
Digesterthat you will be doing namespace aware parsing, by adding this statement in your initalization of the Digester's properties:digester.setNamespaceAware(true); - Declare the public namespace URI of the namespace with which
following rules will be associated. Note that you do not
make any assumptions about the prefix - the XML document author
is free to pick whatever prefix they want:
digester.setRuleNamespaceURI("http://www.mycompany.com/MyNamespace"); - Add the rules that correspond to this namespace, in the usual way,
by calling methods like
addObjectCreate()oraddSetProperties(). In the matching patterns you specify, use only the local name portion of the elements (i.e. the part after the prefix and associated colon (":") character:digester.addObjectCreate("foo/bar", "com.mycompany.MyFoo"); digester.addSetProperties("foo/bar"); - Repeat the previous two steps for each additional public namespace URI
that should be recognized on this
Digesterrun.
Now, consider that you might wish to digest the following document, using the rules that were set up in the steps above:
<m:foo xmlns:m="http://www.mycompany.com/MyNamespace" xmlns:y="http://www.yourcompany.com/YourNamespace"> <m:bar name="My Name" value="My Value"/> <y:bar id="123" product="Product Description"/>L </x:foo>
Note that your object create and set properties rules will be fired for the
first occurrence of the bar element, but not the
second one. This is because we declared that our rules only matched
for the particular namespace we are interested in. Any elements in the
document that are associated with other namespaces (or no namespaces at all)
will not be processed. In this way, you can easily create rules that digest
only the portions of a compound document that they understand, without placing
any restrictions on what other content is present in the document.
You might also want to look at Encapsulated Rule Sets if you wish to reuse a particular set of rules, associated with a particular namespace, in more than one application context.
Using Namespace Prefixes In Pattern Matching
Using rules with namespaces is very useful when you have orthogonal rulesets. One ruleset applies to a namespace and is independent of other rulesets applying to other namespaces. However, if your rule logic requires mixed namespaces, then matching namespace prefix patterns might be a better strategy.
When you set the NamespaceAware property to false, digester uses
the qualified element name (which includes the namespace prefix) rather than the
local name as the patten component for the element. This means that your pattern
matches can include namespace prefixes as well as element names. So, rather than
create namespace-aware rules, create pattern matches including the namespace
prefixes.
For example, (with NamespaceAware false), the pattern
'foo:bar' will match a top level element named 'bar' in the
namespace with (local) prefix 'foo'.
Limitations of Digester Namespace support
Digester does not provide general "xpath-compliant" matching; only the namespace attached to the last element in the match path is involved in the matching process. Namespaces attached to parent elements are ignored for matching purposes.
Pluggable Rules Processing
By default, Digester selects the rules that match a particular
pattern of nested elements as described under
Element Matching Patterns. If you prefer to use
different selection policies, however, you can create your own implementation
of the org.apache.commons.digester.Rules interface,
or subclass the corresponding convenience base class
org.apache.commons.digester.RulesBase.
Your implementation of the match() method will be called when the
processing for a particular element is started or ended, and you must return
a List of the rules that are relevant for the current nesting
pattern. The order of the rules you return is significant,
and should match the order in which rules were initally added.
Your policy for rule selection should generally be sensitive to whether
Namespace Aware Parsing is taking place. In
general, if namespaceAware is true, you should select only rules
that:
- Are registered for the public namespace URI that corresponds to the prefix being used on this element.
- Match on the "local name" portion of the element (so that the document creator can use any prefix that they like).
ExtendedBaseRules
ExtendedBaseRules, adds some additional expression syntax for pattern matching to the default mechanism, but it also executes more slowly. See the JavaDocs for more details on the new pattern matching syntax, and suggestions on when this implementation should be used. To use it, simply do the following as part of your Digester initialization:
Digester digester = ... ... digester.setRules(new ExtendedBaseRules()); ...
RegexRules
RegexRules is an advanced Rules
implementation which does not build on the default pattern matching rules.
It uses a pluggable RegexMatcher implementation to test
if a path matches the pattern for a Rule. All matching rules are returned
(note that this behaviour differs from longest matching rule of the default
pattern matching rules). See the Java Docs for more details.
Example usage:
Digester digester = ... ... digester.setRules(new RegexRules(new SimpleRegexMatcher())); ...
RegexMatchers
Digester ships only with one RegexMatcher
implementation: SimpleRegexMatcher.
This implementation is unsophisticated and lacks many good features
lacking in more power Regex libraries. There are some good reasons
why this approach was adopted. The first is that SimpleRegexMatcher
is simple, it is easy to write and runs quickly. The second has to do with
the way that RegexRules is intended to be used.
There are many good regex libraries available. (For example Jakarta ORO, Jakarta Regex, GNU Regex and Java 1.4 Regex) Not only do different people have different personal tastes when it comes to regular expression matching but these products all offer different functionality and different strengths.
The pluggable RegexMatcher is a thin bridge
designed to adapt other Regex systems. This allows any Regex library the user
desires to be plugged in and used just by creating one class.
Digester does not (currently) ship with bridges to the major
regex (to allow the dependencies required by Digester
to be kept to a minimum).
WithDefaultsRulesWrapper
WithDefaultsRulesWrapper allows
default Rule instances to be added to any existing
Rules implementation. These default Rule instances
will be returned for any match for which the wrapped implementation does not
return any matches.
For example,
Rule alpha;
...
WithDefaultsRulesWrapper rules = new WithDefaultsRulesWrapper(new BaseRules());
rules.addDefault(alpha);
...
digester.setRules(rules);
...
when a pattern does not match any other rule, then rule alpha will be called.
WithDefaultsRulesWrapper follows the Decorator pattern.
Encapsulated Rule Sets
All of the examples above have described a scenario where the rules to be
processed are registered with a Digester instance immediately
after it is created. However, this approach makes it difficult to reuse the
same set of rules in more than one application environment. Ideally, one
could package a set of rules into a single class, which could be easily
loaded and registered with a Digester instance in one easy step.
The RuleSet interface (and the convenience base
class RuleSetBase) make it possible to do this.
In addition, the rule instances registered with a particular
RuleSet can optionally be associated with a particular namespace,
as described under Namespace Aware Processing.
An example of creating a RuleSet might be something like this:
public class MyRuleSet extends RuleSetBase {
public MyRuleSet() {
this("");
}
public MyRuleSet(String prefix) {
super();
this.prefix = prefix;
this.namespaceURI = "http://www.mycompany.com/MyNamespace";
}
protected String prefix = null;
public void addRuleInstances(Digester digester) {
digester.addObjectCreate(prefix + "foo/bar",
"com.mycompany.MyFoo");
digester.addSetProperties(prefix + "foo/bar");
}
}
You might use this RuleSet as follow to initialize a
Digester instance:
Digester digester = new Digester();
... configure Digester properties ...
digester.addRuleSet(new MyRuleSet("baz/"));
A couple of interesting notes about this approach:
- The application that is using these rules does not need to know anything
about the fact that the
RuleSetbeing used is associated with a particular namespace URI. That knowledge is emedded inside theRuleSetclass itself. - If desired, you could make a set of rules work for more than one
namespace URI by providing constructors on the
RuleSetto allow this to be specified dynamically. - The
MyRuleSetexample above illustrates another technique that increases reusability -- you can specify (as an argument to the constructor) the leading portion of the matching pattern to be used. In this way, you can construct aDigesterthat recognizes the same set of nested elements at different nesting levels within an XML document.
Using Named Stacks For Inter-Rule Communication
Digester is based on Rule instances working together
to process xml. For anything other than the most trival processing,
communication between Rule instances is necessary. Since Rule
instances are processed in sequence, this usually means storing an Object
somewhere where later instances can retrieve it.
Digester is based on SAX. The most natural data structure to use with
SAX based xml processing is the stack. This allows more powerful processes to be
specified more simply since the pushing and popping of objects can mimic the
nested structure of the xml.
Digester uses two basic stacks: one for the main beans and the other
for parameters for method calls. These are inadequate for complex processing
where many different Rule instances need to communicate through
different channels.
In this case, it is recommended that named stacks are used. In addition to the
two basic stacks, Digester allows rules to use an unlimited number
of other stacks referred to by an identifying string (the name). (That's where
the term named stack comes from.) These stacks are
accessed through calls to:
- void push(String stackName, Object value)
- Object pop(String stackName)
- Object peek(String stackName)
Note: all stack names beginning with org.apache.commons.digester
are reserved for future use by the Digester component. It is also recommended
that users choose stack names prefixed by the name of their own domain to avoid conflicts
with other Rule implementations.
Registering DTDs
Brief (But Still Too Long) Introduction To System and Public Identifiers
A definition for an external entity comes in one of two forms:
SYSTEM system-identifierPUBLIC public-identifier system-identifier
The system-identifier is an URI from which the resource can be obtained
(either directly or indirectly). Many valid URIs may identify the same resource.
The public-identifier is an additional free identifier which may be used
(by the parser) to locate the resource.
In practice, the weakness with a system-identifier is that most parsers
will attempt to interprete this URI as an URL, try to download the resource directly
from the URL and stop the parsing if this download fails. So, this means that
almost always the URI will have to be an URL from which the declaration
can be downloaded.
URLs may be local or remote but if the URL is chosen to be local, it is likely only to function correctly on a small number of machines (which are configured precisely to allow the xml to be parsed). This is usually unsatisfactory and so a universally accessable URL is preferred. This usually means an internet URL.
To recap, in practice the system-identifier will (most likely) be an
internet URL. Unfortunately downloading from an internet URL is not only slow
but unreliable (since successfully downloading a document from the internet
relies on the client being connect to the internet and the server being
able to satisfy the request).
The public-identifier is a freely defined name but (in practice) it is
strongly recommended that a unique, readable and open format is used (for reasons
that should become clear later). A Formal Public Identifier (FPI) is a very
common choice. This public identifier is often used to provide a unique and location
independent key which can be used to subsistute local resources for remote ones
(hint: this is why ;).
By using the second (PUBLIC) form combined with some form of local
catalog (which matches public-identifiers to local resources) and where
the public-identifier is a unique name and the system-identifier
is an internet URL, the practical disadvantages of specifying just a
system-identifier can be avoided. Those external entities which have been
store locally (on the machine parsing the document) can be identified and used.
Only when no local copy exists is it necessary to download the document
from the internet URL. This naming scheme is recommended when using Digester.
External Entity Resolution Using Digester
SAX factors out the resolution of external entities into an EntityResolver.
Digester supports the use of custom EntityResolver
but ships with a simple internal implementation. This implementation allows local URLs
to be easily associated with public-identifiers.
For example:
digester.register("-//Example Dot Com //DTD Sample Example//EN", "assets/sample.dtd");
will make digester return the relative file path assets/sample.dtd
whenever an external entity with public id
-//Example Dot Com //DTD Sample Example//EN is needed.
Note: This is a simple (but useful) implementation.
Greater sophistication requires a custom EntityResolver.
Troubleshooting
Debugging Exceptions
Digester is based on SAX.
Digestion throws two kinds of Exception:
java.io.IOExceptionorg.xml.sax.SAXException
The first is rarely thrown and indicates the kind of fundemental IO exception that developers know all about. The second is thrown by SAX parsers when the processing of the XML cannot be completed. So, to diagnose the cause a certain familiarity with the way that SAX error handling works is very useful.
Diagnosing SAX Exceptions
This is a short, potted guide to SAX error handling strategies. It's not intended as a proper guide to error handling in SAX.
When a SAX parser encounters a problem with the xml (well, ok - sometime after it
encounters a problem) it will throw a
SAXParseException. This is a subclass of SAXException and contains
a bit of extra information about what exactly when wrong - and more importantly,
where it went wrong. If you catch an exception of this sort, you can be sure that
the problem is with the XML and not Digester or your rules.
It is usually a good idea to catch this exception and log the extra information
to help with diagnosing the reason for the failure.
General
SAXException instances may wrap a causal exception. When exceptions are
throw by Digester each of these will be wrapped into a
SAXException and rethrown. So, catch these and examine the wrapped
exception to diagnose what went wrong.
Frequently Asked Questions
- Why do I get warnings when using a JAXP 1.1 parser?
If you're using a JAXP 1.1 parser, you might see the following warning (in your log):
[WARN] Digester - -Error: JAXP SAXParser property not recognized: http://java.sun.com/xml/jaxp/properties/schemaLanguage
- Why Doesn't Schema Validation Work With Parser XXX Out Of The Box?
Schema location and language settings are often need for validation using schemas. Unfortunately, there isn't a single standard approach to how these properties are configured on a parser. Digester tries to guess the parser being used and configure it appropriately but it's not infallible. You might need to grab an instance, configure it and pass it to Digester.
If you want to support more than one parser in a portable manner, then you'll probably want to take a look at the
org.apache.commons.digester.parserspackage and add a new class to support the particular parser that's causing problems. - Help!
I'm Validating Against Schema But Digester Ignores Errors!
Digester is based on SAX. The convention for SAX parsers is that all errors are reported (to any registered
ErrorHandler) but processing continues. Digester (by default) registers its ownErrorHandlerimplementation. This logs details but does not stop the processing (following the usual convention for SAX based processors).This means that the errors reported by the validation of the schema will appear in the Digester logs but the processing will continue. To change this behaviour, call
digester.setErrorHandlerwith a more suitable implementation. - Where Can I Find Example Code?
Digester ships with a sample application: a mapping for the Rich Site Summary format used by many newsfeeds. Download the source distribution to see how it works.
Digester also ships with a set of examples demonstrating most of the features described in this document. See the "src/examples" subdirectory of the source distribution.
- When Are You Going To Support Rich Site Summary Version x.y.z?
The Rich Site Summary application is intended to be a sample application. It works but we have no plans to add support for other versions of the format.
We would consider donations of standard digester applications but it's unlikely that these would ever be shipped with the base digester distribution. If you want to discuss this, please post to commons dev mailing list
Extensions
Three extension packages are included within the Digester distribution. These provide extra functionality extending the core Digester concepts. Detailed descriptions are contained within their own package documentation.
- plugins provides a framework for the easy dynamic addition of rules during a Digestion. Rules can trigger the dynamic addition of other rules in an intuitive fashion.
- substitution provides for manipulation of attributes and element body text before it is processed by the rules.
- xmlrules package contains a system allowing digester rule configurations to be specifed through an xml file.
Known Limitations
Accessing Public Methods In A Default Access Superclass
There is an issue when invoking public methods contained in a default access superclass.
Reflection locates these methods fine and correctly assigns them as public.
However, an IllegalAccessException is thrown if the method is invoked.
MethodUtils contains a workaround for this situation.
It will attempt to call setAccessible on this method.
If this call succeeds, then the method can be invoked as normal.
This call will only succeed when the application has sufficient security privilages.
If this call fails then a warning will be logged and the method may fail.
Digester uses MethodUtils and so there may be an issue accessing methods
of this kind from a high security environment. If you think that you might be experiencing this
problem, please ask on the mailing list.
Rule implementation that calls a method on an object on the stack
* (normally the top/parent object), passing arguments collected from
* subsequent CallParamRule rules or from the body of this
* element.
By using {@link #CallMethodRule(String methodName)} * a method call can be made to a method which accepts no * arguments.
* *Incompatible method parameter types are converted
* using org.apache.commons.beanutils.ConvertUtils.
*
This rule now uses {@link MethodUtils#invokeMethod} by default.
* This increases the kinds of methods successfully and allows primitives
* to be matched by passing in wrapper classes.
* There are rare cases when {@link MethodUtils#invokeExactMethod}
* (the old default) is required.
* This method is much stricter in it's reflection.
* Setting the UseExactMatch to true reverts to the use of this
* method.
Note that the target method is invoked when the end of * the tag the CallMethodRule fired on is encountered, not when the * last parameter becomes available. This implies that rules which fire on * tags nested within the one associated with the CallMethodRule will * fire before the CallMethodRule invokes the target method. This behaviour is * not configurable.
* *Note also that if a CallMethodRule is expecting exactly one parameter * and that parameter is not available (eg CallParamRule is used with an * attribute name but the attribute does not exist) then the method will * not be invoked. If a CallMethodRule is expecting more than one parameter, * then it is always invoked, regardless of whether the parameters were * available or not; missing parameters are converted to the appropriate target * type by calling ConvertUtils.convert. Note that the default ConvertUtils * converters for the String type returns a null when passed a null, meaning * that CallMethodRule will passed null for all String parameters for which * there is no parameter info available from the XML. However parameters of * type Float and Integer will be passed a real object containing a zero value * as that is the output of the default ConvertUtils converters for those * types when passed a null. You can register custom converters to change * this behaviour; see the beautils library documentation for more info.
* *Note that when a constructor is used with paramCount=0, indicating that * the body of the element is to be passed to the target method, an empty * element will cause an empty string to be passed to the target method, * not null. And if automatic type conversion is being applied (ie if the * target function takes something other than a string as a parameter) then * the conversion will fail if the converter class does not accept an empty * string as valid input.
* *CallMethodRule has a design flaw which can cause it to fail under * certain rule configurations. All CallMethodRule instances share a single * parameter stack, and all CallParamRule instances simply store their data * into the parameter-info structure that is on the top of the stack. This * means that two CallMethodRule instances cannot be associated with the * same pattern without getting scrambled parameter data. This same issue * also applies when a CallMethodRule matches some element X, a different * CallMethodRule matches a child element Y and some of the CallParamRules * associated with the first CallMethodRule match element Y or one of its * child elements. This issue has been present since the very first release * of Digester. Note, however, that this configuration of CallMethodRule * instances is not commonly required.
*/ public class CallMethodRule extends Rule { // ----------------------------------------------------------- Constructors /** * Construct a "call method" rule with the specified method name. The * parameter types (if any) default to java.lang.String. * * @param digester The associated Digester * @param methodName Method name of the parent method to call * @param paramCount The number of parameters to collect, or * zero for a single argument from the body of this element. * * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #CallMethodRule(String methodName,int paramCount)} instead. */ public CallMethodRule(Digester digester, String methodName, int paramCount) { this(methodName, paramCount); } /** * Construct a "call method" rule with the specified method name. * * @param digester The associated Digester * @param methodName Method name of the parent method to call * @param paramCount The number of parameters to collect, or * zero for a single argument from the body of ths element * @param paramTypes The Java class names of the arguments * (if you wish to use a primitive type, specify the corresonding * Java wrapper class instead, such asjava.lang.Boolean
* for a boolean parameter)
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #CallMethodRule(String methodName,int paramCount, String [] paramTypes)} instead.
*/
public CallMethodRule(Digester digester, String methodName,
int paramCount, String paramTypes[]) {
this(methodName, paramCount, paramTypes);
}
/**
* Construct a "call method" rule with the specified method name.
*
* @param digester The associated Digester
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of ths element
* @param paramTypes The Java classes that represent the
* parameter types of the method arguments
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean.TYPE
* for a boolean parameter)
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #CallMethodRule(String methodName,int paramCount, Class [] paramTypes)} instead.
*/
public CallMethodRule(Digester digester, String methodName,
int paramCount, Class paramTypes[]) {
this(methodName, paramCount, paramTypes);
}
/**
* Construct a "call method" rule with the specified method name. The
* parameter types (if any) default to java.lang.String.
*
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of this element.
*/
public CallMethodRule(String methodName,
int paramCount) {
this(0, methodName, paramCount);
}
/**
* Construct a "call method" rule with the specified method name. The
* parameter types (if any) default to java.lang.String.
*
* @param targetOffset location of the target object. Positive numbers are
* relative to the top of the digester object stack. Negative numbers
* are relative to the bottom of the stack. Zero implies the top
* object on the stack.
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of this element.
*/
public CallMethodRule(int targetOffset,
String methodName,
int paramCount) {
this.targetOffset = targetOffset;
this.methodName = methodName;
this.paramCount = paramCount;
if (paramCount == 0) {
this.paramTypes = new Class[] { String.class };
} else {
this.paramTypes = new Class[paramCount];
for (int i = 0; i < this.paramTypes.length; i++) {
this.paramTypes[i] = String.class;
}
}
}
/**
* Construct a "call method" rule with the specified method name.
* The method should accept no parameters.
*
* @param methodName Method name of the parent method to call
*/
public CallMethodRule(String methodName) {
this(0, methodName, 0, (Class[]) null);
}
/**
* Construct a "call method" rule with the specified method name.
* The method should accept no parameters.
*
* @param targetOffset location of the target object. Positive numbers are
* relative to the top of the digester object stack. Negative numbers
* are relative to the bottom of the stack. Zero implies the top
* object on the stack.
* @param methodName Method name of the parent method to call
*/
public CallMethodRule(int targetOffset, String methodName) {
this(targetOffset, methodName, 0, (Class[]) null);
}
/**
* Construct a "call method" rule with the specified method name and
* parameter types. If paramCount is set to zero the rule
* will use the body of this element as the single argument of the
* method, unless paramTypes is null or empty, in this
* case the rule will call the specified method with no arguments.
*
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of ths element
* @param paramTypes The Java class names of the arguments
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
*/
public CallMethodRule(
String methodName,
int paramCount,
String paramTypes[]) {
this(0, methodName, paramCount, paramTypes);
}
/**
* Construct a "call method" rule with the specified method name and
* parameter types. If paramCount is set to zero the rule
* will use the body of this element as the single argument of the
* method, unless paramTypes is null or empty, in this
* case the rule will call the specified method with no arguments.
*
* @param targetOffset location of the target object. Positive numbers are
* relative to the top of the digester object stack. Negative numbers
* are relative to the bottom of the stack. Zero implies the top
* object on the stack.
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of ths element
* @param paramTypes The Java class names of the arguments
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
*/
public CallMethodRule( int targetOffset,
String methodName,
int paramCount,
String paramTypes[]) {
this.targetOffset = targetOffset;
this.methodName = methodName;
this.paramCount = paramCount;
if (paramTypes == null) {
this.paramTypes = new Class[paramCount];
for (int i = 0; i < this.paramTypes.length; i++) {
this.paramTypes[i] = String.class;
}
} else {
// copy the parameter class names into an array
// the classes will be loaded when the digester is set
this.paramClassNames = new String[paramTypes.length];
for (int i = 0; i < this.paramClassNames.length; i++) {
this.paramClassNames[i] = paramTypes[i];
}
}
}
/**
* Construct a "call method" rule with the specified method name and
* parameter types. If paramCount is set to zero the rule
* will use the body of this element as the single argument of the
* method, unless paramTypes is null or empty, in this
* case the rule will call the specified method with no arguments.
*
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of ths element
* @param paramTypes The Java classes that represent the
* parameter types of the method arguments
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean.TYPE
* for a boolean parameter)
*/
public CallMethodRule(
String methodName,
int paramCount,
Class paramTypes[]) {
this(0, methodName, paramCount, paramTypes);
}
/**
* Construct a "call method" rule with the specified method name and
* parameter types. If paramCount is set to zero the rule
* will use the body of this element as the single argument of the
* method, unless paramTypes is null or empty, in this
* case the rule will call the specified method with no arguments.
*
* @param targetOffset location of the target object. Positive numbers are
* relative to the top of the digester object stack. Negative numbers
* are relative to the bottom of the stack. Zero implies the top
* object on the stack.
* @param methodName Method name of the parent method to call
* @param paramCount The number of parameters to collect, or
* zero for a single argument from the body of ths element
* @param paramTypes The Java classes that represent the
* parameter types of the method arguments
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean.TYPE
* for a boolean parameter)
*/
public CallMethodRule( int targetOffset,
String methodName,
int paramCount,
Class paramTypes[]) {
this.targetOffset = targetOffset;
this.methodName = methodName;
this.paramCount = paramCount;
if (paramTypes == null) {
this.paramTypes = new Class[paramCount];
for (int i = 0; i < this.paramTypes.length; i++) {
this.paramTypes[i] = String.class;
}
} else {
this.paramTypes = new Class[paramTypes.length];
for (int i = 0; i < this.paramTypes.length; i++) {
this.paramTypes[i] = paramTypes[i];
}
}
}
// ----------------------------------------------------- Instance Variables
/**
* The body text collected from this element.
*/
protected String bodyText = null;
/**
* location of the target object for the call, relative to the
* top of the digester object stack. The default value of zero
* means the target object is the one on top of the stack.
*/
protected int targetOffset = 0;
/**
* The method name to call on the parent object.
*/
protected String methodName = null;
/**
* The number of parameters to collect from MethodParam rules.
* If this value is zero, a single parameter will be collected from the
* body of this element.
*/
protected int paramCount = 0;
/**
* The parameter types of the parameters to be collected.
*/
protected Class paramTypes[] = null;
/**
* The names of the classes of the parameters to be collected.
* This attribute allows creation of the classes to be postponed until the digester is set.
*/
private String paramClassNames[] = null;
/**
* Should MethodUtils.invokeExactMethod be used for reflection.
*/
protected boolean useExactMatch = false;
// --------------------------------------------------------- Public Methods
/**
* Should MethodUtils.invokeExactMethod
* be used for the reflection.
*/
public boolean getUseExactMatch() {
return useExactMatch;
}
/**
* Set whether MethodUtils.invokeExactMethod
* should be used for the reflection.
*/
public void setUseExactMatch(boolean useExactMatch)
{
this.useExactMatch = useExactMatch;
}
/**
* Set the associated digester.
* If needed, this class loads the parameter classes from their names.
*/
public void setDigester(Digester digester)
{
// call superclass
super.setDigester(digester);
// if necessary, load parameter classes
if (this.paramClassNames != null) {
this.paramTypes = new Class[paramClassNames.length];
for (int i = 0; i < this.paramClassNames.length; i++) {
try {
this.paramTypes[i] =
digester.getClassLoader().loadClass(this.paramClassNames[i]);
} catch (ClassNotFoundException e) {
// use the digester log
digester.getLogger().error("(CallMethodRule) Cannot load class " + this.paramClassNames[i], e);
this.paramTypes[i] = null; // Will cause NPE later
}
}
}
}
/**
* Process the start of this element.
*
* @param attributes The attribute list for this element
*/
public void begin(Attributes attributes) throws Exception {
// Push an array to capture the parameter values if necessary
if (paramCount > 0) {
Object parameters[] = new Object[paramCount];
for (int i = 0; i < parameters.length; i++) {
parameters[i] = null;
}
digester.pushParams(parameters);
}
}
/**
* Process the body text of this element.
*
* @param bodyText The body text of this element
*/
public void body(String bodyText) throws Exception {
if (paramCount == 0) {
this.bodyText = bodyText.trim();
}
}
/**
* Process the end of this element.
*/
public void end() throws Exception {
// Retrieve or construct the parameter values array
Object parameters[] = null;
if (paramCount > 0) {
parameters = (Object[]) digester.popParams();
if (digester.log.isTraceEnabled()) {
for (int i=0,size=parameters.length;iRule implementation that sets properties on the object at the top of the * stack, based on attributes with corresponding names.
* *This rule supports custom mapping of attribute names to property names. * The default mapping for particular attributes can be overridden by using * {@link #SetPropertiesRule(String[] attributeNames, String[] propertyNames)}. * This allows attributes to be mapped to properties with different names. * Certain attributes can also be marked to be ignored.
*/ public class SetPropertiesRule extends Rule { // ----------------------------------------------------------- Constructors /** * Default constructor sets only the the associated Digester. * * @param digester The digester with which this rule is associated * * @deprecated The digester instance is now set in the {@link Digester#addRule} method. * Use {@link #SetPropertiesRule()} instead. */ public SetPropertiesRule(Digester digester) { this(); } /** * Base constructor. */ public SetPropertiesRule() { // nothing to set up } /** *Convenience constructor overrides the mapping for just one property.
* *For details about how this works, see * {@link #SetPropertiesRule(String[] attributeNames, String[] propertyNames)}.
* * @param attributeName map this attribute * @param propertyName to a property with this name */ public SetPropertiesRule(String attributeName, String propertyName) { attributeNames = new String[1]; attributeNames[0] = attributeName; propertyNames = new String[1]; propertyNames[0] = propertyName; } /** *Constructor allows attribute->property mapping to be overriden.
* *Two arrays are passed in. * One contains the attribute names and the other the property names. * The attribute name / property name pairs are match by position * In order words, the first string in the attribute name list matches * to the first string in the property name list and so on.
* *If a property name is null or the attribute name has no matching * property name, then this indicates that the attibute should be ignored.
* *Example One
* The following constructs a rule that maps the alt-city
* attribute to the city property and the alt-state
* to the state property.
* All other attributes are mapped as usual using exact name matching.
*
* SetPropertiesRule(
* new String[] {"alt-city", "alt-state"},
* new String[] {"city", "state"});
*
Example Two
* The following constructs a rule that maps the class
* attribute to the className property.
* The attribute ignore-me is not mapped.
* All other attributes are mapped as usual using exact name matching.
*
* SetPropertiesRule(
* new String[] {"class", "ignore-me"},
* new String[] {"className"});
*
* If false, the parsing will interrupt with an NoSuchMethodException
* if a property specified in the XML is not found. The default is true.
*
NoSuchMethodException
* if an unmatched
* attribute is found. This allows to trap misspellings in the XML file.
* @param ignoreMissingProperty false to stop the parsing on unmatched attributes.
*/
public void setIgnoreMissingProperty(boolean ignoreMissingProperty) {
this.ignoreMissingProperty = ignoreMissingProperty;
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/RegexMatcher.java 0000644 0001750 0001750 00000002725 11226450007 031530 0 ustar twerner twerner /* $Id: RegexMatcher.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
/**
* Regular expression matching strategy for RegexRules.
*
* @since 1.5
*/
abstract public class RegexMatcher {
/**
* Returns true if the given pattern matches the given path
* according to the regex algorithm that this strategy applies.
*
* @param pathPattern the standard digester path representing the element
* @param rulePattern the regex pattern the path will be tested against
* @return true if the given pattern matches the given path
*/
abstract public boolean match(String pathPattern, String rulePattern);
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/ObjectCreationFactory.java 0000644 0001750 0001750 00000004142 11226450007 033370 0 ustar twerner twerner /* $Id: ObjectCreationFactory.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import org.xml.sax.Attributes;
/**
* Interface for use with {@link FactoryCreateRule}.
* The rule calls {@link #createObject} to create an object
* to be pushed onto the Digester stack
* whenever it is matched.
{@link AbstractObjectCreationFactory} is an abstract
* implementation suitable for creating anonymous
* ObjectCreationFactory implementations.
*/
public interface ObjectCreationFactory {
/**
*
Factory method called by {@link FactoryCreateRule} to supply an * object based on the element's attributes. * * @param attributes the element's attributes * * @throws Exception any exception thrown will be propagated upwards */ public Object createObject(Attributes attributes) throws Exception; /** *
Returns the {@link Digester} that was set by the * {@link FactoryCreateRule} upon initialization. */ public Digester getDigester(); /** *
Set the {@link Digester} to allow the implementation to do logging, * classloading based on the digester's classloader, etc. * * @param digester parent Digester object */ public void setDigester(Digester digester); } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/RuleSetBase.java 0000644 0001750 0001750 00000004275 11226450007 031332 0 ustar twerner twerner /* $Id: RuleSetBase.java 471661 2006-11-06 08:09:25Z skitching $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester; /** *
Convenience base class that implements the {@link RuleSet} interface.
* Concrete implementations should list all of their actual rule creation
* logic in the addRuleSet() implementation.
Digester instance, associating them with
* our namespace URI (if any). This method should only be called
* by a Digester instance.
*
* @param digester Digester instance to which the new Rule instances
* should be added.
*/
public abstract void addRuleInstances(Digester digester);
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/ParserFeatureSetterFactory.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/ParserFeatureSetterFactory.0000644 0001750 0001750 00000005423 11226450007 033575 0 ustar twerner twerner /* $Id: ParserFeatureSetterFactory.java 476205 2006-11-17 16:43:10Z dennisl $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.util.Properties;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.apache.commons.digester.parser.GenericParser;
import org.apache.commons.digester.parser.XercesParser;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
/**
* Creates a SAXParser based on the underlying parser.
* Allows logical properties depending on logical parser versions
* to be set.
*
* @since 1.6
*/
public class ParserFeatureSetterFactory {
/**
* true is Xerces is used.
*/
private static boolean isXercesUsed;
static {
try{
// Use reflection to avoid a build dependency with Xerces.
//
// Note that this does not detect Sun's repackaging of
// Xerces as com.sun.org.apache.xerces; perhaps it should?
SAXParserFactory factory = SAXParserFactory.newInstance();
if (factory.getClass().getName().startsWith("org.apache.xerces")) {
isXercesUsed = true;
}
} catch (Exception ex) {
isXercesUsed = false;
}
}
/**
* Create a new SAXParser
* @param properties (logical) properties to be set on parser
* @return a SAXParser configured based on the underlying
* parser implementation.
*/
public static SAXParser newSAXParser(Properties properties)
throws ParserConfigurationException,
SAXException,
SAXNotRecognizedException,
SAXNotSupportedException {
if (isXercesUsed){
return XercesParser.newSAXParser(properties);
} else {
return GenericParser.newSAXParser(properties);
}
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/RegexRules.java 0000644 0001750 0001750 00000012376 11226450007 031242 0 ustar twerner twerner /* $Id: RegexRules.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Rules implementation that uses regular expression matching for paths.
* *The regex implementation is pluggable, allowing different strategies to be used. * The basic way that this class work does not vary. * All patterns are tested to see if they match the path using the regex matcher. * All those that do are return in the order which the rules were added.
* * @since 1.5 */ public class RegexRules extends AbstractRulesImpl { // --------------------------------------------------------- Fields /** All registeredRule's */
private ArrayList registeredRules = new ArrayList();
/** The regex strategy used by this RegexRules */
private RegexMatcher matcher;
// --------------------------------------------------------- Constructor
/**
* Construct sets the Regex matching strategy.
*
* @param matcher the regex strategy to be used, not null
* @throws IllegalArgumentException if the strategy is null
*/
public RegexRules(RegexMatcher matcher) {
setRegexMatcher(matcher);
}
// --------------------------------------------------------- Properties
/**
* Gets the current regex matching strategy.
*/
public RegexMatcher getRegexMatcher() {
return matcher;
}
/**
* Sets the current regex matching strategy.
*
* @param matcher use this RegexMatcher, not null
* @throws IllegalArgumentException if the strategy is null
*/
public void setRegexMatcher(RegexMatcher matcher) {
if (matcher == null) {
throw new IllegalArgumentException("RegexMatcher must not be null.");
}
this.matcher = matcher;
}
// --------------------------------------------------------- Public Methods
/**
* Register a new Rule instance matching the specified pattern.
*
* @param pattern Nesting pattern to be matched for this Rule
* @param rule Rule instance to be registered
*/
protected void registerRule(String pattern, Rule rule) {
registeredRules.add(new RegisteredRule(pattern, rule));
}
/**
* Clear all existing Rule instance registrations.
*/
public void clear() {
registeredRules.clear();
}
/**
* Finds matching rules by using current regex matching strategy.
* The rule associated with each path that matches is added to the list of matches.
* The order of matching rules is the same order that they were added.
*
* @param namespaceURI Namespace URI for which to select matching rules,
* or null to match regardless of namespace URI
* @param pattern Nesting pattern to be matched
* @return a list of matching Rule's
*/
public List match(String namespaceURI, String pattern) {
//
// not a particularly quick implementation
// regex is probably going to be slower than string equality
// so probably should have a set of strings
// and test each only once
//
// XXX FIX ME - Time And Optimize
//
ArrayList rules = new ArrayList(registeredRules.size());
Iterator it = registeredRules.iterator();
while (it.hasNext()) {
RegisteredRule next = (RegisteredRule) it.next();
if (matcher.match(pattern, next.pattern)) {
rules.add(next.rule);
}
}
return rules;
}
/**
* Return a List of all registered Rule instances, or a zero-length List
* if there are no registered Rule instances. If more than one Rule
* instance has been registered, they must be returned
* in the order originally registered through the add()
* method.
*/
public List rules() {
ArrayList rules = new ArrayList(registeredRules.size());
Iterator it = registeredRules.iterator();
while (it.hasNext()) {
rules.add(((RegisteredRule) it.next()).rule);
}
return rules;
}
/** Used to associate rules with paths in the rules list */
private class RegisteredRule {
String pattern;
Rule rule;
RegisteredRule(String pattern, Rule rule) {
this.pattern = pattern;
this.rule = rule;
}
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/Rules.java 0000644 0001750 0001750 00000010010 11226450007 030226 0 ustar twerner twerner /* $Id: Rules.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.util.List;
/**
* Public interface defining a collection of Rule instances (and corresponding
* matching patterns) plus an implementation of a matching policy that selects
* the rules that match a particular pattern of nested elements discovered
* during parsing.
*/
public interface Rules {
// ------------------------------------------------------------- Properties
/**
* Return the Digester instance with which this Rules instance is
* associated.
*/
public Digester getDigester();
/**
* Set the Digester instance with which this Rules instance is associated.
*
* @param digester The newly associated Digester instance
*/
public void setDigester(Digester digester);
/**
* Return the namespace URI that will be applied to all subsequently
* added Rule objects.
*/
public String getNamespaceURI();
/**
* Set the namespace URI that will be applied to all subsequently
* added Rule objects.
*
* @param namespaceURI Namespace URI that must match on all
* subsequently added rules, or null for matching
* regardless of the current namespace URI
*/
public void setNamespaceURI(String namespaceURI);
// --------------------------------------------------------- Public Methods
/**
* Register a new Rule instance matching the specified pattern.
*
* @param pattern Nesting pattern to be matched for this Rule
* @param rule Rule instance to be registered
*/
public void add(String pattern, Rule rule);
/**
* Clear all existing Rule instance registrations.
*/
public void clear();
/**
* Return a List of all registered Rule instances that match the specified
* nesting pattern, or a zero-length List if there are no matches. If more
* than one Rule instance matches, they must be returned
* in the order originally registered through the add()
* method.
*
* @param pattern Nesting pattern to be matched
*
* @deprecated Call match(namespaceURI,pattern) instead.
*/
public List match(String pattern);
/**
* Return a List of all registered Rule instances that match the specified
* nesting pattern, or a zero-length List if there are no matches. If more
* than one Rule instance matches, they must be returned
* in the order originally registered through the add()
* method.
*
* @param namespaceURI Namespace URI for which to select matching rules,
* or null to match regardless of namespace URI
* @param pattern Nesting pattern to be matched
*/
public List match(String namespaceURI, String pattern);
/**
* Return a List of all registered Rule instances, or a zero-length List
* if there are no registered Rule instances. If more than one Rule
* instance has been registered, they must be returned
* in the order originally registered through the add()
* method.
*/
public List rules();
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/BeanPropertySetterRule.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/BeanPropertySetterRule.java0000644 0001750 0001750 00000015465 11226450007 033610 0 ustar twerner twerner /* $Id: BeanPropertySetterRule.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.beans.PropertyDescriptor;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.DynaProperty;
import org.apache.commons.beanutils.PropertyUtils;
/**
* Rule implements sets a bean property on the top object * to the body text.
* *The property set:
*- can be specified when the rule is created *
- or can match the current element when the rule is called.
Using the second method and the {@link ExtendedBaseRules} child match * pattern, all the child elements can be automatically mapped to properties * on the parent object.
*/ public class BeanPropertySetterRule extends Rule { // ----------------------------------------------------------- Constructors /** *Construct rule that sets the given property from the body text.
* * @param digester associatedDigester
* @param propertyName name of property to set
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #BeanPropertySetterRule(String propertyName)} instead.
*/
public BeanPropertySetterRule(Digester digester, String propertyName) {
this(propertyName);
}
/**
* Construct rule that automatically sets a property from the body text. * *
This construct creates a rule that sets the property
* on the top object named the same as the current element.
*
* @param digester associated Digester
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #BeanPropertySetterRule()} instead.
*/
public BeanPropertySetterRule(Digester digester) {
this();
}
/**
*
Construct rule that sets the given property from the body text.
* * @param propertyName name of property to set */ public BeanPropertySetterRule(String propertyName) { this.propertyName = propertyName; } /** *Construct rule that automatically sets a property from the body text. * *
This construct creates a rule that sets the property * on the top object named the same as the current element. */ public BeanPropertySetterRule() { this((String)null); } // ----------------------------------------------------- Instance Variables /** * Set this property on the top object. */ protected String propertyName = null; /** * The body text used to set the property. */ protected String bodyText = null; // --------------------------------------------------------- Public Methods /** * Process the body text of this element. * * @param namespace the namespace URI of the matching element, or an * empty string if the parser is not namespace aware or the element has * no namespace * @param name the local name if the parser is namespace aware, or just * the element name otherwise * @param text The text of the body of this element */ public void body(String namespace, String name, String text) throws Exception { // log some debugging information if (digester.log.isDebugEnabled()) { digester.log.debug("[BeanPropertySetterRule]{" + digester.match + "} Called with text '" + text + "'"); } bodyText = text.trim(); } /** * Process the end of this element. * * @param namespace the namespace URI of the matching element, or an * empty string if the parser is not namespace aware or the element has * no namespace * @param name the local name if the parser is namespace aware, or just * the element name otherwise * * @exception NoSuchMethodException if the bean does not * have a writeable property of the specified name */ public void end(String namespace, String name) throws Exception { String property = propertyName; if (property == null) { // If we don't have a specific property name, // use the element name. property = name; } // Get a reference to the top object Object top = digester.peek(); // log some debugging information if (digester.log.isDebugEnabled()) { digester.log.debug("[BeanPropertySetterRule]{" + digester.match + "} Set " + top.getClass().getName() + " property " + property + " with text " + bodyText); } // Force an exception if the property does not exist // (BeanUtils.setProperty() silently returns in this case) if (top instanceof DynaBean) { DynaProperty desc = ((DynaBean) top).getDynaClass().getDynaProperty(property); if (desc == null) { throw new NoSuchMethodException ("Bean has no property named " + property); } } else /* this is a standard JavaBean */ { PropertyDescriptor desc = PropertyUtils.getPropertyDescriptor(top, property); if (desc == null) { throw new NoSuchMethodException ("Bean has no property named " + property); } } // Set the property (with conversion as necessary) BeanUtils.setProperty(top, property, bodyText); } /** * Clean up after parsing is complete. */ public void finish() throws Exception { bodyText = null; } /** * Render a printable version of this Rule. */ public String toString() { StringBuffer sb = new StringBuffer("BeanPropertySetterRule["); sb.append("propertyName="); sb.append(propertyName); sb.append("]"); return (sb.toString()); } } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/Rule.java 0000644 0001750 0001750 00000020607 11226450007 030060 0 ustar twerner twerner /* $Id: Rule.java 471661 2006-11-06 08:09:25Z skitching $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester; import org.xml.sax.Attributes; /** * Concrete implementations of this class implement actions to be taken when * a corresponding nested pattern of XML elements has been matched. *
* Writing a custom Rule is considered perfectly normal when using Digester, * and is encouraged whenever the default set of Rule classes don't meet your * requirements; the digester framework can help process xml even when the * built-in rules aren't quite what is needed. Creating a custom Rule is * just as easy as subclassing javax.servlet.http.HttpServlet for webapps, * or javax.swing.Action for GUI applications. *
* If a rule wishes to manipulate a digester stack (the default object stack, * a named stack, or the parameter stack) then it should only ever push * objects in the rule's begin method and always pop exactly the same * number of objects off the stack during the rule's end method. Of course * peeking at the objects on the stacks can be done from anywhere. *
* Rule objects should be stateless, ie they should not update any instance * member during the parsing process. A rule instance that changes state * will encounter problems if invoked in a "nested" manner; this can happen * if the same instance is added to digester multiple times or if a * wildcard pattern is used which can match both an element and a child of the * same element. The digester object stack and named stacks should be used to * store any state that a rule requires, making the rule class safe under all * possible uses. */ public abstract class Rule { // ----------------------------------------------------------- Constructors /** * Constructor sets the associated Digester. * * @param digester The digester with which this rule is associated * @deprecated The digester instance is now set in the {@link Digester#addRule} method. Use {@link #Rule()} instead. */ public Rule(Digester digester) { super(); setDigester(digester); } /** *
Base constructor. * Now the digester will be set when the rule is added.
*/ public Rule() {} // ----------------------------------------------------- Instance Variables /** * The Digester with which this Rule is associated. */ protected Digester digester = null; /** * The namespace URI for which this Rule is relevant, if any. */ protected String namespaceURI = null; // ------------------------------------------------------------- Properties /** * Return the Digester with which this Rule is associated. */ public Digester getDigester() { return (this.digester); } /** * Set theDigester with which this Rule is associated.
*/
public void setDigester(Digester digester) {
this.digester = digester;
}
/**
* Return the namespace URI for which this Rule is relevant, if any.
*/
public String getNamespaceURI() {
return (this.namespaceURI);
}
/**
* Set the namespace URI for which this Rule is relevant, if any.
*
* @param namespaceURI Namespace URI for which this Rule is relevant,
* or null to match independent of namespace.
*/
public void setNamespaceURI(String namespaceURI) {
this.namespaceURI = namespaceURI;
}
// --------------------------------------------------------- Public Methods
/**
* This method is called when the beginning of a matching XML element
* is encountered.
*
* @param attributes The attribute list of this element
* @deprecated Use the {@link #begin(String,String,Attributes) begin}
* method with namespace and name
* parameters instead.
*/
public void begin(Attributes attributes) throws Exception {
; // The default implementation does nothing
}
/**
* This method is called when the beginning of a matching XML element
* is encountered. The default implementation delegates to the deprecated
* method {@link #begin(Attributes) begin} without the
* namespace and name parameters, to retain
* backwards compatibility.
*
* @param namespace the namespace URI of the matching element, or an
* empty string if the parser is not namespace aware or the element has
* no namespace
* @param name the local name if the parser is namespace aware, or just
* the element name otherwise
* @param attributes The attribute list of this element
* @since Digester 1.4
*/
public void begin(String namespace, String name, Attributes attributes)
throws Exception {
begin(attributes);
}
/**
* This method is called when the body of a matching XML element
* is encountered. If the element has no body, this method is
* called with an empty string as the body text.
*
* @param text The text of the body of this element
* @deprecated Use the {@link #body(String,String,String) body} method
* with namespace and name parameters
* instead.
*/
public void body(String text) throws Exception {
; // The default implementation does nothing
}
/**
* This method is called when the body of a matching XML element is
* encountered. If the element has no body, this method is
* called with an empty string as the body text.
*
* The default implementation delegates to the deprecated method
* {@link #body(String) body} without the namespace and
* name parameters, to retain backwards compatibility.
*
* @param namespace the namespace URI of the matching element, or an
* empty string if the parser is not namespace aware or the element has
* no namespace
* @param name the local name if the parser is namespace aware, or just
* the element name otherwise
* @param text The text of the body of this element
* @since Digester 1.4
*/
public void body(String namespace, String name, String text)
throws Exception {
body(text);
}
/**
* This method is called when the end of a matching XML element
* is encountered.
*
* @deprecated Use the {@link #end(String,String) end} method with
* namespace and name parameters instead.
*/
public void end() throws Exception {
; // The default implementation does nothing
}
/**
* This method is called when the end of a matching XML element
* is encountered. The default implementation delegates to the deprecated
* method {@link #end end} without the
* namespace and name parameters, to retain
* backwards compatibility.
*
* @param namespace the namespace URI of the matching element, or an
* empty string if the parser is not namespace aware or the element has
* no namespace
* @param name the local name if the parser is namespace aware, or just
* the element name otherwise
* @since Digester 1.4
*/
public void end(String namespace, String name)
throws Exception {
end();
}
/**
* This method is called after all parsing methods have been
* called, to allow Rules to remove temporary data.
*/
public void finish() throws Exception {
; // The default implementation does nothing
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/parser/ 0000755 0001750 0001750 00000000000 11226450007 027575 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/parser/XercesParser.java 0000644 0001750 0001750 00000014614 11226450007 033054 0 ustar twerner twerner /* $Id: XercesParser.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.parser;
import java.lang.reflect.Method;
import java.util.Properties;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
/**
* Create a SAXParser based on the underlying Xerces version.
* Currently, Xerces 2.3 and up doesn't implement schema validation the same way
* 2.1 was. In other to support schema validation in a portable way between
* parser, some features/properties need to be set.
*
* @since 1.6
*/
public class XercesParser{
/**
* The Log to which all SAX event related logging calls will be made.
*/
protected static Log log =
LogFactory.getLog("org.apache.commons.digester.Digester.sax");
/**
* The JAXP 1.2 property required to set up the schema location.
*/
private static final String JAXP_SCHEMA_SOURCE =
"http://java.sun.com/xml/jaxp/properties/schemaSource";
/**
* The JAXP 1.2 property to set up the schemaLanguage used.
*/
protected static String JAXP_SCHEMA_LANGUAGE =
"http://java.sun.com/xml/jaxp/properties/schemaLanguage";
/**
* Xerces dynamic validation property
*/
protected static String XERCES_DYNAMIC =
"http://apache.org/xml/features/validation/dynamic";
/**
* Xerces schema validation property
*/
protected static String XERCES_SCHEMA =
"http://apache.org/xml/features/validation/schema";
/**
* A float representing the underlying Xerces version
*/
protected static float version;
/**
* The current Xerces version.
*/
protected static String versionNumber = null;
/**
* Return the current Xerces version.
* @return the current Xerces version.
*/
private static String getXercesVersion() {
// If for some reason we can't get the version, set it to 1.0.
String versionNumber = "1.0";
try{
// Use reflection to avoid a build dependency with Xerces.
Class versionClass =
Class.forName("org.apache.xerces.impl.Version");
// Will return Xerces-J 2.x.0
Method method =
versionClass.getMethod("getVersion", (Class[])null);
String version = (String)method.invoke(null, (Object[])null);
versionNumber = version.substring( "Xerces-J".length() ,
version.lastIndexOf(".") );
} catch (Exception ex){
// Do nothing.
}
return versionNumber;
}
/**
* Create a SAXParser based on the underlying
* Xerces version.
* @param properties parser specific properties/features
* @return an XML Schema/DTD enabled SAXParser
*/
public static SAXParser newSAXParser(Properties properties)
throws ParserConfigurationException,
SAXException,
SAXNotSupportedException {
SAXParserFactory factory =
(SAXParserFactory)properties.get("SAXParserFactory");
if (versionNumber == null){
versionNumber = getXercesVersion();
version = new Float( versionNumber ).floatValue();
}
// Note: 2.2 is completely broken (with XML Schema).
if (version > 2.1) {
configureXerces(factory);
return factory.newSAXParser();
} else {
SAXParser parser = factory.newSAXParser();
configureOldXerces(parser,properties);
return parser;
}
}
/**
* Configure schema validation as recommended by the JAXP 1.2 spec.
* The properties object may contains information about
* the schema local and language.
* @param properties parser optional info
*/
private static void configureOldXerces(SAXParser parser,
Properties properties)
throws ParserConfigurationException,
SAXNotSupportedException {
String schemaLocation = (String)properties.get("schemaLocation");
String schemaLanguage = (String)properties.get("schemaLanguage");
try{
if (schemaLocation != null) {
parser.setProperty(JAXP_SCHEMA_LANGUAGE, schemaLanguage);
parser.setProperty(JAXP_SCHEMA_SOURCE, schemaLocation);
}
} catch (SAXNotRecognizedException e){
log.info(parser.getClass().getName() + ": "
+ e.getMessage() + " not supported.");
}
}
/**
* Configure schema validation as recommended by the Xerces spec.
* Both DTD and Schema validation will be enabled simultaneously.
*
* NOTE: This method is broken. It is supposed to set up validation * against the schema specified in property "schemaLocation", but * it doesn't. * * @param factory SAXParserFactory to be configured */ private static void configureXerces(SAXParserFactory factory) throws ParserConfigurationException, SAXNotRecognizedException, SAXNotSupportedException { factory.setFeature(XERCES_DYNAMIC, true); factory.setFeature(XERCES_SCHEMA, true); } } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/parser/package.html 0000644 0001750 0001750 00000004403 11226450007 032057 0 ustar twerner twerner
Digester aims to support the widest range possible of parsers. Unfortunately, there are a few parser settings which have not been standardized. In most cases, the best practice is for the user to configure the parser themselves and pass it to Digester to use.
There are a few reasonable exceptions which Digester makes to this general rule. There are a small number of common use cases where insisting that the user configure the parser may reduce the portability of applications using Digester. These are outlined below.
Validating With Schema
When validating using schemas (rather than DTDs), settings for schema language and schema location are commonly needed. Unfortunately, there is a lack of standardization for these settings. In particular, for older versions of Xerces, these are set differently from newer versions.
In order to aid portability for this common use case, Digester uses
the classes in this package (together with ParserFeatureSetterFactory)
to guess the parser and set these properties appropriately.
The aim is for Digester to automagically recognize and configure each parser.
Help would be gratefully appreciated to maintain and improve the support in this area.
SAXParser configured to support XML Schema and DTD.
*
* @since 1.6
*/
public class GenericParser{
/**
* The Log to which all SAX event related logging calls will be made.
*/
protected static Log log =
LogFactory.getLog("org.apache.commons.digester.Digester.sax");
/**
* The JAXP 1.2 property required to set up the schema location.
*/
private static final String JAXP_SCHEMA_SOURCE =
"http://java.sun.com/xml/jaxp/properties/schemaSource";
/**
* The JAXP 1.2 property to set up the schemaLanguage used.
*/
protected static String JAXP_SCHEMA_LANGUAGE =
"http://java.sun.com/xml/jaxp/properties/schemaLanguage";
/**
* Create a SAXParser configured to support XML Scheman and DTD
* @param properties parser specific properties/features
* @return an XML Schema/DTD enabled SAXParser
*/
public static SAXParser newSAXParser(Properties properties)
throws ParserConfigurationException,
SAXException,
SAXNotRecognizedException{
SAXParserFactory factory =
(SAXParserFactory)properties.get("SAXParserFactory");
SAXParser parser = factory.newSAXParser();
String schemaLocation = (String)properties.get("schemaLocation");
String schemaLanguage = (String)properties.get("schemaLanguage");
try{
if (schemaLocation != null) {
parser.setProperty(JAXP_SCHEMA_LANGUAGE, schemaLanguage);
parser.setProperty(JAXP_SCHEMA_SOURCE, schemaLocation);
}
} catch (SAXNotRecognizedException e){
log.info(parser.getClass().getName() + ": "
+ e.getMessage() + " not supported.");
}
return parser;
}
} ././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/SetNestedPropertiesRule.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/SetNestedPropertiesRule.jav0000644 0001750 0001750 00000044416 11226450007 033617 0 ustar twerner twerner /* $Id: SetNestedPropertiesRule.java 472836 2006-11-09 10:06:56Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import java.util.List;
import java.util.LinkedList;
import java.util.ArrayList;
import java.util.HashMap;
import java.beans.PropertyDescriptor;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.DynaProperty;
import org.apache.commons.beanutils.PropertyUtils;
import org.xml.sax.Attributes;
import org.apache.commons.logging.Log;
/**
* Rule implementation that sets properties on the object at the top of the * stack, based on child elements with names matching properties on that * object.
* *Example input that can be processed by this rule:
** [widget] * [height]7[/height] * [width]8[/width] * [label]Hello, world[/label] * [/widget] ** *
For each child element of [widget], a corresponding setter method is * located on the object on the top of the digester stack, the body text of * the child element is converted to the type specified for the (sole) * parameter to the setter method, then the setter method is invoked.
* *This rule supports custom mapping of xml element names to property names. * The default mapping for particular elements can be overridden by using * {@link #SetNestedPropertiesRule(String[] elementNames, * String[] propertyNames)}. * This allows child elements to be mapped to properties with different names. * Certain elements can also be marked to be ignored.
* *A very similar effect can be achieved using a combination of the
* BeanPropertySetterRule and the ExtendedBaseRules
* rules manager; this Rule, however, works fine with the default
* RulesBase rules manager.
Note that this rule is designed to be used to set only "primitive" * bean properties, eg String, int, boolean. If some of the child xml elements * match ObjectCreateRule rules (ie cause objects to be created) then you must * use one of the more complex constructors to this rule to explicitly skip * processing of that xml element, and define a SetNextRule (or equivalent) to * handle assigning the child object to the appropriate property instead.
* *Implementation Notes
* *This class works by creating its own simple Rules implementation. When * begin is invoked on this rule, the digester's current rules object is * replaced by a custom one. When end is invoked for this rule, the original * rules object is restored. The digester rules objects therefore behave in * a stack-like manner.
* *For each child element encountered, the custom Rules implementation * ensures that a special AnyChildRule instance is included in the matches * returned to the digester, and it is this rule instance that is responsible * for setting the appropriate property on the target object (if such a property * exists). The effect is therefore like a "trailing wildcard pattern". The * custom Rules implementation also returns the matches provided by the * underlying Rules implementation for the same pattern, so other rules * are not "disabled" during processing of a SetNestedPropertiesRule.
* *TODO: Optimise this class. Currently, each time begin is called, * new AnyChildRules and AnyChildRule objects are created. It should be * possible to cache these in normal use (though watch out for when a rule * instance is invoked re-entrantly!).
* * @since 1.6 */ public class SetNestedPropertiesRule extends Rule { private Log log = null; private boolean trimData = true; private boolean allowUnknownChildElements = false; private HashMap elementNames = new HashMap(); // ----------------------------------------------------------- Constructors /** * Base constructor, which maps every child element into a bean property * with the same name as the xml element. * *It is an error if a child xml element exists but the target java * bean has no such property (unless setAllowUnknownChildElements has been * set to true).
*/ public SetNestedPropertiesRule() { // nothing to set up } /** *Convenience constructor which overrides the default mappings for * just one property.
* *For details about how this works, see * {@link #SetNestedPropertiesRule(String[] elementNames, * String[] propertyNames)}.
* * @param elementName is the child xml element to match * @param propertyName is the java bean property to be assigned the value * of the specified xml element. This may be null, in which case the * specified xml element will be ignored. */ public SetNestedPropertiesRule(String elementName, String propertyName) { elementNames.put(elementName, propertyName); } /** *Constructor which allows element->property mapping to be overridden. *
* *Two arrays are passed in. One contains xml element names and the * other java bean property names. The element name / property name pairs * are matched by position; in order words, the first string in the element * name array corresponds to the first string in the property name array * and so on.
* *If a property name is null or the xml element name has no matching * property name due to the arrays being of different lengths then this * indicates that the xml element should be ignored.
* *Example One
* The following constructs a rule that maps the alt-city
* element to the city property and the alt-state
* to the state property. All other child elements are mapped
* as usual using exact name matching.
*
* SetNestedPropertiesRule(
* new String[] {"alt-city", "alt-state"},
* new String[] {"city", "state"});
*
Example Two
* The following constructs a rule that maps the class
* xml element to the className property. The xml element
* ignore-me is not mapped, ie is ignored. All other elements
* are mapped as usual using exact name matching.
*
* SetPropertiesRule(
* new String[] {"class", "ignore-me"},
* new String[] {"className"});
*
* When set to true, any child element for which there is no * corresponding object property will simply be ignored. *
* The default value of this attribute is false (unknown child elements * are not allowed). */ public void setAllowUnknownChildElements(boolean allowUnknownChildElements) { this.allowUnknownChildElements = allowUnknownChildElements; } /** See {@link #setAllowUnknownChildElements}. */ public boolean getAllowUnknownChildElements() { return allowUnknownChildElements; } /** * Process the beginning of this element. * * @param namespace is the namespace this attribute is in, or null * @param name is the name of the current xml element * @param attributes is the attribute list of this element */ public void begin(String namespace, String name, Attributes attributes) throws Exception { Rules oldRules = digester.getRules(); AnyChildRule anyChildRule = new AnyChildRule(); anyChildRule.setDigester(digester); AnyChildRules newRules = new AnyChildRules(anyChildRule); newRules.init(digester.getMatch()+"/", oldRules); digester.setRules(newRules); } /** * This is only invoked after all child elements have been processed, * so we can remove the custom Rules object that does the * child-element-matching. */ public void body(String bodyText) throws Exception { AnyChildRules newRules = (AnyChildRules) digester.getRules(); digester.setRules(newRules.getOldRules()); } /** * Add an additional custom xml-element -> property mapping. *
* This is primarily intended to be used from the xml rules module * (as it is not possible there to pass the necessary parameters to the * constructor for this class). However it is valid to use this method * directly if desired. */ public void addAlias(String elementName, String propertyName) { elementNames.put(elementName, propertyName); } /** * Render a printable version of this Rule. */ public String toString() { StringBuffer sb = new StringBuffer("SetNestedPropertiesRule["); sb.append("allowUnknownChildElements="); sb.append(allowUnknownChildElements); sb.append(", trimData="); sb.append(trimData); sb.append(", elementNames="); sb.append(elementNames); sb.append("]"); return sb.toString(); } //----------------------------------------- local classes /** Private Rules implementation */ private class AnyChildRules implements Rules { private String matchPrefix = null; private Rules decoratedRules = null; private ArrayList rules = new ArrayList(1); private AnyChildRule rule; public AnyChildRules(AnyChildRule rule) { this.rule = rule; rules.add(rule); } public Digester getDigester() { return null; } public void setDigester(Digester digester) {} public String getNamespaceURI() {return null;} public void setNamespaceURI(String namespaceURI) {} public void add(String pattern, Rule rule) {} public void clear() {} public List match(String matchPath) { return match(null,matchPath); } public List match(String namespaceURI, String matchPath) { List match = decoratedRules.match(namespaceURI, matchPath); if ((matchPath.startsWith(matchPrefix)) && (matchPath.indexOf('/', matchPrefix.length()) == -1)) { // The current element is a direct child of the element // specified in the init method, so we want to ensure that // the rule passed to this object's constructor is included // in the returned list of matching rules. if ((match == null || match.size()==0)) { // The "real" rules class doesn't have any matches for // the specified path, so we return a list containing // just one rule: the one passed to this object's // constructor. return rules; } else { // The "real" rules class has rules that match the current // node, so we return this list *plus* the rule passed to // this object's constructor. // // It might not be safe to modify the returned list, // so clone it first. LinkedList newMatch = new LinkedList(match); newMatch.addLast(rule); return newMatch; } } else { return match; } } public List rules() { // This is not actually expected to be called during normal // processing. // // There is only one known case where this is called; when a rule // returned from AnyChildRules.match is invoked and throws a // SAXException then method Digester.endDocument will be called // without having "uninstalled" the AnyChildRules ionstance. That // method attempts to invoke the "finish" method for every Rule // instance - and thus needs to call rules() on its Rules object, // which is this one. Actually, java 1.5 and 1.6beta2 have a // bug in their xml implementation such that endDocument is not // called after a SAXException, but other parsers (eg Aelfred) // do call endDocument. Here, we therefore need to return the // rules registered with the underlying Rules object. log.debug("AnyChildRules.rules invoked."); return decoratedRules.rules(); } public void init(String prefix, Rules rules) { matchPrefix = prefix; decoratedRules = rules; } public Rules getOldRules() { return decoratedRules; } } private class AnyChildRule extends Rule { private String currChildNamespaceURI = null; private String currChildElementName = null; public void begin(String namespaceURI, String name, Attributes attributes) throws Exception { currChildNamespaceURI = namespaceURI; currChildElementName = name; } public void body(String value) throws Exception { String propName = currChildElementName; if (elementNames.containsKey(currChildElementName)) { // overide propName propName = (String) elementNames.get(currChildElementName); if (propName == null) { // user wants us to ignore this element return; } } boolean debug = log.isDebugEnabled(); if (debug) { log.debug("[SetNestedPropertiesRule]{" + digester.match + "} Setting property '" + propName + "' to '" + value + "'"); } // Populate the corresponding properties of the top object Object top = digester.peek(); if (debug) { if (top != null) { log.debug("[SetNestedPropertiesRule]{" + digester.match + "} Set " + top.getClass().getName() + " properties"); } else { log.debug("[SetPropertiesRule]{" + digester.match + "} Set NULL properties"); } } if (trimData) { value = value.trim(); } if (!allowUnknownChildElements) { // Force an exception if the property does not exist // (BeanUtils.setProperty() silently returns in this case) if (top instanceof DynaBean) { DynaProperty desc = ((DynaBean) top).getDynaClass().getDynaProperty(propName); if (desc == null) { throw new NoSuchMethodException ("Bean has no property named " + propName); } } else /* this is a standard JavaBean */ { PropertyDescriptor desc = PropertyUtils.getPropertyDescriptor(top, propName); if (desc == null) { throw new NoSuchMethodException ("Bean has no property named " + propName); } } } try { BeanUtils.setProperty(top, propName, value); } catch(NullPointerException e) { log.error("NullPointerException: " + "top=" + top + ",propName=" + propName + ",value=" + value + "!"); throw e; } } public void end(String namespace, String name) throws Exception { currChildElementName = null; } } } libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/RuleSet.java 0000644 0001750 0001750 00000004721 11226450007 030533 0 ustar twerner twerner /* $Id: RuleSet.java 471661 2006-11-06 08:09:25Z skitching $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester; /** *
Public interface defining a shorthand means of configuring a complete
* set of related Rule definitions, possibly associated with
* a particular namespace URI, in one operation. To use an instance of a
* class that imlements this interface:
-
*
- Create a concrete implementation of this interface. *
- Optionally, you can configure a
RuleSetto be relevant * only for a particular namespace URI by configuring the value to be * returned bygetNamespaceURI().
* - As you are configuring your Digester instance, call
*
digester.addRuleSet()and pass the RuleSet instance.
* - Digester will call the
addRuleInstances()method of * your RuleSet to configure the necessary rules.
*
Digester instance, associating them with
* our namespace URI (if any). This method should only be called
* by a Digester instance.
*
* @param digester Digester instance to which the new Rule instances
* should be added.
*/
public void addRuleInstances(Digester digester);
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/SimpleRegexMatcher.java 0000644 0001750 0001750 00000012675 11226450007 032707 0 ustar twerner twerner /* $Id: SimpleRegexMatcher.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Simple regex pattern matching algorithm.
* *This uses just two wildcards: *
-
*
*matches any sequence of none, one or more characters *?matches any one character *
Log implementation.
*/
public Log getLog() {
return log;
}
/**
* Sets the current Log implementation used by this class.
*/
public void setLog(Log log) {
this.log = log;
}
// --------------------------------------------------------- Public Methods
/**
* Matches using simple regex algorithm.
*
*
* @param basePattern the standard digester path representing the element
* @param regexPattern the regex pattern the path will be tested against
* @return true if the given pattern matches the given path
*/
public boolean match(String basePattern, String regexPattern) {
// check for nulls
if (basePattern == null || regexPattern == null) {
return false;
}
return match(basePattern, regexPattern, 0, 0);
}
// --------------------------------------------------------- Implementations Methods
/**
* Implementation of regex matching algorithm.
* This calls itself recursively.
*/
private boolean match(String basePattern, String regexPattern, int baseAt, int regexAt) {
if (log.isTraceEnabled()) {
log.trace("Base: " + basePattern);
log.trace("Regex: " + regexPattern);
log.trace("Base@" + baseAt);
log.trace("Regex@" + regexAt);
}
// check bounds
if (regexAt >= regexPattern.length()) {
// maybe we've got a match
if (baseAt >= basePattern.length()) {
// ok!
return true;
}
// run out early
return false;
} else {
if (baseAt >= basePattern.length()) {
// run out early
return false;
}
}
// ok both within bounds
char regexCurrent = regexPattern.charAt(regexAt);
switch (regexCurrent) {
case '*':
// this is the tricky case
// check for terminal
if (++regexAt >= regexPattern.length()) {
// this matches anything let - so return true
return true;
}
// go through every subsequent apperance of the next character
// and so if the rest of the regex matches
char nextRegex = regexPattern.charAt(regexAt);
if (log.isTraceEnabled()) {
log.trace("Searching for next '" + nextRegex + "' char");
}
int nextMatch = basePattern.indexOf(nextRegex, baseAt);
while (nextMatch != -1) {
if (log.isTraceEnabled()) {
log.trace("Trying '*' match@" + nextMatch);
}
if (match(basePattern, regexPattern, nextMatch, regexAt)) {
return true;
}
nextMatch = basePattern.indexOf(nextRegex, nextMatch + 1);
}
log.trace("No matches found.");
return false;
case '?':
// this matches anything
return match(basePattern, regexPattern, ++baseAt, ++regexAt);
default:
if (log.isTraceEnabled()) {
log.trace("Camparing " + regexCurrent + " to " + basePattern.charAt(baseAt));
}
if (regexCurrent == basePattern.charAt(baseAt)) {
// still got more to go
return match(basePattern, regexPattern, ++baseAt, ++regexAt);
}
return false;
}
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/ 0000755 0001750 0001750 00000000000 11226450007 030154 5 ustar twerner twerner ././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/CircularIncludeException.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/CircularIncludeExc0000644 0001750 0001750 00000002563 11226450007 033615 0 ustar twerner twerner /* $Id: CircularIncludeException.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.xmlrules;
/**
* Thrown when parsing XML into Digester rules, if a circular inclusion occurred
* in the xml digester rules files.
*
* @since 1.2
*/
public class CircularIncludeException extends XmlLoadException {
/**
* @param fileName the name of the XML file suspected of causing the
* circular inclusion
*/
public CircularIncludeException(String fileName) {
super("Circular file inclusion detected for file: " + fileName);
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/DigesterLoader.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/DigesterLoader.jav0000644 0001750 0001750 00000026146 11226450007 033564 0 ustar twerner twerner /* $Id: DigesterLoader.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.xmlrules;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.net.URL;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.RuleSet;
import org.xml.sax.SAXException;
import org.xml.sax.InputSource;
/**
* This class manages the creation of Digester instances from XML digester
* rules files.
*
* @since 1.2
*/
public class DigesterLoader {
/**
* Creates a new digester and initializes it from the specified InputSource
* @param rulesSource load the xml rules from this InputSource
* @return a new Digester initialized with the rules
*/
public static Digester createDigester(InputSource rulesSource) {
RuleSet ruleSet = new FromXmlRuleSet(rulesSource);
Digester digester = new Digester();
digester.addRuleSet(ruleSet);
return digester;
}
/**
* Creates a new digester and initializes it from the specified InputSource.
* This constructor allows the digester to be used to load the rules to be specified.
* This allows properties to be configured on the Digester instance before it is used.
*
* @param rulesSource load the xml rules from this InputSource
* @param rulesDigester digester to load the specified XML file.
* @return a new Digester initialized with the rules
*/
public static Digester createDigester(InputSource rulesSource, Digester rulesDigester) {
RuleSet ruleSet = new FromXmlRuleSet(rulesSource, rulesDigester);
Digester digester = new Digester();
digester.addRuleSet(ruleSet);
return digester;
}
/**
* Creates a new digester and initializes it from the specified XML file
* @param rulesXml URL to the XML file defining the digester rules
* @return a new Digester initialized with the rules
*/
public static Digester createDigester(URL rulesXml) {
RuleSet ruleSet = new FromXmlRuleSet(rulesXml);
Digester digester = new Digester();
digester.addRuleSet(ruleSet);
return digester;
}
/**
* Creates a new digester and initializes it from the specified XML file.
* This constructor allows specifing a rulesDigester to do the XML file
* loading; thus no matter the XML files is packed into a jar, a war, or a
* ear, the rulesDigester can always find the XML files with properly set
* ClassLoader.
*
* @param rulesXml URL to the XML file defining the digester rules
* @param rulesDigester digester to load the specified XML file.
* @return a new Digester initialized with the rules
*/
public static Digester createDigester(URL rulesXml, Digester rulesDigester) {
RuleSet ruleSet = new FromXmlRuleSet(rulesXml, rulesDigester);
Digester digester = new Digester();
digester.addRuleSet(ruleSet);
return digester;
}
/**
* Given the digester rules XML file, a class loader, and an XML input file,
* this method parses the input file into Java objects. The class loader
* is used by the digester to create the Java objects.
* @param digesterRules URL to the XML document defining the digester rules
* @param classLoader the ClassLoader to register with the digester
* @param fileURL URL to the XML file to parse into Java objects
* @return an Object which is the root of the network of Java objects
* created by digesting fileURL
*/
public static Object load(URL digesterRules, ClassLoader classLoader,
URL fileURL) throws IOException, SAXException, DigesterLoadingException {
return load(digesterRules, classLoader, fileURL.openStream());
}
/**
* Given the digester rules XML file, a class loader, and an input stream,
* this method parses the input into Java objects. The class loader
* is used by the digester to create the Java objects.
* @param digesterRules URL to the XML document defining the digester rules
* @param classLoader the ClassLoader to register with the digester
* @param input InputStream over the XML file to parse into Java objects
* @return an Object which is the root of the network of Java objects
* created by digesting fileURL
*/
public static Object load(URL digesterRules, ClassLoader classLoader,
InputStream input) throws IOException, SAXException, DigesterLoadingException {
Digester digester = createDigester(digesterRules);
digester.setClassLoader(classLoader);
try {
return digester.parse(input);
} catch (XmlLoadException ex) {
// This is a runtime exception that can be thrown by
// FromXmlRuleSet#addRuleInstances, which is called by the Digester
// before it parses the file.
throw new DigesterLoadingException(ex.getMessage(), ex);
}
}
/**
* Given the digester rules XML file, a class loader, and an input stream,
* this method parses the input into Java objects. The class loader
* is used by the digester to create the Java objects.
* @param digesterRules URL to the XML document defining the digester rules
* @param classLoader the ClassLoader to register with the digester
* @param reader Reader over the XML file to parse into Java objects
* @return an Object which is the root of the network of Java objects
* created by digesting fileURL
*/
public static Object load(
URL digesterRules,
ClassLoader classLoader,
Reader reader)
throws
IOException,
SAXException,
DigesterLoadingException {
Digester digester = createDigester(digesterRules);
digester.setClassLoader(classLoader);
try {
return digester.parse(reader);
} catch (XmlLoadException ex) {
// This is a runtime exception that can be thrown by
// FromXmlRuleSet#addRuleInstances, which is called by the Digester
// before it parses the file.
throw new DigesterLoadingException(ex.getMessage(), ex);
}
}
/**
* Given the digester rules XML file, a class loader, and an XML input file,
* this method parses the input file into Java objects. The class loader
* is used by the digester to create the Java objects.
* @param digesterRules URL to the XML document defining the digester rules
* @param classLoader the ClassLoader to register with the digester
* @param fileURL URL to the XML file to parse into Java objects
* @param rootObject an Object to push onto the digester's stack, prior
* to parsing the input
* @return an Object which is the root of the network of Java objects.
* Usually, this will be the same object as rootObject
* created by digesting fileURL
*/
public static Object load(URL digesterRules, ClassLoader classLoader,
URL fileURL, Object rootObject) throws IOException, SAXException,
DigesterLoadingException {
return load(digesterRules, classLoader, fileURL.openStream(), rootObject);
}
/**
* Given the digester rules XML file, a class loader, and an input stream,
* this method parses the input into Java objects. The class loader
* is used by the digester to create the Java objects.
* @param digesterRules URL to the XML document defining the digester rules
* @param classLoader the ClassLoader to register with the digester
* @param input InputStream over the XML file to parse into Java objects
* @param rootObject an Object to push onto the digester's stack, prior
* to parsing the input
* @return an Object which is the root of the network of Java objects
* created by digesting fileURL
*/
public static Object load(URL digesterRules, ClassLoader classLoader,
InputStream input, Object rootObject) throws IOException, SAXException,
DigesterLoadingException {
Digester digester = createDigester(digesterRules);
digester.setClassLoader(classLoader);
digester.push(rootObject);
try {
return digester.parse(input);
} catch (XmlLoadException ex) {
// This is a runtime exception that can be thrown by
// FromXmlRuleSet#addRuleInstances, which is called by the Digester
// before it parses the file.
throw new DigesterLoadingException(ex.getMessage(), ex);
}
}
/**
* Given the digester rules XML file, a class loader, and an input stream,
* this method parses the input into Java objects. The class loader
* is used by the digester to create the Java objects.
* @param digesterRules URL to the XML document defining the digester rules
* @param classLoader the ClassLoader to register with the digester
* @param input Reader over the XML file to parse into Java objects
* @param rootObject an Object to push onto the digester's stack, prior
* to parsing the input
* @return an Object which is the root of the network of Java objects
* created by digesting fileURL
*/
public static Object load(
URL digesterRules,
ClassLoader classLoader,
Reader input,
Object rootObject)
throws
IOException,
SAXException,
DigesterLoadingException {
Digester digester = createDigester(digesterRules);
digester.setClassLoader(classLoader);
digester.push(rootObject);
try {
return digester.parse(input);
} catch (XmlLoadException ex) {
// This is a runtime exception that can be thrown by
// FromXmlRuleSet#addRuleInstances, which is called by the Digester
// before it parses the file.
throw new DigesterLoadingException(ex.getMessage(), ex);
}
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/package.html 0000644 0001750 0001750 00000024265 11226450007 032446 0 ustar twerner twerner
The xmlrules package provides for XML-based definition of
rules for Digester. This improves maintainability of Java code,
as rules are now defined in XML and read into Digester at run-time.
[Introduction]
[DTD Overview]
[Rule Elements]
[Matching Patterns]
[Including rules files in other rules files]
[Including programmatically-created rules]
[Creating a digester from XML]
[DTD Overview]
[Rule Elements]
[Matching Patterns]
[Including rules files in other rules files]
[Including programmatically-created rules]
[Creating a digester from XML]
Introduction
This is a brief overview of the digester-rules-in-XML feature. Briefly, this feature lets you define Digester rules in XML, instead of creating and initializing the Rules objects programmatically, which can become tedious. In addition, it allows for including of one XML rules file within another, inclusion of programmatically created rule sets within an XML file (via reflection), and recursively nested matching pattern specifications.
Overview of digester-rules.dtd
A DTD, named digester-rules.dtd has been defined to help in the
understanding of how the loader operates.
The DTD is distributed in the commons-digester.jar. It can be found at
org/apache/commons/digester/xmlrules/digester-rules.dtd. It is not available
for download from the Apache website since users are best advised to use a copy stored
on their local system.
Digester input documents wishing to cite this DTD should include the following DOCTYPE declaration:
<!DOCTYPE digester-rules PUBLIC "-//Jakarta Apache //DTD digester-rules XML V1.0//EN" "digester-rules.dtd">
Rule elements:
The DTD defines an element type corresponding to each predefined Digester
rule. Each rule element type includes attributes for values needed to
initialize the rule, and an optional pattern attribute
specifying the pattern to associate with the rule.
The DigesterLoader adds the rules to the digester in the order in
which they occur in the XML.
The use of each rule element type should be self-explanatory, if you compare
them to the API documentation for the Digester rules classes.
Defining matching patterns:
The matching pattern is a simple, xpath-like string which the
Digester uses to determine which elements to apply each rule to.
See the Digester documentation for
more details.
There are two methods for associating patterns to rules in the XML file. One
is for each rule element to directly define its pattern in a
pattern attribute. An example would like something like:
<digester-rules>
<object-create-rule pattern="*/foo" classname="Foo"/>
<set-properties-rule pattern="*/foo"/>
</digester-rules>
In the above example, an
ObjectCreateRule is created and
associated with the pattern "*/foo"; then a SetPropertiesRule is
created and associated with the pattern "*/foo".
The other method is to nest rules elements inside a
<pattern> element. In this way, the same pattern can be
defined for a group of rules. The following example has the same effect as the
previous example:
<digester-rules>
<pattern value="*/foo">
<object-create-rule classname="Foo"/>
<set-properties-rule/>
</pattern>
</digester-rules>
Pattern elements can be recursively nested. If patterns are nested, the pattern string is formed by concatenating all the patterns together. Example:
<digester-rules>
<pattern value="*/foo">
<pattern value="bar">
<object-create-rule classname="Foobar"/>
<set-properties-rule/>
</pattern>
</pattern>
</digester-rules>
In the above example, an
ObjectCreateRule and a
SetPropertiesRule are associated with the matching pattern
"*/foo/bar".
The use of pattern elements and the use of the pattern attribute inside rules elements can be freely mixed. The next example has the same effect as the previous example:
<digester-rules>
<pattern value="*/foo">
<object-create-rule pattern="bar" classname="Foobar"/>
<set-properties-rule pattern="bar"/>
</pattern>
</digester-rules>
Including rules XML files within other rules XML files:
The <include> element lets you include one rules file within
another. With respect to pattern concatenation, the DigesterLoader
behaves as if the include file was 'macro-expanded'. Example:
File rules1.xml:
<?xml version="1.0"?>
<!DOCTYPE digester-rules SYSTEM "digester-rules.dtd">
<digester-rules>
<pattern value="root/foo">
<object-create-rule classname="Foo"/>
<include path="rules2.xml"/>
</pattern>
</digester-rules>
File rules2.xml:
<?xml version="1.0"?>
<!DOCTYPE digester-rules SYSTEM "digester-rules.dtd">
<digester-rules>
<pattern value="bar">
<object-create-rule classname="Bar"/>
</pattern>
</digester-rules>
Parsing rule1.xml would result in a
Digester initialized with these
pattern/rule pairs:
root/foo -> ObjectCreateRule(Foo)
root/foo/bar -> ObjectCreateRule(Bar)
Note that the pattern for the 'bar' rule has been prepended with the 'root/foo' pattern. If rule2.xml was parsed by itself, it would yield a
Digester
initialized with this pattern/rule:
bar -> ObjectCreateRule(Bar)
Including programmatically-created rules:
Sometimes rules cannot be easily defined via XML. Rule sets that are created
programmatically can still be included within a digester-rules XML file. This
is done by using an <include> element with a
class attribute, containing the name of a class that implements
org.apache.commons.digester.xmlrules.DigesterRulesSource.
This interface defines one method, getRules(Digester), which
creates rules and adds them to the supplied Digester. The pattern concatenation
works exactly as if the rules had been included from an XML file. Example:
File rules3.xml:
<?xml version="1.0"?>
<!DOCTYPE digester-rules SYSTEM "digester-rules.dtd">
<digester-rules>
<pattern value="root/foo">
<object-create-rule classname="Foo"/>
<include class="BarRuleCreator"/>
</pattern>
</digester-rules>
BarRuleCreator class definition:
public class BarRuleCreator implements DigesterRulesSource {
public void getRules(Digester digester) {
digester.addObjectCreate("bar", "Bar");
}
}
Parsing rules3.xml yields the same results as rules1.xml above:
root/foo -> ObjectCreateRule(Foo)
root/foo/bar -> ObjectCreateRule(Bar)
Creating a digester from XML:
FromXmlRuleSet is a RuleSet implementation that
initializes its Digester from rules defined in an XML file. The
path to the XML file is passed to constructor.
Alternatively, the convenience class DigesterLoader defines a
static method,
Digester createDigester(String rulesXml) throws DigesterLoaderException".
When passing the name of the file that contains your digester rules, this
method returns a Digester instance initialized with the rules.
To add your own rules, you need to:
- Update the DTD
You should add an element type for your rule. The element should have an attribute corresponding to each of the rule's initialization parameters. - Define an
ObjectCreationFactory - Extend
DigesterRuleParserDigesterRuleParseris aRuleSetfor parsing a rules XML file. You should extend this, and override theaddRuleInstances()method to add the rules for parsing your new element. Look in DigesterRuleParser.java to see how its done.
* Note that this method doesn't have a matching one on the DigesterLoader
* class, because it is not expected to be widely used, and DigesterLoader's
* load method is already heavily overloaded.
*
* @param digester is the digester that rules will be added to.
* @param basePath is a path that will be prefixed to every
* pattern string defined in the xmlrules input file.
*
* @see org.apache.commons.digester.RuleSetBase
* @since 1.6
*/
public void addRuleInstances(
org.apache.commons.digester.Digester digester,
String basePath)
throws XmlLoadException {
URL dtdURL = getClass().getClassLoader().getResource(DIGESTER_DTD_PATH);
if (dtdURL == null) {
throw new XmlLoadException("Cannot find resource \"" +
DIGESTER_DTD_PATH + "\"");
}
parser.setDigesterRulesDTD(dtdURL.toString());
parser.setTarget(digester);
parser.setBasePath(basePath);
rulesDigester.addRuleSet(parser);
rulesDigester.push(parser);
rulesLoader.loadRules();
}
/**
* Worker class encapsulates loading mechanisms.
* Private until some reason is found to make it public.
*/
private abstract static class XMLRulesLoader {
/** Load rules now */
public abstract void loadRules() throws XmlLoadException;
}
/** Loads XMLRules from an URL */
private class URLXMLRulesLoader extends XMLRulesLoader {
private URL url;
public URLXMLRulesLoader(URL url) {
this.url = url;
}
public void loadRules() throws XmlLoadException {
try {
rulesDigester.parse(url.openStream());
} catch (Exception ex) {
throw new XmlLoadException(ex);
}
}
}
/** Loads XMLRules from an InputSource */
private class InputSourceXMLRulesLoader extends XMLRulesLoader {
private InputSource inputSource;
public InputSourceXMLRulesLoader(InputSource inputSource) {
this.inputSource = inputSource;
}
public void loadRules() throws XmlLoadException {
try {
rulesDigester.parse(inputSource);
} catch (Exception ex) {
throw new XmlLoadException(ex);
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/XmlLoadException.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/XmlLoadException.j0000644 0001750 0001750 00000003226 11226450007 033551 0 ustar twerner twerner /* $Id: XmlLoadException.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.xmlrules;
/**
* Thrown when an error occurs while parsing XML into Digester rules.
*
* @since 1.2
*/
public class XmlLoadException extends RuntimeException {
private Throwable cause = null;
/**
* @param cause underlying exception that caused this to be thrown
*/
public XmlLoadException(Throwable cause) {
this(cause.getMessage());
this.cause = cause;
}
public XmlLoadException(String msg) {
super(msg);
}
public XmlLoadException(String msg, Throwable cause) {
this(msg);
this.cause = cause;
}
/**
* Returns the cause of this throwable or null if the cause is
* nonexistent or unknown.
*/
public Throwable getCause() {
return cause;
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/digester-rules.dtd libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/digester-rules.dtd0000644 0001750 0001750 00000020112 11226450007 033603 0 ustar twerner twerner
././@LongLink 0000000 0000000 0000000 00000000152 00000000000 011563 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/DigesterRuleParser.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/xmlrules/DigesterRuleParser0000644 0001750 0001750 00000101024 11226450007 033650 0 ustar twerner twerner /* $Id: DigesterRuleParser.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.xmlrules;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.collections.ArrayStack;
import org.apache.commons.digester.AbstractObjectCreationFactory;
import org.apache.commons.digester.BeanPropertySetterRule;
import org.apache.commons.digester.CallMethodRule;
import org.apache.commons.digester.CallParamRule;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.FactoryCreateRule;
import org.apache.commons.digester.NodeCreateRule;
import org.apache.commons.digester.ObjectCreateRule;
import org.apache.commons.digester.Rule;
import org.apache.commons.digester.RuleSetBase;
import org.apache.commons.digester.Rules;
import org.apache.commons.digester.SetNestedPropertiesRule;
import org.apache.commons.digester.SetNextRule;
import org.apache.commons.digester.SetPropertiesRule;
import org.apache.commons.digester.SetPropertyRule;
import org.apache.commons.digester.SetRootRule;
import org.apache.commons.digester.SetTopRule;
import org.apache.commons.digester.ObjectParamRule;
import org.w3c.dom.Node;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
/**
* This is a RuleSet that parses XML into Digester rules, and then
* adds those rules to a 'target' Digester.
*
* @since 1.2
*/
public class DigesterRuleParser extends RuleSetBase {
public static final String DIGESTER_PUBLIC_ID = "-//Jakarta Apache //DTD digester-rules XML V1.0//EN";
/**
* path to the DTD
*/
private String digesterDtdUrl;
/**
* This is the digester to which we are adding the rules that we parse
* from the Rules XML document.
*/
protected Digester targetDigester;
/** See {@link #setBasePath}. */
protected String basePath = "";
/**
* A stack whose toString method returns a '/'-separated concatenation
* of all the elements in the stack.
*/
protected class PatternStack extends ArrayStack {
public String toString() {
StringBuffer str = new StringBuffer();
for (int i = 0; i < size(); i++) {
String elem = get(i).toString();
if (elem.length() > 0) {
if (str.length() > 0) {
str.append('/');
}
str.append(elem);
}
}
return str.toString();
}
}
/**
* A stack used to maintain the current pattern. The Rules XML document
* type allows nesting of patterns. If an element defines a matching
* pattern, the resulting pattern is a concatenation of that pattern with
* all the ancestor elements' patterns. Hence the need for a stack.
*/
protected PatternStack patternStack;
/**
* Used to detect circular includes
*/
private Set includedFiles = new HashSet();
/**
* Constructs a DigesterRuleParser. This object will be inoperable
* until the target digester is set, via setTarget(Digester)
*/
public DigesterRuleParser() {
patternStack = new PatternStack();
}
/**
* Constructs a rule set for converting XML digester rule descriptions
* into Rule objects, and adding them to the given Digester
* @param targetDigester the Digester to add the rules to
*/
public DigesterRuleParser(Digester targetDigester) {
this.targetDigester = targetDigester;
patternStack = new PatternStack();
}
/**
* Constructs a rule set for parsing an XML digester rule file that
* has been included within an outer XML digester rule file. In this
* case, we must pass the pattern stack and the target digester
* to the rule set, as well as the list of files that have already
* been included, for cycle detection.
* @param targetDigester the Digester to add the rules to
* @param stack Stack containing the prefix pattern string to be prepended
* to any pattern parsed by this rule set.
*/
private DigesterRuleParser(Digester targetDigester,
PatternStack stack, Set includedFiles) {
this.targetDigester = targetDigester;
patternStack = stack;
this.includedFiles = includedFiles;
}
/**
* Sets the digester into which to add the parsed rules
* @param d the Digester to add the rules to
*/
public void setTarget(Digester d) {
targetDigester = d;
}
/**
* Set a base pattern beneath which all the rules loaded by this
* object will be registered. If this string is not empty, and does
* not end in a "/", then one will be added.
*
* @since 1.6
*/
public void setBasePath(String path) {
if (path == null) {
basePath = "";
}
else if ((path.length() > 0) && !path.endsWith("/")) {
basePath = path + "/";
} else {
basePath = path;
}
}
/**
* Sets the location of the digester rules DTD. This is the DTD used
* to validate the rules XML file.
*/
public void setDigesterRulesDTD(String dtdURL) {
digesterDtdUrl = dtdURL;
}
/**
* Returns the location of the DTD used to validate the digester rules
* XML document.
*/
protected String getDigesterRulesDTD() {
//ClassLoader classLoader = getClass().getClassLoader();
//URL url = classLoader.getResource(DIGESTER_DTD_PATH);
//return url.toString();
return digesterDtdUrl;
}
/**
* Adds a rule the the target digester. After a rule has been created by
* parsing the XML, it is added to the digester by calling this method.
* Typically, this method is called via reflection, when executing
* a SetNextRule, from the Digester that is parsing the rules XML.
* @param rule a Rule to add to the target digester.
*/
public void add(Rule rule) {
targetDigester.addRule(
basePath + patternStack.toString(), rule);
}
/**
* Add to the given digester the set of Rule instances used to parse an XML
* document defining Digester rules. When the digester parses an XML file,
* it will add the resulting rules & patterns to the 'target digester'
* that was passed in this RuleSet's constructor.
* If you extend this class to support additional rules, your implementation
* should of this method should call this implementation first: i.e.
* This rule will detect 'circular' includes,
* which would result in infinite recursion. It throws a
* CircularIncludeException when a cycle is detected, which will terminate
* the parse.
*/
private class IncludeRule extends Rule {
public IncludeRule() {
super();
}
/**
* To include a rules xml file, we instantiate another Digester, and
* another DigesterRulesRuleSet. We pass the
* pattern stack and the target Digester to the new rule set, and
* tell the Digester to parse the file.
*/
public void begin(Attributes attributes) throws Exception {
// The path attribute gives the URI to another digester rules xml file
String fileName = attributes.getValue("path");
if (fileName != null && fileName.length() > 0) {
includeXMLRules(fileName);
}
// The class attribute gives the name of a class that implements
// the DigesterRulesSource interface
String className = attributes.getValue("class");
if (className != null && className.length() > 0) {
includeProgrammaticRules(className);
}
}
/**
* Creates another DigesterRuleParser, and uses it to extract the rules
* out of the give XML file. The contents of the current pattern stack
* will be prepended to all of the pattern strings parsed from the file.
*/
private void includeXMLRules(String fileName)
throws IOException, SAXException, CircularIncludeException {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
if (cl == null) {
cl = DigesterRuleParser.this.getClass().getClassLoader();
}
URL fileURL = cl.getResource(fileName);
if (fileURL == null) {
throw new FileNotFoundException("File \"" + fileName + "\" not found.");
}
fileName = fileURL.toExternalForm();
if (includedFiles.add(fileName) == false) {
// circular include detected
throw new CircularIncludeException(fileName);
}
// parse the included xml file
DigesterRuleParser includedSet =
new DigesterRuleParser(targetDigester, patternStack, includedFiles);
includedSet.setDigesterRulesDTD(getDigesterRulesDTD());
Digester digester = new Digester();
digester.addRuleSet(includedSet);
digester.push(DigesterRuleParser.this);
digester.parse(fileName);
includedFiles.remove(fileName);
}
/**
* Creates an instance of the indicated class. The class must implement
* the DigesterRulesSource interface. Passes the target digester to
* that instance. The DigesterRulesSource instance is supposed to add
* rules into the digester. The contents of the current pattern stack
* will be automatically prepended to all of the pattern strings added
* by the DigesterRulesSource instance.
*/
private void includeProgrammaticRules(String className)
throws ClassNotFoundException, ClassCastException,
InstantiationException, IllegalAccessException {
Class cls = Class.forName(className);
DigesterRulesSource rulesSource = (DigesterRulesSource) cls.newInstance();
// wrap the digester's Rules object, to prepend pattern
Rules digesterRules = targetDigester.getRules();
Rules prefixWrapper =
new RulesPrefixAdapter(patternStack.toString(), digesterRules);
targetDigester.setRules(prefixWrapper);
try {
rulesSource.getRules(targetDigester);
} finally {
// Put the unwrapped rules back
targetDigester.setRules(digesterRules);
}
}
}
/**
* Wraps a Rules object. Delegates all the Rules interface methods
* to the underlying Rules object. Overrides the add method to prepend
* a prefix to the pattern string.
*/
private class RulesPrefixAdapter implements Rules {
private Rules delegate;
private String prefix;
/**
* @param patternPrefix the pattern string to prepend to the pattern
* passed to the add method.
* @param rules The wrapped Rules object. All of this class's methods
* pass through to this object.
*/
public RulesPrefixAdapter(String patternPrefix, Rules rules) {
prefix = patternPrefix;
delegate = rules;
}
/**
* Register a new Rule instance matching a pattern which is constructed
* by concatenating the pattern prefix with the given pattern.
*/
public void add(String pattern, Rule rule) {
StringBuffer buffer = new StringBuffer();
buffer.append(prefix);
if (!pattern.startsWith("/")) {
buffer.append('/');
}
buffer.append(pattern);
delegate.add(buffer.toString(), rule);
}
/**
* This method passes through to the underlying Rules object.
*/
public void clear() {
delegate.clear();
}
/**
* This method passes through to the underlying Rules object.
*/
public Digester getDigester() {
return delegate.getDigester();
}
/**
* This method passes through to the underlying Rules object.
*/
public String getNamespaceURI() {
return delegate.getNamespaceURI();
}
/**
* @deprecated Call match(namespaceURI,pattern) instead.
*/
public List match(String pattern) {
return delegate.match(pattern);
}
/**
* This method passes through to the underlying Rules object.
*/
public List match(String namespaceURI, String pattern) {
return delegate.match(namespaceURI, pattern);
}
/**
* This method passes through to the underlying Rules object.
*/
public List rules() {
return delegate.rules();
}
/**
* This method passes through to the underlying Rules object.
*/
public void setDigester(Digester digester) {
delegate.setDigester(digester);
}
/**
* This method passes through to the underlying Rules object.
*/
public void setNamespaceURI(String namespaceURI) {
delegate.setNamespaceURI(namespaceURI);
}
}
///////////////////////////////////////////////////////////////////////
// Classes beyond this point are ObjectCreationFactory implementations,
// used to create Rule objects and initialize them from SAX attributes.
///////////////////////////////////////////////////////////////////////
/**
* Factory for creating a BeanPropertySetterRule.
*/
private class BeanPropertySetterRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) throws Exception {
Rule beanPropertySetterRule = null;
String propertyname = attributes.getValue("propertyname");
if (propertyname == null) {
// call the setter method corresponding to the element name.
beanPropertySetterRule = new BeanPropertySetterRule();
} else {
beanPropertySetterRule = new BeanPropertySetterRule(propertyname);
}
return beanPropertySetterRule;
}
}
/**
* Factory for creating a CallMethodRule.
*/
protected class CallMethodRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
Rule callMethodRule = null;
String methodName = attributes.getValue("methodname");
// Select which element is to be the target. Default to zero,
// ie the top object on the stack.
int targetOffset = 0;
String targetOffsetStr = attributes.getValue("targetoffset");
if (targetOffsetStr != null) {
targetOffset = Integer.parseInt(targetOffsetStr);
}
if (attributes.getValue("paramcount") == null) {
// call against empty method
callMethodRule = new CallMethodRule(targetOffset, methodName);
} else {
int paramCount = Integer.parseInt(attributes.getValue("paramcount"));
String paramTypesAttr = attributes.getValue("paramtypes");
if (paramTypesAttr == null || paramTypesAttr.length() == 0) {
callMethodRule = new CallMethodRule(targetOffset, methodName, paramCount);
} else {
String[] paramTypes = getParamTypes(paramTypesAttr);
callMethodRule = new CallMethodRule(
targetOffset, methodName, paramCount, paramTypes);
}
}
return callMethodRule;
}
/**
* Process the comma separated list of paramTypes
* into an array of String class names
*/
private String[] getParamTypes(String paramTypes) {
String[] paramTypesArray;
if( paramTypes != null ) {
ArrayList paramTypesList = new ArrayList();
StringTokenizer tokens = new StringTokenizer(
paramTypes, " \t\n\r,");
while (tokens.hasMoreTokens()) {
paramTypesList.add(tokens.nextToken());
}
paramTypesArray = (String[])paramTypesList.toArray(new String[0]);
} else {
paramTypesArray = new String[0];
}
return paramTypesArray;
}
}
/**
* Factory for creating a CallParamRule.
*/
protected class CallParamRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
// create callparamrule
int paramIndex = Integer.parseInt(attributes.getValue("paramnumber"));
String attributeName = attributes.getValue("attrname");
String fromStack = attributes.getValue("from-stack");
String stackIndex = attributes.getValue("stack-index");
Rule callParamRule = null;
if (attributeName == null) {
if (stackIndex != null) {
callParamRule = new CallParamRule(
paramIndex, Integer.parseInt(stackIndex));
} else if (fromStack != null) {
callParamRule = new CallParamRule(
paramIndex, Boolean.valueOf(fromStack).booleanValue());
} else {
callParamRule = new CallParamRule(paramIndex);
}
} else {
if (fromStack == null) {
callParamRule = new CallParamRule(paramIndex, attributeName);
} else {
// specifying both from-stack and attribute name is not allowed
throw new RuntimeException(
"Attributes from-stack and attrname cannot both be present.");
}
}
return callParamRule;
}
}
/**
* Factory for creating a ObjectParamRule
*/
protected class ObjectParamRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) throws Exception {
// create callparamrule
int paramIndex = Integer.parseInt(attributes.getValue("paramnumber"));
String attributeName = attributes.getValue("attrname");
String type = attributes.getValue("type");
String value = attributes.getValue("value");
Rule objectParamRule = null;
// type name is requried
if (type == null) {
throw new RuntimeException("Attribute 'type' is required.");
}
// create object instance
Object param = null;
Class clazz = Class.forName(type);
if (value == null) {
param = clazz.newInstance();
} else {
param = ConvertUtils.convert(value, clazz);
}
if (attributeName == null) {
objectParamRule = new ObjectParamRule(paramIndex, param);
} else {
objectParamRule = new ObjectParamRule(paramIndex, attributeName, param);
}
return objectParamRule;
}
}
/**
* Factory for creating a NodeCreateRule
*/
protected class NodeCreateRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) throws Exception {
String nodeType = attributes.getValue("type");
if (nodeType == null || "".equals(nodeType)) {
// uses Node.ELEMENT_NODE
return new NodeCreateRule();
} else if ("element".equals(nodeType)) {
return new NodeCreateRule(Node.ELEMENT_NODE);
} else if ("fragment".equals(nodeType)) {
return new NodeCreateRule(Node.DOCUMENT_FRAGMENT_NODE);
} else {
throw new RuntimeException(
"Unrecognized node type: "
+ nodeType
+ ". This attribute is optional or can have a value of element|fragment.");
}
}
}
/**
* Factory for creating a FactoryCreateRule
*/
protected class FactoryCreateRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
String className = attributes.getValue("classname");
String attrName = attributes.getValue("attrname");
boolean ignoreExceptions =
"true".equalsIgnoreCase(attributes.getValue("ignore-exceptions"));
return (attrName == null || attrName.length() == 0) ?
new FactoryCreateRule( className, ignoreExceptions) :
new FactoryCreateRule( className, attrName, ignoreExceptions);
}
}
/**
* Factory for creating a ObjectCreateRule
*/
protected class ObjectCreateRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
String className = attributes.getValue("classname");
String attrName = attributes.getValue("attrname");
return (attrName == null || attrName.length() == 0) ?
new ObjectCreateRule( className) :
new ObjectCreateRule( className, attrName);
}
}
/**
* Factory for creating a SetPropertiesRule
*/
protected class SetPropertiesRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
return new SetPropertiesRule();
}
}
/**
* Factory for creating a SetPropertyRule
*/
protected class SetPropertyRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
String name = attributes.getValue("name");
String value = attributes.getValue("value");
return new SetPropertyRule( name, value);
}
}
/**
* Factory for creating a SetNestedPropertiesRule
*/
protected class SetNestedPropertiesRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
boolean allowUnknownChildElements =
"true".equalsIgnoreCase(attributes.getValue("allow-unknown-child-elements"));
SetNestedPropertiesRule snpr = new SetNestedPropertiesRule();
snpr.setAllowUnknownChildElements( allowUnknownChildElements );
return snpr;
}
}
/**
* Factory for creating a SetTopRuleFactory
*/
protected class SetTopRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
String methodName = attributes.getValue("methodname");
String paramType = attributes.getValue("paramtype");
return (paramType == null || paramType.length() == 0) ?
new SetTopRule( methodName) :
new SetTopRule( methodName, paramType);
}
}
/**
* Factory for creating a SetNextRuleFactory
*/
protected class SetNextRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
String methodName = attributes.getValue("methodname");
String paramType = attributes.getValue("paramtype");
return (paramType == null || paramType.length() == 0) ?
new SetNextRule( methodName) :
new SetNextRule( methodName, paramType);
}
}
/**
* Factory for creating a SetRootRuleFactory
*/
protected class SetRootRuleFactory extends AbstractObjectCreationFactory {
public Object createObject(Attributes attributes) {
String methodName = attributes.getValue("methodname");
String paramType = attributes.getValue("paramtype");
return (paramType == null || paramType.length() == 0) ?
new SetRootRule( methodName) :
new SetRootRule( methodName, paramType);
}
}
/**
* A rule for adding a attribute-property alias to the custom alias mappings of
* the containing SetPropertiesRule rule.
*/
protected class SetPropertiesAliasRule extends Rule {
/**
* Base constructor. Base constructor. Rule implementation that saves a parameter containing the
* A Digester processes an XML input stream by matching a
* series of element nesting patterns to execute Rules that have been added
* prior to the start of parsing. This package was inspired by the
* See the Digester
* Developer Guide for more information. IMPLEMENTATION NOTE - A single Digester instance may
* only be used within the context of a single thread at a time, and a call
* to A Digester instance should not be used for parsing more than one input
* document. The problem is that the Digester class has quite a few member
* variables whose values "evolve" as SAX events are received during a parse.
* When reusing the Digester instance, all these members must be reset back
* to their initial states before the second parse begins. The "clear()"
* method makes a stab at resetting these, but it is actually rather a
* difficult problem. If you are determined to reuse Digester instances, then
* at the least you should call the clear() method before each parse, and must
* call it if the Digester parse terminates due to an exception during a parse.
* IMPLEMENTATION NOTE - A bug in Xerces 2.0.2 prevents
* the support of XML schema. You need Xerces 2.1/2.3 and up to make
* this class working with XML schema
* See setCustomContentHandler.
*/
private ContentHandler customContentHandler = null;
/**
* Object which will receive callbacks for every pop/push action
* on the default stack or named stacks.
*/
private StackAction stackAction = null;
// ------------------------------------------------------------- Properties
/**
* Return the currently mapped namespace URI for the specified prefix,
* if any; otherwise return
* It is often desirable to force the input document to be
* validated against a particular schema regardless of what type
* the input document declares itself to be. This method allows that
* to be done.
*
* Note, however, that there is no standard API for enabling this
* feature on the underlying SAX parser; this method therefore only works
* for those parsers explicitly supported by Digester's
* ParserFeatureSetterFactory class. If the underlying parser does not
* support the feature, or is not one of the supported parsers, then
* an exception will be thrown when getParser is called (explicitly,
* or implicitly via the parse method).
*
* See also method setSchemaLanguage which allows the type of the schema
* specified here to be defined. By default, the schema is expected to
* be a W3C xml schema definition.
*
* IMPORTANT NOTE: This functionality was never very reliable, and has
* been horribly broken since the 1.6 release of Digester. There are
* currently no plans to fix it, so you are strongly recommended to
* avoid using this method. Instead, create an XMLParser instance
* yourself, configure validation appropriately, and pass it as a
* parameter to the Digester constructor.
*
* @param schemaLocation a URI to the schema.
*/
public void setSchema(String schemaLocation){
this.schemaLocation = schemaLocation;
}
/**
* Return the XML Schema language used when parsing.
*/
public String getSchemaLanguage() {
return (this.schemaLanguage);
}
/**
* Set the XML Schema language used when parsing. By default, we use W3C.
*
* @param schemaLanguage a URI to the schema language.
*/
public void setSchemaLanguage(String schemaLanguage){
this.schemaLanguage = schemaLanguage;
}
/**
* Return the boolean as to whether the context classloader should be used.
*/
public boolean getUseContextClassLoader() {
return useContextClassLoader;
}
/**
* Determine whether to use the Context ClassLoader (the one found by
* calling
* When this object's customContentHandler is non-null, any SAX events
* received from the parser will simply be passed on to the specified
* object instead of this object handling them. This allows Rule classes
* to take control of the SAX event stream for a while in order to do
* custom processing. Such a rule should save the old value before setting
* a new one, and restore the old value in order to resume normal digester
* processing.
*
* An example of a Rule which needs this feature is NodeCreateRule.
*
* Note that saving the old value is probably not needed as it should always
* be null; a custom rule that wants to take control could only have been
* called when there was no custom content handler. But it seems cleaner
* to properly save/restore the value and maybe some day this will come in
* useful.
*
* Note also that this is not quite equivalent to
* Register the specified DTD URL for the specified public identifier.
* This must be called before the first call to
*
* Note: This method will have no effect when a custom
* Convenience method that registers the string version of an entity URL
* instead of a URL version.
* Ideally this function would not be needed and code could just use
*
* In JDK1.4 and later, Apache XercesJ is used as the xml parser.
* The InputSource object provided is converted into an XMLInputSource,
* and eventually passed to an instance of XMLDocumentScannerImpl to
* specify the source data to be converted into tokens for the rest
* of the XMLReader code to handle. XMLDocumentScannerImpl calls
* fEntityManager.startDocumentEntity(source), where fEntityManager
* is declared in ancestor class XMLScanner to be an XMLEntityManager. In
* that class, if the input source stream is null, then:
* Convenience method that creates an Register a new Rule matching the specified pattern.
* This method sets the
* Note that when attempting to locate a matching method to invoke,
* the true type of the paramObj is used, so that despite the paramObj
* being passed in here as type Object, the target method can declare
* its parameters as being the true type of the object (or some ancestor
* type, according to the usual type-conversion rules).
*
* @param paramIndex The zero-relative parameter number
* @param paramObj Any arbitrary object to be passed to the target
* method.
* @see CallMethodRule
*
* @since 1.6
*/
public void addObjectParam(String pattern, int paramIndex,
Object paramObj) {
addRule(pattern,
new ObjectParamRule(paramIndex, paramObj));
}
/**
* Add a "factory create" rule for the specified parameters.
* Exceptions thrown during the object creation process will be propagated.
*
* @param pattern Element matching pattern
* @param className Java class name of the object creation factory class
* @see FactoryCreateRule
*/
public void addFactoryCreate(String pattern, String className) {
addFactoryCreate(pattern, className, false);
}
/**
* Add a "factory create" rule for the specified parameters.
* Exceptions thrown during the object creation process will be propagated.
*
* @param pattern Element matching pattern
* @param clazz Java class of the object creation factory class
* @see FactoryCreateRule
*/
public void addFactoryCreate(String pattern, Class clazz) {
addFactoryCreate(pattern, clazz, false);
}
/**
* Add a "factory create" rule for the specified parameters.
* Exceptions thrown during the object creation process will be propagated.
*
* @param pattern Element matching pattern
* @param className Java class name of the object creation factory class
* @param attributeName Attribute name which, if present, overrides the
* value specified by
* Calling this method might allow another document of the same type
* to be correctly parsed. However this method was not intended for this
* purpose (just to tidy up memory usage). In general, a separate Digester
* object should be created for each document to be parsed.
*
* Note that this method is called automatically after a document has been
* successfully parsed by a Digester instance. However it is not invoked
* automatically when a parse fails, so when reusing a Digester instance
* (which is not recommended) this method must be called manually
* after a parse failure.
*/
public void clear() {
match = "";
bodyTexts.clear();
params.clear();
publicId = null;
stack.clear();
stacksByName.clear();
customContentHandler = null;
}
/**
* Return the top object on the stack without removing it. If there are
* no objects on the stack, return Pops (gets and removes) the top object from the stack with the given name. Note: a stack is considered empty
* if no objects have been pushed onto it yet. Gets the top object from the stack with the given name.
* This method does not remove the object from the stack.
* Note: a stack is considered empty
* if no objects have been pushed onto it yet. Gets the top object from the stack with the given name.
* This method does not remove the object from the stack.
* Note: a stack is considered empty
* if no objects have been pushed onto it yet. Is the stack with the given name empty? Note: a stack is considered empty
* if no objects have been pushed onto it yet.
* If the digester stack was "primed" by explicitly pushing a root
* object onto the stack before parsing started, then that root object
* is returned here.
*
* Alternatively, if a Rule which creates an object (eg ObjectCreateRule)
* matched the root element of the xml, then the object created will be
* returned here.
*
* In other cases, the object most recently pushed onto an empty digester
* stack is returned. This would be a most unusual use of digester, however;
* one of the previous configurations is much more likely.
*
* Note that when using one of the Digester.parse methods, the return
* value from the parse method is exactly the same as the return value
* from this method. However when the Digester is being used as a
* SAXContentHandler, no such return value is available; in this case, this
* method allows you to access the root object that has been created
* after parsing has completed.
*
* @return the root object that has been created after parsing
* or null if the digester has not parsed any XML yet.
*/
public Object getRoot() {
return root;
}
/**
* This method allows the "root" variable to be reset to null.
*
* It is not considered safe for a digester instance to be reused
* to parse multiple xml documents. However if you are determined to
* do so, then you should call both clear() and resetRoot() before
* each parse.
*
* @since 1.7
*/
public void resetRoot() {
root = null;
}
// ------------------------------------------------ Parameter Stack Methods
// ------------------------------------------------------ Protected Methods
/**
* Clean up allocated resources after parsing is complete. The
* default method closes input streams that have been created by
* Digester itself. If you override this method in a subclass, be
* sure to call
* Provide a hook for lazy configuration of this
* Note This method may be called more than once.
* Once only initialization code should be placed in {@link #initialize}
* or the code should take responsibility by checking and setting the
* {@link #configured} flag.
*
* Provides a hook for lazy initialization of this
* Note This method will be called by {@link #configure}
* only when the {@link #configured} flag is false.
* Subclasses that override Return the top object on the parameters stack without removing it. If there are
* no objects on the stack, return The parameters stack is used to store Return the n'th object down the parameters stack, where 0 is the top element
* and [getCount()-1] is the bottom element. If the specified index
* is out of range, return The parameters stack is used to store Pop the top object off of the parameters stack, and return it. If there are
* no objects on the stack, return The parameters stack is used to store Push a new object onto the top of the parameters stack. The parameters stack is used to store
* This class is intended only for the use of the code in the
* plugins packages. No "user" code should use this package.
*
* The Digester module has an interesting approach to logging:
* all logging should be done via the Log object stored on the
* digester instance that the object *doing* the logging is associated
* with.
*
* This is done because apparently some "container"-type applications
* such as Avalon and Tomcat need to be able to configure different logging
* for different instances of the Digester class which have been
* loaded from the same ClassLoader [info from Craig McClanahan].
* Not only the logging of the Digester instance should be affected; all
* objects associated with that Digester instance should obey the
* reconfiguration of their owning Digester instance's logging. The current
* solution is to force all objects to output logging info via a single
* Log object stored on the Digester instance they are associated with.
*
* Of course this causes problems if logging is attempted before an
* object has a valid reference to its owning Digester. The
* getLogging method provided here resolves this issue by returning a
* Log object which silently discards all logging output in this
* situation.
*
* And it also implies that logging filtering can no longer be applied
* to subcomponents of the Digester, because all logging is done via
* a single Log object (a single Category). C'est la vie...
*
* @since 1.6
*/
class LogUtils {
/**
* Get the Log object associated with the specified Digester instance,
* or a "no-op" logging object if the digester reference is null.
*
* You should use this method instead of digester.getLogger() in
* any situation where the digester might be null.
*/
static Log getLogger(Digester digester) {
if (digester == null) {
return new org.apache.commons.logging.impl.NoOpLog();
}
return digester.getLogger();
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/InitializableRule.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/InitializableRule.j0000644 0001750 0001750 00000003433 11226450007 033550 0 ustar twerner twerner /* $Id: InitializableRule.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
/**
* Defines an interface that a Rule class can implement if it wishes to get an
* initialisation callback after the rule has been added to the set of Rules
* within a PluginRules instance.
*
* @since 1.6
*/
public interface InitializableRule {
/**
* Called after this Rule object has been added to the list of all Rules.
* Note that if a single InitializableRule instance is associated with
* more than one pattern, then this method will be called more than once.
*
* @param pattern is the digester match pattern that will trigger this
* rule.
* @exception
* PluginConfigurationException is thrown if the InitializableRule
* determines that it cannot correctly initialise itself for any reason.
*/
public void postRegisterInit(String pattern)
throws PluginConfigurationException;
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginCreateRule.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginCreateRule.ja0000644 0001750 0001750 00000054621 11226450007 033520 0 ustar twerner twerner /* $Id: PluginCreateRule.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
import java.util.List;
import org.apache.commons.digester.Rule;
import org.apache.commons.logging.Log;
/**
* Allows the original rules for parsing the configuration file to define
* points at which plugins are allowed, by configuring a PluginCreateRule
* with the appropriate pattern.
*
* @since 1.6
*/
public class PluginCreateRule extends Rule implements InitializableRule {
// see setPluginClassAttribute
private String pluginClassAttrNs = null;
private String pluginClassAttr = null;
// see setPluginIdAttribute
private String pluginIdAttrNs = null;
private String pluginIdAttr = null;
/**
* In order to invoke the addRules method on the plugin class correctly,
* we need to know the pattern which this rule is matched by.
*/
private String pattern;
/** A base class that any plugin must derive from. */
private Class baseClass = null;
/**
* Info about optional default plugin to be used if no plugin-id is
* specified in the input data. This can simplify the syntax where one
* particular plugin is usually used.
*/
private Declaration defaultPlugin;
/**
* Currently, none of the Rules methods allow exceptions to be thrown.
* Therefore if this class cannot initialise itself properly, it cannot
* cause the digester to stop. Instead, we cache the exception and throw
* it the first time the begin() method is called.
*/
private PluginConfigurationException initException;
//-------------------- constructors -------------------------------------
/**
* Create a plugin rule where the user must specify a plugin-class
* or plugin-id.
*
* @param baseClass is the class which any specified plugin must be
* descended from.
*/
public PluginCreateRule(Class baseClass) {
this.baseClass = baseClass;
}
/**
* Create a plugin rule where the user may specify a plugin.
* If the user doesn't specify a plugin, then the default class specified
* in this constructor is used.
*
* @param baseClass is the class which any specified plugin must be
* descended from.
* @param dfltPluginClass is the class which will be used if the user
* doesn't specify any plugin-class or plugin-id. This class will have
* custom rules installed for it just like a declared plugin.
*/
public PluginCreateRule(Class baseClass, Class dfltPluginClass) {
this.baseClass = baseClass;
if (dfltPluginClass != null) {
defaultPlugin = new Declaration(dfltPluginClass);
}
}
/**
* Create a plugin rule where the user may specify a plugin.
* If the user doesn't specify a plugin, then the default class specified
* in this constructor is used.
*
* @param baseClass is the class which any specified plugin must be
* descended from.
* @param dfltPluginClass is the class which will be used if the user
* doesn't specify any plugin-class or plugin-id. This class will have
* custom rules installed for it just like a declared plugin.
* @param dfltPluginRuleLoader is a RuleLoader instance which knows how
* to load the custom rules associated with this default plugin.
*/
public PluginCreateRule(Class baseClass, Class dfltPluginClass,
RuleLoader dfltPluginRuleLoader) {
this.baseClass = baseClass;
if (dfltPluginClass != null) {
defaultPlugin =
new Declaration(dfltPluginClass, dfltPluginRuleLoader);
}
}
//------------------- properties ---------------------------------------
/**
* Sets the xml attribute which the input xml uses to indicate to a
* PluginCreateRule which class should be instantiated.
*
* See {@link PluginRules#setPluginClassAttribute} for more info.
*/
public void setPluginClassAttribute(String namespaceUri, String attrName) {
pluginClassAttrNs = namespaceUri;
pluginClassAttr = attrName;
}
/**
* Sets the xml attribute which the input xml uses to indicate to a
* PluginCreateRule which plugin declaration is being referenced.
*
* See {@link PluginRules#setPluginIdAttribute} for more info.
*/
public void setPluginIdAttribute(String namespaceUri, String attrName) {
pluginIdAttrNs = namespaceUri;
pluginIdAttr = attrName;
}
//------------------- methods --------------------------------------------
/**
* Invoked after this rule has been added to the set of digester rules,
* associated with the specified pattern. Check all configuration data is
* valid and remember the pattern for later.
*
* @param matchPattern is the digester match pattern that is associated
* with this rule instance, eg "root/widget".
* @exception PluginConfigurationException
*/
public void postRegisterInit(String matchPattern)
throws PluginConfigurationException {
Log log = LogUtils.getLogger(digester);
boolean debug = log.isDebugEnabled();
if (debug) {
log.debug("PluginCreateRule.postRegisterInit" +
": rule registered for pattern [" + matchPattern + "]");
}
if (digester == null) {
// We require setDigester to be called before this method.
// Note that this means that PluginCreateRule cannot be added
// to a Rules object which has not yet been added to a
// Digester object.
initException = new PluginConfigurationException(
"Invalid invocation of postRegisterInit" +
": digester not set.");
throw initException;
}
if (pattern != null) {
// We have been called twice, ie a single instance has been
// associated with multiple patterns.
//
// Generally, Digester Rule instances can be associated with
// multiple patterns. However for plugins, this creates some
// complications. Some day this may be supported; however for
// now we just reject this situation.
initException = new PluginConfigurationException(
"A single PluginCreateRule instance has been mapped to" +
" multiple patterns; this is not supported.");
throw initException;
}
if (matchPattern.indexOf('*') != -1) {
// having wildcards in patterns is extremely difficult to
// deal with. For now, we refuse to allow this.
//
// TODO: check for any chars not valid in xml element name
// rather than just *.
//
// Reasons include:
// (a) handling recursive plugins, and
// (b) determining whether one pattern is "below" another,
// as done by PluginRules. Without wildcards, "below"
// just means startsWith, which is easy to check.
initException = new PluginConfigurationException(
"A PluginCreateRule instance has been mapped to" +
" pattern [" + matchPattern + "]." +
" This pattern includes a wildcard character." +
" This is not supported by the plugin architecture.");
throw initException;
}
if (baseClass == null) {
baseClass = Object.class;
}
PluginRules rules = (PluginRules) digester.getRules();
PluginManager pm = rules.getPluginManager();
// check default class is valid
if (defaultPlugin != null) {
if (!baseClass.isAssignableFrom(defaultPlugin.getPluginClass())) {
initException = new PluginConfigurationException(
"Default class [" +
defaultPlugin.getPluginClass().getName() +
"] does not inherit from [" +
baseClass.getName() + "].");
throw initException;
}
try {
defaultPlugin.init(digester, pm);
} catch(PluginException pwe) {
throw new PluginConfigurationException(
pwe.getMessage(), pwe.getCause());
}
}
// remember the pattern for later
pattern = matchPattern;
if (pluginClassAttr == null) {
// the user hasn't set explicit xml attr names on this rule,
// so fetch the default values
pluginClassAttrNs = rules.getPluginClassAttrNs();
pluginClassAttr = rules.getPluginClassAttr();
if (debug) {
log.debug(
"init: pluginClassAttr set to per-digester values ["
+ "ns=" + pluginClassAttrNs
+ ", name=" + pluginClassAttr + "]");
}
} else {
if (debug) {
log.debug(
"init: pluginClassAttr set to rule-specific values ["
+ "ns=" + pluginClassAttrNs
+ ", name=" + pluginClassAttr + "]");
}
}
if (pluginIdAttr == null) {
// the user hasn't set explicit xml attr names on this rule,
// so fetch the default values
pluginIdAttrNs = rules.getPluginIdAttrNs();
pluginIdAttr = rules.getPluginIdAttr();
if (debug) {
log.debug(
"init: pluginIdAttr set to per-digester values ["
+ "ns=" + pluginIdAttrNs
+ ", name=" + pluginIdAttr + "]");
}
} else {
if (debug) {
log.debug(
"init: pluginIdAttr set to rule-specific values ["
+ "ns=" + pluginIdAttrNs
+ ", name=" + pluginIdAttr + "]");
}
}
}
/**
* Invoked when the Digester matches this rule against an xml element.
*
* A new instance of the target class is created, and pushed onto the
* stack. A new "private" PluginRules object is then created and set as
* the digester's default Rules object. Any custom rules associated with
* the plugin class are then loaded into that new Rules object.
* Finally, any custom rules that are associated with the current pattern
* (such as SetPropertiesRules) have their begin methods executed.
*
* @param namespace
* @param name
* @param attributes
*
* @throws ClassNotFoundException
* @throws PluginInvalidInputException
* @throws PluginConfigurationException
*/
public void begin(String namespace, String name,
org.xml.sax.Attributes attributes)
throws java.lang.Exception {
Log log = digester.getLogger();
boolean debug = log.isDebugEnabled();
if (debug) {
log.debug("PluginCreateRule.begin" + ": pattern=[" + pattern + "]" +
" match=[" + digester.getMatch() + "]");
}
if (initException != null) {
// we had a problem during initialisation that we could
// not report then; report it now.
throw initException;
}
// load any custom rules associated with the plugin
PluginRules oldRules = (PluginRules) digester.getRules();
PluginManager pluginManager = oldRules.getPluginManager();
Declaration currDeclaration = null;
String pluginClassName;
if (pluginClassAttrNs == null) {
// Yep, this is ugly.
//
// In a namespace-aware parser, the one-param version will
// return attributes with no namespace.
//
// In a non-namespace-aware parser, the two-param version will
// never return any attributes, ever.
pluginClassName = attributes.getValue(pluginClassAttr);
} else {
pluginClassName =
attributes.getValue(pluginClassAttrNs, pluginClassAttr);
}
String pluginId;
if (pluginIdAttrNs == null) {
pluginId = attributes.getValue(pluginIdAttr);
} else {
pluginId =
attributes.getValue(pluginIdAttrNs, pluginIdAttr);
}
if (pluginClassName != null) {
// The user is using a plugin "inline", ie without a previous
// explicit declaration. If they have used the same plugin class
// before, we have already gone to the effort of creating a
// Declaration object, so retrieve it. If there is no existing
// declaration object for this class, then create one.
currDeclaration = pluginManager.getDeclarationByClass(
pluginClassName);
if (currDeclaration == null) {
currDeclaration = new Declaration(pluginClassName);
try {
currDeclaration.init(digester, pluginManager);
} catch(PluginException pwe) {
throw new PluginInvalidInputException(
pwe.getMessage(), pwe.getCause());
}
pluginManager.addDeclaration(currDeclaration);
}
} else if (pluginId != null) {
currDeclaration = pluginManager.getDeclarationById(pluginId);
if (currDeclaration == null) {
throw new PluginInvalidInputException(
"Plugin id [" + pluginId + "] is not defined.");
}
} else if (defaultPlugin != null) {
currDeclaration = defaultPlugin;
} else {
throw new PluginInvalidInputException(
"No plugin class specified for element " +
pattern);
}
// get the class of the user plugged-in type
Class pluginClass = currDeclaration.getPluginClass();
String path = digester.getMatch();
// create a new Rules object and effectively push it onto a stack of
// rules objects. The stack is actually a linked list; using the
// PluginRules constructor below causes the new instance to link
// to the previous head-of-stack, then the Digester.setRules() makes
// the new instance the new head-of-stack.
PluginRules newRules = new PluginRules(digester, path, oldRules, pluginClass);
digester.setRules(newRules);
if (debug) {
log.debug("PluginCreateRule.begin: installing new plugin: " +
"oldrules=" + oldRules.toString() +
", newrules=" + newRules.toString());
}
// load up the custom rules
currDeclaration.configure(digester, pattern);
// create an instance of the plugin class
Object instance = pluginClass.newInstance();
getDigester().push(instance);
if (debug) {
log.debug(
"PluginCreateRule.begin" + ": pattern=[" + pattern + "]" +
" match=[" + digester.getMatch() + "]" +
" pushed instance of plugin [" + pluginClass.getName() + "]");
}
// and now we have to fire any custom rules which would have
// been matched by the same path that matched this rule, had
// they been loaded at that time.
List rules = newRules.getDecoratedRules().match(namespace, path);
fireBeginMethods(rules, namespace, name, attributes);
}
/**
* Process the body text of this element.
*
* @param text The body text of this element
*/
public void body(String namespace, String name, String text)
throws Exception {
// While this class itself has no work to do in the body method,
// we do need to fire the body methods of all dynamically-added
// rules matching the same path as this rule. During begin, we had
// to manually execute the dynamic rules' begin methods because they
// didn't exist in the digester's Rules object when the match begin.
// So in order to ensure consistent ordering of rule execution, the
// PluginRules class deliberately avoids returning any such rules
// in later calls to the match method, instead relying on this
// object to execute them at the appropriate time.
//
// Note that this applies only to rules matching exactly the path
// which is also matched by this PluginCreateRule.
String path = digester.getMatch();
PluginRules newRules = (PluginRules) digester.getRules();
List rules = newRules.getDecoratedRules().match(namespace, path);
fireBodyMethods(rules, namespace, name, text);
}
/**
* Invoked by the digester when the closing tag matching this Rule's
* pattern is encountered.
*
* In general, Rule instances can be associated with multiple
* patterns. A PluginCreateRule, however, will only function correctly
* when associated with a single pattern. It is possible to fix this, but
* I can't be bothered just now because this feature is unlikely to be
* used.
* Provides an easy mechanism whereby new digestion rules
can be added dynamically during a digestion.
Given the following digester rules in the main "parsing" application:
the following input can be processed:
Note that the "SubstituteTransform" class is not hard-wired into the
application, and also that this class is configuring itself from the
same configuration file.
The user can specify any class they like here, and (provided that class follows
the plugins conventions) it can use any Digester functionality to process
the configuration data within the transform tag and its subtags.
The original application simply defined a "plugin point" of
"pipeline/transform" at which user classes could be plugged in. However
it did not specify what classes were permitted, other than that they
must implement the Transform interface. It is the input file which has
defined exactly which class should be instantiated when the transform
element is encountered, and furthermore the "plugin" class itself has
dynamically added rules for parsing elements nested within itself.
A class used as a plugin may dynamically add its own rules to the digester,
in order to process its attributes and any subtags in any manner it wishes.
This may be done by several mechanisms, including:
In the example above, an end user may create their own classes which implement
the required Transform interface, then cause these custom classes to be used
instead of, or in addition to, classes distributed with the application.
The plugin class can be declared once:
Note also that plugged-in classes can themselves allow user-defined classes
to be plugged in within their configuration. This allows a very simple
framework to be extended almost without limit by the end user.
The term "plugin point" refers to a pattern associated with a PluginCreateRule.
An xml element matching that pattern is expected to have a plugin-id attribute
(but see note on "default plugins" elsewhere in this document).
An instance of "PluginRules" must be used as the Rules implementation
for the Digester (see example). However a PluginRules can use any other Rules
implementation as its rule-matching engine, so this is not a significant issue.
Plugged-in classes may only use the default RulesBase matching for the rules
they add dynamically.
For technical reasons, a single instance of PluginCreateRule cannot
currently be associated with multiple patterns; multiple instances are
required. This is not expected to be a problem.
Processing elements which match patterns added dynamically by plugin classes
does have a performance impact, but not excessively so.
Well, if the class has a no-argument constuctor, and only simple configuration
needs that can be met by a SetPropertiesRule, then no changes need to be
made at all.
In other circumstances, you may either define an "addRules" method on the
class which adds any necessary rules to the digester, a separate class
containing that information, or write an xmlrules-format file defining the
necessary rules. In the "separate rule info class" approach, the class containing
the rule info may have any name of your choice, but the original class +
"RuleInfo" is recommended.
Here is the addRules method on class SubstituteTransform, from the example:
If a plugin class does not define an "addRules" method, and the plugin
declaration does not associate a rule info class with it, then the
plugins module will define a "SetPropertiesRule" by default. However if
any custom rules are defined for the plugin class, then that implementation
is required to define a SetPropertiesRule for itself if it desires one.
Note that when adding any rules, the pattern passed to the digester
must start with the pathPrefix provided. A plugin cannot
define rules with absolute paths. And as defined in the limitations, the
pattern should not include any wildcard characters.
In situations where a user might want to specify a custom class,
but will often want "default" behaviour, a PluginCreateRule can specify
a default class. If the user then omits the "plugin-id" attribute on
the matching xml element, an instance of the default class will be
created.
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/RuleFinder.java 0000644 0001750 0001750 00000006360 11226450007 032671 0 ustar twerner twerner /* $Id: RuleFinder.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
import java.util.Properties;
import org.apache.commons.digester.Digester;
/**
* Each concrete implementation of RuleFinder is an algorithm for
* locating a source of digester rules for a plugin. The algorithm may
* use info explicitly provided by the user as part of the plugin
* declaration, or not (in which case the concrete RuleFinder subclass
* typically has Dflt as part of its name).
*
* Instances of this class can also be regarded as a Factory for RuleLoaders,
* except that an instance of a RuleLoader is only created if the particular
* finder algorithm can locate a suitable source of rules given the plugin
* class and associated properties.
*
* This is an abstract class rather than an interface in order to make
* it possible to enhance this class in future without breaking binary
* compatibility; it is possible to add methods to an abstract class, but
* not to an interface.
*
* @since 1.6
*/
public abstract class RuleFinder {
/**
* Apply the finder algorithm to attempt to locate a source of
* digester rules for the specified plugin class.
*
* This method is invoked when a plugin is declared by the user, either
* via an explicit use of PluginDeclarationRule, or implicitly via an
* "inline declaration" where the declaration and use are simultaneous.
*
* If dynamic rules for the specified plugin class are located, then
* the RuleFinder will return a RuleLoader object encapsulating those
* rules, and this object will be invoked each time the user actually
* requests an instance of the declared plugin class, to load the
* custom rules associated with that plugin instance.
*
* If no dynamic rules can be found, null is returned. This is not an
* error; merely an indication that this particular algorithm found
* no matches.
*
* The properties object holds any xml attributes the user may have
* specified on the plugin declaration in order to indicate how to locate
* the plugin rules.
*
* @throws PluginConfigurationException if the algorithm finds a source
* of rules, but there is something invalid about that source.
*/
public abstract RuleLoader findLoader(
Digester d, Class pluginClass,
Properties p) throws PluginException;
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginAssertionFailure.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginAssertionFail0000644 0001750 0001750 00000005552 11226450007 033636 0 ustar twerner twerner /* $Id: PluginAssertionFailure.java 476205 2006-11-17 16:43:10Z dennisl $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
/**
* Thrown when a bug is detected in the plugins code.
*
* This class is intended to be used in assertion statements, similar to
* the way that java 1.4's native assertion mechanism is used. However there
* is a difference: when a java 1.4 assertion fails, an AssertionError
* is thrown, which is a subclass of Error; here, the PluginAssertionFailure
* class extends RuntimeException rather than Error.
*
* This difference in design is because throwing Error objects is not
* good in a container-based architecture.
*
* Example:
*
* Note that PluginAssertionFailure should not be thrown when user
* input is bad, or when code external to the Digester module passes invalid
* parameters to a plugins method. It should be used only in checks for
* problems which indicate internal bugs within the plugins module.
*
* @since 1.6
*/
public class PluginAssertionFailure extends RuntimeException {
private Throwable cause = null;
/**
* @param cause underlying exception that caused this to be thrown
*/
public PluginAssertionFailure(Throwable cause) {
this(cause.getMessage());
this.cause = cause;
}
/**
* @param msg describes the reason this exception is being thrown.
*/
public PluginAssertionFailure(String msg) {
super(msg);
}
/**
* @param msg describes the reason this exception is being thrown.
* @param cause underlying exception that caused this to be thrown
*/
public PluginAssertionFailure(String msg, Throwable cause) {
this(msg);
this.cause = cause;
}
/**
* Return the cause of this exception (if any) as specified in the
* exception constructor.
*
* @since 1.8
*/
public Throwable getCause() {
return cause;
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginContext.java 0000644 0001750 0001750 00000022724 11226450007 033437 0 ustar twerner twerner /* $Id: PluginContext.java 476312 2006-11-17 20:59:09Z rahul $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
import java.util.List;
import java.util.LinkedList;
import org.apache.commons.digester.plugins.strategies.FinderFromFile;
import org.apache.commons.digester.plugins.strategies.FinderFromResource;
import org.apache.commons.digester.plugins.strategies.FinderFromClass;
import org.apache.commons.digester.plugins.strategies.FinderFromMethod;
import org.apache.commons.digester.plugins.strategies.FinderFromDfltMethod;
import org.apache.commons.digester.plugins.strategies.FinderFromDfltClass;
import org.apache.commons.digester.plugins.strategies.FinderFromDfltResource;
import org.apache.commons.digester.plugins.strategies.FinderSetProperties;
/**
* Provides data and services which should exist only once per digester.
*
* This class holds a number of useful items which should be shared by all
* plugin objects. Such data cannot be stored on the PluginRules or
* PluginManager classes, as there can be multiple instances of these at
* various times during a parse.
*
* The name "Context" refers to the similarity between this class and a
* ServletContext class in a servlet engine. A ServletContext object provides
* access to the container's services such as obtaining global configuration
* parameters for the container, or getting access to logging services. For
* plugins, a Digester instance can be regarded as "the container".
*
* @since 1.6
*/
public class PluginContext {
// TODO: Consider making following four constants static in 2.0
// the xml attribute the user uses on an xml element to specify
// the plugin's class
public final String DFLT_PLUGIN_CLASS_ATTR_NS = null;
public final String DFLT_PLUGIN_CLASS_ATTR = "plugin-class";
// the xml attribute the user uses on an xml element to specify
// the plugin's class
public final String DFLT_PLUGIN_ID_ATTR_NS = null;
public final String DFLT_PLUGIN_ID_ATTR = "plugin-id";
/** See {@link #setPluginClassAttribute}. */
private String pluginClassAttrNs = DFLT_PLUGIN_CLASS_ATTR_NS;
/** See {@link #setPluginClassAttribute}. */
private String pluginClassAttr = DFLT_PLUGIN_CLASS_ATTR;
/** See {@link #setPluginClassAttribute}. */
private String pluginIdAttrNs = DFLT_PLUGIN_ID_ATTR_NS;
/** See {@link #setPluginClassAttribute}. */
private String pluginIdAttr = DFLT_PLUGIN_ID_ATTR;
/**
* A list of RuleFinder objects used by all Declarations (and thus
* indirectly by all PluginCreateRules to locate the custom rules
* for plugin classes.
*/
private List ruleFinders;
//------------------- constructors ---------------------------------------
public PluginContext() {
}
//------------------- methods ---------------------------------------
/**
* Return the list of RuleFinder objects. Under normal circumstances
* this method creates a default list of these objects when first called
* (ie "on-demand" or "lazy initialization"). However if setRuleFinders
* has been called first, then the list specified there is returned.
*
* It is explicitly permitted for the caller to modify this list
* by inserting or removing RuleFinder objects.
*/
public List getRuleFinders() {
if (ruleFinders == null) {
// when processing a plugin declaration, attempts are made to
// find custom rules in the order in which the Finder objects
// are added below. However this list can be modified
ruleFinders = new LinkedList();
ruleFinders.add(new FinderFromFile());
ruleFinders.add(new FinderFromResource());
ruleFinders.add(new FinderFromClass());
ruleFinders.add(new FinderFromMethod());
ruleFinders.add(new FinderFromDfltMethod());
ruleFinders.add(new FinderFromDfltClass());
ruleFinders.add(new FinderFromDfltResource());
ruleFinders.add(new FinderFromDfltResource(".xml"));
ruleFinders.add(new FinderSetProperties());
}
return ruleFinders;
}
/**
* Set the list of RuleFinder objects. This may be useful if working
* in a non-english language, allowing the application developer to
* replace the standard list with a list of objects which look for xml
* attributes in the local language.
*
* If the intent is just to add an additional rule-finding algorithm, then
* it may be better to call #getRuleFinders, and insert a new object into
* the start of the list.
*/
public void setRuleFinders(List ruleFinders) {
this.ruleFinders = ruleFinders;
}
/**
* Sets the xml attribute which the input xml uses to indicate to a
* PluginCreateRule which class should be instantiated.
*
* Example:
*
* Note that the xml attributes used by PluginDeclarationRules are not
* affected by this method.
*
* @param namespaceUri is the namespace uri that the specified attribute
* is in. If the attribute is in no namespace, then this should be null.
* Note that if a namespace is used, the attrName value should not
* contain any kind of namespace-prefix. Note also that if you are using
* a non-namespace-aware parser, this parameter must be null.
*
* @param attrName is the attribute whose value contains the name of the
* class to be instantiated.
*/
public void setPluginClassAttribute(String namespaceUri,
String attrName) {
pluginClassAttrNs = namespaceUri;
pluginClassAttr = attrName;
}
/**
* Sets the xml attribute which the input xml uses to indicate to a
* PluginCreateRule which plugin declaration is being referenced.
*
* Example:
*
* Note that the xml attributes used by PluginDeclarationRules are not
* affected by this method.
*
* @param namespaceUri is the namespace uri that the specified attribute
* is in. If the attribute is in no namespace, then this should be null.
* Note that if a namespace is used, the attrName value should not
* contain any kind of namespace-prefix. Note also that if you are using
* a non-namespace-aware parser, this parameter must be null.
*
* @param attrName is the attribute whose value contains the id of the
* plugin declaration to be used when instantiating an object.
*/
public void setPluginIdAttribute(String namespaceUri,
String attrName) {
pluginIdAttrNs = namespaceUri;
pluginIdAttr = attrName;
}
/**
* Get the namespace for the xml attribute which indicates to a
* PluginCreateRule which class is to be plugged in.
*
* May be null (in fact, normally will be).
*/
public String getPluginClassAttrNs() {
return pluginClassAttrNs;
}
/**
* Get the namespace for the xml attribute which indicates to a
* PluginCreateRule which class is to be plugged in.
*
* The return value is never null.
*/
public String getPluginClassAttr() {
return pluginClassAttr;
}
/**
* Get the namespace for the xml attribute which indicates to a
* PluginCreateRule which previous plugin declaration should be used.
*
* May be null (in fact, normally will be).
*/
public String getPluginIdAttrNs() {
return pluginIdAttrNs;
}
/**
* Get the namespace for the xml attribute which indicates to a
* PluginCreateRule which previous plugin declaration should be used.
*
* The return value is never null.
*/
public String getPluginIdAttr() {
return pluginIdAttr;
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/Declaration.java 0000644 0001750 0001750 00000016147 11226450007 033063 0 ustar twerner twerner /* $Id: Declaration.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.digester.Digester;
/**
* Represents a Class that can be instantiated by a PluginCreateRule, plus
* info on how to load custom digester rules for mapping xml into that
* plugged-in class.
*
* @since 1.6
*/
public class Declaration {
/** The class of the object to be instantiated. */
private Class pluginClass;
/** The name of the class of the object to be instantiated. */
private String pluginClassName;
/** See {@link #setId}. */
private String id;
/** See {@link #setProperties}. */
private Properties properties = new Properties();
/** See {@link #init}. */
private boolean initialized = false;
/**
* Class which is responsible for dynamically loading this
* plugin's rules on demand.
*/
private RuleLoader ruleLoader = null;
//---------------------- constructors ----------------------------------
/**
* Constructor.
*/
public Declaration(String pluginClassName) {
// We can't load the pluginClass at this time, because we don't
// have a digester instance yet to load it through. So just
// save the name away, and we'll load the Class object in the
// init method.
this.pluginClassName = pluginClassName;
}
/**
* Constructor.
*/
public Declaration(Class pluginClass) {
this.pluginClass = pluginClass;
this.pluginClassName = pluginClass.getName();
}
/**
* Create an instance where a fully-initialised ruleLoader instance
* is provided by the caller instead of having the PluginManager
* "discover" an appropriate one.
*/
public Declaration(Class pluginClass, RuleLoader ruleLoader) {
this.pluginClass = pluginClass;
this.pluginClassName = pluginClass.getName();
this.ruleLoader = ruleLoader;
}
//---------------------- properties -----------------------------------
/**
* The id that the user associated with a particular plugin declaration
* in the input xml. This id is later used in the input xml to refer
* back to the original declaration.
*
* For plugins declared "in-line", the id is null.
*/
public void setId(String id) {
this.id = id;
}
/**
* Return the id associated with this declaration. For plugins
* declared "inline", null will be returned.
*
* @return The id value. May be null.
*/
public String getId() {
return id;
}
/**
* Copy all (key,value) pairs in the param into the properties member of
* this object.
*
* The declaration properties cannot be explicit member variables,
* because the set of useful properties a user can provide on a declaration
* depends on what RuleFinder classes are available - and extra RuleFinders
* can be added by the user. So here we keep a map of the settings, and
* let the RuleFinder objects look for whatever properties they consider
* significant.
*
* The "id" and "class" properties are treated differently.
*/
public void setProperties(Properties p) {
properties.putAll(p);
}
/**
* Return plugin class associated with this declaration.
*
* @return The pluginClass.
*/
public Class getPluginClass() {
return pluginClass;
}
//---------------------- methods -----------------------------------
/**
* Must be called exactly once, and must be called before any call
* to the configure method.
*/
public void init(Digester digester, PluginManager pm) throws PluginException {
Log log = digester.getLogger();
boolean debug = log.isDebugEnabled();
if (debug) {
log.debug("init being called!");
}
if (initialized) {
throw new PluginAssertionFailure("Init called multiple times.");
}
if ((pluginClass == null) && (pluginClassName != null)) {
try {
// load the plugin class object
pluginClass =
digester.getClassLoader().loadClass(pluginClassName);
} catch(ClassNotFoundException cnfe) {
throw new PluginException(
"Unable to load class " + pluginClassName, cnfe);
}
}
if (ruleLoader == null) {
// the caller didn't provide a ruleLoader to the constructor,
// so get the plugin manager to "discover" one.
log.debug("Searching for ruleloader...");
ruleLoader = pm.findLoader(digester, id, pluginClass, properties);
} else {
log.debug("This declaration has an explicit ruleLoader.");
}
if (debug) {
if (ruleLoader == null) {
log.debug(
"No ruleLoader found for plugin declaration"
+ " id [" + id + "]"
+ ", class [" + pluginClass.getClass().getName() + "].");
} else {
log.debug(
"RuleLoader of type [" + ruleLoader.getClass().getName()
+ "] associated with plugin declaration"
+ " id [" + id + "]"
+ ", class [" + pluginClass.getClass().getName() + "].");
}
}
initialized = true;
}
/**
* Attempt to load custom rules for the target class at the specified
* pattern.
*
* On return, any custom rules associated with the plugin class have
* been loaded into the Rules object currently associated with the
* specified digester object.
*/
public void configure(Digester digester, String pattern)
throws PluginException {
Log log = digester.getLogger();
boolean debug = log.isDebugEnabled();
if (debug) {
log.debug("configure being called!");
}
if (!initialized) {
throw new PluginAssertionFailure("Not initialized.");
}
if (ruleLoader != null) {
ruleLoader.addRules(digester, pattern);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginException.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginException.jav0000644 0001750 0001750 00000003611 11226450007 033602 0 ustar twerner twerner /* $Id: PluginException.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
/**
* Thrown when some plugin-related error has occurred, and none of the
* other exception types are appropriate.
*
* @since 1.6
*/
public class PluginException extends Exception {
private Throwable cause = null;
/**
* @param cause underlying exception that caused this to be thrown
*/
public PluginException(Throwable cause) {
this(cause.getMessage());
this.cause = cause;
}
/**
* @param msg describes the reason this exception is being thrown.
*/
public PluginException(String msg) {
super(msg);
}
/**
* @param msg describes the reason this exception is being thrown.
* @param cause underlying exception that caused this to be thrown
*/
public PluginException(String msg, Throwable cause) {
this(msg);
this.cause = cause;
}
/**
* @return the underlying exception that caused this to be thrown
*/
public Throwable getCause() {
return cause;
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginRules.java 0000644 0001750 0001750 00000035544 11226450007 033111 0 ustar twerner twerner /* $Id: PluginRules.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
import java.util.List;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.Rule;
import org.apache.commons.digester.Rules;
import org.apache.commons.digester.RulesBase;
import org.apache.commons.logging.Log;
/**
* A custom digester Rules manager which must be used as the Rules object
* when using the plugins module functionality.
*
* During parsing, a linked list of PluginCreateRule instances develop, and
* this list also acts like a stack. The original instance that was set before
* the Digester started parsing is always at the tail of the list, and the
* Digester always holds a reference to the instance at the head of the list
* in the rules member. Initially, this list/stack holds just one instance,
* ie head and tail are the same object.
*
* When the start of an xml element causes a PluginCreateRule to fire, a new
* PluginRules instance is created and inserted at the head of the list (ie
* pushed onto the stack of Rules objects). Digester.getRules() therefore
* returns this new Rules object, and any custom rules associated with that
* plugin are added to that instance.
*
* When the end of the xml element is encountered (and therefore the
* PluginCreateRule end method fires), the stack of Rules objects is popped,
* so that Digester.getRules returns the previous Rules object.
*
* @since 1.6
*/
public class PluginRules implements Rules {
/**
* The Digester instance with which this Rules instance is associated.
*/
protected Digester digester = null;
/**
* The (optional) object which generates new rules instances.
*/
private RulesFactory rulesFactory;
/**
* The rules implementation that we are "enhancing" with plugins
* functionality, as per the Decorator pattern.
*/
private Rules decoratedRules;
/** Object which contains information about all known plugins. */
private PluginManager pluginManager;
/**
* The path below which this rules object has responsibility.
* For paths shorter than or equal the mountpoint, the parent's
* match is called.
*/
private String mountPoint = null;
/**
* The Rules object that holds rules applying "above" the mountpoint,
* ie the next Rules object down in the stack.
*/
private PluginRules parent = null;
/**
* A reference to the object that holds all data which should only
* exist once per digester instance.
*/
private PluginContext pluginContext = null;
// ------------------------------------------------------------- Constructor
/**
* Constructor for top-level Rules objects. Exactly one of these must
* be created and installed into the Digester instance as the Rules
* object before parsing starts.
*/
public PluginRules() {
this(new RulesBase());
}
/**
* Constructor for top-level Rules object which handles rule-matching
* using the specified implementation.
*/
public PluginRules(Rules decoratedRules) {
this.decoratedRules = decoratedRules;
pluginContext = new PluginContext();
pluginManager = new PluginManager(pluginContext);
}
/**
* Constructs a Rules instance which has a parent Rules object
* (which is different from having a delegate rules object).
*
* One of these is created each time a PluginCreateRule's begin method
* fires, in order to manage the custom rules associated with whatever
* concrete plugin class the user has specified.
*
* @param digester is the object this rules will be associated with.
* @param mountPoint is the digester match path for the element
* matching a PluginCreateRule which caused this "nested parsing scope"
* to begin. This is expected to be equal to digester.getMatch().
* @param parent must be non-null.
* @param pluginClass is the plugin class whose custom rules will be
* loaded into this new PluginRules object.
*/
PluginRules(
Digester digester,
String mountPoint,
PluginRules parent,
Class pluginClass)
throws PluginException {
// no need to set digester or decoratedRules.digester,
// because when Digester.setRules is called, the setDigester
// method on this object will be called.
this.digester = digester;
this.mountPoint = mountPoint;
this.parent = parent;
this.rulesFactory = parent.rulesFactory;
if (rulesFactory == null) {
decoratedRules = new RulesBase();
} else {
decoratedRules = rulesFactory.newRules(digester, pluginClass);
}
pluginContext = parent.pluginContext;
pluginManager = new PluginManager(parent.pluginManager);
}
// ------------------------------------------------------------- Properties
/**
* Return the parent Rules object.
*/
public Rules getParent() {
return parent;
}
/**
* Return the Digester instance with which this instance is associated.
*/
public Digester getDigester() {
return digester;
}
/**
* Set the Digester instance with which this Rules instance is associated.
*
* @param digester The newly associated Digester instance
*/
public void setDigester(Digester digester) {
this.digester = digester;
decoratedRules.setDigester(digester);
}
/**
* Return the namespace URI that will be applied to all subsequently
* added
* Note that Rule objects stored in parent Rules objects are not
* returned by this method.
*
* @return list of all Rule objects known to this Rules instance.
*/
public List rules() {
return decoratedRules.rules();
}
/**
* Register a new Rule instance matching the specified pattern.
*
* @param pattern Nesting pattern to be matched for this Rule.
* This parameter treats equally patterns that begin with and without
* a leading slash ('/').
* @param rule Rule instance to be registered
*/
public void add(String pattern, Rule rule) {
Log log = LogUtils.getLogger(digester);
boolean debug = log.isDebugEnabled();
if (debug) {
log.debug("add entry" + ": mapping pattern [" + pattern + "]" +
" to rule of type [" + rule.getClass().getName() + "]");
}
// allow patterns with a leading slash character
if (pattern.startsWith("/"))
{
pattern = pattern.substring(1);
}
if (mountPoint != null) {
if (!pattern.equals(mountPoint)
&& !pattern.startsWith(mountPoint + "/")) {
// This can only occur if a plugin attempts to add a
// rule with a pattern that doesn't start with the
// prefix passed to the addRules method. Plugins mustn't
// add rules outside the scope of the tag they were specified
// on, so refuse this.
// alas, can't throw exception
log.warn(
"An attempt was made to add a rule with a pattern that"
+ "is not at or below the mountpoint of the current"
+ " PluginRules object."
+ " Rule pattern: " + pattern
+ ", mountpoint: " + mountPoint
+ ", rule type: " + rule.getClass().getName());
return;
}
}
decoratedRules.add(pattern, rule);
if (rule instanceof InitializableRule) {
try {
((InitializableRule)rule).postRegisterInit(pattern);
} catch (PluginConfigurationException e) {
// Currently, Digester doesn't handle exceptions well
// from the add method. The workaround is for the
// initialisable rule to remember that its initialisation
// failed, and to throw the exception when begin is
// called for the first time.
if (debug) {
log.debug("Rule initialisation failed", e);
}
// throw e; -- alas, can't do this
return;
}
}
if (debug) {
log.debug("add exit" + ": mapped pattern [" + pattern + "]" +
" to rule of type [" + rule.getClass().getName() + "]");
}
}
/**
* Clear all rules.
*/
public void clear() {
decoratedRules.clear();
}
/**
* Return a List of all registered Rule instances that match the specified
* nesting pattern, or a zero-length List if there are no matches. If more
* than one Rule instance matches, they must be returned
* in the order originally registered through the
* @param namespaceURI Namespace URI for which to select matching rules,
* or
* If there is no such class, then just return null.
*
* The returned object (when non-null) will invoke the target method
* on the selected class whenever its addRules method is invoked. The
* target method is expected to have the following prototype:
*
* If there is no matching method then just return null.
*
* The returned object (when non-null) will invoke the target method
* on the plugin class whenever its addRules method is invoked. The
* target method is expected to have the following prototype:
*
* This loader ensures that any xml attributes on the plugin tag get
* mapped to equivalent properties on a javabean. This allows JavaBean
* classes to be used as plugins without any requirement to create custom
* plugin rules.
*
* @since 1.6
*/
public class LoaderSetProperties extends RuleLoader {
/**
* Just add a SetPropertiesRule at the specified path.
*/
public void addRules(Digester digester, String path) {
Log log = digester.getLogger();
boolean debug = log.isDebugEnabled();
if (debug) {
log.debug(
"LoaderSetProperties loading rules for plugin at path ["
+ path + "]");
}
digester.addSetProperties(path);
}
}
././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFromMethod.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFr0000644 0001750 0001750 00000005613 11226450007 033563 0 ustar twerner twerner /* $Id: FinderFromMethod.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.util.Properties;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.RuleFinder;
import org.apache.commons.digester.plugins.RuleLoader;
import org.apache.commons.digester.plugins.PluginException;
/**
* A rule-finding algorithm which expects the caller to specify a methodname
* as a plugin property, where the method exists on the plugin class.
*
* @since 1.6
*/
public class FinderFromMethod extends RuleFinder {
/**
* Xml attribute that needs to be present on a plugin declaration
* in order to specify the method to load rules from.
*/
public static String DFLT_METHOD_ATTR = "method";
/** See {@link #findLoader}. */
private String methodAttr;
/** Constructor. */
public FinderFromMethod() {
this(DFLT_METHOD_ATTR);
}
/** See {@link #findLoader}. */
public FinderFromMethod(String methodAttr) {
this.methodAttr = methodAttr;
}
/**
* If there exists a property with the name matching constructor param
* methodAttr, then locate the appropriate Method on the plugin class
* and return an object encapsulating that info.
*
* If there is no matching property provided, then just return null.
*
* The returned object (when non-null) will invoke the target method
* on the plugin class whenever its addRules method is invoked. The
* target method is expected to have the following prototype:
*
This package contains "rule-finding" strategy classes, and their associated
"helper" loader classes.
Note that you do not need to understand or deal with any of the classes in
this package in order to use the plugins functionality. If you wish to use
plugins functionality in non-english languages and therefore want to
change the attribute names used on plugin declaration tags ("id", "file", etc)
then you will need some familiarity with this package. Otherwise, this package
is only relevant to people really wishing to tweak plugins in unexpected
ways. If this is the case, come and talk to us on the digester email lists
as we would be interested in knowing about your requirements.
When the plugins module is being used and the input xml indicates that
a specific plugin class is to be instantiated, that class may then wish
to configure itself from the xml attributes on that tag or xml attributes
and elements nested within that tag.
The question is: how is the digester going to figure out where the plugin
keeps its custom rules which are to be applied to the xml within that
plugin tag?
Well, the answer is that there is a list of "rule finding strategies",
generally containing an instance of each of the Finder classes in this
package in a specific order. The strategies provided here should satisfy
just about everyone, but if they don't you can add extra strategies if
desired.
A RuleFinder is essentially a "strategy" or "algorithm" for finding the dynamic
rules associated with a plugin class. When a plugin declaration is encountered
in the input xml, the PluginContext object is asked for the list of RuleFinder
objects, then each RuleFinder instance in turn is passed the declaration
parameters, and asked "are you able to locate custom parsing rules for this
declaration?". When one can, it returns a RuleLoader instance which is
remembered. When the input xml indicates that an instance of the declared
plugin class is to be created, that RuleLoader is invoked to temporarily add
the relevant custom rules to the Digester in order to map xml
attributes/elements/etc into the instantiated plugin object. Once the end of
the plugin tag is encountered, those temporary rules are removed. This repeats
each time the input xml indicates that an instance of a plugin class is to be
instantiated.
If the plugin is declared "inline", using the "plugin-class" attribute
instead of using "plugin-id" to reference a previous declaration then the
process is exactly the same, except that the RuleFinder objects don't
have any user-provided attribute "hints" to tell them where the custom
rules are.
The RuleFinder list is carefully ordered; classes which look at the
user-provided data in the declaration come first, and classes which look in
"well-known places" come later so that users can override default behaviour by
providing the appropriate tags on the plugin declaration.
See the javadoc on the different Finder classes for information on what
each does, and what attribute (if any) it looks for in the declaration.
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFromFile.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFr0000644 0001750 0001750 00000007171 11226450007 033564 0 ustar twerner twerner /* $Id: FinderFromFile.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.util.Properties;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.RuleFinder;
import org.apache.commons.digester.plugins.RuleLoader;
import org.apache.commons.digester.plugins.PluginException;
/**
* A rule-finding algorithm which expects the user to specify an absolute
* or relative path in the plugin declaration.
*
* The file is expected to contain Digester rules in xmlrules format.
*
* @since 1.6
*/
public class FinderFromFile extends RuleFinder {
/**
* Xml attribute that needs to be present on a plugin declaration
* in order to specify the file to load rules from.
*/
public static String DFLT_FILENAME_ATTR = "file";
/** See {@link #findLoader}. */
private String filenameAttr;
/** See {@link #findLoader}. */
public FinderFromFile() {
this(DFLT_FILENAME_ATTR);
}
/** See {@link #findLoader}. */
public FinderFromFile(String filenameAttr) {
this.filenameAttr = filenameAttr;
}
/**
* If there exists a property with the name specified in the constructor,
* then load that file, run it through the xmlrules module and return an
* object encapsulating those rules.
*
* If there is no matching property provided, then just return null.
*
* The returned object (when non-null) will add the selected rules to
* the digester whenever its addRules method is invoked.
*/
public RuleLoader findLoader(Digester d, Class pluginClass, Properties p)
throws PluginException {
String rulesFileName = p.getProperty(filenameAttr);
if (rulesFileName == null) {
// nope, user hasn't requested dynamic rules to be loaded
// from a specific file.
return null;
}
InputStream is = null;
try {
is = new FileInputStream(rulesFileName);
} catch(IOException ioe) {
throw new PluginException(
"Unable to process file [" + rulesFileName + "]", ioe);
}
try {
RuleLoader loader = new LoaderFromStream(is);
return loader;
} catch(Exception e) {
throw new PluginException(
"Unable to load xmlrules from file [" +
rulesFileName + "]", e);
} finally {
try {
is.close();
} catch(java.io.IOException ioe) {
throw new PluginException(
"Unable to close stream for file [" +
rulesFileName + "]", ioe);
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000164 00000000000 011566 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFromResource.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFr0000644 0001750 0001750 00000010630 11226450007 033556 0 ustar twerner twerner /* $Id: FinderFromResource.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.util.Properties;
import java.io.InputStream;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.RuleFinder;
import org.apache.commons.digester.plugins.RuleLoader;
import org.apache.commons.digester.plugins.PluginException;
/**
* A rule-finding algorithm which expects the user to specify a resource
* name (ie a file in the classpath). The file is expected to contain Digester
* rules in xmlrules format.
*
* @since 1.6
*/
public class FinderFromResource extends RuleFinder {
/**
* Name of xml attribute on the plugin declaration which is used
* to configure rule-loading for that declaration.
*/
public static String DFLT_RESOURCE_ATTR = "resource";
/** See {@link #findLoader}. */
private String resourceAttr;
/** Constructor. */
public FinderFromResource() {
this(DFLT_RESOURCE_ATTR);
}
/** See {@link #findLoader}. */
public FinderFromResource(String resourceAttr) {
this.resourceAttr = resourceAttr;
}
/**
* If there exists a property with the name matching constructor param
* resourceAttr, then load that file, run it through the xmlrules
* module and return an object encapsulating those rules.
*
* If there is no matching property provided, then just return null.
*
* The returned object (when non-null) will add the selected rules to
* the digester whenever its addRules method is invoked.
*/
public RuleLoader findLoader(Digester d, Class pluginClass, Properties p)
throws PluginException {
String resourceName = p.getProperty(resourceAttr);
if (resourceName == null) {
// nope, user hasn't requested dynamic rules to be loaded
// from a specific file.
return null;
}
InputStream is =
pluginClass.getClassLoader().getResourceAsStream(
resourceName);
if (is == null) {
throw new PluginException(
"Resource " + resourceName + " not found.");
}
return loadRules(d, pluginClass, is, resourceName);
}
/**
* Open the specified resource file (ie a file in the classpath,
* including being within a jar in the classpath), run it through
* the xmlrules module and return an object encapsulating those rules.
*
* @param d is the digester into which rules will eventually be loaded.
* @param pluginClass is the class whose xml params the rules are parsing.
* @param is is where the xmlrules will be read from, and must be non-null.
* @param resourceName is a string describing the source of the xmlrules,
* for use in generating error messages.
*/
public static RuleLoader loadRules(Digester d, Class pluginClass,
InputStream is, String resourceName)
throws PluginException {
try {
RuleLoader loader = new LoaderFromStream(is);
return loader;
} catch(Exception e) {
throw new PluginException(
"Unable to load xmlrules from resource [" +
resourceName + "]", e);
} finally {
try {
is.close();
} catch(java.io.IOException ioe) {
throw new PluginException(
"Unable to close stream for resource [" +
resourceName + "]", ioe);
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000161 00000000000 011563 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/LoaderFromClass.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/LoaderFr0000644 0001750 0001750 00000006710 11226450007 033561 0 ustar twerner twerner /* $Id: LoaderFromClass.java 472842 2006-11-09 10:19:56Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.lang.reflect.Method;
import org.apache.commons.digester.Digester;
import org.apache.commons.beanutils.MethodUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.digester.plugins.RuleLoader;
import org.apache.commons.digester.plugins.PluginException;
/**
* A RuleLoader which invokes a static method on a target class, leaving that
* method to actually instantiate and add new rules to a Digester instance.
*
* @since 1.6
*/
public class LoaderFromClass extends RuleLoader {
private Class rulesClass;
private Method rulesMethod;
/** Constructor. */
public LoaderFromClass(Class rulesClass, Method rulesMethod) {
this.rulesClass = rulesClass;
this.rulesMethod = rulesMethod;
}
/** Constructor. */
public LoaderFromClass(Class rulesClass, String methodName)
throws PluginException {
Method method = locateMethod(rulesClass, methodName);
if (method == null) {
throw new PluginException(
"rule class " + rulesClass.getName()
+ " does not have method " + methodName
+ " or that method has an invalid signature.");
}
this.rulesClass = rulesClass;
this.rulesMethod = method;
}
/**
* Just invoke the target method.
*/
public void addRules(Digester d, String path) throws PluginException {
Log log = d.getLogger();
boolean debug = log.isDebugEnabled();
if (debug) {
log.debug(
"LoaderFromClass loading rules for plugin at path ["
+ path + "]");
}
try {
Object[] params = {d, path};
rulesMethod.invoke(null, params);
} catch (Exception e) {
throw new PluginException(
"Unable to invoke rules method " + rulesMethod
+ " on rules class " + rulesClass, e);
}
}
/**
* Find a method on the specified class whose name matches methodName,
* and whose signature is:
*
* This allows ordinary JavaBean classes to be used as plugins, and have
* xml attributes be mapped to bean properties of the same name, without
* any custom plugin rules being created for them.
*
* This RuleFinder is typically used as the last RuleFinder, so that
* automatic property setting only occurs if there is no other source of
* custom rules available.
*
* @since 1.6
*/
public class FinderSetProperties extends RuleFinder {
public static String DFLT_PROPS_ATTR = "setprops";
public static String DFLT_FALSEVAL = "false";
private String propsAttr;
private String falseval;
/** See {@link #findLoader}. */
public FinderSetProperties() {
this(DFLT_PROPS_ATTR, DFLT_FALSEVAL);
}
/**
* Create a rule-finder which will arrange for a SetPropertiesRule to
* be defined for each instance of a plugin, so that xml attributes
* map to bean properties.
*
* Param falseval will commonly be the string "false" for config files
* written in English.
*
* @param propsAttr must be non-null.
* @param falseval must be non-null.
*/
public FinderSetProperties(String propsAttr, String falseval) {
this.propsAttr = propsAttr;
this.falseval = falseval;
}
/**
* Returns a RuleLoader unless the properties contain an entry
* with the name matching constructor param propsAttr, and the value
* matching what is in falseval.
*
* If no custom source of rules for a plugin is found, then the user
* almost always wants xml attributes to map to java bean properties,
* so this is the default behaviour unless the user explicitly indicates
* that they do not want a SetPropertiesRule to be provided for
* the plugged-in class.
*
* The returned object (when non-null) will add a SetPropertiesRule to
* the digester whenever its addRules method is invoked.
*/
public RuleLoader findLoader(Digester d, Class pluginClass, Properties p) {
String state = p.getProperty(propsAttr);
if ((state != null) && state.equals(falseval)) {
// user has explicitly disabled automatic setting of properties.
// this is not expected to be common, but allowed.
return null;
}
return new LoaderSetProperties();
}
}
././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/LoaderFromStream.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/LoaderFr0000644 0001750 0001750 00000006304 11226450007 033560 0 ustar twerner twerner /* $Id: LoaderFromStream.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.io.InputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import org.xml.sax.InputSource;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.RuleLoader;
import org.apache.commons.digester.plugins.PluginException;
import org.apache.commons.digester.xmlrules.FromXmlRuleSet;
import org.apache.commons.logging.Log;
/**
* A rule-finding algorithm which loads an xmlplugins-format file.
*
* Note that the "include" feature of xmlrules is not supported.
*
* @since 1.6
*/
public class LoaderFromStream extends RuleLoader {
private byte[] input;
private FromXmlRuleSet ruleSet;
/** See {@link #load}. */
public LoaderFromStream(InputStream s) throws Exception {
load(s);
}
/**
* The contents of the input stream are loaded into memory, and
* cached for later use.
*
* The caller is responsible for closing the input stream after this
* method has returned.
*/
private void load(InputStream s) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buf = new byte[256];
for(;;) {
int i = s.read(buf);
if (i == -1)
break;
baos.write(buf, 0, i);
}
input = baos.toByteArray();
}
/**
* Add the rules previously loaded from the input stream into the
* specified digester.
*/
public void addRules(Digester d, String path) throws PluginException {
Log log = d.getLogger();
boolean debug = log.isDebugEnabled();
if (debug) {
log.debug(
"LoaderFromStream: loading rules for plugin at path ["
+ path + "]");
}
// Note that this input-source doesn't have any idea of its
// system id, so it has no way of resolving relative URLs
// such as the "include" feature of xmlrules. This is ok,
// because that doesn't work well with our approach of
// caching the input data in memory anyway.
InputSource source = new InputSource(new ByteArrayInputStream(input));
FromXmlRuleSet ruleSet = new FromXmlRuleSet(source);
ruleSet.addRuleInstances(d, path);
}
}
././@LongLink 0000000 0000000 0000000 00000000170 00000000000 011563 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFromDfltResource.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFr0000644 0001750 0001750 00000006217 11226450007 033564 0 ustar twerner twerner /* $Id: FinderFromDfltResource.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.io.InputStream;
import java.util.Properties;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.RuleFinder;
import org.apache.commons.digester.plugins.RuleLoader;
import org.apache.commons.digester.plugins.PluginException;
/**
* A rule-finding algorithm which looks for a resource file in the classpath
* whose name is derived from the plugin class name plus a specified suffix.
*
* If the resource-file is found, then it is expected to define a set of
* Digester rules in xmlrules format.
*
* @since 1.6
*/
public class FinderFromDfltResource extends RuleFinder {
public static String DFLT_RESOURCE_SUFFIX = "RuleInfo.xml";
private String resourceSuffix;
/** See {@link #findLoader}. */
public FinderFromDfltResource() {
this(DFLT_RESOURCE_SUFFIX);
}
/**
* Create a rule-finder which can load an xmlrules file, cache
* the rules away, and later add them as a plugin's custom rules
* when that plugin is referenced.
*
* @param resourceSuffix must be non-null.
*/
public FinderFromDfltResource(String resourceSuffix) {
this.resourceSuffix = resourceSuffix;
}
/**
* If there exists a resource file whose name is equal to the plugin
* class name + the suffix specified in the constructor, then
* load that file, run it through the xmlrules module and return an object
* encapsulating those rules.
*
* If there is no such resource file, then just return null.
*
* The returned object (when non-null) will add the selected rules to
* the digester whenever its addRules method is invoked.
*/
public RuleLoader findLoader(Digester d, Class pluginClass, Properties p)
throws PluginException {
String resourceName =
pluginClass.getName().replace('.', '/')
+ resourceSuffix;
InputStream is =
pluginClass.getClassLoader().getResourceAsStream(
resourceName);
if (is == null) {
// ok, no such resource
return null;
}
return FinderFromResource.loadRules(d, pluginClass, is, resourceName);
}
}
././@LongLink 0000000 0000000 0000000 00000000161 00000000000 011563 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFromClass.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFr0000644 0001750 0001750 00000011733 11226450007 033563 0 ustar twerner twerner /* $Id: FinderFromClass.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.util.Properties;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.RuleFinder;
import org.apache.commons.digester.plugins.RuleLoader;
import org.apache.commons.digester.plugins.PluginException;
/**
* A rule-finding algorithm which expects the caller to specify a classname and
* methodname as plugin properties.
*
* @since 1.6
*/
public class FinderFromClass extends RuleFinder {
public static String DFLT_RULECLASS_ATTR = "ruleclass";
public static String DFLT_METHOD_ATTR = "method";
public static String DFLT_METHOD_NAME = "addRules";
private String ruleClassAttr;
private String methodAttr;
private String dfltMethodName;
/**
* See {@link #findLoader}.
*/
public FinderFromClass() {
this(DFLT_RULECLASS_ATTR, DFLT_METHOD_ATTR, DFLT_METHOD_NAME);
}
/**
* Create a rule-finder which invokes a user-specified method on a
* user-specified class whenever dynamic rules for a plugin need to be
* loaded. See the findRules method for more info.
*
* @param ruleClassAttr must be non-null.
* @param methodAttr may be null.
* @param dfltMethodName may be null.
*/
public FinderFromClass(String ruleClassAttr, String methodAttr,
String dfltMethodName) {
this.ruleClassAttr = ruleClassAttr;
this.methodAttr = methodAttr;
this.dfltMethodName = dfltMethodName;
}
/**
* If there exists a property with the name matching constructor param
* ruleClassAttr, then load the specified class, locate the appropriate
* rules-adding method on that class, and return an object encapsulating
* that info.
*
* If there is no matching property provided, then just return null.
*
* The returned object (when non-null) will invoke the target method
* on the selected class whenever its addRules method is invoked. The
* target method is expected to have the following prototype:
*
* The target method can be specified in several ways. If this object's
* constructor was passed a non-null methodAttr parameter, and the
* properties defines a value with that key, then that is taken as the
* target method name. If there is no matching property, or the constructor
* was passed null for methodAttr, then the dfltMethodName passed to the
* constructor is used as the name of the method on the target class. And
* if that was null, then DFLT_METHOD_NAME will be used.
*
* When the user explicitly declares a plugin in the input xml, the
* xml attributes on the declaration tag are passed here as properties,
* so the user can select any class in the classpath (and any method on
* that class provided it has the correct prototype) as the source of
* dynamic rules for the plugged-in class.
*/
public RuleLoader findLoader(Digester digester, Class pluginClass,
Properties p) throws PluginException {
String ruleClassName = p.getProperty(ruleClassAttr);
if (ruleClassName == null) {
// nope, user hasn't requested dynamic rules to be loaded
// from a specific class.
return null;
}
// ok, we are in business
String methodName = null;
if (methodAttr != null) {
methodName = p.getProperty(methodAttr);
}
if (methodName == null) {
methodName = dfltMethodName;
}
if (methodName == null) {
methodName = DFLT_METHOD_NAME;
}
Class ruleClass;
try {
// load the plugin class object
ruleClass =
digester.getClassLoader().loadClass(ruleClassName);
} catch(ClassNotFoundException cnfe) {
throw new PluginException(
"Unable to load class " + ruleClassName, cnfe);
}
return new LoaderFromClass(ruleClass, methodName);
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/RuleLoader.java 0000644 0001750 0001750 00000003751 11226450007 032671 0 ustar twerner twerner /* $Id: RuleLoader.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
import org.apache.commons.digester.Digester;
/**
* Interface for classes which can dynamically load custom
* plugin rules associated with a user's plugin class.
*
* Each plugin declaration has an associated RuleLoader instance, and that
* instance's addRules method is invoked each time the input xml specifies
* that an instance of that plugged-in class is to be created.
*
* This is an abstract class rather than an interface in order to make
* it possible to enhance this class in future without breaking binary
* compatibility; it is possible to add methods to an abstract class, but
* not to an interface.
*
* @since 1.6
*/
public abstract class RuleLoader {
/**
* Configures the digester with custom rules for some plugged-in
* class.
*
* This method is invoked when the start of an xml tag is encountered
* which maps to a PluginCreateRule. Any rules added here are removed
* from the digester when the end of that xml tag is encountered.
*/
public abstract void addRules(Digester d, String path) throws PluginException;
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginDeclarationRule.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/PluginDeclarationRu0000644 0001750 0001750 00000010264 11226450007 033623 0 ustar twerner twerner /* $Id: PluginDeclarationRule.java 472837 2006-11-09 10:07:51Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
import java.util.Properties;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.Rule;
/**
* A Digester rule which allows the user to pre-declare a class which is to
* be referenced later at a plugin point by a PluginCreateRule.
*
* Normally, a PluginDeclarationRule is added to a Digester instance with
* the pattern "{root}/plugin" or "* /plugin" where {root} is the name of
* the root tag in the input document.
*
* @since 1.6
*/
public class PluginDeclarationRule extends Rule {
//------------------- constructors ---------------------------------------
/** constructor */
public PluginDeclarationRule() {
super();
}
//------------------- methods --------------------------------------------
/**
* Invoked upon reading a tag defining a plugin declaration. The tag
* must have the following mandatory attributes:
*
* @param parent must be non-null.
*/
public PluginManager(PluginManager parent) {
this.parent = parent;
this.pluginContext = parent.pluginContext;
}
//------------------- methods --------------------------------------------
/**
* Add the declaration to the set of known declarations.
*
* TODO: somehow get a reference to a Digester object
* so that we can really log here. Currently, all
* logging is disabled from this method.
*
*@param decl an object representing a plugin class.
*/
public void addDeclaration(Declaration decl) {
Log log = LogUtils.getLogger(null);
boolean debug = log.isDebugEnabled();
Class pluginClass = decl.getPluginClass();
String id = decl.getId();
declarationsByClass.put(pluginClass.getName(), decl);
if (id != null) {
declarationsById.put(id, decl);
if (debug) {
log.debug(
"Indexing plugin-id [" + id + "]" +
" -> class [" + pluginClass.getName() + "]");
}
}
}
/**
* Return the declaration object with the specified class.
* If no such plugin is known, null is returned.
*/
public Declaration getDeclarationByClass(String className) {
Declaration decl =
(Declaration) declarationsByClass.get(className);
if ((decl == null) && (parent != null)) {
decl = parent.getDeclarationByClass(className);
}
return decl;
}
/**
* Return the declaration object with the specified id.
* If no such plugin is known, null is returned.
*
*@param id Description of the Parameter
*@return The declaration value
*/
public Declaration getDeclarationById(String id) {
Declaration decl = (Declaration) declarationsById.get(id);
if ((decl == null) && (parent != null)) {
decl = parent.getDeclarationById(id);
}
return decl;
}
/**
* Given a plugin class and some associated properties, scan the
* list of known RuleFinder instances until one detects a source of
* custom rules for this plugin (aka a RuleLoader).
*
* If no source of custom rules can be found, null is returned.
*/
public RuleLoader findLoader(Digester digester, String id,
Class pluginClass, Properties props)
throws PluginException {
// iterate over the list of RuleFinders, trying each one
// until one of them locates a source of dynamic rules given
// this specific plugin class and the associated declaration
// properties.
Log log = LogUtils.getLogger(digester);
boolean debug = log.isDebugEnabled();
log.debug("scanning ruleFinders to locate loader..");
List ruleFinders = pluginContext.getRuleFinders();
RuleLoader ruleLoader = null;
try {
for(Iterator i = ruleFinders.iterator();
i.hasNext() && ruleLoader == null; ) {
RuleFinder finder = (RuleFinder) i.next();
if (debug) {
log.debug("checking finder of type " + finder.getClass().getName());
}
ruleLoader = finder.findLoader(digester, pluginClass, props);
}
}
catch(PluginException e) {
throw new PluginException(
"Unable to locate plugin rules for plugin"
+ " with id [" + id + "]"
+ ", and class [" + pluginClass.getName() + "]"
+ ":" + e.getMessage(), e.getCause());
}
log.debug("scanned ruleFinders.");
return ruleLoader;
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/RulesFactory.java 0000644 0001750 0001750 00000004134 11226450007 033251 0 ustar twerner twerner /* $Id: RulesFactory.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.Rules;
/**
* Whenever the scope of a plugin tag is entered, the PluginRules class
* creates a new Rules instance and configures it with the appropriate
* parsing rules for the plugged-in class.
*
* Users of the plugins module can specify a subclass of this one to
* control the creation of that Rules object. In particular, it can
* set up default rules within the returned instance which are applicable
* to all plugged-in classes.
*
* @since 1.6
*/
public abstract class RulesFactory {
/**
* Return an instance of some Rules implementation that the plugged-in
* class shall use to match its private parsing rules.
*
* @param d is the digester that the returned rules object will be
* associated with.
*
* @param pluginClass is the class that is to be configured using rules
* added to the returnedobject.
*
* @throws PluginException if the algorithm finds a source
* of rules, but there is something invalid about that source.
*/
public abstract Rules newRules(Digester d, Class pluginClass)
throws PluginException;
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/NodeCreateRule.java 0000644 0001750 0001750 00000042045 11226450007 032012 0 ustar twerner twerner /* $Id: NodeCreateRule.java 730333 2008-12-31 07:20:47Z rahul $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Attr;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
/**
* A rule implementation that creates a DOM
* {@link org.w3c.dom.Node Node} containing the XML at the element that matched
* the rule. Two concrete types of nodes can be created by this rule:
* The created Important Note: This is implemented by replacing the SAX
* {@link org.xml.sax.ContentHandler ContentHandler} in the parser used by
* Digester, and resetting it when the matched element is closed. As a side
* effect, rules that would match XML nodes under the element that matches
* a Note that the current implementation does not set the namespace prefixes
* in the exported nodes. The (usually more important) namespace URIs are set,
* of course. Stores the content handler currently used by Digester so it can
* be reset when done, and initializes the DOM objects needed to
* build the node.
* An xml parser calls this when text is found. We need to ensure that this
* text gets attached to the new Node we are creating - except in the case
* where the only text in the node is whitespace.
*
* There is a catch, however. According to the sax specification, a parser
* does not need to pass all of the text content of a node in one go; it can
* make multiple calls passing part of the data on each call. In particular,
* when the body of an element includes xml entity-references, at least some
* parsers make a separate call to this method to pass just the entity content.
*
* In this method, we therefore just append the provided text to a
* "current text" buffer. When the element end is found, or a child element
* is found then we can check whether we have all-whitespace. See method
* addTextIfPresent.
*
* @param ch the characters from the XML document
* @param start the start position in the array
* @param length the number of characters to read from the array
* @throws SAXException if the DOM implementation throws an exception
*/
public void characters(char[] ch, int start, int length)
throws SAXException {
topText.append(ch, start, length);
}
/**
* Checks whether control needs to be returned to Digester.
*
* @param namespaceURI the namespace URI
* @param localName the local name
* @param qName the qualified (prefixed) name
* @throws SAXException if the DOM implementation throws an exception
*/
public void endElement(String namespaceURI, String localName,
String qName)
throws SAXException {
addTextIfPresent();
try {
if (depth == 0) {
getDigester().setCustomContentHandler(oldContentHandler);
getDigester().push(root);
getDigester().endElement(namespaceURI, localName, qName);
}
top = top.getParentNode();
depth--;
} catch (DOMException e) {
throw new SAXException(e.getMessage());
}
}
/**
* Adds a new
* {@link org.w3c.dom.ProcessingInstruction ProcessingInstruction} to
* the current node.
*
* @param target the processing instruction target
* @param data the processing instruction data, or null if none was
* supplied
* @throws SAXException if the DOM implementation throws an exception
*/
public void processingInstruction(String target, String data)
throws SAXException {
try {
top.appendChild(doc.createProcessingInstruction(target, data));
} catch (DOMException e) {
throw new SAXException(e.getMessage());
}
}
/**
* Adds a new child {@link org.w3c.dom.Element Element} to the current
* node.
*
* @param namespaceURI the namespace URI
* @param localName the local name
* @param qName the qualified (prefixed) name
* @param atts the list of attributes
* @throws SAXException if the DOM implementation throws an exception
*/
public void startElement(String namespaceURI, String localName,
String qName, Attributes atts)
throws SAXException {
addTextIfPresent();
try {
Node previousTop = top;
if ((localName == null) || (localName.length() == 0)) {
top = doc.createElement(qName);
} else {
top = doc.createElementNS(namespaceURI, localName);
}
for (int i = 0; i < atts.getLength(); i++) {
Attr attr = null;
if ((atts.getLocalName(i) == null) ||
(atts.getLocalName(i).length() == 0)) {
attr = doc.createAttribute(atts.getQName(i));
attr.setNodeValue(atts.getValue(i));
((Element)top).setAttributeNode(attr);
} else {
attr = doc.createAttributeNS(atts.getURI(i),
atts.getLocalName(i));
attr.setNodeValue(atts.getValue(i));
((Element)top).setAttributeNodeNS(attr);
}
}
previousTop.appendChild(top);
depth++;
} catch (DOMException e) {
throw new SAXException(e.getMessage());
}
}
}
// ----------------------------------------------------------- Constructors
/**
* Default constructor. Creates an instance of this rule that will create a
* DOM {@link org.w3c.dom.Element Element}.
*/
public NodeCreateRule() throws ParserConfigurationException {
this(Node.ELEMENT_NODE);
}
/**
* Constructor. Creates an instance of this rule that will create a DOM
* {@link org.w3c.dom.Element Element}, but lets you specify the JAXP
* Abstract base class for Factory method called by {@link FactoryCreateRule} to supply an
* object based on the element's attributes.
*
* @param attributes the element's attributes
*
* @throws Exception any exception thrown will be propagated upwards
*/
public abstract Object createObject(Attributes attributes) throws Exception;
/**
* Returns the {@link Digester} that was set by the
* {@link FactoryCreateRule} upon initialization.
*/
public Digester getDigester() {
return (this.digester);
}
/**
* Set the {@link Digester} to allow the implementation to do logging,
* classloading based on the digester's classloader, etc.
*
* @param digester parent Digester object
*/
public void setDigester(Digester digester) {
this.digester = digester;
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/FactoryCreateRule.java 0000644 0001750 0001750 00000042537 11226450007 032542 0 ustar twerner twerner /* $Id: FactoryCreateRule.java 728882 2008-12-23 06:27:54Z rahul $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import org.xml.sax.Attributes;
import org.apache.commons.collections.ArrayStack;
/**
* Rule implementation that uses an {@link ObjectCreationFactory} to create
* a new object which it pushes onto the object stack. When the element is
* complete, the object will be popped. This rule is intended in situations where the element's attributes are
* needed before the object can be created. A common senario is for the
* ObjectCreationFactory implementation to use the attributes as parameters
* in a call to either a factory method or to a non-empty constructor.
*/
public class FactoryCreateRule extends Rule {
// ----------------------------------------------------------- Fields
/** Should exceptions thrown by the factory be ignored? */
private boolean ignoreCreateExceptions;
/** Stock to manage */
private ArrayStack exceptionIgnoredStack;
// ----------------------------------------------------------- Constructors
/**
* Construct a factory create rule that will use the specified
* class name to create an {@link ObjectCreationFactory} which will
* then be used to create an object and push it on the stack.
*
* @param digester The associated Digester
* @param className Java class name of the object creation factory class
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #FactoryCreateRule(String className)} instead.
*/
public FactoryCreateRule(Digester digester, String className) {
this(className);
}
/**
* Construct a factory create rule that will use the specified
* class to create an {@link ObjectCreationFactory} which will
* then be used to create an object and push it on the stack.
*
* @param digester The associated Digester
* @param clazz Java class name of the object creation factory class
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #FactoryCreateRule(Class clazz)} instead.
*/
public FactoryCreateRule(Digester digester, Class clazz) {
this(clazz);
}
/**
* Construct a factory create rule that will use the specified
* class name (possibly overridden by the specified attribute if present)
* to create an {@link ObjectCreationFactory}, which will then be used
* to instantiate an object instance and push it onto the stack.
*
* @param digester The associated Digester
* @param className Default Java class name of the factory class
* @param attributeName Attribute name which, if present, contains an
* override of the class name of the object creation factory to create.
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #FactoryCreateRule(String className, String attributeName)} instead.
*/
public FactoryCreateRule(Digester digester,
String className, String attributeName) {
this(className, attributeName);
}
/**
* Construct a factory create rule that will use the specified
* class (possibly overridden by the specified attribute if present)
* to create an {@link ObjectCreationFactory}, which will then be used
* to instantiate an object instance and push it onto the stack.
*
* @param digester The associated Digester
* @param clazz Default Java class name of the factory class
* @param attributeName Attribute name which, if present, contains an
* override of the class name of the object creation factory to create.
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #FactoryCreateRule(Class clazz, String attributeName)} instead.
*/
public FactoryCreateRule(Digester digester,
Class clazz, String attributeName) {
this(clazz, attributeName);
}
/**
* Construct a factory create rule using the given, already instantiated,
* {@link ObjectCreationFactory}.
*
* @param digester The associated Digester
* @param creationFactory called on to create the object.
*
* @deprecated The digester instance is now set in the {@link Digester#addRule} method.
* Use {@link #FactoryCreateRule(ObjectCreationFactory creationFactory)} instead.
*/
public FactoryCreateRule(Digester digester,
ObjectCreationFactory creationFactory) {
this(creationFactory);
}
/**
* Construct a factory create rule that will use the specified
* class name to create an {@link ObjectCreationFactory} which will
* then be used to create an object and push it on the stack. Exceptions thrown during the object creation process will be propagated. Construct a factory create rule that will use the specified
* class to create an {@link ObjectCreationFactory} which will
* then be used to create an object and push it on the stack. Exceptions thrown during the object creation process will be propagated. Construct a factory create rule that will use the specified
* class name (possibly overridden by the specified attribute if present)
* to create an {@link ObjectCreationFactory}, which will then be used
* to instantiate an object instance and push it onto the stack. Exceptions thrown during the object creation process will be propagated. Construct a factory create rule that will use the specified
* class (possibly overridden by the specified attribute if present)
* to create an {@link ObjectCreationFactory}, which will then be used
* to instantiate an object instance and push it onto the stack. Exceptions thrown during the object creation process will be propagated. Construct a factory create rule using the given, already instantiated,
* {@link ObjectCreationFactory}. Exceptions thrown during the object creation process will be propagated. Rule implementation that saves a parameter for use by a surrounding
* This parameter may be:
* super.addRuleInstances(digester);
*/
public void addRuleInstances(Digester digester) {
final String ruleClassName = Rule.class.getName();
digester.register(DIGESTER_PUBLIC_ID, getDigesterRulesDTD());
digester.addRule("*/pattern", new PatternRule("value"));
digester.addRule("*/include", new IncludeRule());
digester.addFactoryCreate("*/bean-property-setter-rule", new BeanPropertySetterRuleFactory());
digester.addRule("*/bean-property-setter-rule", new PatternRule("pattern"));
digester.addSetNext("*/bean-property-setter-rule", "add", ruleClassName);
digester.addFactoryCreate("*/call-method-rule", new CallMethodRuleFactory());
digester.addRule("*/call-method-rule", new PatternRule("pattern"));
digester.addSetNext("*/call-method-rule", "add", ruleClassName);
digester.addFactoryCreate("*/object-param-rule", new ObjectParamRuleFactory());
digester.addRule("*/object-param-rule", new PatternRule("pattern"));
digester.addSetNext("*/object-param-rule", "add", ruleClassName);
digester.addFactoryCreate("*/call-param-rule", new CallParamRuleFactory());
digester.addRule("*/call-param-rule", new PatternRule("pattern"));
digester.addSetNext("*/call-param-rule", "add", ruleClassName);
digester.addFactoryCreate("*/factory-create-rule", new FactoryCreateRuleFactory());
digester.addRule("*/factory-create-rule", new PatternRule("pattern"));
digester.addSetNext("*/factory-create-rule", "add", ruleClassName);
digester.addFactoryCreate("*/object-create-rule", new ObjectCreateRuleFactory());
digester.addRule("*/object-create-rule", new PatternRule("pattern"));
digester.addSetNext("*/object-create-rule", "add", ruleClassName);
digester.addFactoryCreate("*/node-create-rule", new NodeCreateRuleFactory());
digester.addRule("*/node-create-rule", new PatternRule("pattern"));
digester.addSetNext("*/node-create-rule", "add", ruleClassName);
digester.addFactoryCreate("*/set-properties-rule", new SetPropertiesRuleFactory());
digester.addRule("*/set-properties-rule", new PatternRule("pattern"));
digester.addSetNext("*/set-properties-rule", "add", ruleClassName);
digester.addRule("*/set-properties-rule/alias", new SetPropertiesAliasRule());
digester.addFactoryCreate("*/set-property-rule", new SetPropertyRuleFactory());
digester.addRule("*/set-property-rule", new PatternRule("pattern"));
digester.addSetNext("*/set-property-rule", "add", ruleClassName);
digester.addFactoryCreate("*/set-nested-properties-rule", new SetNestedPropertiesRuleFactory());
digester.addRule("*/set-nested-properties-rule", new PatternRule("pattern"));
digester.addSetNext("*/set-nested-properties-rule", "add", ruleClassName);
digester.addRule("*/set-nested-properties-rule/alias", new SetNestedPropertiesAliasRule());
digester.addFactoryCreate("*/set-top-rule", new SetTopRuleFactory());
digester.addRule("*/set-top-rule", new PatternRule("pattern"));
digester.addSetNext("*/set-top-rule", "add", ruleClassName);
digester.addFactoryCreate("*/set-next-rule", new SetNextRuleFactory());
digester.addRule("*/set-next-rule", new PatternRule("pattern"));
digester.addSetNext("*/set-next-rule", "add", ruleClassName);
digester.addFactoryCreate("*/set-root-rule", new SetRootRuleFactory());
digester.addRule("*/set-root-rule", new PatternRule("pattern"));
digester.addSetNext("*/set-root-rule", "add", ruleClassName);
}
/**
* A rule for extracting the pattern matching strings from the rules XML.
* In the digester-rules document type, a pattern can either be declared
* in the 'value' attribute of a Digester matching path for use by a surrounding
* CallMethodRule. This Rule is most useful when making
* extensive use of wildcards in rule patterns.XmlMapper class that was part of Tomcat 3.0 and 3.1,
* but is organized somewhat differently.parse() must be completed before another can be initiated
* even from the same thread.useContextClassLoader variable.
*/
protected ClassLoader classLoader = null;
/**
* Has this Digester been configured yet.
*/
protected boolean configured = false;
/**
* The EntityResolver used by the SAX parser. By default it use this class
*/
protected EntityResolver entityResolver;
/**
* The URLs of entityValidator that have been registered, keyed by the public
* identifier that corresponds.
*/
protected HashMap entityValidator = new HashMap();
/**
* The application-supplied error handler that is notified when parsing
* warnings, errors, or fatal errors occur.
*/
protected ErrorHandler errorHandler = null;
/**
* The SAXParserFactory that is created the first time we need it.
*/
protected SAXParserFactory factory = null;
/**
* @deprecated This is now managed by {@link ParserFeatureSetterFactory}
*/
protected String JAXP_SCHEMA_LANGUAGE =
"http://java.sun.com/xml/jaxp/properties/schemaLanguage";
/**
* The Locator associated with our parser.
*/
protected Locator locator = null;
/**
* The current match pattern for nested element processing.
*/
protected String match = "";
/**
* Do we want a "namespace aware" parser.
*/
protected boolean namespaceAware = false;
/**
* Registered namespaces we are currently processing. The key is the
* namespace prefix that was declared in the document. The value is an
* ArrayStack of the namespace URIs this prefix has been mapped to --
* the top Stack element is the most current one. (This architecture
* is required because documents can declare nested uses of the same
* prefix for different Namespace URIs).
*/
protected HashMap namespaces = new HashMap();
/**
* The parameters stack being utilized by CallMethodRule and
* CallParamRule rules.
*/
protected ArrayStack params = new ArrayStack();
/**
* The SAXParser we will use to parse the input stream.
*/
protected SAXParser parser = null;
/**
* The public identifier of the DTD we are currently parsing under
* (if any).
*/
protected String publicId = null;
/**
* The XMLReader used to parse digester rules.
*/
protected XMLReader reader = null;
/**
* The "root" element of the stack (in other words, the last object
* that was popped.
*/
protected Object root = null;
/**
* The Rules implementation containing our collection of
* Rule instances and associated matching policy. If not
* established before the first rule is added, a default implementation
* will be provided.
*/
protected Rules rules = null;
/**
* The XML schema language to use for validating an XML instance. By
* default this value is set to W3C_XML_SCHEMA
*/
protected String schemaLanguage = W3C_XML_SCHEMA;
/**
* The XML schema to use for validating an XML instance.
*/
protected String schemaLocation = null;
/**
* The object stack being constructed.
*/
protected ArrayStack stack = new ArrayStack();
/**
* Do we want to use the Context ClassLoader when loading classes
* for instantiating new objects. Default is false.
*/
protected boolean useContextClassLoader = false;
/**
* Do we want to use a validating parser.
*/
protected boolean validating = false;
/**
* The Log to which most logging calls will be made.
*/
protected Log log =
LogFactory.getLog("org.apache.commons.digester.Digester");
/**
* The Log to which all SAX event related logging calls will be made.
*/
protected Log saxLog =
LogFactory.getLog("org.apache.commons.digester.Digester.sax");
/**
* The schema language supported. By default, we use this one.
*/
protected static final String W3C_XML_SCHEMA =
"http://www.w3.org/2001/XMLSchema";
/**
* An optional class that substitutes values in attributes and body text.
* This may be null and so a null check is always required before use.
*/
protected Substitutor substitutor;
/** Stacks used for interrule communication, indexed by name String */
private HashMap stacksByName = new HashMap();
/**
* If not null, then calls by the parser to this object's characters,
* startElement, endElement and processingInstruction methods are
* forwarded to the specified object. This is intended to allow rules
* to temporarily "take control" of the sax events. In particular,
* this is used by NodeCreateRule.
* null. These mappings come and
* go dynamically as the document is parsed.
*
* @param prefix Prefix to look up
*/
public String findNamespaceURI(String prefix) {
ArrayStack nsStack = (ArrayStack) namespaces.get(prefix);
if (nsStack == null) {
return null;
}
try {
return ((String) nsStack.peek());
} catch (EmptyStackException e) {
return null;
}
}
/**
* Return the class loader to be used for instantiating application objects
* when required. This is determined based upon the following rules:
*
*
*/
public ClassLoader getClassLoader() {
if (this.classLoader != null) {
return (this.classLoader);
}
if (this.useContextClassLoader) {
ClassLoader classLoader =
Thread.currentThread().getContextClassLoader();
if (classLoader != null) {
return (classLoader);
}
}
return (this.getClass().getClassLoader());
}
/**
* Set the class loader to be used for instantiating application objects
* when required.
*
* @param classLoader The new class loader to use, or setClassLoader(), if anyuseContextClassLoader property is set to truenull
* to revert to the standard rules
*/
public void setClassLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
}
/**
* Return the current depth of the element stack.
*/
public int getCount() {
return (stack.size());
}
/**
* Return the name of the XML element that is currently being processed.
*/
public String getCurrentElementName() {
String elementName = match;
int lastSlash = elementName.lastIndexOf('/');
if (lastSlash >= 0) {
elementName = elementName.substring(lastSlash + 1);
}
return (elementName);
}
/**
* Return the debugging detail level of our currently enabled logger.
*
* @deprecated This method now always returns 0. Digester uses the apache
* jakarta commons-logging library; see the documentation for that library
* for more information.
*/
public int getDebug() {
return (0);
}
/**
* Set the debugging detail level of our currently enabled logger.
*
* @param debug New debugging detail level (0=off, increasing integers
* for more detail)
*
* @deprecated This method now has no effect at all. Digester uses
* the apache jakarta comons-logging library; see the documentation
* for that library for more information.
*/
public void setDebug(int debug) {
; // No action is taken
}
/**
* Return the error handler for this Digester.
*/
public ErrorHandler getErrorHandler() {
return (this.errorHandler);
}
/**
* Set the error handler for this Digester.
*
* @param errorHandler The new error handler
*/
public void setErrorHandler(ErrorHandler errorHandler) {
this.errorHandler = errorHandler;
}
/**
* Return the SAXParserFactory we will use, creating one if necessary.
*/
public SAXParserFactory getFactory() {
if (factory == null) {
factory = SAXParserFactory.newInstance();
factory.setNamespaceAware(namespaceAware);
factory.setValidating(validating);
}
return (factory);
}
/**
* Returns a flag indicating whether the requested feature is supported
* by the underlying implementation of org.xml.sax.XMLReader.
* See the saxproject website
* for information about the standard SAX2 feature flags.
*
* @param feature Name of the feature to inquire about
*
* @exception ParserConfigurationException if a parser configuration error
* occurs
* @exception SAXNotRecognizedException if the property name is
* not recognized
* @exception SAXNotSupportedException if the property name is
* recognized but not supported
*/
public boolean getFeature(String feature)
throws ParserConfigurationException, SAXNotRecognizedException,
SAXNotSupportedException {
return (getFactory().getFeature(feature));
}
/**
* Sets a flag indicating whether the requested feature is supported
* by the underlying implementation of org.xml.sax.XMLReader.
* See the saxproject website
* for information about the standard SAX2 feature flags. In order to be
* effective, this method must be called before the
* getParser() method is called for the first time, either
* directly or indirectly.
*
* @param feature Name of the feature to set the status for
* @param value The new value for this feature
*
* @exception ParserConfigurationException if a parser configuration error
* occurs
* @exception SAXNotRecognizedException if the property name is
* not recognized
* @exception SAXNotSupportedException if the property name is
* recognized but not supported
*/
public void setFeature(String feature, boolean value)
throws ParserConfigurationException, SAXNotRecognizedException,
SAXNotSupportedException {
getFactory().setFeature(feature, value);
}
/**
* Return the current Logger associated with this instance of the Digester
*/
public Log getLogger() {
return log;
}
/**
* Set the current logger for this Digester.
*/
public void setLogger(Log log) {
this.log = log;
}
/**
* Gets the logger used for logging SAX-related information.
* Note the output is finely grained.
*
* @since 1.6
*/
public Log getSAXLogger() {
return saxLog;
}
/**
* Sets the logger used for logging SAX-related information.
* Note the output is finely grained.
* @param saxLog Log, not null
*
* @since 1.6
*/
public void setSAXLogger(Log saxLog) {
this.saxLog = saxLog;
}
/**
* Return the current rule match path
*/
public String getMatch() {
return match;
}
/**
* Return the "namespace aware" flag for parsers we create.
*/
public boolean getNamespaceAware() {
return (this.namespaceAware);
}
/**
* Set the "namespace aware" flag for parsers we create.
*
* @param namespaceAware The new "namespace aware" flag
*/
public void setNamespaceAware(boolean namespaceAware) {
this.namespaceAware = namespaceAware;
}
/**
* Set the publid id of the current file being parse.
* @param publicId the DTD/Schema public's id.
*/
public void setPublicId(String publicId){
this.publicId = publicId;
}
/**
* Return the public identifier of the DTD we are currently
* parsing under, if any.
*/
public String getPublicId() {
return (this.publicId);
}
/**
* Return the namespace URI that will be applied to all subsequently
* added Rule objects.
*/
public String getRuleNamespaceURI() {
return (getRules().getNamespaceURI());
}
/**
* Set the namespace URI that will be applied to all subsequently
* added Rule objects.
*
* @param ruleNamespaceURI Namespace URI that must match on all
* subsequently added rules, or null for matching
* regardless of the current namespace URI
*/
public void setRuleNamespaceURI(String ruleNamespaceURI) {
getRules().setNamespaceURI(ruleNamespaceURI);
}
/**
* Return the SAXParser we will use to parse the input stream. If there
* is a problem creating the parser, return null.
*/
public SAXParser getParser() {
// Return the parser we already created (if any)
if (parser != null) {
return (parser);
}
// Create a new parser
try {
if (validating && (schemaLocation != null)) {
// There is no portable way to specify the location of
// an xml schema to be applied to the input document, so
// we have to use parser-specific code for this. That code
// is hidden behind the ParserFeatureSetterFactory class.
Properties properties = new Properties();
properties.put("SAXParserFactory", getFactory());
if (schemaLocation != null) {
properties.put("schemaLocation", schemaLocation);
properties.put("schemaLanguage", schemaLanguage);
}
parser = ParserFeatureSetterFactory.newSAXParser(properties);
} else {
// The user doesn't want to use any non-portable parsing features,
// so we can just use the portable API here. Note that method
// getFactory returns a factory already configured with the
// appropriate namespaceAware and validating properties.
parser = getFactory().newSAXParser();
}
} catch (Exception e) {
log.error("Digester.getParser: ", e);
return (null);
}
return (parser);
}
/**
* Return the current value of the specified property for the underlying
* XMLReader implementation.
* See the saxproject website
* for information about the standard SAX2 properties.
*
* @param property Property name to be retrieved
*
* @exception SAXNotRecognizedException if the property name is
* not recognized
* @exception SAXNotSupportedException if the property name is
* recognized but not supported
*/
public Object getProperty(String property)
throws SAXNotRecognizedException, SAXNotSupportedException {
return (getParser().getProperty(property));
}
/**
* Set the current value of the specified property for the underlying
* XMLReader implementation.
* See the saxproject website
* for information about the standard SAX2 properties.
*
* @param property Property name to be set
* @param value Property value to be set
*
* @exception SAXNotRecognizedException if the property name is
* not recognized
* @exception SAXNotSupportedException if the property name is
* recognized but not supported
*/
public void setProperty(String property, Object value)
throws SAXNotRecognizedException, SAXNotSupportedException {
getParser().setProperty(property, value);
}
/**
* By setting the reader in the constructor, you can bypass JAXP and
* be able to use digester in Weblogic 6.0.
*
* @deprecated Use getXMLReader() instead, which can throw a
* SAXException if the reader cannot be instantiated
*/
public XMLReader getReader() {
try {
return (getXMLReader());
} catch (SAXException e) {
log.error("Cannot get XMLReader", e);
return (null);
}
}
/**
* Return the Rules implementation object containing our
* rules collection and associated matching policy. If none has been
* established, a default implementation will be created and returned.
*/
public Rules getRules() {
if (this.rules == null) {
this.rules = new RulesBase();
this.rules.setDigester(this);
}
return (this.rules);
}
/**
* Set the Rules implementation object containing our
* rules collection and associated matching policy.
*
* @param rules New Rules implementation
*/
public void setRules(Rules rules) {
this.rules = rules;
this.rules.setDigester(this);
}
/**
* Return the XML Schema URI used for validating an XML instance.
*/
public String getSchema() {
return (this.schemaLocation);
}
/**
* Set the XML Schema URI used for validating the input XML.
* Thread.currentThread().getContextClassLoader())
* to resolve/load classes that are defined in various rules. If not
* using Context ClassLoader, then the class-loading defaults to
* using the calling-class' ClassLoader.
*
* @param use determines whether to use Context ClassLoader.
*/
public void setUseContextClassLoader(boolean use) {
useContextClassLoader = use;
}
/**
* Return the validating parser flag.
*/
public boolean getValidating() {
return (this.validating);
}
/**
* Set the validating parser flag. This must be called before
* parse() is called the first time.
*
* @param validating The new validating parser flag.
*/
public void setValidating(boolean validating) {
this.validating = validating;
}
/**
* Return the XMLReader to be used for parsing the input document.
*
* FIX ME: there is a bug in JAXP/XERCES that prevent the use of a
* parser that contains a schema with a DTD.
* @exception SAXException if no XMLReader can be instantiated
*/
public XMLReader getXMLReader() throws SAXException {
if (reader == null){
reader = getParser().getXMLReader();
}
reader.setDTDHandler(this);
reader.setContentHandler(this);
if (entityResolver == null){
reader.setEntityResolver(this);
} else {
reader.setEntityResolver(entityResolver);
}
reader.setErrorHandler(this);
return reader;
}
/**
* Gets the Substitutor used to convert attributes and body text.
* @return Substitutor, null if not substitutions are to be performed.
*/
public Substitutor getSubstitutor() {
return substitutor;
}
/**
* Sets the Substitutor to be used to convert attributes and body text.
* @param substitutor the Substitutor to be used to convert attributes and body text
* or null if not substitution of these values is to be performed.
*/
public void setSubstitutor(Substitutor substitutor) {
this.substitutor = substitutor;
}
/*
* See setCustomContentHandler.
*
* @since 1.7
*/
public ContentHandler getCustomContentHandler() {
return customContentHandler;
}
/**
* Redirects (or cancels redirecting) of SAX ContentHandler events to an
* external object.
*
* digester.getXMLReader().setContentHandler(handler)
*
* for these reasons:
*
*
*
* @since 1.7
*/
public void setCustomContentHandler(ContentHandler handler) {
customContentHandler = handler;
}
/**
* Define a callback object which is invoked whever an object is pushed onto
* a digester object stack, or popped off one.
*
* @since 1.8
*/
public void setStackAction(StackAction stackAction) {
this.stackAction = stackAction;
}
/**
* See setStackAction.
*
* @since 1.8
*/
public StackAction getStackAction() {
return stackAction;
}
/**
* Get the most current namespaces for all prefixes.
*
* @return Map A map with namespace prefixes as keys and most current
* namespace URIs for the corresponding prefixes as values
*
* @since 1.8
*/
public Map getCurrentNamespaces() {
if (!namespaceAware) {
log.warn("Digester is not namespace aware");
}
Map currentNamespaces = new HashMap();
Iterator nsIterator = namespaces.entrySet().iterator();
while (nsIterator.hasNext()) {
Map.Entry nsEntry = (Map.Entry) nsIterator.next();
try {
currentNamespaces.put(nsEntry.getKey(),
((ArrayStack) nsEntry.getValue()).peek());
} catch (RuntimeException e) {
// rethrow, after logging
log.error(e.getMessage(), e);
throw e;
}
}
return currentNamespaces;
}
// ------------------------------------------------- ContentHandler Methods
/**
* Process notification of character data received from the body of
* an XML element.
*
* @param buffer The characters from the XML document
* @param start Starting offset into the buffer
* @param length Number of characters from the buffer
*
* @exception SAXException if a parsing error is to be reported
*/
public void characters(char buffer[], int start, int length)
throws SAXException {
if (customContentHandler != null) {
// forward calls instead of handling them here
customContentHandler.characters(buffer, start, length);
return;
}
if (saxLog.isDebugEnabled()) {
saxLog.debug("characters(" + new String(buffer, start, length) + ")");
}
bodyText.append(buffer, start, length);
}
/**
* Process notification of the end of the document being reached.
*
* @exception SAXException if a parsing error is to be reported
*/
public void endDocument() throws SAXException {
if (saxLog.isDebugEnabled()) {
if (getCount() > 1) {
saxLog.debug("endDocument(): " + getCount() +
" elements left");
} else {
saxLog.debug("endDocument()");
}
}
// Fire "finish" events for all defined rules
Iterator rules = getRules().rules().iterator();
while (rules.hasNext()) {
Rule rule = (Rule) rules.next();
try {
rule.finish();
} catch (Exception e) {
log.error("Finish event threw exception", e);
throw createSAXException(e);
} catch (Error e) {
log.error("Finish event threw error", e);
throw e;
}
}
// Perform final cleanup
clear();
}
/**
* Process notification of the end of an XML element being reached.
*
* @param namespaceURI - The Namespace URI, or the empty string if the
* element has no Namespace URI or if Namespace processing is not
* being performed.
* @param localName - The local name (without prefix), or the empty
* string if Namespace processing is not being performed.
* @param qName - The qualified XML 1.0 name (with prefix), or the
* empty string if qualified names are not available.
* @exception SAXException if a parsing error is to be reported
*/
public void endElement(String namespaceURI, String localName,
String qName) throws SAXException {
if (customContentHandler != null) {
// forward calls instead of handling them here
customContentHandler.endElement(namespaceURI, localName, qName);
return;
}
boolean debug = log.isDebugEnabled();
if (debug) {
if (saxLog.isDebugEnabled()) {
saxLog.debug("endElement(" + namespaceURI + "," + localName +
"," + qName + ")");
}
log.debug(" match='" + match + "'");
log.debug(" bodyText='" + bodyText + "'");
}
// the actual element name is either in localName or qName, depending
// on whether the parser is namespace aware
String name = localName;
if ((name == null) || (name.length() < 1)) {
name = qName;
}
// Fire "body" events for all relevant rules
List rules = (List) matches.pop();
if ((rules != null) && (rules.size() > 0)) {
String bodyText = this.bodyText.toString();
Substitutor substitutor = getSubstitutor();
if (substitutor!= null) {
bodyText = substitutor.substitute(bodyText);
}
for (int i = 0; i < rules.size(); i++) {
try {
Rule rule = (Rule) rules.get(i);
if (debug) {
log.debug(" Fire body() for " + rule);
}
rule.body(namespaceURI, name, bodyText);
} catch (Exception e) {
log.error("Body event threw exception", e);
throw createSAXException(e);
} catch (Error e) {
log.error("Body event threw error", e);
throw e;
}
}
} else {
if (debug) {
log.debug(" No rules found matching '" + match + "'.");
}
}
// Recover the body text from the surrounding element
bodyText = (StringBuffer) bodyTexts.pop();
if (debug) {
log.debug(" Popping body text '" + bodyText.toString() + "'");
}
// Fire "end" events for all relevant rules in reverse order
if (rules != null) {
for (int i = 0; i < rules.size(); i++) {
int j = (rules.size() - i) - 1;
try {
Rule rule = (Rule) rules.get(j);
if (debug) {
log.debug(" Fire end() for " + rule);
}
rule.end(namespaceURI, name);
} catch (Exception e) {
log.error("End event threw exception", e);
throw createSAXException(e);
} catch (Error e) {
log.error("End event threw error", e);
throw e;
}
}
}
// Recover the previous match expression
int slash = match.lastIndexOf('/');
if (slash >= 0) {
match = match.substring(0, slash);
} else {
match = "";
}
}
/**
* Process notification that a namespace prefix is going out of scope.
*
* @param prefix Prefix that is going out of scope
*
* @exception SAXException if a parsing error is to be reported
*/
public void endPrefixMapping(String prefix) throws SAXException {
if (saxLog.isDebugEnabled()) {
saxLog.debug("endPrefixMapping(" + prefix + ")");
}
// Deregister this prefix mapping
ArrayStack stack = (ArrayStack) namespaces.get(prefix);
if (stack == null) {
return;
}
try {
stack.pop();
if (stack.empty())
namespaces.remove(prefix);
} catch (EmptyStackException e) {
throw createSAXException("endPrefixMapping popped too many times");
}
}
/**
* Process notification of ignorable whitespace received from the body of
* an XML element.
*
* @param buffer The characters from the XML document
* @param start Starting offset into the buffer
* @param len Number of characters from the buffer
*
* @exception SAXException if a parsing error is to be reported
*/
public void ignorableWhitespace(char buffer[], int start, int len)
throws SAXException {
if (saxLog.isDebugEnabled()) {
saxLog.debug("ignorableWhitespace(" +
new String(buffer, start, len) + ")");
}
; // No processing required
}
/**
* Process notification of a processing instruction that was encountered.
*
* @param target The processing instruction target
* @param data The processing instruction data (if any)
*
* @exception SAXException if a parsing error is to be reported
*/
public void processingInstruction(String target, String data)
throws SAXException {
if (customContentHandler != null) {
// forward calls instead of handling them here
customContentHandler.processingInstruction(target, data);
return;
}
if (saxLog.isDebugEnabled()) {
saxLog.debug("processingInstruction('" + target + "','" + data + "')");
}
; // No processing is required
}
/**
* Gets the document locator associated with our parser.
*
* @return the Locator supplied by the document parser
*/
public Locator getDocumentLocator() {
return locator;
}
/**
* Sets the document locator associated with our parser.
*
* @param locator The new locator
*/
public void setDocumentLocator(Locator locator) {
if (saxLog.isDebugEnabled()) {
saxLog.debug("setDocumentLocator(" + locator + ")");
}
this.locator = locator;
}
/**
* Process notification of a skipped entity.
*
* @param name Name of the skipped entity
*
* @exception SAXException if a parsing error is to be reported
*/
public void skippedEntity(String name) throws SAXException {
if (saxLog.isDebugEnabled()) {
saxLog.debug("skippedEntity(" + name + ")");
}
; // No processing required
}
/**
* Process notification of the beginning of the document being reached.
*
* @exception SAXException if a parsing error is to be reported
*/
public void startDocument() throws SAXException {
if (saxLog.isDebugEnabled()) {
saxLog.debug("startDocument()");
}
// ensure that the digester is properly configured, as
// the digester could be used as a SAX ContentHandler
// rather than via the parse() methods.
configure();
}
/**
* Process notification of the start of an XML element being reached.
*
* @param namespaceURI The Namespace URI, or the empty string if the element
* has no Namespace URI or if Namespace processing is not being performed.
* @param localName The local name (without prefix), or the empty
* string if Namespace processing is not being performed.
* @param qName The qualified name (with prefix), or the empty
* string if qualified names are not available.\
* @param list The attributes attached to the element. If there are
* no attributes, it shall be an empty Attributes object.
* @exception SAXException if a parsing error is to be reported
*/
public void startElement(String namespaceURI, String localName,
String qName, Attributes list)
throws SAXException {
boolean debug = log.isDebugEnabled();
if (customContentHandler != null) {
// forward calls instead of handling them here
customContentHandler.startElement(namespaceURI, localName, qName, list);
return;
}
if (saxLog.isDebugEnabled()) {
saxLog.debug("startElement(" + namespaceURI + "," + localName + "," +
qName + ")");
}
// Save the body text accumulated for our surrounding element
bodyTexts.push(bodyText);
if (debug) {
log.debug(" Pushing body text '" + bodyText.toString() + "'");
}
bodyText = new StringBuffer();
// the actual element name is either in localName or qName, depending
// on whether the parser is namespace aware
String name = localName;
if ((name == null) || (name.length() < 1)) {
name = qName;
}
// Compute the current matching rule
StringBuffer sb = new StringBuffer(match);
if (match.length() > 0) {
sb.append('/');
}
sb.append(name);
match = sb.toString();
if (debug) {
log.debug(" New match='" + match + "'");
}
// Fire "begin" events for all relevant rules
List rules = getRules().match(namespaceURI, match);
matches.push(rules);
if ((rules != null) && (rules.size() > 0)) {
Substitutor substitutor = getSubstitutor();
if (substitutor!= null) {
list = substitutor.substitute(list);
}
for (int i = 0; i < rules.size(); i++) {
try {
Rule rule = (Rule) rules.get(i);
if (debug) {
log.debug(" Fire begin() for " + rule);
}
rule.begin(namespaceURI, name, list);
} catch (Exception e) {
log.error("Begin event threw exception", e);
throw createSAXException(e);
} catch (Error e) {
log.error("Begin event threw error", e);
throw e;
}
}
} else {
if (debug) {
log.debug(" No rules found matching '" + match + "'.");
}
}
}
/**
* Process notification that a namespace prefix is coming in to scope.
*
* @param prefix Prefix that is being declared
* @param namespaceURI Corresponding namespace URI being mapped to
*
* @exception SAXException if a parsing error is to be reported
*/
public void startPrefixMapping(String prefix, String namespaceURI)
throws SAXException {
if (saxLog.isDebugEnabled()) {
saxLog.debug("startPrefixMapping(" + prefix + "," + namespaceURI + ")");
}
// Register this prefix mapping
ArrayStack stack = (ArrayStack) namespaces.get(prefix);
if (stack == null) {
stack = new ArrayStack();
namespaces.put(prefix, stack);
}
stack.push(namespaceURI);
}
// ----------------------------------------------------- DTDHandler Methods
/**
* Receive notification of a notation declaration event.
*
* @param name The notation name
* @param publicId The public identifier (if any)
* @param systemId The system identifier (if any)
*/
public void notationDecl(String name, String publicId, String systemId) {
if (saxLog.isDebugEnabled()) {
saxLog.debug("notationDecl(" + name + "," + publicId + "," +
systemId + ")");
}
}
/**
* Receive notification of an unparsed entity declaration event.
*
* @param name The unparsed entity name
* @param publicId The public identifier (if any)
* @param systemId The system identifier (if any)
* @param notation The name of the associated notation
*/
public void unparsedEntityDecl(String name, String publicId,
String systemId, String notation) {
if (saxLog.isDebugEnabled()) {
saxLog.debug("unparsedEntityDecl(" + name + "," + publicId + "," +
systemId + "," + notation + ")");
}
}
// ----------------------------------------------- EntityResolver Methods
/**
* Set the EntityResolver used by SAX when resolving
* public id and system id.
* This must be called before the first call to parse().
* @param entityResolver a class that implement the EntityResolver interface.
*/
public void setEntityResolver(EntityResolver entityResolver){
this.entityResolver = entityResolver;
}
/**
* Return the Entity Resolver used by the SAX parser.
* @return Return the Entity Resolver used by the SAX parser.
*/
public EntityResolver getEntityResolver(){
return entityResolver;
}
/**
* Resolve the requested external entity.
*
* @param publicId The public identifier of the entity being referenced
* @param systemId The system identifier of the entity being referenced
*
* @exception SAXException if a parsing exception occurs
*
*/
public InputSource resolveEntity(String publicId, String systemId)
throws SAXException {
if (saxLog.isDebugEnabled()) {
saxLog.debug("resolveEntity('" + publicId + "', '" + systemId + "')");
}
if (publicId != null)
this.publicId = publicId;
// Has this system identifier been registered?
URL entityURL = null;
if (publicId != null) {
entityURL = (URL) entityValidator.get(publicId);
}
// Redirect the schema location to a local destination
if (schemaLocation != null && entityURL == null && systemId != null){
entityURL = (URL) entityValidator.get(systemId);
}
if (entityURL == null) {
if (systemId == null) {
// cannot resolve
if (log.isDebugEnabled()) {
log.debug(" Cannot resolve null entity, returning null InputSource");
}
return (null);
} else {
// try to resolve using system ID
if (log.isDebugEnabled()) {
log.debug(" Trying to resolve using system ID '" + systemId + "'");
}
try {
entityURL = new URL(systemId);
} catch (MalformedURLException e) {
throw new IllegalArgumentException("Malformed URL '" + systemId
+ "' : " + e.getMessage());
}
}
}
// Return an input source to our alternative URL
if (log.isDebugEnabled()) {
log.debug(" Resolving to alternate DTD '" + entityURL + "'");
}
try {
return createInputSourceFromURL(entityURL);
} catch (Exception e) {
throw createSAXException(e);
}
}
// ------------------------------------------------- ErrorHandler Methods
/**
* Forward notification of a parsing error to the application supplied
* error handler (if any).
*
* @param exception The error information
*
* @exception SAXException if a parsing exception occurs
*/
public void error(SAXParseException exception) throws SAXException {
log.error("Parse Error at line " + exception.getLineNumber() +
" column " + exception.getColumnNumber() + ": " +
exception.getMessage(), exception);
if (errorHandler != null) {
errorHandler.error(exception);
}
}
/**
* Forward notification of a fatal parsing error to the application
* supplied error handler (if any).
*
* @param exception The fatal error information
*
* @exception SAXException if a parsing exception occurs
*/
public void fatalError(SAXParseException exception) throws SAXException {
log.error("Parse Fatal Error at line " + exception.getLineNumber() +
" column " + exception.getColumnNumber() + ": " +
exception.getMessage(), exception);
if (errorHandler != null) {
errorHandler.fatalError(exception);
}
}
/**
* Forward notification of a parse warning to the application supplied
* error handler (if any).
*
* @param exception The warning information
*
* @exception SAXException if a parsing exception occurs
*/
public void warning(SAXParseException exception) throws SAXException {
if (errorHandler != null) {
log.warn("Parse Warning Error at line " + exception.getLineNumber() +
" column " + exception.getColumnNumber() + ": " +
exception.getMessage(), exception);
errorHandler.warning(exception);
}
}
// ------------------------------------------------------- Public Methods
/**
* Log a message to our associated logger.
*
* @param message The message to be logged
* @deprecated Call getLogger() and use it's logging methods
*/
public void log(String message) {
log.info(message);
}
/**
* Log a message and exception to our associated logger.
*
* @param message The message to be logged
* @deprecated Call getLogger() and use it's logging methods
*/
public void log(String message, Throwable exception) {
log.error(message, exception);
}
/**
* Parse the content of the specified file using this Digester. Returns
* the root element from the object stack (if any).
*
* @param file File containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*/
public Object parse(File file) throws IOException, SAXException {
if (file == null) {
throw new IllegalArgumentException("File to parse is null");
}
configure();
InputSource input = new InputSource(new FileInputStream(file));
input.setSystemId(file.toURL().toString());
getXMLReader().parse(input);
cleanup();
return (root);
}
/**
* Parse the content of the specified input source using this Digester.
* Returns the root element from the object stack (if any).
*
* @param input Input source containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*/
public Object parse(InputSource input) throws IOException, SAXException {
if (input == null) {
throw new IllegalArgumentException("InputSource to parse is null");
}
configure();
getXMLReader().parse(input);
cleanup();
return (root);
}
/**
* Parse the content of the specified input stream using this Digester.
* Returns the root element from the object stack (if any).
*
* @param input Input stream containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*/
public Object parse(InputStream input) throws IOException, SAXException {
if (input == null) {
throw new IllegalArgumentException("InputStream to parse is null");
}
configure();
InputSource is = new InputSource(input);
getXMLReader().parse(is);
cleanup();
return (root);
}
/**
* Parse the content of the specified reader using this Digester.
* Returns the root element from the object stack (if any).
*
* @param reader Reader containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*/
public Object parse(Reader reader) throws IOException, SAXException {
if (reader == null) {
throw new IllegalArgumentException("Reader to parse is null");
}
configure();
InputSource is = new InputSource(reader);
getXMLReader().parse(is);
cleanup();
return (root);
}
/**
* Parse the content of the specified URI using this Digester.
* Returns the root element from the object stack (if any).
*
* @param uri URI containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*/
public Object parse(String uri) throws IOException, SAXException {
if (uri == null) {
throw new IllegalArgumentException("String URI to parse is null");
}
configure();
InputSource is = createInputSourceFromURL(uri);
getXMLReader().parse(is);
cleanup();
return (root);
}
/**
* Parse the content of the specified URL using this Digester.
* Returns the root element from the object stack (if any).
*
* @param url URL containing the XML data to be parsed
*
* @exception IOException if an input/output error occurs
* @exception SAXException if a parsing exception occurs
*
* @since 1.8
*/
public Object parse(URL url) throws IOException, SAXException {
if (url == null) {
throw new IllegalArgumentException("URL to parse is null");
}
configure();
InputSource is = createInputSourceFromURL(url);
getXMLReader().parse(is);
cleanup();
return (root);
}
/**
* parse().
* Digester contains an internal EntityResolver
* implementation. This maps PUBLICID's to URLs
* (from which the resource will be loaded). A common use case for this
* method is to register local URLs (possibly computed at runtime by a
* classloader) for DTDs. This allows the performance advantage of using
* a local version without having to ensure every SYSTEM
* URI on every processed xml document is local. This implementation provides
* only basic functionality. If more sophisticated features are required,
* using {@link #setEntityResolver} to set a custom resolver is recommended.
* EntityResolver has been set. (Setting a custom
* EntityResolver overrides the internal implementation.)
* List of InputSource instances
* created by a createInputSourceFromURL() method
* call. These represent open input streams that need to be
* closed to avoid resource leaks, as well as potentially locked
* JAR files on Windows.new InputSource(entityURL). Unfortunately it appears
* that when the entityURL points to a file within a jar archive a
* caching mechanism inside the InputSource implementation causes a
* file-handle to the jar file to remain open. On Windows systems
* this then causes the jar archive file to be locked on disk
* ("in use") which makes it impossible to delete the jar file -
* and that really stuffs up "undeploy" in webapps in particular.
*
* URL location = new URL(expandedSystemId);
* URLConnection connect = location.openConnection();
* if (connect instanceof HttpURLConnection) {
* setHttpProperties(connect,xmlInputSource);
* }
* stream = connect.getInputStream();
*
* This method pretty much duplicates the standard behaviour, except
* that it calls URLConnection.setUseCaches(false) before opening
* the connection.
*
* @since 1.8
*/
public InputSource createInputSourceFromURL(URL url)
throws MalformedURLException, IOException {
URLConnection connection = url.openConnection();
connection.setUseCaches(false);
InputStream stream = connection.getInputStream();
InputSource source = new InputSource(stream);
source.setSystemId(url.toExternalForm());
inputSources.add(source);
return source;
}
/**
* InputSource
* from the string version of a URL.InputSource
*
* @since 1.8
*/
public InputSource createInputSourceFromURL(String url)
throws MalformedURLException, IOException {
return createInputSourceFromURL(new URL(url));
}
// --------------------------------------------------------- Rule Methods
/**
* Digester property on the rule.paramCount is set to zero the rule will use
* the body of the matched element as the single argument of the
* method, unless paramTypes is null or empty, in this
* case the rule will call the specified method with no arguments.
*
* @param pattern Element matching pattern
* @param methodName Method name to be called
* @param paramCount Number of expected parameters (or zero
* for a single parameter from the body of this element)
* @param paramTypes Set of Java class names for the types
* of the expected parameters
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
* @see CallMethodRule
*/
public void addCallMethod(String pattern, String methodName,
int paramCount, String paramTypes[]) {
addRule(pattern,
new CallMethodRule(
methodName,
paramCount,
paramTypes));
}
/**
* Add an "call method" rule for the specified parameters.
* If paramCount is set to zero the rule will use
* the body of the matched element as the single argument of the
* method, unless paramTypes is null or empty, in this
* case the rule will call the specified method with no arguments.
*
* @param pattern Element matching pattern
* @param methodName Method name to be called
* @param paramCount Number of expected parameters (or zero
* for a single parameter from the body of this element)
* @param paramTypes The Java class names of the arguments
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
* @see CallMethodRule
*/
public void addCallMethod(String pattern, String methodName,
int paramCount, Class paramTypes[]) {
addRule(pattern,
new CallMethodRule(
methodName,
paramCount,
paramTypes));
}
/**
* Add a "call parameter" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param paramIndex Zero-relative parameter index to set
* (from the body of this element)
* @see CallParamRule
*/
public void addCallParam(String pattern, int paramIndex) {
addRule(pattern,
new CallParamRule(paramIndex));
}
/**
* Add a "call parameter" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param paramIndex Zero-relative parameter index to set
* (from the specified attribute)
* @param attributeName Attribute whose value is used as the
* parameter value
* @see CallParamRule
*/
public void addCallParam(String pattern, int paramIndex,
String attributeName) {
addRule(pattern,
new CallParamRule(paramIndex, attributeName));
}
/**
* Add a "call parameter" rule.
* This will either take a parameter from the stack
* or from the current element body text.
*
* @param paramIndex The zero-relative parameter number
* @param fromStack Should the call parameter be taken from the top of the stack?
* @see CallParamRule
*/
public void addCallParam(String pattern, int paramIndex, boolean fromStack) {
addRule(pattern,
new CallParamRule(paramIndex, fromStack));
}
/**
* Add a "call parameter" rule that sets a parameter from the stack.
* This takes a parameter from the given position on the stack.
*
* @param paramIndex The zero-relative parameter number
* @param stackIndex set the call parameter to the stackIndex'th object down the stack,
* where 0 is the top of the stack, 1 the next element down and so on
* @see CallMethodRule
*/
public void addCallParam(String pattern, int paramIndex, int stackIndex) {
addRule(pattern,
new CallParamRule(paramIndex, stackIndex));
}
/**
* Add a "call parameter" rule that sets a parameter from the current
* Digester matching path.
* This is sometimes useful when using rules that support wildcards.
*
* @param pattern the pattern that this rule should match
* @param paramIndex The zero-relative parameter number
* @see CallMethodRule
*/
public void addCallParamPath(String pattern,int paramIndex) {
addRule(pattern, new PathCallParamRule(paramIndex));
}
/**
* Add a "call parameter" rule that sets a parameter from a
* caller-provided object. This can be used to pass constants such as
* strings to methods; it can also be used to pass mutable objects,
* providing ways for objects to do things like "register" themselves
* with some shared object.
* className
* @see FactoryCreateRule
*/
public void addFactoryCreate(String pattern, String className,
String attributeName) {
addFactoryCreate(pattern, className, attributeName, false);
}
/**
* Add a "factory create" rule for the specified parameters.
* Exceptions thrown during the object creation process will be propagated.
*
* @param pattern Element matching pattern
* @param clazz Java class of the object creation factory class
* @param attributeName Attribute name which, if present, overrides the
* value specified by className
* @see FactoryCreateRule
*/
public void addFactoryCreate(String pattern, Class clazz,
String attributeName) {
addFactoryCreate(pattern, clazz, attributeName, false);
}
/**
* Add a "factory create" rule for the specified parameters.
* Exceptions thrown during the object creation process will be propagated.
*
* @param pattern Element matching pattern
* @param creationFactory Previously instantiated ObjectCreationFactory
* to be utilized
* @see FactoryCreateRule
*/
public void addFactoryCreate(String pattern,
ObjectCreationFactory creationFactory) {
addFactoryCreate(pattern, creationFactory, false);
}
/**
* Add a "factory create" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param className Java class name of the object creation factory class
* @param ignoreCreateExceptions when true any exceptions thrown during
* object creation will be ignored.
* @see FactoryCreateRule
*/
public void addFactoryCreate(
String pattern,
String className,
boolean ignoreCreateExceptions) {
addRule(
pattern,
new FactoryCreateRule(className, ignoreCreateExceptions));
}
/**
* Add a "factory create" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param clazz Java class of the object creation factory class
* @param ignoreCreateExceptions when true any exceptions thrown during
* object creation will be ignored.
* @see FactoryCreateRule
*/
public void addFactoryCreate(
String pattern,
Class clazz,
boolean ignoreCreateExceptions) {
addRule(
pattern,
new FactoryCreateRule(clazz, ignoreCreateExceptions));
}
/**
* Add a "factory create" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param className Java class name of the object creation factory class
* @param attributeName Attribute name which, if present, overrides the
* value specified by className
* @param ignoreCreateExceptions when true any exceptions thrown during
* object creation will be ignored.
* @see FactoryCreateRule
*/
public void addFactoryCreate(
String pattern,
String className,
String attributeName,
boolean ignoreCreateExceptions) {
addRule(
pattern,
new FactoryCreateRule(className, attributeName, ignoreCreateExceptions));
}
/**
* Add a "factory create" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param clazz Java class of the object creation factory class
* @param attributeName Attribute name which, if present, overrides the
* value specified by className
* @param ignoreCreateExceptions when true any exceptions thrown during
* object creation will be ignored.
* @see FactoryCreateRule
*/
public void addFactoryCreate(
String pattern,
Class clazz,
String attributeName,
boolean ignoreCreateExceptions) {
addRule(
pattern,
new FactoryCreateRule(clazz, attributeName, ignoreCreateExceptions));
}
/**
* Add a "factory create" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param creationFactory Previously instantiated ObjectCreationFactory
* to be utilized
* @param ignoreCreateExceptions when true any exceptions thrown during
* object creation will be ignored.
* @see FactoryCreateRule
*/
public void addFactoryCreate(String pattern,
ObjectCreationFactory creationFactory,
boolean ignoreCreateExceptions) {
creationFactory.setDigester(this);
addRule(pattern,
new FactoryCreateRule(creationFactory, ignoreCreateExceptions));
}
/**
* Add an "object create" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param className Java class name to be created
* @see ObjectCreateRule
*/
public void addObjectCreate(String pattern, String className) {
addRule(pattern,
new ObjectCreateRule(className));
}
/**
* Add an "object create" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param clazz Java class to be created
* @see ObjectCreateRule
*/
public void addObjectCreate(String pattern, Class clazz) {
addRule(pattern,
new ObjectCreateRule(clazz));
}
/**
* Add an "object create" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param className Default Java class name to be created
* @param attributeName Attribute name that optionally overrides
* the default Java class name to be created
* @see ObjectCreateRule
*/
public void addObjectCreate(String pattern, String className,
String attributeName) {
addRule(pattern,
new ObjectCreateRule(className, attributeName));
}
/**
* Add an "object create" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param attributeName Attribute name that optionally overrides
* @param clazz Default Java class to be created
* the default Java class name to be created
* @see ObjectCreateRule
*/
public void addObjectCreate(String pattern,
String attributeName,
Class clazz) {
addRule(pattern,
new ObjectCreateRule(attributeName, clazz));
}
/**
* Adds an {@link SetNestedPropertiesRule}.
*
* @param pattern register the rule with this pattern
*
* @since 1.6
*/
public void addSetNestedProperties(String pattern) {
addRule(pattern, new SetNestedPropertiesRule());
}
/**
* Adds an {@link SetNestedPropertiesRule}.
*
* @param pattern register the rule with this pattern
* @param elementName elment name that a property maps to
* @param propertyName property name of the element mapped from
*
* @since 1.6
*/
public void addSetNestedProperties(String pattern, String elementName, String propertyName) {
addRule(pattern, new SetNestedPropertiesRule(elementName, propertyName));
}
/**
* Adds an {@link SetNestedPropertiesRule}.
*
* @param pattern register the rule with this pattern
* @param elementNames elment names that (in order) map to properties
* @param propertyNames property names that (in order) elements are mapped to
*
* @since 1.6
*/
public void addSetNestedProperties(String pattern, String[] elementNames, String[] propertyNames) {
addRule(pattern, new SetNestedPropertiesRule(elementNames, propertyNames));
}
/**
* Add a "set next" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param methodName Method name to call on the parent element
* @see SetNextRule
*/
public void addSetNext(String pattern, String methodName) {
addRule(pattern,
new SetNextRule(methodName));
}
/**
* Add a "set next" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param methodName Method name to call on the parent element
* @param paramType Java class name of the expected parameter type
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
* @see SetNextRule
*/
public void addSetNext(String pattern, String methodName,
String paramType) {
addRule(pattern,
new SetNextRule(methodName, paramType));
}
/**
* Add {@link SetRootRule} with the specified parameters.
*
* @param pattern Element matching pattern
* @param methodName Method name to call on the root object
* @see SetRootRule
*/
public void addSetRoot(String pattern, String methodName) {
addRule(pattern,
new SetRootRule(methodName));
}
/**
* Add {@link SetRootRule} with the specified parameters.
*
* @param pattern Element matching pattern
* @param methodName Method name to call on the root object
* @param paramType Java class name of the expected parameter type
* @see SetRootRule
*/
public void addSetRoot(String pattern, String methodName,
String paramType) {
addRule(pattern,
new SetRootRule(methodName, paramType));
}
/**
* Add a "set properties" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @see SetPropertiesRule
*/
public void addSetProperties(String pattern) {
addRule(pattern,
new SetPropertiesRule());
}
/**
* Add a "set properties" rule with a single overridden parameter.
* See {@link SetPropertiesRule#SetPropertiesRule(String attributeName, String propertyName)}
*
* @param pattern Element matching pattern
* @param attributeName map this attribute
* @param propertyName to this property
* @see SetPropertiesRule
*/
public void addSetProperties(
String pattern,
String attributeName,
String propertyName) {
addRule(pattern,
new SetPropertiesRule(attributeName, propertyName));
}
/**
* Add a "set properties" rule with overridden parameters.
* See {@link SetPropertiesRule#SetPropertiesRule(String [] attributeNames, String [] propertyNames)}
*
* @param pattern Element matching pattern
* @param attributeNames names of attributes with custom mappings
* @param propertyNames property names these attributes map to
* @see SetPropertiesRule
*/
public void addSetProperties(
String pattern,
String [] attributeNames,
String [] propertyNames) {
addRule(pattern,
new SetPropertiesRule(attributeNames, propertyNames));
}
/**
* Add a "set property" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param name Attribute name containing the property name to be set
* @param value Attribute name containing the property value to set
* @see SetPropertyRule
*/
public void addSetProperty(String pattern, String name, String value) {
addRule(pattern,
new SetPropertyRule(name, value));
}
/**
* Add a "set top" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param methodName Method name to call on the parent element
* @see SetTopRule
*/
public void addSetTop(String pattern, String methodName) {
addRule(pattern,
new SetTopRule(methodName));
}
/**
* Add a "set top" rule for the specified parameters.
*
* @param pattern Element matching pattern
* @param methodName Method name to call on the parent element
* @param paramType Java class name of the expected parameter type
* (if you wish to use a primitive type, specify the corresonding
* Java wrapper class instead, such as java.lang.Boolean
* for a boolean parameter)
* @see SetTopRule
*/
public void addSetTop(String pattern, String methodName,
String paramType) {
addRule(pattern,
new SetTopRule(methodName, paramType));
}
// --------------------------------------------------- Object Stack Methods
/**
* Clear the current contents of the default object stack, the param stack,
* all named stacks, and other internal variables.
* null.
*/
public Object peek() {
try {
return (stack.peek());
} catch (EmptyStackException e) {
log.warn("Empty stack (returning null)");
return (null);
}
}
/**
* Return the n'th object down the stack, where 0 is the top element
* and [getCount()-1] is the bottom element. If the specified index
* is out of range, return null.
*
* @param n Index of the desired element, where 0 is the top of the stack,
* 1 is the next element down, and so on.
*/
public Object peek(int n) {
try {
return (stack.peek(n));
} catch (EmptyStackException e) {
log.warn("Empty stack (returning null)");
return (null);
}
}
/**
* Pop the top object off of the stack, and return it. If there are
* no objects on the stack, return null.
*/
public Object pop() {
try {
Object popped = stack.pop();
if (stackAction != null) {
popped = stackAction.onPop(this, null, popped);
}
return popped;
} catch (EmptyStackException e) {
log.warn("Empty stack (returning null)");
return (null);
}
}
/**
* Push a new object onto the top of the object stack.
*
* @param object The new object
*/
public void push(Object object) {
if (stackAction != null) {
object = stackAction.onPush(this, null, object);
}
if (stack.size() == 0) {
root = object;
}
stack.push(object);
}
/**
* Pushes the given object onto the stack with the given name.
* If no stack already exists with the given name then one will be created.
*
* @param stackName the name of the stack onto which the object should be pushed
* @param value the Object to be pushed onto the named stack.
*
* @since 1.6
*/
public void push(String stackName, Object value) {
if (stackAction != null) {
value = stackAction.onPush(this, stackName, value);
}
ArrayStack namedStack = (ArrayStack) stacksByName.get(stackName);
if (namedStack == null) {
namedStack = new ArrayStack();
stacksByName.put(stackName, namedStack);
}
namedStack.push(value);
}
/**
* Object on the stack or or null if the stack is either
* empty or has not been created yet
* @throws EmptyStackException if the named stack is empty
*
* @since 1.6
*/
public Object pop(String stackName) {
Object result = null;
ArrayStack namedStack = (ArrayStack) stacksByName.get(stackName);
if (namedStack == null) {
if (log.isDebugEnabled()) {
log.debug("Stack '" + stackName + "' is empty");
}
throw new EmptyStackException();
}
result = namedStack.pop();
if (stackAction != null) {
result = stackAction.onPop(this, stackName, result);
}
return result;
}
/**
* Object on the stack or null if the stack is either
* empty or has not been created yet
* @throws EmptyStackException if the named stack is empty
*
* @since 1.6
*/
public Object peek(String stackName) {
return peek(stackName, 0);
}
/**
* Object on the stack.
* @throws EmptyStackException if the named stack is empty
*
* @since 1.6
*/
public Object peek(String stackName, int n) {
Object result = null;
ArrayStack namedStack = (ArrayStack) stacksByName.get(stackName);
if (namedStack == null ) {
if (log.isDebugEnabled()) {
log.debug("Stack '" + stackName + "' is empty");
}
throw new EmptyStackException();
} else {
result = namedStack.peek(n);
}
return result;
}
/**
* super.cleanup() to invoke this logic.Digester
* instance. The default implementation does nothing, but subclasses
* can override as needed.
* Digester
* instance.
* The default implementation does nothing, but subclasses
* can override as needed.
* Digester (by default) only calls this method once.
* configure or who set configured
* may find that this method may be called more than once.
* match() on the Rules
* implementation returned by getRules()
*/
List getRules(String match) {
return (getRules().match(match));
}
/**
* null.CallMethodRule parameters.
* See {@link #params}.null.CallMethodRule parameters.
* See {@link #params}.null.CallMethodRule parameters.
* See {@link #params}.CallMethodRule parameters.
* See {@link #params}. Introduction.
Many applications have xml configuration files which are "extensible".
Some examples of this are:
The Digester "plugins" module can be used to add this kind of functionality
to your own applications.
An Example
Let's start off with an example.
Digester digester = new Digester();
PluginRules rc = new PluginRules();
digester.setRules(rc);
digester.addObjectCreate("pipeline", Pipeline.class);
digester.addCallMethod("pipeline/source", "setSource", 1);
digester.addCallParam("pipeline/source", 0, "file");
PluginCreateRule pcr = new PluginCreateRule(Transform.class);
digester.addRule("pipeline/transform", pcr);
digester.addSetNext("pipeline/transform", "setTransform");
digester.addCallMethod("pipeline/destination", "setDest", 1);
digester.addCallParam("pipeline/destination", 0, "file");
digester.parse(filename);
<pipeline>
<source file="input.txt"/>
<transform plugin-class="SubstituteTransform">
<from>changeme</from>
<to>changed</to>
</transform>
<destination file="output.txt"/>
</pipeline>
If a plugin class has a no-parameter constructor, does not expect any subtags,
and is satisfied with mapping any attributes on the parent xml tag to
bean-property-setter methods on itself, then no rules need to be defined at
all; the class can be used as a plugin without any coding.
public static void addRules(Digester d, String
pattern) on the class being "plugged in", or Plugin Declarations
As well as the syntax shown above, where plugin classnames were defined
as they were used, plugin classes can be pre-declared (provided the application
associates a PluginDeclarationRule with a tag for that purpose). Example:
<plugin id="widget" class="com.acme.Widget"/>
and later referenced via the short "id" value:
<sometag plugin-id="widget" ... >
Suggested Applications
Any application where user-specific operations may need to be performed
that cannot be known in advance by the initial application developer may
benefit from this module. Applications in the style of the Apache projects
listed at the top of this page (Log4j, Cocoon, Ant) are examples.
Terminology
The term "plugin declaration" refers to an xml element which matches a
PluginDeclarationRule, where the user specifies an id-to-class mapping.
Limitations
The user cannot replace the name of the tag used as the plugin-point;
<statement plugin-id="if"> cannot become <if>.
Performance
For patterns which do not involve "plugin points" there is minimal
performance impact when adding rules to the Digester, and none when
processing input data.
Alternatives
The "xmlrules" digester module allows modification of parsing rules
without code changes or recompilation. However this feature is aimed
at the developer, not the end user of an application. The differences
between xmlrules functionality and plugins functionality are:
How to write plugin classes
In order to be useful, the problem domain needs to involve a base class or
interface which can have multiple implementations. This section assumes that
this is the case, that you have already created a concrete implementation
of that base class or interface, and are wondering what changes need to
be made to that class to make it suitable for a "plugin".
public static void addRules(Digester d, String pathPrefix) {
d.addCallMethod(pathPrefix+"/from", "setFrom", 0);
d.addCallMethod(pathPrefix+"/to", "setTo", 0);
}
A "rule info" class consists of nothing but a static method defined as above.
Other features
Multiple plugin declarations are permitted; the latest simply overrides
earlier ones.
* if (impossibleCondition) {
* throw new PluginAssertionFailure(
* "internal error: impossible condition is true");
* }
*
*
* setPluginClassAttribute(null, "class");
*
* will allow this in the input xml:
*
* <root>
* <some-plugin class="com.acme.widget"> ......
*
* instead of the default syntax:
*
* <root>
* <some-plugin plugin-class="com.acme.widget"> ......
*
* This is particularly useful if the input xml document is not in
* English.
*
* setPluginIdAttribute(null, "id");
*
* will allow this in the input xml:
*
* <root>
* <some-plugin id="widget"> ......
*
* rather than the default behaviour:
*
* <root>
* <some-plugin plugin-id="widget"> ......
*
* This is particularly useful if the input xml document is not in
* English.
* Rule objects.
*/
public String getNamespaceURI() {
return decoratedRules.getNamespaceURI();
}
/**
* Set the namespace URI that will be applied to all subsequently
* added Rule objects.
*
* @param namespaceURI Namespace URI that must match on all
* subsequently added rules, or null for matching
* regardless of the current namespace URI
*/
public void setNamespaceURI(String namespaceURI) {
decoratedRules.setNamespaceURI(namespaceURI);
}
/**
* Return the object which "knows" about all declared plugins.
*
* @return The pluginManager value
*/
public PluginManager getPluginManager() {
return pluginManager;
}
/**
* See {@link PluginContext#getRuleFinders}.
*/
public List getRuleFinders() {
return pluginContext.getRuleFinders();
}
/**
* See {@link PluginContext#setRuleFinders}.
*/
public void setRuleFinders(List ruleFinders) {
pluginContext.setRuleFinders(ruleFinders);
}
/**
* Return the rules factory object (or null if one has not been specified).
*/
public RulesFactory getRulesFactory() {
return rulesFactory;
}
/**
* Set the object which is used to generate the new Rules instances created
* to hold and process the rules associated with each plugged-in class.
*/
public void setRulesFactory(RulesFactory factory) {
rulesFactory = factory;
}
// --------------------------------------------------------- Public Methods
/**
* This package-scope method is used by the PluginCreateRule class to
* get direct access to the rules that were dynamically added by the
* plugin. No other class should need access to this object.
*/
Rules getDecoratedRules() {
return decoratedRules;
}
/**
* Return the list of rules registered with this object, in the order
* they were registered with this object.
* add()
* method.
*
* @param path the path to the xml nodes to be matched.
*
* @deprecated Call match(namespaceURI,pattern) instead.
*/
public List match(String path) {
return (match(null, path));
}
/**
* Return a List of all registered Rule instances that match the specified
* nodepath, or a zero-length List if there are no matches. If more
* than one Rule instance matches, they must be returned
* in the order originally registered through the add()
* method.
* null to match regardless of namespace URI
* @param path the path to the xml nodes to be matched.
*/
public List match(String namespaceURI, String path) {
Log log = LogUtils.getLogger(digester);
boolean debug = log.isDebugEnabled();
if (debug) {
log.debug(
"Matching path [" + path +
"] on rules object " + this.toString());
}
List matches;
if ((mountPoint != null) &&
(path.length() <= mountPoint.length())) {
if (debug) {
log.debug(
"Path [" + path + "] delegated to parent.");
}
matches = parent.match(namespaceURI, path);
// Note that in the case where path equals mountPoint,
// we deliberately return only the rules from the parent,
// even though this object may hold some rules matching
// this same path. See PluginCreateRule's begin, body and end
// methods for the reason.
} else {
log.debug("delegating to decorated rules.");
matches = decoratedRules.match(namespaceURI, path);
}
return matches;
}
/** See {@link PluginContext#setPluginClassAttribute}. */
public void setPluginClassAttribute(String namespaceUri,
String attrName) {
pluginContext.setPluginClassAttribute(namespaceUri, attrName);
}
/** See {@link PluginContext#setPluginIdAttribute}. */
public void setPluginIdAttribute(String namespaceUri,
String attrName) {
pluginContext.setPluginIdAttribute(namespaceUri, attrName);
}
/** See {@link PluginContext#getPluginClassAttrNs}. */
public String getPluginClassAttrNs() {
return pluginContext.getPluginClassAttrNs();
}
/** See {@link PluginContext#getPluginClassAttr}. */
public String getPluginClassAttr() {
return pluginContext.getPluginClassAttr();
}
/** See {@link PluginContext#getPluginIdAttrNs}. */
public String getPluginIdAttrNs() {
return pluginContext.getPluginIdAttrNs();
}
/** See {@link PluginContext#getPluginIdAttr}. */
public String getPluginIdAttr() {
return pluginContext.getPluginIdAttr();
}
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/ 0000755 0001750 0001750 00000000000 11226450007 032134 5 ustar twerner twerner ././@LongLink 0000000 0000000 0000000 00000000165 00000000000 011567 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFromDfltClass.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFr0000644 0001750 0001750 00000006756 11226450007 033574 0 ustar twerner twerner /* $Id: FinderFromDfltClass.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.util.Properties;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.RuleFinder;
import org.apache.commons.digester.plugins.RuleLoader;
import org.apache.commons.digester.plugins.PluginException;
/**
* A rule-finding algorithm which looks for a method with a specific name
* on a class whose name is derived from the plugin class name.
*
* @since 1.6
*/
public class FinderFromDfltClass extends RuleFinder {
public static String DFLT_RULECLASS_SUFFIX = "RuleInfo";
public static String DFLT_METHOD_NAME = "addRules";
private String rulesClassSuffix;
private String methodName;
/** See {@link #findLoader}. */
public FinderFromDfltClass() {
this(DFLT_RULECLASS_SUFFIX, DFLT_METHOD_NAME);
}
/**
* Create a rule-finder which invokes a method on a class whenever
* dynamic rules for a plugin need to be loaded. See the findRules
* method for more info.
*
* @param rulesClassSuffix must be non-null.
* @param methodName may be null.
*/
public FinderFromDfltClass(String rulesClassSuffix, String methodName) {
this.rulesClassSuffix = rulesClassSuffix;
this.methodName = methodName;
}
/**
* If there exists a class whose name is the plugin class name + the
* suffix specified to the constructor, then load that class, locate
* the appropriate rules-adding method on that class, and return an
* object encapsulating that info.
* public static void xxxxx(Digester d, String patternPrefix);
*/
public RuleLoader findLoader(Digester digester, Class pluginClass, Properties p)
throws PluginException {
String rulesClassName = pluginClass.getName() + rulesClassSuffix;
Class rulesClass = null;
try {
rulesClass = digester.getClassLoader().loadClass(rulesClassName);
} catch(ClassNotFoundException cnfe) {
// ok, ignore
}
if (rulesClass == null) {
// nope, no rule-info class in the classpath
return null;
}
if (methodName == null) {
methodName = DFLT_METHOD_NAME;
}
return new LoaderFromClass(rulesClass, methodName);
}
}
././@LongLink 0000000 0000000 0000000 00000000166 00000000000 011570 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFromDfltMethod.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderFr0000644 0001750 0001750 00000005572 11226450007 033567 0 ustar twerner twerner /* $Id: FinderFromDfltMethod.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.util.Properties;
import java.lang.reflect.Method;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.RuleFinder;
import org.apache.commons.digester.plugins.RuleLoader;
import org.apache.commons.digester.plugins.PluginException;
/**
* A rule-finding algorithm which looks for a method with a specific name
* on the plugin class.
*
* @since 1.6
*/
public class FinderFromDfltMethod extends RuleFinder {
public static String DFLT_METHOD_NAME = "addRules";
private String methodName;
/** See {@link #findLoader}. */
public FinderFromDfltMethod() {
this(DFLT_METHOD_NAME);
}
/**
* Create a rule-finder which invokes a specific method on the plugin
* class whenever dynamic rules for a plugin need to be loaded. See the
* findRules method for more info.
*
* @param methodName must be non-null.
*/
public FinderFromDfltMethod(String methodName) {
this.methodName = methodName;
}
/**
* If there exists on the plugin class a method with name matching the
* constructor's methodName value then locate the appropriate Method on
* the plugin class and return an object encapsulating that info.
* public static void xxxxx(Digester d, String patternPrefix);
*/
public RuleLoader findLoader(Digester d, Class pluginClass, Properties p)
throws PluginException {
Method rulesMethod = LoaderFromClass.locateMethod(pluginClass, methodName);
if (rulesMethod == null) {
return null;
}
return new LoaderFromClass(pluginClass, rulesMethod);
}
}
././@LongLink 0000000 0000000 0000000 00000000165 00000000000 011567 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/LoaderSetProperties.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/LoaderSe0000644 0001750 0001750 00000003646 11226450007 033566 0 ustar twerner twerner /* $Id: LoaderSetProperties.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import org.apache.commons.digester.Digester;
import org.apache.commons.logging.Log;
import org.apache.commons.digester.plugins.RuleLoader;
/**
* A RuleLoader which creates a single SetPropertiesRule and adds it to the
* digester when its addRules() method is invoked.
* public static void xxxxx(Digester d, String patternPrefix);
*/
public RuleLoader findLoader(Digester d, Class pluginClass, Properties p)
throws PluginException {
String methodName = p.getProperty(methodAttr);
if (methodName == null) {
// nope, user hasn't requested dynamic rules to be loaded
// from a specific class.
return null;
}
return new LoaderFromClass(pluginClass, methodName);
}
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/package.html libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/package.0000644 0001750 0001750 00000007700 11226450007 033534 0 ustar twerner twerner
public static void foo(Digester d, String patternPrefix);.
*
* @return null if no such method exists.
*/
public static Method locateMethod(Class rulesClass, String methodName)
throws PluginException {
Class[] paramSpec = { Digester.class, String.class };
Method rulesMethod = MethodUtils.getAccessibleMethod(
rulesClass, methodName, paramSpec);
return rulesMethod;
}
}
././@LongLink 0000000 0000000 0000000 00000000165 00000000000 011567 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderSetProperties.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/plugins/strategies/FinderSe0000644 0001750 0001750 00000007412 11226450007 033562 0 ustar twerner twerner /* $Id: FinderSetProperties.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.plugins.strategies;
import java.util.Properties;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.plugins.RuleFinder;
import org.apache.commons.digester.plugins.RuleLoader;
/**
* A rule-finding algorithm which expects the user to specify whether
* "automatic property setting" is desired. If this class discovers that
* this is in fact the case for a declaration, then a RuleLoader is returned
* which, when invoked, adds a single SetPropertiesRule instance to the
* digester.
* public static void xxxxx(Digester d, String patternPrefix);
*
*
*
*@param namespace The xml namespace in which the xml element which
* triggered this rule resides.
*@param name The name of the xml element which triggered this rule.
*@param attributes The set of attributes on the xml element which
* triggered this rule.
*@exception java.lang.Exception
*/
public void begin(String namespace, String name,
org.xml.sax.Attributes attributes)
throws java.lang.Exception {
int nAttrs = attributes.getLength();
Properties props = new Properties();
for(int i=0; i
*
* The created node will be normalized, meaning it will not contain text nodes
* that only contain white space characters.
*
*
* Node will be pushed on Digester's object stack
* when done. To use it in the context of another DOM
* {@link org.w3c.dom.Document Document}, it must be imported first, using the
* Document method
* {@link org.w3c.dom.Document#importNode(org.w3c.dom.Node, boolean) importNode()}.
* NodeCreateRule will never be triggered by Digester, which
* usually is the behavior one would expect.DocumentBuilder that should be used when constructing the
* node tree.
*
* @param documentBuilder the JAXP DocumentBuilder to use
*/
public NodeCreateRule(DocumentBuilder documentBuilder) {
this(Node.ELEMENT_NODE, documentBuilder);
}
/**
* Constructor. Creates an instance of this rule that will create either a
* DOM {@link org.w3c.dom.Element Element} or a DOM
* {@link org.w3c.dom.DocumentFragment DocumentFragment}, depending on the
* value of the nodeType parameter.
*
* @param nodeType the type of node to create, which can be either
* {@link org.w3c.dom.Node#ELEMENT_NODE Node.ELEMENT_NODE} or
* {@link org.w3c.dom.Node#DOCUMENT_FRAGMENT_NODE Node.DOCUMENT_FRAGMENT_NODE}
* @throws IllegalArgumentException if the node type is not supported
*/
public NodeCreateRule(int nodeType) throws ParserConfigurationException {
this(nodeType,
DocumentBuilderFactory.newInstance().newDocumentBuilder());
}
/**
* Constructor. Creates an instance of this rule that will create either a
* DOM {@link org.w3c.dom.Element Element} or a DOM
* {@link org.w3c.dom.DocumentFragment DocumentFragment}, depending on the
* value of the nodeType parameter. This constructor lets you
* specify the JAXP DocumentBuilder that should be used when
* constructing the node tree.
*
* @param nodeType the type of node to create, which can be either
* {@link org.w3c.dom.Node#ELEMENT_NODE Node.ELEMENT_NODE} or
* {@link org.w3c.dom.Node#DOCUMENT_FRAGMENT_NODE Node.DOCUMENT_FRAGMENT_NODE}
* @param documentBuilder the JAXP DocumentBuilder to use
* @throws IllegalArgumentException if the node type is not supported
*/
public NodeCreateRule(int nodeType, DocumentBuilder documentBuilder) {
if (!((nodeType == Node.DOCUMENT_FRAGMENT_NODE) ||
(nodeType == Node.ELEMENT_NODE))) {
throw new IllegalArgumentException(
"Can only create nodes of type DocumentFragment and Element");
}
this.nodeType = nodeType;
this.documentBuilder = documentBuilder;
}
// ----------------------------------------------------- Instance Variables
/**
* The JAXP DocumentBuilder to use.
*/
private DocumentBuilder documentBuilder = null;
/**
* The type of the node that should be created. Must be one of the
* constants defined in {@link org.w3c.dom.Node Node}, but currently only
* {@link org.w3c.dom.Node#ELEMENT_NODE Node.ELEMENT_NODE} and
* {@link org.w3c.dom.Node#DOCUMENT_FRAGMENT_NODE Node.DOCUMENT_FRAGMENT_NODE}
* are allowed values.
*/
private int nodeType = Node.ELEMENT_NODE;
// ----------------------------------------------------------- Rule Methods
/**
* When this method fires, the digester is told to forward all SAX
* ContentHandler events to the builder object, resulting in a DOM being
* built instead of normal digester rule-handling occurring. When the
* end of the current xml element is encountered, the original content
* handler is restored (expected to be NULL, allowing normal Digester
* operations to continue).
*
* @param namespaceURI the namespace URI of the matching element, or an
* empty string if the parser is not namespace aware or the element has
* no namespace
* @param name the local name if the parser is namespace aware, or just
* the element name otherwise
* @param attributes The attribute list of this element
* @throws Exception indicates a JAXP configuration problem
*/
public void begin(String namespaceURI, String name, Attributes attributes)
throws Exception {
Document doc = documentBuilder.newDocument();
NodeBuilder builder = null;
if (nodeType == Node.ELEMENT_NODE) {
Element element = null;
if (getDigester().getNamespaceAware()) {
element =
doc.createElementNS(namespaceURI, name);
for (int i = 0; i < attributes.getLength(); i++) {
element.setAttributeNS(attributes.getURI(i),
attributes.getQName(i),
attributes.getValue(i));
}
} else {
element = doc.createElement(name);
for (int i = 0; i < attributes.getLength(); i++) {
element.setAttribute(attributes.getQName(i),
attributes.getValue(i));
}
}
builder = new NodeBuilder(doc, element);
} else {
builder = new NodeBuilder(doc, doc.createDocumentFragment());
}
// the NodeBuilder constructor has already saved the original
// value of the digester's custom content handler (expected to
// be null, but we save it just in case). So now we just
// need to tell the digester to forward events to the builder.
getDigester().setCustomContentHandler(builder);
}
/**
* Pop the Node off the top of the stack.
*/
public void end() throws Exception {
digester.pop();
}
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/AbstractObjectCreationFactory.java libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/AbstractObjectCreationFacto0000644 0001750 0001750 00000004475 11226450007 033572 0 ustar twerner twerner /* $Id: AbstractObjectCreationFactory.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import org.xml.sax.Attributes;
/**
* ObjectCreationFactory
* implementations.Digester instance that was set up by
* {@link FactoryCreateRule} upon initialization.
*/
protected Digester digester = null;
// --------------------------------------------------------- Public Methods
/**
* AbstractRuleImpl provides basic services for Rules implementations.
* Extending this class should make it easier to create a Rules implementation.AbstractRuleImpl manages the Digester
* and namespaceUri properties.
* If the subclass overrides {@link #registerRule} (rather than {@link #add}),
* then the Digester and namespaceURI of the Rule
* will be set correctly before it is passed to registerRule.
* The subclass can then perform whatever it needs to do to register the rule.Rules implementation */
private Digester digester;
/** Namespace uri to assoicate with subsequent Rule's */
private String namespaceURI;
// ------------------------------------------------------------- Properties
/**
* Return the Digester instance with which this Rules instance is
* associated.
*/
public Digester getDigester() {
return digester;
}
/**
* Set the Digester instance with which this Rules instance is associated.
*
* @param digester The newly associated Digester instance
*/
public void setDigester(Digester digester) {
this.digester = digester;
}
/**
* Return the namespace URI that will be applied to all subsequently
* added Rule objects.
*/
public String getNamespaceURI() {
return namespaceURI;
}
/**
* Set the namespace URI that will be applied to all subsequently
* added Rule objects.
*
* @param namespaceURI Namespace URI that must match on all
* subsequently added rules, or null for matching
* regardless of the current namespace URI
*/
public void setNamespaceURI(String namespaceURI) {
this.namespaceURI = namespaceURI;
}
// --------------------------------------------------------- Public Methods
/**
* Registers a new Rule instance matching the specified pattern.
* This implementation sets the Digester and the
* namespaceURI on the Rule before calling {@link #registerRule}.
*
* @param pattern Nesting pattern to be matched for this Rule
* @param rule Rule instance to be registered
*/
public void add(String pattern, Rule rule) {
// set up rule
if (this.digester != null) {
rule.setDigester(this.digester);
}
if (this.namespaceURI != null) {
rule.setNamespaceURI(this.namespaceURI);
}
registerRule(pattern, rule);
}
/**
* Register rule at given pattern.
* The the Digester and namespaceURI properties of the given Rule
* can be assumed to have been set properly before this method is called.
*
* @param pattern Nesting pattern to be matched for this Rule
* @param rule Rule instance to be registered
*/
abstract protected void registerRule(String pattern, Rule rule);
/**
* Clear all existing Rule instance registrations.
*/
abstract public void clear();
/**
* Return a List of all registered Rule instances that match the specified
* nesting pattern, or a zero-length List if there are no matches. If more
* than one Rule instance matches, they must be returned
* in the order originally registered through the add()
* method.
*
* @param pattern Nesting pattern to be matched
*
* @deprecated Call match(namespaceURI,pattern) instead.
*/
public List match(String pattern) {
return match(namespaceURI, pattern);
}
/**
* Return a List of all registered Rule instances that match the specified
* nesting pattern, or a zero-length List if there are no matches. If more
* than one Rule instance matches, they must be returned
* in the order originally registered through the add()
* method.
*
* @param namespaceURI Namespace URI for which to select matching rules,
* or null to match regardless of namespace URI
* @param pattern Nesting pattern to be matched
*/
abstract public List match(String namespaceURI, String pattern);
/**
* Return a List of all registered Rule instances, or a zero-length List
* if there are no registered Rule instances. If more than one Rule
* instance has been registered, they must be returned
* in the order originally registered through the add()
* method.
*/
abstract public List rules();
}
libcommons-digester-java-1.8.1.orig/src/java/org/apache/commons/digester/ObjectParamRule.java 0000644 0001750 0001750 00000010175 11226450007 032167 0 ustar twerner twerner /* $Id: ObjectParamRule.java 471661 2006-11-06 08:09:25Z skitching $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester;
import org.xml.sax.Attributes;
/**
* CallMethodRule.
*
*
(Logical) Interface for substitution strategies. * (It happens to be implemented as a Java abstract class to allow * future additions to be made without breaking backwards compatibility.) *
*
* Usage: When {@link Digester#setSubstitutor} is set, Digester
* calls the methods in this interface to create substitute values which will
* be passed into the Rule implementations.
* Of course, it is perfectly acceptable for implementations not to make
* substitutions and simply return the inputs.
*
Different strategies are supported for attributes and body text.
* * @since 1.6 */ public abstract class Substitutor { /** *Substitutes the attributes (before they are passed to the
* Rule implementations's).
Digester will only call this method a second time
* once the original Attributes instance can be safely reused.
* The implementation is therefore free to reuse the same Attributes instance
* for all calls.
Attributes passed into Digester by the SAX parser,
* not null (but may be empty)
* @return Attributes to be passed to the Rule implementations.
* This method may pass back the Attributes passed in.
* Not null but possibly empty.
*/
public abstract Attributes substitute(Attributes attributes);
/**
* Substitutes for the body text.
* This method may substitute values into the body text of the
* elements that Digester parses.
*
* @param bodyText the body text (as passed to Digester)
* @return the body text to be passed to the Rule implementations
*/
public abstract String substitute(String bodyText);
}
libcommons-digester-java-1.8.1.orig/src/conf/ 0000755 0001750 0001750 00000000000 11226450007 021014 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/conf/MANIFEST.MF 0000644 0001750 0001750 00000000660 11226450007 022450 0 ustar twerner twerner Manifest-Version: 1.0
Package: org.apache.commons.digester
Extension-Name: commons-digester
Specification-Title: Rule based XML->Java object mapping module
Specification-Vendor: The Apache Software Foundation
Implementation-Title: org.apache.commons.digester
Implementation-Vendor: The Apache Software Foundation
Implementation-Version: 1.8.1
Implementation-Vendor-Id: org.apache
X-Compile-Source-JDK: 1.2
X-Compile-Target-JDK: 1.2
libcommons-digester-java-1.8.1.orig/src/assembly/ 0000755 0001750 0001750 00000000000 11226450007 021706 5 ustar twerner twerner libcommons-digester-java-1.8.1.orig/src/assembly/bin.xml 0000644 0001750 0001750 00000002734 11226450007 023206 0 ustar twerner twerner