<patternset> support the refid attribute directly instead. git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@267973 13f79535-47bb-0310-9956-ffa450edef68master
@@ -136,7 +136,7 @@ | |||
<copydir src="${src.bin.dir}" dest="${bin.dir}"/> | |||
<chmod perm="+x"> | |||
<fileset dir="${bin.dir}"> | |||
<patternsetref refid="chmod.patterns"/> | |||
<patternset refid="chmod.patterns"/> | |||
</fileset> | |||
</chmod> | |||
<fixcrlf srcdir="${bin.dir}" includes="ant,antRun" cr="remove"/> | |||
@@ -180,7 +180,7 @@ | |||
<chmod perm="+x"> | |||
<fileset dir="${ant.dist.dir}/bin"> | |||
<patternsetref refid="chmod.patterns"/> | |||
<patternset refid="chmod.patterns"/> | |||
</fileset> | |||
</chmod> | |||
@@ -219,7 +219,7 @@ | |||
<copydir src="${ant.dist.dir}" dest="${ant.install}"/> | |||
<chmod perm="+x"> | |||
<fileset dir="${ant.install}/bin"> | |||
<patternsetref refid="chmod.patterns"/> | |||
<patternset refid="chmod.patterns"/> | |||
</fileset> | |||
</chmod> | |||
</target> | |||
@@ -233,7 +233,7 @@ | |||
<copydir src="${bin.dir}" dest="${ant.install}/bin"/> | |||
<chmod perm="+x"> | |||
<fileset dir="${ant.install}/bin"> | |||
<patternsetref refid="chmod.patterns"/> | |||
<patternset refid="chmod.patterns"/> | |||
</fileset> | |||
</chmod> | |||
</target> | |||
@@ -280,8 +280,7 @@ | |||
<javac srcdir="${src.tests.dir}" | |||
destdir="${build.tests}" | |||
debug="on" | |||
deprecation="off" | |||
optimize="on" > | |||
deprecation="off" > | |||
<classpath> | |||
<pathelement location="${lib.dir}/${name}.jar" /> | |||
<path refid="classpath" /> | |||
@@ -294,6 +293,8 @@ | |||
<exclude name="**/CommandlineTest.java" unless="junit.present" /> | |||
<exclude name="**/CommandlineJavaTest.java" unless="junit.present" /> | |||
<exclude name="**/ProjectTest.java" unless="junit.present" /> | |||
<exclude name="**/PatternSetTest.java" unless="junit.present" /> | |||
<exclude name="**/FileSetTest.java" unless="junit.present" /> | |||
</javac> | |||
</target> | |||
@@ -25,7 +25,7 @@ | |||
<li>Dave Walend (<a href="mailto:dwalend@cs.tufts.edu">dwalend@cs.tufts.edu</a>)</li> | |||
</ul> | |||
<p>Version 1.2 - 2000/08/10</p> | |||
<p>Version 1.2 - 2000/09/07</p> | |||
<hr> | |||
<h2>Table of Contents</h2> | |||
@@ -444,8 +444,7 @@ location attributes of its own, so</p> | |||
<classpath path="${classpath}" /> | |||
</pre> | |||
<p>In addition, <a href="#fileset">FileSet</a>s can be specified via | |||
nested <code><fileset></code> and | |||
<code><filesetref></code> elements. The order in which the files | |||
nested <code><fileset></code> elements. The order in which the files | |||
building up FileSet are added to the PATH like structure is not | |||
defined.</p> | |||
<pre> | |||
@@ -746,7 +745,7 @@ directory based task that constitutes an implicit FileSet. In addition | |||
<p>Builds a set of patterns, that matches all <code>.java</code> files | |||
that do not contain the text <code>Test</code> in their name. This set | |||
can be <a href="#references">referred</a> to via | |||
<code><patternsetref refid="non.test.sources" | |||
<code><patternset refid="non.test.sources" | |||
/></code> by tasks that support this feature or by FileSets.</p> | |||
<h3><a name="fileset">FileSets</a></h3> | |||
<p>FileSets are groups of files. These files can be found in a | |||
@@ -756,7 +755,7 @@ href="#patternset">PatternSets</a>. FileSets can appear inside task | |||
that support this feature or at the same level as <code>target</code> | |||
- i.e. as children of <code>project</code>.</p> | |||
<p>PatternSets can be specified as nested | |||
<code><patternset></code> or <code><patternsetref></code> | |||
<code><patternset></code> | |||
elements. In addition FileSet holds an implicit PatternSet and | |||
supports the nested <code><include></code> and | |||
<code><exclude></code> elements of PatternSet directly as well | |||
@@ -817,7 +816,7 @@ source files and don't have the text <code>Test</code> in their | |||
name.</p> | |||
<blockquote><pre> | |||
<fileset dir="${client.src}" > | |||
<patternsetref refid="non.test.sources" /> | |||
<patternset refid="non.test.sources" /> | |||
</fileset> | |||
</pre></blockquote> | |||
<p>Groups all files in directory <code>${client.src}</code> using the | |||
@@ -998,8 +997,7 @@ write patterns.</p> | |||
<p>This task holds an implicit <a href="#fileset">FileSet</a> and | |||
supports all of FileSet's attributes and nested elements | |||
directly. More FileSets can be specified using nested | |||
<code><fileset></code> or <code><filesetref></code> | |||
elements.</p> | |||
<code><fileset></code> elements.</p> | |||
<h3>Parameters</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -1088,7 +1086,7 @@ readable and executable for anyone on a UNIX system.</p> | |||
<fileset dir="shared/sources1" > | |||
<exclude name="**/trial/**" /> | |||
</fileset> | |||
<filesetref refid="other.shared.sources" /> | |||
<fileset refid="other.shared.sources" /> | |||
</chmod> | |||
</pre> | |||
</blockquote> | |||
@@ -1113,9 +1111,8 @@ inclusion/exclusion of files works, and how to write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>src</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<h3>Parameters</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -1326,9 +1323,8 @@ href="#directorybasedtasks">directory based tasks</a>, on how the | |||
inclusion/exclusion of files works, and how to write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> as well as the | |||
nested <code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
nested <code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<h3>Parameters</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -1558,8 +1554,7 @@ the command is only executed when Ant is run on one of the specified operating | |||
systems.</p> | |||
<p>The files and/or directories of a number of <a | |||
href="#fileset">FileSet</a>s are passed as arguments to the system | |||
command. At least one nested <code><fileset></code> or | |||
<code><filesetref></code> is required.</p> | |||
command. At least one nested <code><fileset></code> is required.</p> | |||
<h3>Parameters</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -1619,11 +1614,10 @@ command. At least one nested <code><fileset></code> or | |||
</tr> | |||
</table> | |||
<h3>Parameters specified as nested elements</h3> | |||
<h4>fileset and filesetref</h4> | |||
<h4>fileset</h4> | |||
<p>You can use any number of nested <code><fileset></code> | |||
elements to define the files for this task and refer to | |||
<code><fileset></code>s defined elsewhere via | |||
<code><filesetref></code> elements.</p> | |||
<code><fileset></code>s defined elsewhere.</p> | |||
<h4>arg</h4> | |||
<p>Command line arguments should be specified as nested | |||
<code><arg></code> elements. See <a | |||
@@ -1644,7 +1638,7 @@ description in the section about <a href="#env">exec</a></p> | |||
<exclude name="**/*.txt" /> | |||
</patternset> | |||
</fileset> | |||
<filesetref refid="other.files" /> | |||
<fileset refid="other.files" /> | |||
</execon> | |||
</pre></blockquote> | |||
<p>invokes <code>ls -l</code>, adding the absolute filenames of all | |||
@@ -1698,9 +1692,8 @@ inclusion/exclusion of files works, and how to write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>srcdir</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<h3>Parameters</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -2075,9 +2068,8 @@ inclusion/exclusion of files works, and how to write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>basedir</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<p>You can also use nested file sets for more flexibility, and specify | |||
multiple ones to merge together different trees of files into one JAR. | |||
See the <a href="#zip">Zip</a> task for more details and examples.</p> | |||
@@ -2424,9 +2416,8 @@ inclusion/exclusion of files works, and how to write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>srcdir</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<h4>src, classpath, bootclasspath and extdirs</h4> | |||
<p><code>Javac</code>'s <em>srcdir</em>, <em>classpath</em>, | |||
<em>bootclasspath</em> and <em>extdirs</em> attributes are <a | |||
@@ -3161,9 +3152,8 @@ must use a nested <code><replacetoken></code> element.</p> | |||
<h3>Parameters specified as nested elements</h3> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> as well as the | |||
nested <code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
nested <code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<p>If either the text you want to replace or the replacement text | |||
cross line boundaries, you can use nested elements to specify | |||
them.</p> | |||
@@ -3206,9 +3196,8 @@ inclusion/exclusion of files works, and how to write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>base</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<h3>Parameters</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -3399,9 +3388,8 @@ inclusion/exclusion of files works, and how to write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>basedir</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<p>Note that this task does not perform compression. You might want to use the <a href="#gzip">GZip</a> | |||
task to come up with a .tar.gz package.</p> | |||
<h3>Parameters</h3> | |||
@@ -3576,9 +3564,8 @@ inclusion/exclusion of files works, and how to write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>basedir</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<h3>Parameters</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -3734,16 +3721,14 @@ inclusion/exclusion of files works, and how to write patterns. | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>basedir</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<p>Or, you may place within it nested file sets, or references to file sets. | |||
In this case <code>basedir</code> is optional; the implicit file set is <em>only used</em> | |||
if <code>basedir</code> is set. You may use any mixture of the implicit file set | |||
(with <code>basedir</code> set, and optional attributes like <code>includes</code> | |||
and optional subelements like <code><include></code>); explicit nested | |||
<code><fileset></code> elements; and nested <code><filesetref></code> | |||
elements; so long as at least one fileset total is specified. The ZIP file will | |||
<code><fileset></code> elements so long as at least one fileset total is specified. The ZIP file will | |||
only reflect the relative paths of files <em>within</em> each fileset.</p> | |||
<p>The <code>whenempty</code> parameter controls what happens when no files match. | |||
If <code>skip</code> (the default), the ZIP is not created and a warning is issued. | |||
@@ -3864,9 +3849,8 @@ write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>basedir</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<h3>Parameters:</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -4193,9 +4177,8 @@ inclusion/exclusion of files works, and how to write patterns.</p> | |||
<p>This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>srcdir</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<h3>Parameters:</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
@@ -4443,9 +4426,8 @@ inclusion/exclusion of files works, and how to write patterns. | |||
This task forms an implicit <a href="#fileset">FileSet</a> and | |||
supports all attributes of <code><fileset></code> | |||
(<code>dir</code> becomes <code>srcDir</code>) as well as the nested | |||
<code><include></code>, <code><exclude></code>, | |||
<code><patternset></code> and <code><patternsetref></code> | |||
elements.</p> | |||
<code><include></code>, <code><exclude></code> and | |||
<code><patternset></code> elements.</p> | |||
<h3>Parameters:</h3> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -186,11 +186,9 @@ can be specified.</p> | |||
<p><code>batchtest</code> collects the included files from any number | |||
of nested <a | |||
href="index.html#fileset"><code><fileset></code></a> and | |||
<code><filesetref></code> (referring to a | |||
<code><fileset></code> defined elsewhere via its <code>id</code> | |||
attribute) elements. It then generates a test class name for each file | |||
that ends in <code>.java</code> or <code>.class</code>.</p> | |||
href="index.html#fileset"><code><fileset></code></a>s. It then | |||
generates a test class name for each file that ends in | |||
<code>.java</code> or <code>.class</code>.</p> | |||
<table border="1" cellpadding="2" cellspacing="0"> | |||
<tr> | |||
@@ -89,13 +89,6 @@ public class Chmod extends ExecuteOn { | |||
defaultSet.setDir(src); | |||
} | |||
public void XsetSrc(File src) { | |||
log("The src attribute is deprecated. " + | |||
"Please use the file attribute.", | |||
Project.MSG_WARN); | |||
setFile(src); | |||
} | |||
public void setPerm(String perm) { | |||
createArg().setValue(perm); | |||
havePerm = true; | |||
@@ -122,13 +115,6 @@ public class Chmod extends ExecuteOn { | |||
return defaultSet.createPatternSet(); | |||
} | |||
/** | |||
* add a reference to a set of patterns | |||
*/ | |||
public Reference createPatternSetRef() { | |||
return defaultSet.createPatternSetRef(); | |||
} | |||
/** | |||
* Sets the set of include patterns. Patterns may be separated by a comma | |||
* or a space. | |||
@@ -166,7 +152,7 @@ public class Chmod extends ExecuteOn { | |||
location); | |||
} | |||
if (defaultSet.getDir() != null) { | |||
if (defaultSet.getDir(project) != null) { | |||
addFileset(defaultSet); | |||
} | |||
super.checkConfiguration(); | |||
@@ -80,13 +80,6 @@ public class ExecuteOn extends ExecTask { | |||
filesets.addElement(set); | |||
} | |||
/** | |||
* Adds a reference to a set of files (nested filesetref element). | |||
*/ | |||
public void addFilesetref(Reference ref) { | |||
filesets.addElement(ref); | |||
} | |||
/** | |||
* Shall the command work on all specified files in parallel? | |||
*/ | |||
@@ -113,34 +106,20 @@ public class ExecuteOn extends ExecTask { | |||
Vector v = new Vector(); | |||
for (int i=0; i<filesets.size(); i++) { | |||
Object o = filesets.elementAt(i); | |||
FileSet fs = null; | |||
if (o instanceof FileSet) { | |||
fs = (FileSet) o; | |||
} else { | |||
Reference r = (Reference) o; | |||
o = r.getReferencedObject(project); | |||
if (o instanceof FileSet) { | |||
fs = (FileSet) o; | |||
} else { | |||
String msg = r.getRefId()+" doesn\'t denote a fileset"; | |||
throw new BuildException(msg, location); | |||
} | |||
} | |||
FileSet fs = (FileSet) filesets.elementAt(i); | |||
DirectoryScanner ds = fs.getDirectoryScanner(project); | |||
if (!"dir".equals(type)) { | |||
String[] s = ds.getIncludedFiles(); | |||
for (int j=0; j<s.length; j++) { | |||
v.addElement(new File(fs.getDir(), s[j]).getAbsolutePath()); | |||
v.addElement(new File(fs.getDir(project), s[j]).getAbsolutePath()); | |||
} | |||
} | |||
if (!"file".equals(type)) { | |||
String[] s = ds.getIncludedDirectories(); | |||
for (int j=0; j<s.length; j++) { | |||
v.addElement(new File(fs.getDir(), s[j]).getAbsolutePath()); | |||
v.addElement(new File(fs.getDir(project), s[j]).getAbsolutePath()); | |||
} | |||
} | |||
} | |||
@@ -97,13 +97,6 @@ public abstract class MatchingTask extends Task { | |||
return fileset.createPatternSet(); | |||
} | |||
/** | |||
* add a reference to a set of patterns | |||
*/ | |||
public Reference createPatternSetRef() { | |||
return fileset.createPatternSetRef(); | |||
} | |||
/** | |||
* Sets the set of include patterns. Patterns may be separated by a comma | |||
* or a space. | |||
@@ -112,13 +112,6 @@ public class Zip extends MatchingTask { | |||
filesets.addElement(set); | |||
} | |||
/** | |||
* Adds a reference to a set of files (nested filesetref element). | |||
*/ | |||
public void addFilesetref(Reference ref) { | |||
filesets.addElement(ref); | |||
} | |||
/** | |||
* Sets behavior of the task when no files match. | |||
* Possible values are: <code>fail</code> (throw an exception | |||
@@ -144,19 +137,7 @@ public class Zip extends MatchingTask { | |||
if (baseDir != null) | |||
dss.addElement(getDirectoryScanner(baseDir)); | |||
for (int i=0; i<filesets.size(); i++) { | |||
Object o = filesets.elementAt(i); | |||
FileSet fs; | |||
if (o instanceof FileSet) { | |||
fs = (FileSet) o; | |||
} else { | |||
Reference r = (Reference) o; | |||
o = r.getReferencedObject(project); | |||
if (o instanceof FileSet) { | |||
fs = (FileSet) o; | |||
} else { | |||
throw new BuildException(r.getRefId() + " does not denote a fileset", location); | |||
} | |||
} | |||
FileSet fs = (FileSet) filesets.elementAt(i); | |||
dss.addElement (fs.getDirectoryScanner(project)); | |||
} | |||
FileScanner[] scanners = new FileScanner[dss.size()]; | |||
@@ -134,13 +134,6 @@ public class Cab extends MatchingTask { | |||
filesets.addElement(set); | |||
} | |||
/** | |||
* Adds a reference to a set of files (nested filesetref element). | |||
*/ | |||
public void addFilesetref(Reference ref) { | |||
filesets.addElement(ref); | |||
} | |||
/* | |||
* I'm not fond of this pattern: "sub-method expected to throw | |||
* task-cancelling exceptions". It feels too much like programming | |||
@@ -290,35 +283,7 @@ public class Cab extends MatchingTask { | |||
// get files from filesets | |||
for (int i = 0; i < filesets.size(); i++) | |||
{ | |||
Object o = filesets.elementAt(i); | |||
FileSet fs; | |||
if (o instanceof FileSet) | |||
{ | |||
fs = (FileSet)o; | |||
} | |||
else if (o instanceof Reference) | |||
{ | |||
Reference r = (Reference)o; | |||
o = r.getReferencedObject(project); | |||
if (o instanceof FileSet) | |||
{ | |||
fs = (FileSet)o; | |||
} | |||
else | |||
{ | |||
throw new BuildException( | |||
r.getRefId() + " does not denote a fileset", | |||
location); | |||
} | |||
} | |||
else | |||
{ | |||
throw new BuildException( | |||
"nested element is not a FileSet or Reference", | |||
location); | |||
} | |||
FileSet fs = (FileSet) filesets.elementAt(i); | |||
if (fs != null) | |||
{ | |||
appendFiles(files, fs.getDirectoryScanner(project)); | |||
@@ -295,13 +295,6 @@ public class FTP | |||
filesets.addElement(set); | |||
} | |||
/** | |||
* Adds a reference to a set of files (nested filesetref element). | |||
*/ | |||
public void addFilesetref(Reference ref) { | |||
filesets.addElement(ref); | |||
} | |||
/** | |||
* Sets the FTP action to be taken. Currently accepts "put", "get", | |||
* "del", and "list". | |||
@@ -457,35 +450,7 @@ public class FTP | |||
// get files from filesets | |||
for (int i = 0; i < filesets.size(); i++) | |||
{ | |||
Object o = filesets.elementAt(i); | |||
FileSet fs; | |||
if (o instanceof FileSet) | |||
{ | |||
fs = (FileSet)o; | |||
} | |||
else if (o instanceof Reference) | |||
{ | |||
Reference r = (Reference)o; | |||
o = r.getReferencedObject(project); | |||
if (o instanceof FileSet) | |||
{ | |||
fs = (FileSet)o; | |||
} | |||
else | |||
{ | |||
throw new BuildException( | |||
r.getRefId() + " does not denote a fileset", | |||
location); | |||
} | |||
} | |||
else | |||
{ | |||
throw new BuildException( | |||
"nested element is not a FileSet or Reference", | |||
location); | |||
} | |||
FileSet fs = (FileSet) filesets.elementAt(i); | |||
if (fs != null) | |||
{ | |||
transferFiles(ftp, fs); | |||
@@ -87,10 +87,6 @@ public final class BatchTest { | |||
filesets.addElement(fs); | |||
} | |||
public void addFileSetRef(Reference r) { | |||
filesets.addElement(r); | |||
} | |||
public void addFormatter(FormatterElement elem) { | |||
formatters.addElement(elem); | |||
} | |||
@@ -122,20 +118,7 @@ public final class BatchTest { | |||
private FileList(){ | |||
Vector v = new Vector(); | |||
for (int j=0; j<filesets.size(); j++) { | |||
Object o = filesets.elementAt(j); | |||
FileSet fs = null; | |||
if (o instanceof FileSet) { | |||
fs = (FileSet) o; | |||
} else { | |||
Reference r = (Reference) o; | |||
o = r.getReferencedObject(project); | |||
if (o instanceof FileSet) { | |||
fs = (FileSet) o; | |||
} else { | |||
String msg = r.getRefId()+" doesn\'t denote a fileset"; | |||
throw new BuildException(msg); | |||
} | |||
} | |||
FileSet fs = (FileSet) filesets.elementAt(j); | |||
DirectoryScanner ds = fs.getDirectoryScanner(project); | |||
ds.scan(); | |||
String[] f = ds.getIncludedFiles(); | |||
@@ -0,0 +1,187 @@ | |||
/* | |||
* The Apache Software License, Version 1.1 | |||
* | |||
* Copyright (c) 2000 The Apache Software Foundation. All rights | |||
* reserved. | |||
* | |||
* Redistribution and use in source and binary forms, with or without | |||
* modification, are permitted provided that the following conditions | |||
* are met: | |||
* | |||
* 1. Redistributions of source code must retain the above copyright | |||
* notice, this list of conditions and the following disclaimer. | |||
* | |||
* 2. Redistributions in binary form must reproduce the above copyright | |||
* notice, this list of conditions and the following disclaimer in | |||
* the documentation and/or other materials provided with the | |||
* distribution. | |||
* | |||
* 3. The end-user documentation included with the redistribution, if | |||
* any, must include the following acknowlegement: | |||
* "This product includes software developed by the | |||
* Apache Software Foundation (http://www.apache.org/)." | |||
* Alternately, this acknowlegement may appear in the software itself, | |||
* if and wherever such third-party acknowlegements normally appear. | |||
* | |||
* 4. The names "The Jakarta Project", "Tomcat", and "Apache Software | |||
* Foundation" must not be used to endorse or promote products derived | |||
* from this software without prior written permission. For written | |||
* permission, please contact apache@apache.org. | |||
* | |||
* 5. Products derived from this software may not be called "Apache" | |||
* nor may "Apache" appear in their names without prior written | |||
* permission of the Apache Group. | |||
* | |||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED | |||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | |||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR | |||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF | |||
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |||
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT | |||
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |||
* SUCH DAMAGE. | |||
* ==================================================================== | |||
* | |||
* This software consists of voluntary contributions made by many | |||
* individuals on behalf of the Apache Software Foundation. For more | |||
* information on the Apache Software Foundation, please see | |||
* <http://www.apache.org/>. | |||
*/ | |||
package org.apache.tools.ant.types; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.Project; | |||
import java.util.Stack; | |||
/** | |||
* Base class for those classes that can appear inside the build file | |||
* as stand alone data types. | |||
* | |||
* <p>This class handles the common description attribute and provides | |||
* a default implementation for reference handling and checking for | |||
* circular references that is appropriate for types that can not be | |||
* nested inside elements of the same type (i.e. <patternset> | |||
* but not <path>).</p> | |||
* | |||
* @author <a href="mailto:stefan.bodewig@megabit.net">Stefan Bodewig</a> | |||
*/ | |||
public abstract class DataType { | |||
/** | |||
* The descriptin the user has set. | |||
*/ | |||
protected String description = null; | |||
/** | |||
* Value to the refid attribute. | |||
*/ | |||
protected Reference ref = null; | |||
/** | |||
* Are we sure we don't hold circular references? | |||
* | |||
* <p>Subclasses are responsible for setting this value to false | |||
* if we'd need to investigate this condition (usually because a | |||
* child element has been added that is a subclass of | |||
* DataType).</p> | |||
*/ | |||
protected boolean checked = true; | |||
/** | |||
* Sets a description of the current data type. It will be useful | |||
* in commenting what we are doing. | |||
*/ | |||
public void setDescription( String desc ) { | |||
description=desc; | |||
} | |||
/** | |||
* Return the description for the current data type. | |||
*/ | |||
public String getDescription() { | |||
return description; | |||
} | |||
/** | |||
* Has the refid attribute of this element been set? | |||
*/ | |||
public boolean isReference() { | |||
return ref != null; | |||
} | |||
/** | |||
* Set the value of the refid attribute. | |||
* | |||
* <p>Subclasses may need to check whether any other attributes | |||
* have been set as well or child elements have been created and | |||
* thus override this method. if they do the must call | |||
* <code>super.setRefid</code>.</p> | |||
*/ | |||
public void setRefid(Reference ref) { | |||
this.ref = ref; | |||
checked = false; | |||
} | |||
/** | |||
* Check to see whether any DataType we hold references to is | |||
* included in the Stack (which holds all DataType instances that | |||
* directly or indirectly reference this instance, including this | |||
* instance itself). | |||
* | |||
* <p>If one is included, throw a BuildException created by {@link | |||
* #circularReference circularReference}.</p> | |||
* | |||
* <p>This implementation is appropriate only for a DataType that | |||
* cannot hold other DataTypes as children.</p> | |||
* | |||
* <p>The general contract of this method is that it shouldn't do | |||
* anything if {@link #checked <code>checked</code>} is true and | |||
* set it to true on exit.</p> | |||
*/ | |||
protected void dieOnCircularReference(Stack stk, Project p) | |||
throws BuildException { | |||
if (checked || !isReference()) { | |||
return; | |||
} | |||
Object o = ref.getReferencedObject(p); | |||
if (o instanceof DataType) { | |||
if (stk.contains(o)) { | |||
throw circularReference(); | |||
} else { | |||
stk.push(o); | |||
((DataType) o).dieOnCircularReference(stk, p); | |||
stk.pop(); | |||
} | |||
} | |||
checked = true; | |||
} | |||
/** | |||
* Creates an exception that indicates that refid has to be the | |||
* only attribute if it is set. | |||
*/ | |||
protected BuildException tooManyAttributes() { | |||
return new BuildException("You must not specify more than one attribute when using refid"); | |||
} | |||
/** | |||
* Creates an exception that indicates that this XML element must | |||
* not have child elements if the refid attribute is set. | |||
*/ | |||
protected BuildException noChildrenAllowed() { | |||
return new BuildException("You must not specify nested elements when using refid"); | |||
} | |||
/** | |||
* Creates an exception that indicates the user has generated a | |||
* loop of data types referencing each other. | |||
*/ | |||
protected BuildException circularReference() { | |||
return new BuildException("This data type contains a circular reference."); | |||
} | |||
} |
@@ -60,6 +60,7 @@ import org.apache.tools.ant.DirectoryScanner; | |||
import org.apache.tools.ant.Project; | |||
import java.io.File; | |||
import java.util.Stack; | |||
import java.util.Vector; | |||
/** | |||
@@ -72,7 +73,7 @@ import java.util.Vector; | |||
* @author Jon S. Stevens <a href="mailto:jon@clearink.com">jon@clearink.com</a> | |||
* @author <a href="mailto:stefan.bodewig@megabit.net">Stefan Bodewig</a> | |||
*/ | |||
public class FileSet { | |||
public class FileSet extends DataType { | |||
private PatternSet defaultPatterns = new PatternSet(); | |||
private Vector additionalPatterns = new Vector(); | |||
@@ -84,7 +85,28 @@ public class FileSet { | |||
super(); | |||
} | |||
/** | |||
* Makes this instance in effect a reference to another PatternSet | |||
* instance. | |||
* | |||
* <p>You must not set another attribute or nest elements inside | |||
* this element if you make it a reference.</p> | |||
*/ | |||
public void setRefid(Reference r) throws BuildException { | |||
if (dir != null || defaultPatterns.countPatterns() > 0) { | |||
throw tooManyAttributes(); | |||
} | |||
if (!additionalPatterns.isEmpty()) { | |||
throw noChildrenAllowed(); | |||
} | |||
super.setRefid(r); | |||
} | |||
public void setDir(File dir) throws BuildException { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
/* | |||
* XXX cannot check as long as tasks get configured at parse time. | |||
* | |||
@@ -100,26 +122,29 @@ public class FileSet { | |||
this.dir = dir; | |||
} | |||
public File getDir() { | |||
public File getDir(Project p) { | |||
if (isReference()) { | |||
return getRef(p).getDir(p); | |||
} | |||
return dir; | |||
} | |||
public PatternSet createPatternSet() { | |||
if (isReference()) { | |||
throw noChildrenAllowed(); | |||
} | |||
PatternSet patterns = new PatternSet(); | |||
additionalPatterns.addElement(patterns); | |||
return patterns; | |||
} | |||
public Reference createPatternSetRef() { | |||
Reference r = new Reference(); | |||
additionalPatterns.addElement(r); | |||
return r; | |||
} | |||
/** | |||
* add a name entry on the include list | |||
*/ | |||
public PatternSet.NameEntry createInclude() { | |||
if (isReference()) { | |||
throw noChildrenAllowed(); | |||
} | |||
return defaultPatterns.createInclude(); | |||
} | |||
@@ -127,6 +152,9 @@ public class FileSet { | |||
* add a name entry on the exclude list | |||
*/ | |||
public PatternSet.NameEntry createExclude() { | |||
if (isReference()) { | |||
throw noChildrenAllowed(); | |||
} | |||
return defaultPatterns.createExclude(); | |||
} | |||
@@ -137,6 +165,10 @@ public class FileSet { | |||
* @param includes the string containing the include patterns | |||
*/ | |||
public void setIncludes(String includes) { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
defaultPatterns.setIncludes(includes); | |||
} | |||
@@ -147,6 +179,10 @@ public class FileSet { | |||
* @param excludes the string containing the exclude patterns | |||
*/ | |||
public void setExcludes(String excludes) { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
defaultPatterns.setExcludes(excludes); | |||
} | |||
@@ -156,6 +192,10 @@ public class FileSet { | |||
* @param incl The file to fetch the include patterns from. | |||
*/ | |||
public void setIncludesfile(File incl) throws BuildException { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
defaultPatterns.setIncludesfile(incl); | |||
} | |||
@@ -165,6 +205,10 @@ public class FileSet { | |||
* @param excl The file to fetch the exclude patterns from. | |||
*/ | |||
public void setExcludesfile(File excl) throws BuildException { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
defaultPatterns.setExcludesfile(excl); | |||
} | |||
@@ -176,6 +220,10 @@ public class FileSet { | |||
* shouldn't be used. | |||
*/ | |||
public void setDefaultexcludes(boolean useDefaultExcludes) { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
this.useDefaultExcludes = useDefaultExcludes; | |||
} | |||
@@ -183,6 +231,10 @@ public class FileSet { | |||
* Returns the directory scanner needed to access the files to process. | |||
*/ | |||
public DirectoryScanner getDirectoryScanner(Project p) { | |||
if (isReference()) { | |||
return getRef(p).getDirectoryScanner(p); | |||
} | |||
if (dir == null) { | |||
throw new BuildException("No directory specified for fileset."); | |||
} | |||
@@ -213,22 +265,32 @@ public class FileSet { | |||
for (int i=0; i<additionalPatterns.size(); i++) { | |||
Object o = additionalPatterns.elementAt(i); | |||
if (o instanceof PatternSet) { | |||
defaultPatterns.append((PatternSet) o); | |||
} else { | |||
Reference r = (Reference) o; | |||
o = r.getReferencedObject(p); | |||
if (o instanceof PatternSet) { | |||
defaultPatterns.append((PatternSet) o); | |||
} else { | |||
String msg = r.getRefId()+" doesn\'t denote a patternset"; | |||
throw new BuildException(msg); | |||
} | |||
} | |||
defaultPatterns.append((PatternSet) o, p); | |||
} | |||
ds.setIncludes(defaultPatterns.getIncludePatterns(p)); | |||
ds.setExcludes(defaultPatterns.getExcludePatterns(p)); | |||
if (useDefaultExcludes) ds.addDefaultExcludes(); | |||
} | |||
/** | |||
* Performs the check for circular references and returns the | |||
* referenced FileSet. | |||
*/ | |||
private FileSet getRef(Project p) { | |||
if (!checked) { | |||
Stack stk = new Stack(); | |||
stk.push(this); | |||
dieOnCircularReference(stk, p); | |||
} | |||
Object o = ref.getReferencedObject(p); | |||
if (!(o instanceof FileSet)) { | |||
String msg = ref.getRefId()+" doesn\'t denote a fileset"; | |||
throw new BuildException(msg); | |||
} else { | |||
return (FileSet) o; | |||
} | |||
} | |||
} |
@@ -95,15 +95,10 @@ import java.text.StringCharacterIterator; | |||
* @author <a href="mailto:stefan.bodewig@megabit.net">Stefan Bodewig</a> | |||
*/ | |||
public class Path implements Cloneable { | |||
public class Path extends DataType implements Cloneable { | |||
private Vector elements; | |||
private Project project; | |||
private boolean isReference = false; | |||
/** | |||
* Are we sure we don't hold circular references? | |||
*/ | |||
private boolean checked = true; | |||
public static Path systemClasspath = | |||
new Path(null, System.getProperty("java.class.path")); | |||
@@ -148,7 +143,7 @@ public class Path implements Cloneable { | |||
* <code>null</code> nor empty. | |||
*/ | |||
public void setLocation(File location) throws BuildException { | |||
if (isReference) { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
createPathElement().setLocation(location); | |||
@@ -160,32 +155,31 @@ public class Path implements Cloneable { | |||
* @param path the path definition. | |||
*/ | |||
public void setPath(String path) throws BuildException { | |||
if (isReference) { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
createPathElement().setPath(path); | |||
} | |||
/** | |||
* Makes this instance in effect a reference too another Path instance. | |||
* Makes this instance in effect a reference to another Path instance. | |||
* | |||
* <p>You must not set another attribute or nest elements inside | |||
* this element if you make it a reference. | |||
* this element if you make it a reference.</p> | |||
*/ | |||
public void setRefid(Reference r) throws BuildException { | |||
isReference = true; | |||
if (!elements.isEmpty()) { | |||
throw tooManyAttributes(); | |||
} | |||
elements.addElement(r); | |||
checked = false; | |||
super.setRefid(r); | |||
} | |||
/** | |||
* Creates the nested <pathelement> element. | |||
*/ | |||
public PathElement createPathElement() throws BuildException { | |||
if (isReference) { | |||
if (isReference()) { | |||
throw noChildrenAllowed(); | |||
} | |||
PathElement pe = new PathElement(); | |||
@@ -197,27 +191,18 @@ public class Path implements Cloneable { | |||
* Adds a nested <fileset> element. | |||
*/ | |||
public void addFileset(FileSet fs) throws BuildException { | |||
if (isReference) { | |||
if (isReference()) { | |||
throw noChildrenAllowed(); | |||
} | |||
elements.addElement(fs); | |||
} | |||
/** | |||
* Adds a nested <filesetref> element. | |||
*/ | |||
public void addFilesetRef(Reference r) throws BuildException { | |||
if (isReference) { | |||
throw noChildrenAllowed(); | |||
} | |||
elements.addElement(r); | |||
checked = false; | |||
} | |||
/** | |||
* Creates a nested <path> element. | |||
*/ | |||
public Path createPath() throws BuildException { | |||
if (isReference) { | |||
if (isReference()) { | |||
throw noChildrenAllowed(); | |||
} | |||
Path p = new Path(project); | |||
@@ -271,7 +256,7 @@ public class Path implements Cloneable { | |||
// make sure we don't have a circular reference here | |||
Stack stk = new Stack(); | |||
stk.push(this); | |||
bailOnCircularReference(stk); | |||
dieOnCircularReference(stk, project); | |||
} | |||
Vector result = new Vector(2*elements.size()); | |||
@@ -280,9 +265,9 @@ public class Path implements Cloneable { | |||
if (o instanceof Reference) { | |||
Reference r = (Reference) o; | |||
o = r.getReferencedObject(project); | |||
// we only support references to filesets and paths right now | |||
if (!(o instanceof FileSet) && !(o instanceof Path)) { | |||
String msg = r.getRefId()+" doesn\'t denote a fileset or path"; | |||
// we only support references to paths right now | |||
if (!(o instanceof Path)) { | |||
String msg = r.getRefId()+" doesn\'t denote a path"; | |||
throw new BuildException(msg); | |||
} | |||
} | |||
@@ -307,7 +292,7 @@ public class Path implements Cloneable { | |||
FileSet fs = (FileSet) o; | |||
DirectoryScanner ds = fs.getDirectoryScanner(project); | |||
String[] s = ds.getIncludedFiles(); | |||
File dir = fs.getDir(); | |||
File dir = fs.getDir(project); | |||
for (int j=0; j<s.length; j++) { | |||
addUnlessPresent(result, | |||
translateFile((new File(dir, s[j])).getAbsolutePath())); | |||
@@ -378,6 +363,11 @@ public class Path implements Cloneable { | |||
return result.toString(); | |||
} | |||
/** | |||
* Translates all occurrences of / or \ to correct separator of the | |||
* current platform and returns whether it had to do any | |||
* replacements. | |||
*/ | |||
protected static boolean translateFileSep(StringBuffer buffer, int pos) { | |||
if (buffer.charAt(pos) == '/' || buffer.charAt(pos) == '\\') { | |||
buffer.setCharAt(pos, File.separatorChar); | |||
@@ -393,26 +383,39 @@ public class Path implements Cloneable { | |||
return list().length; | |||
} | |||
/** | |||
* Return a Path that holds the same elements as this instance. | |||
*/ | |||
public Object clone() { | |||
Path p = new Path(project); | |||
p.append(this); | |||
return p; | |||
} | |||
protected void bailOnCircularReference(Stack stk) throws BuildException { | |||
/** | |||
* Overrides the version of DataType to recurse on all DataType | |||
* child elements that may have been added. | |||
*/ | |||
protected void dieOnCircularReference(Stack stk, Project p) | |||
throws BuildException { | |||
if (checked) { | |||
return; | |||
} | |||
Enumeration enum = elements.elements(); | |||
while (enum.hasMoreElements()) { | |||
Object o = enum.nextElement(); | |||
if (o instanceof Reference) { | |||
o = ((Reference) o).getReferencedObject(project); | |||
o = ((Reference) o).getReferencedObject(p); | |||
} | |||
if (o instanceof Path) { | |||
if (o instanceof DataType) { | |||
if (stk.contains(o)) { | |||
throw circularReference(); | |||
} else { | |||
stk.push(o); | |||
((Path) o).bailOnCircularReference(stk); | |||
((DataType) o).dieOnCircularReference(stk, p); | |||
stk.pop(); | |||
} | |||
} | |||
@@ -420,6 +423,11 @@ public class Path implements Cloneable { | |||
checked = true; | |||
} | |||
/** | |||
* Resolve a filename with Project's help - if we know one that is. | |||
* | |||
* <p>Assume the filename is absolute if project is null.</p> | |||
*/ | |||
private static String resolveFile(Project project, String relativeName) { | |||
if (project != null) { | |||
return project.resolveFile(relativeName).getAbsolutePath(); | |||
@@ -427,21 +435,13 @@ public class Path implements Cloneable { | |||
return relativeName; | |||
} | |||
/** | |||
* Adds a String to the Vector if it isn't already included. | |||
*/ | |||
private static void addUnlessPresent(Vector v, String s) { | |||
if (v.indexOf(s) == -1) { | |||
v.addElement(s); | |||
} | |||
} | |||
private BuildException tooManyAttributes() { | |||
return new BuildException("You must not specify more than one attribute when using refid"); | |||
} | |||
private BuildException noChildrenAllowed() { | |||
return new BuildException("You must not specify nested elements when using refid"); | |||
} | |||
private BuildException circularReference() { | |||
return new BuildException("This path contains a circular reference."); | |||
} | |||
} |
@@ -59,6 +59,7 @@ import org.apache.tools.ant.BuildException; | |||
import java.io.*; | |||
import java.util.Enumeration; | |||
import java.util.Stack; | |||
import java.util.StringTokenizer; | |||
import java.util.Vector; | |||
@@ -74,7 +75,7 @@ import java.util.Vector; | |||
* @author Jon S. Stevens <a href="mailto:jon@clearink.com">jon@clearink.com</a> | |||
* @author <a href="mailto:stefan.bodewig@megabit.net">Stefan Bodewig</a> | |||
*/ | |||
public class PatternSet { | |||
public class PatternSet extends DataType { | |||
private Vector includeList = new Vector(); | |||
private Vector excludeList = new Vector(); | |||
@@ -122,10 +123,27 @@ public class PatternSet { | |||
super(); | |||
} | |||
/** | |||
* Makes this instance in effect a reference to another PatternSet | |||
* instance. | |||
* | |||
* <p>You must not set another attribute or nest elements inside | |||
* this element if you make it a reference.</p> | |||
*/ | |||
public void setRefid(Reference r) throws BuildException { | |||
if (!includeList.isEmpty() || !excludeList.isEmpty()) { | |||
throw tooManyAttributes(); | |||
} | |||
super.setRefid(r); | |||
} | |||
/** | |||
* add a name entry on the include list | |||
*/ | |||
public NameEntry createInclude() { | |||
if (isReference()) { | |||
throw noChildrenAllowed(); | |||
} | |||
return addPatternToList(includeList); | |||
} | |||
@@ -133,6 +151,9 @@ public class PatternSet { | |||
* add a name entry on the exclude list | |||
*/ | |||
public NameEntry createExclude() { | |||
if (isReference()) { | |||
throw noChildrenAllowed(); | |||
} | |||
return addPatternToList(excludeList); | |||
} | |||
@@ -143,6 +164,9 @@ public class PatternSet { | |||
* @param includes the string containing the include patterns | |||
*/ | |||
public void setIncludes(String includes) { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
if (includes != null && includes.length() > 0) { | |||
StringTokenizer tok = new StringTokenizer(includes, ", ", false); | |||
while (tok.hasMoreTokens()) { | |||
@@ -158,6 +182,9 @@ public class PatternSet { | |||
* @param excludes the string containing the exclude patterns | |||
*/ | |||
public void setExcludes(String excludes) { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
if (excludes != null && excludes.length() > 0) { | |||
StringTokenizer tok = new StringTokenizer(excludes, ", ", false); | |||
while (tok.hasMoreTokens()) { | |||
@@ -181,6 +208,9 @@ public class PatternSet { | |||
* @param incl The file to fetch the include patterns from. | |||
*/ | |||
public void setIncludesfile(File incl) throws BuildException { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
if (!incl.exists()) { | |||
throw new BuildException("Includesfile "+incl.getAbsolutePath() | |||
+" not found."); | |||
@@ -195,6 +225,9 @@ public class PatternSet { | |||
* @param excl The file to fetch the exclude patterns from. | |||
*/ | |||
public void setExcludesfile(File excl) throws BuildException { | |||
if (isReference()) { | |||
throw tooManyAttributes(); | |||
} | |||
if (!excl.exists()) { | |||
throw new BuildException("Excludesfile "+excl.getAbsolutePath() | |||
+" not found."); | |||
@@ -234,12 +267,23 @@ public class PatternSet { | |||
/** | |||
* Adds the patterns of the other instance to this set. | |||
*/ | |||
public void append(PatternSet other) { | |||
for (int i=0; i<other.includeList.size(); i++) { | |||
includeList.addElement(other.includeList.elementAt(i)); | |||
public void append(PatternSet other, Project p) { | |||
if (isReference()) { | |||
throw new BuildException("Cannot append to a reference"); | |||
} | |||
String[] incl = other.getIncludePatterns(p); | |||
if (incl != null) { | |||
for (int i=0; i<incl.length; i++) { | |||
createInclude().setName(incl[i]); | |||
} | |||
} | |||
for (int i=0; i<other.excludeList.size(); i++) { | |||
excludeList.addElement(other.excludeList.elementAt(i)); | |||
String[] excl = other.getExcludePatterns(p); | |||
if (excl != null) { | |||
for (int i=0; i<excl.length; i++) { | |||
createExclude().setName(excl[i]); | |||
} | |||
} | |||
} | |||
@@ -247,14 +291,49 @@ public class PatternSet { | |||
* Returns the filtered include patterns. | |||
*/ | |||
public String[] getIncludePatterns(Project p) { | |||
return makeArray(includeList, p); | |||
if (isReference()) { | |||
return getRef(p).getIncludePatterns(p); | |||
} else { | |||
return makeArray(includeList, p); | |||
} | |||
} | |||
/** | |||
* Returns the filtered include patterns. | |||
*/ | |||
public String[] getExcludePatterns(Project p) { | |||
return makeArray(excludeList, p); | |||
if (isReference()) { | |||
return getRef(p).getExcludePatterns(p); | |||
} else { | |||
return makeArray(excludeList, p); | |||
} | |||
} | |||
/** | |||
* helper for FileSet. | |||
*/ | |||
int countPatterns() { | |||
return includeList.size() + excludeList.size(); | |||
} | |||
/** | |||
* Performs the check for circular references and returns the | |||
* referenced PatternSet. | |||
*/ | |||
private PatternSet getRef(Project p) { | |||
if (!checked) { | |||
Stack stk = new Stack(); | |||
stk.push(this); | |||
dieOnCircularReference(stk, p); | |||
} | |||
Object o = ref.getReferencedObject(p); | |||
if (!(o instanceof PatternSet)) { | |||
String msg = ref.getRefId()+" doesn\'t denote a patternset"; | |||
throw new BuildException(msg); | |||
} else { | |||
return (PatternSet) o; | |||
} | |||
} | |||
/** | |||
@@ -74,6 +74,8 @@ public class AllJUnitTests extends TestCase { | |||
suite.addTest(new TestSuite(CommandlineJavaTest.class)); | |||
suite.addTest(new TestSuite(EnumeratedAttributeTest.class)); | |||
suite.addTest(new TestSuite(PathTest.class)); | |||
suite.addTest(new TestSuite(PatternSetTest.class)); | |||
suite.addTest(new TestSuite(FileSetTest.class)); | |||
return suite; | |||
} | |||
} |
@@ -0,0 +1,235 @@ | |||
/* | |||
* The Apache Software License, Version 1.1 | |||
* | |||
* Copyright (c) 2000 The Apache Software Foundation. All rights | |||
* reserved. | |||
* | |||
* Redistribution and use in source and binary forms, with or without | |||
* modification, are permitted provided that the following conditions | |||
* are met: | |||
* | |||
* 1. Redistributions of source code must retain the above copyright | |||
* notice, this list of conditions and the following disclaimer. | |||
* | |||
* 2. Redistributions in binary form must reproduce the above copyright | |||
* notice, this list of conditions and the following disclaimer in | |||
* the documentation and/or other materials provided with the | |||
* distribution. | |||
* | |||
* 3. The end-user documentation included with the redistribution, if | |||
* any, must include the following acknowlegement: | |||
* "This product includes software developed by the | |||
* Apache Software Foundation (http://www.apache.org/)." | |||
* Alternately, this acknowlegement may appear in the software itself, | |||
* if and wherever such third-party acknowlegements normally appear. | |||
* | |||
* 4. The names "The Jakarta Project", "Tomcat", and "Apache Software | |||
* Foundation" must not be used to endorse or promote products derived | |||
* from this software without prior written permission. For written | |||
* permission, please contact apache@apache.org. | |||
* | |||
* 5. Products derived from this software may not be called "Apache" | |||
* nor may "Apache" appear in their names without prior written | |||
* permission of the Apache Group. | |||
* | |||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED | |||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | |||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR | |||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF | |||
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |||
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT | |||
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |||
* SUCH DAMAGE. | |||
* ==================================================================== | |||
* | |||
* This software consists of voluntary contributions made by many | |||
* individuals on behalf of the Apache Software Foundation. For more | |||
* information on the Apache Software Foundation, please see | |||
* <http://www.apache.org/>. | |||
*/ | |||
package org.apache.tools.ant.types; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.Project; | |||
import junit.framework.TestCase; | |||
import junit.framework.AssertionFailedError; | |||
import java.io.File; | |||
/** | |||
* JUnit 3 testcases for org.apache.tools.ant.types.FileSet. | |||
* | |||
* <p>This doesn't actually test much, mainly reference handling. | |||
* | |||
* @author <a href="mailto:stefan.bodewig@megabit.net">Stefan Bodewig</a> | |||
*/ | |||
public class FileSetTest extends TestCase { | |||
private Project project; | |||
public FileSetTest(String name) { | |||
super(name); | |||
} | |||
public void setUp() { | |||
project = new Project(); | |||
project.setBasedir("."); | |||
} | |||
public void testEmptyElementIfIsReference() { | |||
FileSet f = new FileSet(); | |||
f.setIncludes("**/*.java"); | |||
try { | |||
f.setRefid(new Reference("dummyref")); | |||
fail("Can add reference to FileSet with elements from setIncludes"); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
f = new FileSet(); | |||
f.createPatternSet(); | |||
try { | |||
f.setRefid(new Reference("dummyref")); | |||
fail("Can add reference to FileSet with nested patternset element."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify nested elements when using refid", | |||
be.getMessage()); | |||
} | |||
f = new FileSet(); | |||
f.createInclude(); | |||
try { | |||
f.setRefid(new Reference("dummyref")); | |||
fail("Can add reference to FileSet with nested include element."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
f = new FileSet(); | |||
f.setRefid(new Reference("dummyref")); | |||
try { | |||
f.setIncludes("**/*.java"); | |||
fail("Can set includes in FileSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
f.setIncludesfile(new File("/a")); | |||
fail("Can set includesfile in FileSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
f.setExcludes("**/*.java"); | |||
fail("Can set excludes in FileSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
f.setExcludesfile(new File("/a")); | |||
fail("Can set excludesfile in FileSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
f.setDir(project.resolveFile(".")); | |||
fail("Can set dir in FileSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
f.createInclude(); | |||
fail("Can add nested include in FileSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify nested elements when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
f.createExclude(); | |||
fail("Can add nested exclude in FileSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify nested elements when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
f.createPatternSet(); | |||
fail("Can add nested patternset in FileSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify nested elements when using refid", | |||
be.getMessage()); | |||
} | |||
} | |||
public void testCircularReferenceCheck() { | |||
FileSet f = new FileSet(); | |||
project.addReference("dummy", f); | |||
f.setRefid(new Reference("dummy")); | |||
try { | |||
f.getDir(project); | |||
fail("Can make FileSet a Reference to itself."); | |||
} catch (BuildException be) { | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
try { | |||
f.getDirectoryScanner(project); | |||
fail("Can make FileSet a Reference to itself."); | |||
} catch (BuildException be) { | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
// dummy1 --> dummy2 --> dummy3 --> dummy1 | |||
FileSet f1 = new FileSet(); | |||
project.addReference("dummy1", f1); | |||
f1.setRefid(new Reference("dummy2")); | |||
FileSet f2 = new FileSet(); | |||
project.addReference("dummy2", f2); | |||
f2.setRefid(new Reference("dummy3")); | |||
FileSet f3 = new FileSet(); | |||
project.addReference("dummy3", f3); | |||
f3.setRefid(new Reference("dummy1")); | |||
try { | |||
f1.getDir(project); | |||
fail("Can make circular reference."); | |||
} catch (BuildException be) { | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
try { | |||
f1.getDirectoryScanner(project); | |||
fail("Can make circular reference."); | |||
} catch (BuildException be) { | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
// dummy1 --> dummy2 --> dummy3 | |||
// (which has the Project's basedir as root). | |||
f1 = new FileSet(); | |||
project.addReference("dummy1", f1); | |||
f1.setRefid(new Reference("dummy2")); | |||
f2 = new FileSet(); | |||
project.addReference("dummy2", f2); | |||
f2.setRefid(new Reference("dummy3")); | |||
f3 = new FileSet(); | |||
project.addReference("dummy3", f3); | |||
f3.setDir(project.resolveFile(".")); | |||
File dir = f1.getDir(project); | |||
assertEquals("Die is basedir", dir, project.getBaseDir()); | |||
} | |||
} |
@@ -63,9 +63,9 @@ import junit.framework.AssertionFailedError; | |||
import java.io.File; | |||
/** | |||
* JUnit 3 testcases for org.apache.tools.ant.Path | |||
* JUnit 3 testcases for org.apache.tools.ant.types.Path | |||
* | |||
* @author Stefan Bodewig <a href="mailto:stefan.bodewig@megabit.net">stefan.bodewig@megabit.net</a> | |||
* @author <a href="mailto:stefan.bodewig@megabit.net">Stefan Bodewig</a> | |||
*/ | |||
public class PathTest extends TestCase { | |||
@@ -270,15 +270,6 @@ public class PathTest extends TestCase { | |||
assertEquals("You must not specify nested elements when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
p.addFilesetRef(new Reference("dummy2")); | |||
fail("Can add nested FileSetRef in Path that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify nested elements when using refid", | |||
be.getMessage()); | |||
} | |||
} | |||
public void testCircularReferenceCheck() { | |||
@@ -289,7 +280,7 @@ public class PathTest extends TestCase { | |||
p.list(); | |||
fail("Can make Path a Reference to itself."); | |||
} catch (BuildException be) { | |||
assertEquals("This path contains a circular reference.", | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
@@ -305,7 +296,7 @@ public class PathTest extends TestCase { | |||
p1.list(); | |||
fail("Can make circular reference."); | |||
} catch (BuildException be) { | |||
assertEquals("This path contains a circular reference.", | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
@@ -318,7 +309,7 @@ public class PathTest extends TestCase { | |||
project.addReference("dummy3", p3); | |||
p3.setLocation(new File("/a")); | |||
String[] l = p1.list(); | |||
assertEquals("One element burried deep inside a nested path structure", | |||
assertEquals("One element buried deep inside a nested path structure", | |||
1, l.length); | |||
if (isUnixStyle) { | |||
assertEquals("/a", l[0]); | |||
@@ -0,0 +1,211 @@ | |||
/* | |||
* The Apache Software License, Version 1.1 | |||
* | |||
* Copyright (c) 2000 The Apache Software Foundation. All rights | |||
* reserved. | |||
* | |||
* Redistribution and use in source and binary forms, with or without | |||
* modification, are permitted provided that the following conditions | |||
* are met: | |||
* | |||
* 1. Redistributions of source code must retain the above copyright | |||
* notice, this list of conditions and the following disclaimer. | |||
* | |||
* 2. Redistributions in binary form must reproduce the above copyright | |||
* notice, this list of conditions and the following disclaimer in | |||
* the documentation and/or other materials provided with the | |||
* distribution. | |||
* | |||
* 3. The end-user documentation included with the redistribution, if | |||
* any, must include the following acknowlegement: | |||
* "This product includes software developed by the | |||
* Apache Software Foundation (http://www.apache.org/)." | |||
* Alternately, this acknowlegement may appear in the software itself, | |||
* if and wherever such third-party acknowlegements normally appear. | |||
* | |||
* 4. The names "The Jakarta Project", "Tomcat", and "Apache Software | |||
* Foundation" must not be used to endorse or promote products derived | |||
* from this software without prior written permission. For written | |||
* permission, please contact apache@apache.org. | |||
* | |||
* 5. Products derived from this software may not be called "Apache" | |||
* nor may "Apache" appear in their names without prior written | |||
* permission of the Apache Group. | |||
* | |||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED | |||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | |||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR | |||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF | |||
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |||
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT | |||
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |||
* SUCH DAMAGE. | |||
* ==================================================================== | |||
* | |||
* This software consists of voluntary contributions made by many | |||
* individuals on behalf of the Apache Software Foundation. For more | |||
* information on the Apache Software Foundation, please see | |||
* <http://www.apache.org/>. | |||
*/ | |||
package org.apache.tools.ant.types; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.Project; | |||
import junit.framework.TestCase; | |||
import junit.framework.AssertionFailedError; | |||
import java.io.File; | |||
/** | |||
* JUnit 3 testcases for org.apache.tools.ant.types.PatternSet. | |||
* | |||
* <p>This doesn't actually test much, mainly reference handling. | |||
* | |||
* @author <a href="mailto:stefan.bodewig@megabit.net">Stefan Bodewig</a> | |||
*/ | |||
public class PatternSetTest extends TestCase { | |||
private Project project; | |||
public PatternSetTest(String name) { | |||
super(name); | |||
} | |||
public void setUp() { | |||
project = new Project(); | |||
project.setBasedir("."); | |||
} | |||
public void testEmptyElementIfIsReference() { | |||
PatternSet p = new PatternSet(); | |||
p.setIncludes("**/*.java"); | |||
try { | |||
p.setRefid(new Reference("dummyref")); | |||
fail("Can add reference to PatternSet with elements from setIncludes"); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
p = new PatternSet(); | |||
p.setRefid(new Reference("dummyref")); | |||
try { | |||
p.setIncludes("**/*.java"); | |||
fail("Can set includes in PatternSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
p = new PatternSet(); | |||
p.setRefid(new Reference("dummyref")); | |||
try { | |||
p.setIncludesfile(new File("/a")); | |||
fail("Can set includesfile in PatternSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
p.setExcludes("**/*.java"); | |||
fail("Can set excludes in PatternSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
p.setExcludesfile(new File("/a")); | |||
fail("Can set excludesfile in PatternSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify more than one attribute when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
p.createInclude(); | |||
fail("Can add nested include in PatternSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify nested elements when using refid", | |||
be.getMessage()); | |||
} | |||
try { | |||
p.createExclude(); | |||
fail("Can add nested exclude in PatternSet that is a reference."); | |||
} catch (BuildException be) { | |||
assertEquals("You must not specify nested elements when using refid", | |||
be.getMessage()); | |||
} | |||
} | |||
public void testCircularReferenceCheck() { | |||
PatternSet p = new PatternSet(); | |||
project.addReference("dummy", p); | |||
p.setRefid(new Reference("dummy")); | |||
try { | |||
p.getIncludePatterns(project); | |||
fail("Can make PatternSet a Reference to itself."); | |||
} catch (BuildException be) { | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
try { | |||
p.getExcludePatterns(project); | |||
fail("Can make PatternSet a Reference to itself."); | |||
} catch (BuildException be) { | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
// dummy1 --> dummy2 --> dummy3 --> dummy1 | |||
PatternSet p1 = new PatternSet(); | |||
project.addReference("dummy1", p1); | |||
p1.setRefid(new Reference("dummy2")); | |||
PatternSet p2 = new PatternSet(); | |||
project.addReference("dummy2", p2); | |||
p2.setRefid(new Reference("dummy3")); | |||
PatternSet p3 = new PatternSet(); | |||
project.addReference("dummy3", p3); | |||
p3.setRefid(new Reference("dummy1")); | |||
try { | |||
p1.getIncludePatterns(project); | |||
fail("Can make circular reference."); | |||
} catch (BuildException be) { | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
try { | |||
p1.getExcludePatterns(project); | |||
fail("Can make circular reference."); | |||
} catch (BuildException be) { | |||
assertEquals("This data type contains a circular reference.", | |||
be.getMessage()); | |||
} | |||
// dummy1 --> dummy2 --> dummy3 | |||
// (which holds patterns "include" and "exclude") | |||
p1 = new PatternSet(); | |||
project.addReference("dummy1", p1); | |||
p1.setRefid(new Reference("dummy2")); | |||
p2 = new PatternSet(); | |||
project.addReference("dummy2", p2); | |||
p2.setRefid(new Reference("dummy3")); | |||
p3 = new PatternSet(); | |||
project.addReference("dummy3", p3); | |||
p3.setIncludes("include"); | |||
p3.createExclude().setName("exclude"); | |||
String[] i = p1.getIncludePatterns(project); | |||
assertEquals("One include pattern buried deep inside a nested patternset structure", | |||
1, i.length); | |||
assertEquals("include", i[0]); | |||
i = p3.getExcludePatterns(project); | |||
assertEquals("One exclude pattern buried deep inside a nested patternset structure", | |||
1, i.length); | |||
assertEquals("exclude", i[0]); | |||
} | |||
} |