@@ -178,7 +178,7 @@ public class AntClassLoader extends ClassLoader implements SubBuildListener, Clo | |||
* The components of the classpath that the classloader searches | |||
* for classes. | |||
*/ | |||
private final Vector<File> pathComponents = new VectorSet<File>(); | |||
private final Vector<File> pathComponents = new VectorSet<>(); | |||
/** | |||
* The project to which this class loader belongs. | |||
@@ -196,14 +196,14 @@ public class AntClassLoader extends ClassLoader implements SubBuildListener, Clo | |||
* loader regardless of whether the parent class loader is being searched | |||
* first or not. | |||
*/ | |||
private final Vector<String> systemPackages = new Vector<String>(); | |||
private final Vector<String> systemPackages = new Vector<>(); | |||
/** | |||
* These are the package roots that are to be loaded by this class loader | |||
* regardless of whether the parent class loader is being searched first | |||
* or not. | |||
*/ | |||
private final Vector<String> loaderPackages = new Vector<String>(); | |||
private final Vector<String> loaderPackages = new Vector<>(); | |||
/** | |||
* Whether or not this classloader will ignore the base | |||
@@ -221,7 +221,7 @@ public class AntClassLoader extends ClassLoader implements SubBuildListener, Clo | |||
/** | |||
* A hashtable of zip files opened by the classloader (File to JarFile). | |||
*/ | |||
private Hashtable<File, JarFile> jarFiles = new Hashtable<File, JarFile>(); | |||
private Hashtable<File, JarFile> jarFiles = new Hashtable<>(); | |||
/** Static map of jar file/time to manifest class-path entries */ | |||
private static Map<String, String> pathMap = | |||
@@ -293,8 +293,8 @@ public class AntClassLoader extends ClassLoader implements SubBuildListener, Clo | |||
* classloader should be consulted before trying to | |||
* load the a class through this loader. | |||
*/ | |||
public AntClassLoader( | |||
final ClassLoader parent, final Project project, final Path classpath, final boolean parentFirst) { | |||
public AntClassLoader(final ClassLoader parent, final Project project, | |||
final Path classpath, final boolean parentFirst) { | |||
this(project, classpath); | |||
if (parent != null) { | |||
setParent(parent); | |||
@@ -315,7 +315,8 @@ public class AntClassLoader extends ClassLoader implements SubBuildListener, Clo | |||
* classloader should be consulted before trying to | |||
* load the a class through this loader. | |||
*/ | |||
public AntClassLoader(final Project project, final Path classpath, final boolean parentFirst) { | |||
public AntClassLoader(final Project project, final Path classpath, | |||
final boolean parentFirst) { | |||
this(null, project, classpath, parentFirst); | |||
} | |||
@@ -21,6 +21,7 @@ import java.io.BufferedReader; | |||
import java.io.IOException; | |||
import java.io.InputStream; | |||
import java.io.InputStreamReader; | |||
import java.io.UnsupportedEncodingException; | |||
import java.net.URL; | |||
import java.net.URLConnection; | |||
import java.util.ArrayList; | |||
@@ -151,7 +152,7 @@ public class ArgumentProcessorRegistry { | |||
try { | |||
try { | |||
isr = new InputStreamReader(is, "UTF-8"); | |||
} catch (java.io.UnsupportedEncodingException e) { | |||
} catch (UnsupportedEncodingException e) { | |||
isr = new InputStreamReader(is); | |||
} | |||
BufferedReader rd = new BufferedReader(isr); | |||
@@ -38,12 +38,25 @@ public class BuildException extends RuntimeException { | |||
* Constructs an exception with the given descriptive message. | |||
* | |||
* @param message A description of or information about the exception. | |||
* Should not be <code>null</code>. | |||
* Should not be {@code null}. | |||
*/ | |||
public BuildException(String message) { | |||
super(message); | |||
} | |||
/** | |||
* Constructs an exception with the given format pattern and arguments. | |||
* | |||
* @param pattern A description of or information about the exception. | |||
* Should not be {@code null}. | |||
* @param formatArguments | |||
* @see String#format(String, Object...) | |||
* @since Ant 1.11 | |||
*/ | |||
public BuildException(String pattern, Object... formatArguments) { | |||
super(String.format(pattern, formatArguments)); | |||
} | |||
/** | |||
* Constructs an exception with the given message and exception as | |||
* a root cause. | |||
@@ -59,31 +59,31 @@ import org.apache.tools.ant.util.FileUtils; | |||
*/ | |||
public class ComponentHelper { | |||
/** Map of component name to lists of restricted definitions */ | |||
private Map<String, List<AntTypeDefinition>> restrictedDefinitions = new HashMap<String, List<AntTypeDefinition>>(); | |||
private Map<String, List<AntTypeDefinition>> restrictedDefinitions = new HashMap<>(); | |||
/** Map from component name to anttypedefinition */ | |||
private final Hashtable<String, AntTypeDefinition> antTypeTable = new Hashtable<String, AntTypeDefinition>(); | |||
private final Hashtable<String, AntTypeDefinition> antTypeTable = new Hashtable<>(); | |||
/** Map of tasks generated from antTypeTable */ | |||
private final Hashtable<String, Class<?>> taskClassDefinitions = new Hashtable<String, Class<?>>(); | |||
private final Hashtable<String, Class<?>> taskClassDefinitions = new Hashtable<>(); | |||
/** flag to rebuild taskClassDefinitions */ | |||
private boolean rebuildTaskClassDefinitions = true; | |||
/** Map of types generated from antTypeTable */ | |||
private final Hashtable<String, Class<?>> typeClassDefinitions = new Hashtable<String, Class<?>>(); | |||
private final Hashtable<String, Class<?>> typeClassDefinitions = new Hashtable<>(); | |||
/** flag to rebuild typeClassDefinitions */ | |||
private boolean rebuildTypeClassDefinitions = true; | |||
/** Set of namespaces that have been checked for antlibs */ | |||
private final HashSet<String> checkedNamespaces = new HashSet<String>(); | |||
private final HashSet<String> checkedNamespaces = new HashSet<>(); | |||
/** | |||
* Stack of antlib contexts used to resolve definitions while | |||
* processing antlib | |||
*/ | |||
private Stack<String> antLibStack = new Stack<String>(); | |||
private Stack<String> antLibStack = new Stack<>(); | |||
/** current antlib uri */ | |||
private String antLibCurrentUri = null; | |||
@@ -189,7 +189,6 @@ public class ComponentHelper { | |||
*/ | |||
public void setProject(Project project) { | |||
this.project = project; | |||
// antTypeTable = new Hashtable<String, AntTypeDefinition>(project); | |||
} | |||
/** | |||
@@ -205,13 +204,13 @@ public class ComponentHelper { | |||
* @return A deep copy of the restrictredDefinition | |||
*/ | |||
private Map<String, List<AntTypeDefinition>> getRestrictedDefinition() { | |||
final Map<String, List<AntTypeDefinition>> result = new HashMap<String, List<AntTypeDefinition>>(); | |||
final Map<String, List<AntTypeDefinition>> result = new HashMap<>(); | |||
synchronized (restrictedDefinitions) { | |||
for (Map.Entry<String, List<AntTypeDefinition>> entry : restrictedDefinitions.entrySet()) { | |||
List<AntTypeDefinition> entryVal = entry.getValue(); | |||
synchronized (entryVal) { | |||
//copy the entryVal | |||
entryVal = new ArrayList<AntTypeDefinition> (entryVal); | |||
entryVal = new ArrayList<>(entryVal); | |||
} | |||
result.put(entry.getKey(), entryVal); | |||
} | |||
@@ -750,7 +749,7 @@ public class ComponentHelper { | |||
*/ | |||
public void exitAntLib() { | |||
antLibStack.pop(); | |||
antLibCurrentUri = (antLibStack.size() == 0) ? null : (String) antLibStack.peek(); | |||
antLibCurrentUri = (antLibStack.isEmpty()) ? null : (String) antLibStack.peek(); | |||
} | |||
/** | |||
@@ -759,9 +758,7 @@ public class ComponentHelper { | |||
private void initTasks() { | |||
ClassLoader classLoader = getClassLoader(null); | |||
Properties props = getDefaultDefinitions(false); | |||
Enumeration<?> e = props.propertyNames(); | |||
while (e.hasMoreElements()) { | |||
String name = (String) e.nextElement(); | |||
for (String name : props.stringPropertyNames()) { | |||
String className = props.getProperty(name); | |||
AntTypeDefinition def = new AntTypeDefinition(); | |||
def.setName(name); | |||
@@ -902,7 +899,7 @@ public class ComponentHelper { | |||
probablyIDE = true; | |||
antHomeLib = "ANT_HOME" + File.separatorChar + "lib"; | |||
} | |||
StringBuffer dirListingText = new StringBuffer(); | |||
StringBuilder dirListingText = new StringBuilder(); | |||
final String tab = " -"; | |||
dirListingText.append(tab); | |||
dirListingText.append(antHomeLib); | |||
@@ -1026,14 +1023,7 @@ public class ComponentHelper { | |||
+ " declarations have taken place."); | |||
if (uri.length() > 0) { | |||
final List<AntTypeDefinition> matches = findTypeMatches(uri); | |||
if (matches.size() > 0) { | |||
out.println(); | |||
out.println("The definitions in the namespace " + uri + " are:"); | |||
for (AntTypeDefinition def : matches) { | |||
String local = ProjectHelper.extractNameFromComponentName(def.getName()); | |||
out.println(" " + local); | |||
} | |||
} else { | |||
if (matches.isEmpty()) { | |||
out.println("No types or tasks have been defined in this namespace yet"); | |||
if (isAntlib) { | |||
out.println(); | |||
@@ -1041,6 +1031,13 @@ public class ComponentHelper { | |||
out.println("Action: Check that the implementing library exists in one of:"); | |||
out.println(dirListing); | |||
} | |||
} else { | |||
out.println(); | |||
out.println("The definitions in the namespace " + uri + " are:"); | |||
for (AntTypeDefinition def : matches) { | |||
String local = ProjectHelper.extractNameFromComponentName(def.getName()); | |||
out.println(" " + local); | |||
} | |||
} | |||
} | |||
} | |||
@@ -66,7 +66,6 @@ public final class DefaultDefinitions { | |||
private void componentDef(String ns, String name, String classname) { | |||
AntTypeDefinition def = new AntTypeDefinition(); | |||
String n = ProjectHelper.genComponentName(ns, name); | |||
def.setName(ProjectHelper.genComponentName(ns, name)); | |||
def.setClassName(classname); | |||
def.setClassLoader(getClass().getClassLoader()); | |||
@@ -24,9 +24,10 @@ import java.io.PrintStream; | |||
import java.io.StringReader; | |||
import java.text.DateFormat; | |||
import java.util.Date; | |||
import java.util.stream.Collectors; | |||
import java.util.stream.Stream; | |||
import org.apache.tools.ant.util.DateUtils; | |||
import org.apache.tools.ant.util.FileUtils; | |||
import org.apache.tools.ant.util.StringUtils; | |||
/** | |||
@@ -257,48 +258,30 @@ public class DefaultLogger implements BuildLogger { | |||
// Filter out messages based on priority | |||
if (priority <= msgOutputLevel) { | |||
StringBuffer message = new StringBuffer(); | |||
if (event.getTask() != null && !emacsMode) { | |||
StringBuilder message = new StringBuilder(); | |||
if (event.getTask() == null || emacsMode) { | |||
//emacs mode or there is no task | |||
message.append(event.getMessage()); | |||
} else { | |||
// Print out the name of the task if we're in one | |||
String name = event.getTask().getTaskName(); | |||
String label = "[" + name + "] "; | |||
int size = LEFT_COLUMN_SIZE - label.length(); | |||
StringBuffer tmp = new StringBuffer(); | |||
for (int i = 0; i < size; i++) { | |||
tmp.append(" "); | |||
} | |||
tmp.append(label); | |||
label = tmp.toString(); | |||
BufferedReader r = null; | |||
try { | |||
r = new BufferedReader( | |||
new StringReader(event.getMessage())); | |||
String line = r.readLine(); | |||
boolean first = true; | |||
do { | |||
if (first) { | |||
if (line == null) { | |||
message.append(label); | |||
break; | |||
} | |||
} else { | |||
message.append(StringUtils.LINE_SEP); | |||
} | |||
first = false; | |||
message.append(label).append(line); | |||
line = r.readLine(); | |||
} while (line != null); | |||
final String prefix = size > 0 ? Stream.generate(() -> " ") | |||
.limit(size).collect(Collectors.joining()) + label : label; | |||
try (BufferedReader r = | |||
new BufferedReader(new StringReader(event.getMessage()))) { | |||
message.append(r.lines().map(line -> prefix + line) | |||
.collect(Collectors.joining(StringUtils.LINE_SEP))); | |||
if (message.length() == 0) { | |||
message.append(prefix); | |||
} | |||
} catch (IOException e) { | |||
// shouldn't be possible | |||
message.append(label).append(event.getMessage()); | |||
} finally { | |||
FileUtils.close(r); | |||
} | |||
} else { | |||
//emacs mode or there is no task | |||
message.append(event.getMessage()); | |||
} | |||
Throwable ex = event.getException(); | |||
if (Project.MSG_DEBUG <= msgOutputLevel && ex != null) { | |||
@@ -361,8 +344,7 @@ public class DefaultLogger implements BuildLogger { | |||
protected String getTimestamp() { | |||
Date date = new Date(System.currentTimeMillis()); | |||
DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT); | |||
String finishTime = formatter.format(date); | |||
return finishTime; | |||
return formatter.format(date); | |||
} | |||
/** | |||
@@ -50,6 +50,7 @@ public class DemuxInputStream extends InputStream { | |||
* @return the next byte | |||
* @throws IOException on error | |||
*/ | |||
@Override | |||
public int read() throws IOException { | |||
byte[] buffer = new byte[1]; | |||
if (project.demuxInput(buffer, 0, 1) == -1) { | |||
@@ -67,6 +68,7 @@ public class DemuxInputStream extends InputStream { | |||
* @return the number of bytes read | |||
* @throws IOException on error | |||
*/ | |||
@Override | |||
public int read(byte[] buffer, int offset, int length) throws IOException { | |||
return project.demuxInput(buffer, offset, length); | |||
} | |||
@@ -64,7 +64,7 @@ public class DemuxOutputStream extends OutputStream { | |||
private static final int LF = 0x0a; | |||
/** Mapping from thread to buffer (Thread to BufferInfo). */ | |||
private WeakHashMap<Thread, BufferInfo> buffers = new WeakHashMap<Thread, BufferInfo>(); | |||
private WeakHashMap<Thread, BufferInfo> buffers = new WeakHashMap<>(); | |||
/** | |||
* The project to send output to. | |||
@@ -98,14 +98,12 @@ public class DemuxOutputStream extends OutputStream { | |||
*/ | |||
private BufferInfo getBufferInfo() { | |||
Thread current = Thread.currentThread(); | |||
BufferInfo bufferInfo = (BufferInfo) buffers.get(current); | |||
if (bufferInfo == null) { | |||
bufferInfo = new BufferInfo(); | |||
return buffers.computeIfAbsent(current, x -> { | |||
BufferInfo bufferInfo = new BufferInfo(); | |||
bufferInfo.buffer = new ByteArrayOutputStream(INITIAL_SIZE); | |||
bufferInfo.crSeen = false; | |||
buffers.put(current, bufferInfo); | |||
} | |||
return bufferInfo; | |||
return bufferInfo; | |||
}); | |||
} | |||
/** | |||
@@ -113,7 +111,7 @@ public class DemuxOutputStream extends OutputStream { | |||
*/ | |||
private void resetBufferInfo() { | |||
Thread current = Thread.currentThread(); | |||
BufferInfo bufferInfo = (BufferInfo) buffers.get(current); | |||
BufferInfo bufferInfo = buffers.get(current); | |||
FileUtils.close(bufferInfo.buffer); | |||
bufferInfo.buffer = new ByteArrayOutputStream(); | |||
bufferInfo.crSeen = false; | |||
@@ -134,6 +132,7 @@ public class DemuxOutputStream extends OutputStream { | |||
* @param cc data to log (byte). | |||
* @exception IOException if the data cannot be written to the stream | |||
*/ | |||
@Override | |||
public void write(int cc) throws IOException { | |||
final byte c = (byte) cc; | |||
@@ -192,6 +191,7 @@ public class DemuxOutputStream extends OutputStream { | |||
* | |||
* @see #flush | |||
*/ | |||
@Override | |||
public void close() throws IOException { | |||
flush(); | |||
removeBuffer(); | |||
@@ -203,6 +203,7 @@ public class DemuxOutputStream extends OutputStream { | |||
* | |||
* @exception IOException if there is a problem flushing the stream. | |||
*/ | |||
@Override | |||
public void flush() throws IOException { | |||
BufferInfo bufferInfo = getBufferInfo(); | |||
if (bufferInfo.buffer.size() > 0) { | |||
@@ -219,6 +220,7 @@ public class DemuxOutputStream extends OutputStream { | |||
* | |||
* @throws IOException if the data cannot be written into the stream. | |||
*/ | |||
@Override | |||
public void write(byte[] b, int off, int len) throws IOException { | |||
// find the line breaks and pass other chars through in blocks | |||
int offset = off; | |||
@@ -54,9 +54,6 @@ import org.xml.sax.XMLReader; | |||
*/ | |||
public final class Diagnostics { | |||
/** the version number for java 1.5 returned from JavaEnvUtils */ | |||
private static final int JAVA_1_5_NUMBER = 15; | |||
/** | |||
* value for which a difference between clock and temp file time triggers | |||
* a warning. | |||
@@ -113,8 +110,7 @@ public final class Diagnostics { | |||
if (home == null) { | |||
return null; | |||
} | |||
File libDir = new File(home, "lib"); | |||
return listJarFiles(libDir); | |||
return listJarFiles(new File(home, "lib")); | |||
} | |||
@@ -124,13 +120,8 @@ public final class Diagnostics { | |||
* @return array of files (or null for no such directory) | |||
*/ | |||
private static File[] listJarFiles(File libDir) { | |||
FilenameFilter filter = new FilenameFilter() { | |||
public boolean accept(File dir, String name) { | |||
return name.endsWith(".jar"); | |||
} | |||
}; | |||
File[] files = libDir.listFiles(filter); | |||
return files; | |||
return libDir | |||
.listFiles((FilenameFilter) (dir, name) -> name.endsWith(".jar")); | |||
} | |||
/** | |||
@@ -173,8 +164,7 @@ public final class Diagnostics { | |||
return "Could not create an XML Parser"; | |||
} | |||
// check to what is in the classname | |||
String saxParserName = saxParser.getClass().getName(); | |||
return saxParserName; | |||
return saxParser.getClass().getName(); | |||
} | |||
/** | |||
@@ -187,8 +177,7 @@ public final class Diagnostics { | |||
return "Could not create an XSLT Processor"; | |||
} | |||
// check to what is in the classname | |||
String processorName = transformer.getClass().getName(); | |||
return processorName; | |||
return transformer.getClass().getName(); | |||
} | |||
/** | |||
@@ -216,17 +205,15 @@ public final class Diagnostics { | |||
*/ | |||
private static Transformer getXSLTProcessor() { | |||
TransformerFactory transformerFactory = TransformerFactory.newInstance(); | |||
if (transformerFactory == null) { | |||
return null; | |||
} | |||
Transformer transformer = null; | |||
try { | |||
transformer = transformerFactory.newTransformer(); | |||
} catch (Exception e) { | |||
// ignore | |||
ignoreThrowable(e); | |||
if (transformerFactory != null) { | |||
try { | |||
return transformerFactory.newTransformer(); | |||
} catch (Exception e) { | |||
// ignore | |||
ignoreThrowable(e); | |||
} | |||
} | |||
return transformer; | |||
return null; | |||
} | |||
/** | |||
@@ -22,13 +22,17 @@ import java.io.File; | |||
import java.io.IOException; | |||
import java.util.ArrayList; | |||
import java.util.Arrays; | |||
import java.util.Collections; | |||
import java.util.Deque; | |||
import java.util.HashMap; | |||
import java.util.HashSet; | |||
import java.util.Iterator; | |||
import java.util.LinkedList; | |||
import java.util.List; | |||
import java.util.Map; | |||
import java.util.Set; | |||
import java.util.Vector; | |||
import java.util.function.Predicate; | |||
import java.util.stream.Stream; | |||
import org.apache.tools.ant.taskdefs.condition.Os; | |||
import org.apache.tools.ant.types.Resource; | |||
@@ -39,7 +43,6 @@ import org.apache.tools.ant.types.selectors.SelectorScanner; | |||
import org.apache.tools.ant.types.selectors.SelectorUtils; | |||
import org.apache.tools.ant.types.selectors.TokenizedPath; | |||
import org.apache.tools.ant.types.selectors.TokenizedPattern; | |||
import org.apache.tools.ant.util.CollectionUtils; | |||
import org.apache.tools.ant.util.FileUtils; | |||
import org.apache.tools.ant.util.SymbolicLinkUtils; | |||
import org.apache.tools.ant.util.VectorSet; | |||
@@ -217,7 +220,7 @@ public class DirectoryScanner | |||
* | |||
* @see #addDefaultExcludes() | |||
*/ | |||
private static final Set<String> defaultExcludes = new HashSet<String>(); | |||
private static final Set<String> defaultExcludes = new HashSet<>(); | |||
static { | |||
resetDefaultExcludes(); | |||
} | |||
@@ -310,7 +313,7 @@ public class DirectoryScanner | |||
* | |||
* @since Ant 1.6 | |||
*/ | |||
private final Set<String> scannedDirs = new HashSet<String>(); | |||
private final Set<String> scannedDirs = new HashSet<>(); | |||
/** | |||
* Map of all include patterns that are full file names and don't | |||
@@ -327,7 +330,7 @@ public class DirectoryScanner | |||
* | |||
* @since Ant 1.8.0 | |||
*/ | |||
private final Map<String, TokenizedPath> includeNonPatterns = new HashMap<String, TokenizedPath>(); | |||
private final Map<String, TokenizedPath> includeNonPatterns = new HashMap<>(); | |||
/** | |||
* Map of all exclude patterns that are full file names and don't | |||
@@ -344,7 +347,7 @@ public class DirectoryScanner | |||
* | |||
* @since Ant 1.8.0 | |||
*/ | |||
private final Map<String, TokenizedPath> excludeNonPatterns = new HashMap<String, TokenizedPath>(); | |||
private final Map<String, TokenizedPath> excludeNonPatterns = new HashMap<>(); | |||
/** | |||
* Array of all include patterns that contain wildcards. | |||
@@ -423,13 +426,7 @@ public class DirectoryScanner | |||
* | |||
* @since Ant 1.8.0 | |||
*/ | |||
private final Set<String> notFollowedSymlinks = new HashSet<String>(); | |||
/** | |||
* Sole constructor. | |||
*/ | |||
public DirectoryScanner() { | |||
} | |||
private final Set<String> notFollowedSymlinks = new HashSet<>(); | |||
/** | |||
* Test whether or not a given path matches the start of a given | |||
@@ -605,8 +602,8 @@ public class DirectoryScanner | |||
public static void resetDefaultExcludes() { | |||
synchronized (defaultExcludes) { | |||
defaultExcludes.clear(); | |||
for (int i = 0; i < DEFAULTEXCLUDES.length; i++) { | |||
defaultExcludes.add(DEFAULTEXCLUDES[i]); | |||
for (String element : DEFAULTEXCLUDES) { | |||
defaultExcludes.add(element); | |||
} | |||
} | |||
} | |||
@@ -619,8 +616,9 @@ public class DirectoryScanner | |||
* | |||
* @param basedir The base directory to scan. | |||
*/ | |||
@Override | |||
public void setBasedir(final String basedir) { | |||
setBasedir(basedir == null ? (File) null | |||
setBasedir(basedir == null ? null | |||
: new File(basedir.replace('/', File.separatorChar).replace( | |||
'\\', File.separatorChar))); | |||
} | |||
@@ -631,6 +629,7 @@ public class DirectoryScanner | |||
* | |||
* @param basedir The base directory for scanning. | |||
*/ | |||
@Override | |||
public synchronized void setBasedir(final File basedir) { | |||
this.basedir = basedir; | |||
} | |||
@@ -641,6 +640,7 @@ public class DirectoryScanner | |||
* | |||
* @return the base directory to be scanned. | |||
*/ | |||
@Override | |||
public synchronized File getBasedir() { | |||
return basedir; | |||
} | |||
@@ -662,6 +662,7 @@ public class DirectoryScanner | |||
* @param isCaseSensitive whether or not the file system should be | |||
* regarded as a case sensitive one. | |||
*/ | |||
@Override | |||
public synchronized void setCaseSensitive(final boolean isCaseSensitive) { | |||
this.isCaseSensitive = isCaseSensitive; | |||
} | |||
@@ -720,14 +721,13 @@ public class DirectoryScanner | |||
* list is given, all elements must be | |||
* non-<code>null</code>. | |||
*/ | |||
@Override | |||
public synchronized void setIncludes(final String[] includes) { | |||
if (includes == null) { | |||
this.includes = null; | |||
} else { | |||
this.includes = new String[includes.length]; | |||
for (int i = 0; i < includes.length; i++) { | |||
this.includes[i] = normalizePattern(includes[i]); | |||
} | |||
this.includes = Stream.of(includes) | |||
.map(DirectoryScanner::normalizePattern).toArray(String[]::new); | |||
} | |||
} | |||
@@ -743,14 +743,13 @@ public class DirectoryScanner | |||
* should be excluded. If a non-<code>null</code> list is | |||
* given, all elements must be non-<code>null</code>. | |||
*/ | |||
@Override | |||
public synchronized void setExcludes(final String[] excludes) { | |||
if (excludes == null) { | |||
this.excludes = null; | |||
} else { | |||
this.excludes = new String[excludes.length]; | |||
for (int i = 0; i < excludes.length; i++) { | |||
this.excludes[i] = normalizePattern(excludes[i]); | |||
} | |||
this.excludes = Stream.of(excludes) | |||
.map(DirectoryScanner::normalizePattern).toArray(String[]::new); | |||
} | |||
} | |||
@@ -769,18 +768,14 @@ public class DirectoryScanner | |||
*/ | |||
public synchronized void addExcludes(final String[] excludes) { | |||
if (excludes != null && excludes.length > 0) { | |||
if (this.excludes != null && this.excludes.length > 0) { | |||
final String[] tmp = new String[excludes.length | |||
+ this.excludes.length]; | |||
System.arraycopy(this.excludes, 0, tmp, 0, | |||
this.excludes.length); | |||
for (int i = 0; i < excludes.length; i++) { | |||
tmp[this.excludes.length + i] = | |||
normalizePattern(excludes[i]); | |||
} | |||
this.excludes = tmp; | |||
} else { | |||
if (this.excludes == null || this.excludes.length == 0) { | |||
setExcludes(excludes); | |||
} else { | |||
this.excludes = Stream | |||
.concat(Stream.of(this.excludes), | |||
Stream.of(excludes) | |||
.map(DirectoryScanner::normalizePattern)) | |||
.toArray(String[]::new); | |||
} | |||
} | |||
} | |||
@@ -808,6 +803,7 @@ public class DirectoryScanner | |||
* | |||
* @param selectors specifies the selectors to be invoked on a scan. | |||
*/ | |||
@Override | |||
public synchronized void setSelectors(final FileSelector[] selectors) { | |||
this.selectors = selectors; | |||
} | |||
@@ -833,6 +829,7 @@ public class DirectoryScanner | |||
* @exception IllegalStateException if the base directory was set | |||
* incorrectly (i.e. if it doesn't exist or isn't a directory). | |||
*/ | |||
@Override | |||
public void scan() throws IllegalStateException { | |||
synchronized (scanLock) { | |||
if (scanning) { | |||
@@ -857,10 +854,10 @@ public class DirectoryScanner | |||
clearResults(); | |||
// set in/excludes to reasonable defaults if needed: | |||
final boolean nullIncludes = (includes == null); | |||
final boolean nullIncludes = includes == null; | |||
includes = nullIncludes | |||
? new String[] {SelectorUtils.DEEP_TREE_MATCH} : includes; | |||
final boolean nullExcludes = (excludes == null); | |||
? new String[] { SelectorUtils.DEEP_TREE_MATCH } : includes; | |||
final boolean nullExcludes = excludes == null; | |||
excludes = nullExcludes ? new String[0] : excludes; | |||
if (basedir != null && !followSymlinks | |||
@@ -887,22 +884,19 @@ public class DirectoryScanner | |||
} else if (!basedir.isDirectory()) { | |||
illegal = new IllegalStateException("basedir " | |||
+ basedir | |||
+ " is not a" | |||
+ " directory."); | |||
+ " is not a directory."); | |||
} | |||
if (illegal != null) { | |||
throw illegal; | |||
} | |||
} | |||
if (isIncluded(TokenizedPath.EMPTY_PATH)) { | |||
if (!isExcluded(TokenizedPath.EMPTY_PATH)) { | |||
if (isSelected("", basedir)) { | |||
dirsIncluded.addElement(""); | |||
} else { | |||
dirsDeselected.addElement(""); | |||
} | |||
} else { | |||
if (isExcluded(TokenizedPath.EMPTY_PATH)) { | |||
dirsExcluded.addElement(""); | |||
} else if (isSelected("", basedir)) { | |||
dirsIncluded.addElement(""); | |||
} else { | |||
dirsDeselected.addElement(""); | |||
} | |||
} else { | |||
dirsNotIncluded.addElement(""); | |||
@@ -930,18 +924,19 @@ public class DirectoryScanner | |||
*/ | |||
private void checkIncludePatterns() { | |||
ensureNonPatternSetsReady(); | |||
final Map<TokenizedPath, String> newroots = new HashMap<TokenizedPath, String>(); | |||
final Map<TokenizedPath, String> newroots = new HashMap<>(); | |||
// put in the newroots map the include patterns without | |||
// wildcard tokens | |||
for (int i = 0; i < includePatterns.length; i++) { | |||
final String pattern = includePatterns[i].toString(); | |||
for (TokenizedPattern includePattern : includePatterns) { | |||
final String pattern = includePattern.toString(); | |||
if (!shouldSkipPattern(pattern)) { | |||
newroots.put(includePatterns[i].rtrimWildcardTokens(), | |||
newroots.put(includePattern.rtrimWildcardTokens(), | |||
pattern); | |||
} | |||
} | |||
for (final Map.Entry<String, TokenizedPath> entry : includeNonPatterns.entrySet()) { | |||
for (final Map.Entry<String, TokenizedPath> entry : includeNonPatterns | |||
.entrySet()) { | |||
final String pattern = entry.getKey(); | |||
if (!shouldSkipPattern(pattern)) { | |||
newroots.put(entry.getValue(), pattern); | |||
@@ -1046,10 +1041,9 @@ public class DirectoryScanner | |||
private boolean shouldSkipPattern(final String pattern) { | |||
if (FileUtils.isAbsolutePath(pattern)) { | |||
//skip abs. paths not under basedir, if set: | |||
if (basedir != null | |||
&& !SelectorUtils.matchPatternStart(pattern, | |||
basedir.getAbsolutePath(), | |||
isCaseSensitive())) { | |||
if (!(basedir == null || SelectorUtils.matchPatternStart(pattern, | |||
basedir.getAbsolutePath(), | |||
isCaseSensitive()))) { | |||
return true; | |||
} | |||
} else if (basedir == null) { | |||
@@ -1063,14 +1057,14 @@ public class DirectoryScanner | |||
* Clear the result caches for a scan. | |||
*/ | |||
protected synchronized void clearResults() { | |||
filesIncluded = new VectorSet<String>(); | |||
filesNotIncluded = new VectorSet<String>(); | |||
filesExcluded = new VectorSet<String>(); | |||
filesDeselected = new VectorSet<String>(); | |||
dirsIncluded = new VectorSet<String>(); | |||
dirsNotIncluded = new VectorSet<String>(); | |||
dirsExcluded = new VectorSet<String>(); | |||
dirsDeselected = new VectorSet<String>(); | |||
filesIncluded = new VectorSet<>(); | |||
filesNotIncluded = new VectorSet<>(); | |||
filesExcluded = new VectorSet<>(); | |||
filesDeselected = new VectorSet<>(); | |||
dirsIncluded = new VectorSet<>(); | |||
dirsNotIncluded = new VectorSet<>(); | |||
dirsExcluded = new VectorSet<>(); | |||
dirsDeselected = new VectorSet<>(); | |||
everythingIncluded = (basedir != null); | |||
scannedDirs.clear(); | |||
notFollowedSymlinks.clear(); | |||
@@ -1135,10 +1129,10 @@ public class DirectoryScanner | |||
} | |||
private void processSlowScan(final String[] arr) { | |||
for (int i = 0; i < arr.length; i++) { | |||
final TokenizedPath path = new TokenizedPath(arr[i]); | |||
for (String element : arr) { | |||
final TokenizedPath path = new TokenizedPath(element); | |||
if (!couldHoldIncluded(path) || contentsExcluded(path)) { | |||
scandir(new File(basedir, arr[i]), path, false); | |||
scandir(new File(basedir, element), path, false); | |||
} | |||
} | |||
} | |||
@@ -1196,17 +1190,17 @@ public class DirectoryScanner | |||
if (!dir.exists()) { | |||
throw new BuildException(dir + DOES_NOT_EXIST_POSTFIX); | |||
} else if (!dir.isDirectory()) { | |||
throw new BuildException(dir + " is not a directory."); | |||
throw new BuildException("%s is not a directory.", dir); | |||
} else { | |||
throw new BuildException("IO error scanning directory '" | |||
+ dir.getAbsolutePath() + "'"); | |||
throw new BuildException("IO error scanning directory '%s'", | |||
dir.getAbsolutePath()); | |||
} | |||
} | |||
scandir(dir, path, fast, newfiles, new LinkedList<String>()); | |||
} | |||
private void scandir(final File dir, final TokenizedPath path, final boolean fast, | |||
String[] newfiles, final LinkedList<String> directoryNamesFollowed) { | |||
String[] newfiles, final Deque<String> directoryNamesFollowed) { | |||
String vpath = path.toString(); | |||
if (vpath.length() > 0 && !vpath.endsWith(File.separator)) { | |||
vpath += File.separator; | |||
@@ -1217,12 +1211,12 @@ public class DirectoryScanner | |||
return; | |||
} | |||
if (!followSymlinks) { | |||
final ArrayList<String> noLinks = new ArrayList<String>(); | |||
for (int i = 0; i < newfiles.length; i++) { | |||
final ArrayList<String> noLinks = new ArrayList<>(); | |||
for (String newfile : newfiles) { | |||
try { | |||
if (SYMLINK_UTILS.isSymbolicLink(dir, newfiles[i])) { | |||
final String name = vpath + newfiles[i]; | |||
final File file = new File(dir, newfiles[i]); | |||
if (SYMLINK_UTILS.isSymbolicLink(dir, newfile)) { | |||
final String name = vpath + newfile; | |||
final File file = new File(dir, newfile); | |||
if (file.isDirectory()) { | |||
dirsExcluded.addElement(name); | |||
} else if (file.isFile()) { | |||
@@ -1230,17 +1224,17 @@ public class DirectoryScanner | |||
} | |||
accountForNotFollowedSymlink(name, file); | |||
} else { | |||
noLinks.add(newfiles[i]); | |||
noLinks.add(newfile); | |||
} | |||
} catch (final IOException ioe) { | |||
final String msg = "IOException caught while checking " | |||
+ "for links, couldn't get canonical path!"; | |||
// will be caught and redirected to Ant's logging system | |||
System.err.println(msg); | |||
noLinks.add(newfiles[i]); | |||
noLinks.add(newfile); | |||
} | |||
} | |||
newfiles = (noLinks.toArray(new String[noLinks.size()])); | |||
newfiles = noLinks.toArray(new String[noLinks.size()]); | |||
} else { | |||
directoryNamesFollowed.addFirst(dir.getName()); | |||
} | |||
@@ -1322,7 +1316,7 @@ public class DirectoryScanner | |||
private void accountForIncludedDir(final TokenizedPath name, | |||
final File file, final boolean fast, | |||
final String[] children, | |||
final LinkedList<String> directoryNamesFollowed) { | |||
final Deque<String> directoryNamesFollowed) { | |||
processIncluded(name, file, dirsIncluded, dirsExcluded, dirsDeselected); | |||
if (fast && couldHoldIncluded(name) && !contentsExcluded(name)) { | |||
scandir(file, name, fast, children, directoryNamesFollowed); | |||
@@ -1343,13 +1337,12 @@ public class DirectoryScanner | |||
} | |||
private void processIncluded(final TokenizedPath path, | |||
final File file, final Vector<String> inc, final Vector<String> exc, | |||
final Vector<String> des) { | |||
final File file, final List<String> inc, final List<String> exc, | |||
final List<String> des) { | |||
final String name = path.toString(); | |||
if (inc.contains(name) || exc.contains(name) || des.contains(name)) { | |||
return; | |||
} | |||
boolean included = false; | |||
if (isExcluded(path)) { | |||
exc.add(name); | |||
@@ -1385,17 +1378,13 @@ public class DirectoryScanner | |||
private boolean isIncluded(final TokenizedPath path) { | |||
ensureNonPatternSetsReady(); | |||
if (isCaseSensitive() | |||
? includeNonPatterns.containsKey(path.toString()) | |||
: includeNonPatterns.containsKey(path.toString().toUpperCase())) { | |||
return true; | |||
} | |||
for (int i = 0; i < includePatterns.length; i++) { | |||
if (includePatterns[i].matchPath(path, isCaseSensitive())) { | |||
return true; | |||
} | |||
String toMatch = path.toString(); | |||
if (!isCaseSensitive()) { | |||
toMatch = toMatch.toUpperCase(); | |||
} | |||
return false; | |||
return includeNonPatterns.containsKey(toMatch) | |||
|| Stream.of(includePatterns) | |||
.anyMatch(p -> p.matchPath(path, isCaseSensitive())); | |||
} | |||
/** | |||
@@ -1419,19 +1408,11 @@ public class DirectoryScanner | |||
* least one include pattern, or <code>false</code> otherwise. | |||
*/ | |||
private boolean couldHoldIncluded(final TokenizedPath tokenizedName) { | |||
for (int i = 0; i < includePatterns.length; i++) { | |||
if (couldHoldIncluded(tokenizedName, includePatterns[i])) { | |||
return true; | |||
} | |||
} | |||
for (final Iterator<TokenizedPath> iter = includeNonPatterns.values().iterator(); | |||
iter.hasNext();) { | |||
if (couldHoldIncluded(tokenizedName, | |||
iter.next().toPattern())) { | |||
return true; | |||
} | |||
} | |||
return false; | |||
return Stream | |||
.concat(Stream.of(includePatterns), | |||
includeNonPatterns.values().stream() | |||
.map(TokenizedPath::toPattern)) | |||
.anyMatch(pat -> couldHoldIncluded(tokenizedName, pat)); | |||
} | |||
/** | |||
@@ -1481,12 +1462,8 @@ public class DirectoryScanner | |||
private boolean isMorePowerfulThanExcludes(final String name) { | |||
final String soughtexclude = | |||
name + File.separatorChar + SelectorUtils.DEEP_TREE_MATCH; | |||
for (int counter = 0; counter < excludePatterns.length; counter++) { | |||
if (excludePatterns[counter].toString().equals(soughtexclude)) { | |||
return false; | |||
} | |||
} | |||
return true; | |||
return Stream.of(excludePatterns).map(Object::toString) | |||
.noneMatch(Predicate.isEqual(soughtexclude)); | |||
} | |||
/** | |||
@@ -1495,14 +1472,10 @@ public class DirectoryScanner | |||
* @return whether all the specified directory's contents are excluded. | |||
*/ | |||
/* package */ boolean contentsExcluded(final TokenizedPath path) { | |||
for (int i = 0; i < excludePatterns.length; i++) { | |||
if (excludePatterns[i].endsWith(SelectorUtils.DEEP_TREE_MATCH) | |||
&& excludePatterns[i].withoutLastToken() | |||
.matchPath(path, isCaseSensitive())) { | |||
return true; | |||
} | |||
} | |||
return false; | |||
return Stream.of(excludePatterns) | |||
.filter(p -> p.endsWith(SelectorUtils.DEEP_TREE_MATCH)) | |||
.map(TokenizedPattern::withoutLastToken) | |||
.anyMatch(wlt -> wlt.matchPath(path, isCaseSensitive())); | |||
} | |||
/** | |||
@@ -1528,17 +1501,13 @@ public class DirectoryScanner | |||
private boolean isExcluded(final TokenizedPath name) { | |||
ensureNonPatternSetsReady(); | |||
if (isCaseSensitive() | |||
? excludeNonPatterns.containsKey(name.toString()) | |||
: excludeNonPatterns.containsKey(name.toString().toUpperCase())) { | |||
return true; | |||
} | |||
for (int i = 0; i < excludePatterns.length; i++) { | |||
if (excludePatterns[i].matchPath(name, isCaseSensitive())) { | |||
return true; | |||
} | |||
String toMatch = name.toString(); | |||
if (!isCaseSensitive()) { | |||
toMatch = toMatch.toUpperCase(); | |||
} | |||
return false; | |||
return excludeNonPatterns.containsKey(toMatch) | |||
|| Stream.of(excludePatterns) | |||
.anyMatch(p -> p.matchPath(name, isCaseSensitive())); | |||
} | |||
/** | |||
@@ -1550,14 +1519,8 @@ public class DirectoryScanner | |||
* should not be selected, <code>true</code> otherwise. | |||
*/ | |||
protected boolean isSelected(final String name, final File file) { | |||
if (selectors != null) { | |||
for (int i = 0; i < selectors.length; i++) { | |||
if (!selectors[i].isSelected(basedir, name, file)) { | |||
return false; | |||
} | |||
} | |||
} | |||
return true; | |||
return selectors == null || Stream.of(selectors) | |||
.allMatch(sel -> sel.isSelected(basedir, name, file)); | |||
} | |||
/** | |||
@@ -1568,14 +1531,14 @@ public class DirectoryScanner | |||
* @return the names of the files which matched at least one of the | |||
* include patterns and none of the exclude patterns. | |||
*/ | |||
@Override | |||
public String[] getIncludedFiles() { | |||
String[] files; | |||
synchronized (this) { | |||
if (filesIncluded == null) { | |||
throw new IllegalStateException("Must call scan() first"); | |||
} | |||
files = new String[filesIncluded.size()]; | |||
filesIncluded.copyInto(files); | |||
files = filesIncluded.toArray(new String[filesIncluded.size()]); | |||
} | |||
Arrays.sort(files); | |||
return files; | |||
@@ -1603,11 +1566,10 @@ public class DirectoryScanner | |||
* | |||
* @see #slowScan | |||
*/ | |||
@Override | |||
public synchronized String[] getNotIncludedFiles() { | |||
slowScan(); | |||
final String[] files = new String[filesNotIncluded.size()]; | |||
filesNotIncluded.copyInto(files); | |||
return files; | |||
return filesNotIncluded.toArray(new String[filesNotIncluded.size()]); | |||
} | |||
/** | |||
@@ -1621,11 +1583,10 @@ public class DirectoryScanner | |||
* | |||
* @see #slowScan | |||
*/ | |||
@Override | |||
public synchronized String[] getExcludedFiles() { | |||
slowScan(); | |||
final String[] files = new String[filesExcluded.size()]; | |||
filesExcluded.copyInto(files); | |||
return files; | |||
return filesExcluded.toArray(new String[filesExcluded.size()]); | |||
} | |||
/** | |||
@@ -1639,11 +1600,10 @@ public class DirectoryScanner | |||
* | |||
* @see #slowScan | |||
*/ | |||
@Override | |||
public synchronized String[] getDeselectedFiles() { | |||
slowScan(); | |||
final String[] files = new String[filesDeselected.size()]; | |||
filesDeselected.copyInto(files); | |||
return files; | |||
return filesDeselected.toArray(new String[filesDeselected.size()]); | |||
} | |||
/** | |||
@@ -1654,14 +1614,14 @@ public class DirectoryScanner | |||
* @return the names of the directories which matched at least one of the | |||
* include patterns and none of the exclude patterns. | |||
*/ | |||
@Override | |||
public String[] getIncludedDirectories() { | |||
String[] directories; | |||
synchronized (this) { | |||
if (dirsIncluded == null) { | |||
throw new IllegalStateException("Must call scan() first"); | |||
} | |||
directories = new String[dirsIncluded.size()]; | |||
dirsIncluded.copyInto(directories); | |||
directories = dirsIncluded.toArray(new String[dirsIncluded.size()]); | |||
} | |||
Arrays.sort(directories); | |||
return directories; | |||
@@ -1689,11 +1649,10 @@ public class DirectoryScanner | |||
* | |||
* @see #slowScan | |||
*/ | |||
@Override | |||
public synchronized String[] getNotIncludedDirectories() { | |||
slowScan(); | |||
final String[] directories = new String[dirsNotIncluded.size()]; | |||
dirsNotIncluded.copyInto(directories); | |||
return directories; | |||
return dirsNotIncluded.toArray(new String[dirsNotIncluded.size()]); | |||
} | |||
/** | |||
@@ -1707,11 +1666,10 @@ public class DirectoryScanner | |||
* | |||
* @see #slowScan | |||
*/ | |||
@Override | |||
public synchronized String[] getExcludedDirectories() { | |||
slowScan(); | |||
final String[] directories = new String[dirsExcluded.size()]; | |||
dirsExcluded.copyInto(directories); | |||
return directories; | |||
return dirsExcluded.toArray(new String[dirsExcluded.size()]); | |||
} | |||
/** | |||
@@ -1725,11 +1683,10 @@ public class DirectoryScanner | |||
* | |||
* @see #slowScan | |||
*/ | |||
@Override | |||
public synchronized String[] getDeselectedDirectories() { | |||
slowScan(); | |||
final String[] directories = new String[dirsDeselected.size()]; | |||
dirsDeselected.copyInto(directories); | |||
return directories; | |||
return dirsDeselected.toArray(new String[dirsDeselected.size()]); | |||
} | |||
/** | |||
@@ -1754,20 +1711,15 @@ public class DirectoryScanner | |||
/** | |||
* Add default exclusions to the current exclusions set. | |||
*/ | |||
@Override | |||
public synchronized void addDefaultExcludes() { | |||
final int excludesLength = excludes == null ? 0 : excludes.length; | |||
String[] newExcludes; | |||
final String[] defaultExcludesTemp = getDefaultExcludes(); | |||
newExcludes = new String[excludesLength + defaultExcludesTemp.length]; | |||
if (excludesLength > 0) { | |||
System.arraycopy(excludes, 0, newExcludes, 0, excludesLength); | |||
} | |||
for (int i = 0; i < defaultExcludesTemp.length; i++) { | |||
newExcludes[i + excludesLength] = | |||
defaultExcludesTemp[i].replace('/', File.separatorChar) | |||
.replace('\\', File.separatorChar); | |||
Stream<String> s = Stream.of(getDefaultExcludes()) | |||
.map(p -> p.replace('/', File.separatorChar).replace('\\', | |||
File.separatorChar)); | |||
if (excludes != null) { | |||
s = Stream.concat(Stream.of(excludes), s); | |||
} | |||
excludes = newExcludes; | |||
excludes = s.toArray(String[]::new); | |||
} | |||
/** | |||
@@ -1777,6 +1729,7 @@ public class DirectoryScanner | |||
* @return the resource with the given name. | |||
* @since Ant 1.5.2 | |||
*/ | |||
@Override | |||
public synchronized Resource getResource(final String name) { | |||
return new FileResource(basedir, name); | |||
} | |||
@@ -1838,14 +1791,14 @@ public class DirectoryScanner | |||
* @since Ant 1.8.0 | |||
*/ | |||
private TokenizedPattern[] fillNonPatternSet(final Map<String, TokenizedPath> map, final String[] patterns) { | |||
final ArrayList<TokenizedPattern> al = new ArrayList<TokenizedPattern>(patterns.length); | |||
for (int i = 0; i < patterns.length; i++) { | |||
if (!SelectorUtils.hasWildcards(patterns[i])) { | |||
final List<TokenizedPattern> al = new ArrayList<>(patterns.length); | |||
for (String pattern : patterns) { | |||
if (SelectorUtils.hasWildcards(pattern)) { | |||
al.add(new TokenizedPattern(pattern)); | |||
} else { | |||
final String s = isCaseSensitive() | |||
? patterns[i] : patterns[i].toUpperCase(); | |||
? pattern : pattern.toUpperCase(); | |||
map.put(s, new TokenizedPath(s)); | |||
} else { | |||
al.add(new TokenizedPattern(patterns[i])); | |||
} | |||
} | |||
return al.toArray(new TokenizedPattern[al.size()]); | |||
@@ -1863,14 +1816,14 @@ public class DirectoryScanner | |||
* @since Ant 1.8.0 | |||
*/ | |||
private boolean causesIllegalSymlinkLoop(final String dirName, final File parent, | |||
final LinkedList<String> directoryNamesFollowed) { | |||
final Deque<String> directoryNamesFollowed) { | |||
try { | |||
if (directoryNamesFollowed.size() >= maxLevelsOfSymlinks | |||
&& CollectionUtils.frequency(directoryNamesFollowed, dirName) | |||
&& Collections.frequency(directoryNamesFollowed, dirName) | |||
>= maxLevelsOfSymlinks | |||
&& SYMLINK_UTILS.isSymbolicLink(parent, dirName)) { | |||
final ArrayList<String> files = new ArrayList<String>(); | |||
final List<String> files = new ArrayList<>(); | |||
File f = FILE_UTILS.resolveFile(parent, dirName); | |||
final String target = f.getCanonicalPath(); | |||
files.add(target); | |||
@@ -1882,18 +1835,17 @@ public class DirectoryScanner | |||
f = FILE_UTILS.resolveFile(parent, relPath + dir); | |||
files.add(f.getCanonicalPath()); | |||
if (files.size() > maxLevelsOfSymlinks | |||
&& CollectionUtils.frequency(files, target) | |||
&& Collections.frequency(files, target) | |||
> maxLevelsOfSymlinks) { | |||
return true; | |||
} | |||
} | |||
} | |||
} | |||
return false; | |||
} catch (final IOException ex) { | |||
throw new BuildException("Caught error while checking for" | |||
+ " symbolic links", ex); | |||
throw new BuildException( | |||
"Caught error while checking for symbolic links", ex); | |||
} | |||
} | |||
@@ -26,4 +26,3 @@ package org.apache.tools.ant; | |||
public interface DynamicConfigurator | |||
extends DynamicAttribute, DynamicElement { | |||
} | |||
@@ -17,13 +17,19 @@ | |||
*/ | |||
package org.apache.tools.ant; | |||
import java.util.function.Supplier; | |||
/** | |||
* Kind of task attribute that can be evaluated before being assigned | |||
* @param <T> as {@link Supplier} | |||
* | |||
* @see RuntimeConfigurable | |||
*/ | |||
public interface Evaluable { | |||
public interface Evaluable<T> extends Supplier<T> { | |||
Object eval(); | |||
T eval(); | |||
default T get() { | |||
return eval(); | |||
} | |||
} |
@@ -63,7 +63,7 @@ public final class IntrospectionHelper { | |||
/** | |||
* Helper instances we've already created (Class.getName() to IntrospectionHelper). | |||
*/ | |||
private static final Map<String, IntrospectionHelper> HELPERS = new Hashtable<String, IntrospectionHelper>(); | |||
private static final Map<String, IntrospectionHelper> HELPERS = new Hashtable<>(); | |||
/** | |||
* Map from primitive types to wrapper classes for use in | |||
@@ -71,7 +71,7 @@ public final class IntrospectionHelper { | |||
* and boolean are in here even though they get special treatment | |||
* - this way we only need to test for the wrapper class. | |||
*/ | |||
private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPE_MAP = new HashMap<Class<?>, Class<?>>(8); | |||
private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPE_MAP = new HashMap<>(8); | |||
// Set up PRIMITIVE_TYPE_MAP | |||
static { | |||
@@ -91,30 +91,30 @@ public final class IntrospectionHelper { | |||
* Map from attribute names to attribute types | |||
* (String to Class). | |||
*/ | |||
private final Hashtable<String, Class<?>> attributeTypes = new Hashtable<String, Class<?>>(); | |||
private final Map<String, Class<?>> attributeTypes = new Hashtable<>(); | |||
/** | |||
* Map from attribute names to attribute setter methods | |||
* (String to AttributeSetter). | |||
*/ | |||
private final Hashtable<String, AttributeSetter> attributeSetters = new Hashtable<String, AttributeSetter>(); | |||
private final Map<String, AttributeSetter> attributeSetters = new Hashtable<>(); | |||
/** | |||
* Map from attribute names to nested types | |||
* (String to Class). | |||
*/ | |||
private final Hashtable<String, Class<?>> nestedTypes = new Hashtable<String, Class<?>>(); | |||
private final Map<String, Class<?>> nestedTypes = new Hashtable<>(); | |||
/** | |||
* Map from attribute names to methods to create nested types | |||
* (String to NestedCreator). | |||
*/ | |||
private final Hashtable<String, NestedCreator> nestedCreators = new Hashtable<String, NestedCreator>(); | |||
private final Map<String, NestedCreator> nestedCreators = new Hashtable<>(); | |||
/** | |||
* Vector of methods matching add[Configured](Class) pattern. | |||
*/ | |||
private final List<Method> addTypeMethods = new ArrayList<Method>(); | |||
private final List<Method> addTypeMethods = new ArrayList<>(); | |||
/** | |||
* The method to invoke to add PCDATA. | |||
@@ -706,7 +706,7 @@ public final class IntrospectionHelper { | |||
* @return true if the given nested element is supported | |||
*/ | |||
public boolean supportsNestedElement(final String parentUri, final String elementName) { | |||
if (isDynamic() || addTypeMethods.size() > 0) { | |||
if (isDynamic() || !addTypeMethods.isEmpty()) { | |||
return true; | |||
} | |||
return supportsReflectElement(parentUri, elementName); | |||
@@ -731,7 +731,7 @@ public final class IntrospectionHelper { | |||
*/ | |||
public boolean supportsNestedElement(final String parentUri, final String elementName, | |||
final Project project, final Object parent) { | |||
if (addTypeMethods.size() > 0 | |||
if (!addTypeMethods.isEmpty() | |||
&& createAddTypeCreator(project, parent, elementName) != null) { | |||
return true; | |||
} | |||
@@ -944,7 +944,7 @@ public final class IntrospectionHelper { | |||
* @see #getAttributeMap | |||
*/ | |||
public Enumeration<String> getAttributes() { | |||
return attributeSetters.keys(); | |||
return Collections.enumeration(attributeSetters.keySet()); | |||
} | |||
/** | |||
@@ -968,7 +968,7 @@ public final class IntrospectionHelper { | |||
* @see #getNestedElementMap | |||
*/ | |||
public Enumeration<String> getNestedElements() { | |||
return nestedTypes.keys(); | |||
return Collections.enumeration(nestedTypes.keySet()); | |||
} | |||
/** | |||
@@ -1533,7 +1533,7 @@ public final class IntrospectionHelper { | |||
*/ | |||
private NestedCreator createAddTypeCreator( | |||
final Project project, final Object parent, final String elementName) throws BuildException { | |||
if (addTypeMethods.size() == 0) { | |||
if (addTypeMethods.isEmpty()) { | |||
return null; | |||
} | |||
final ComponentHelper helper = ComponentHelper.getComponentHelper(project); | |||
@@ -1602,7 +1602,7 @@ public final class IntrospectionHelper { | |||
for (int c = 0; c < size; ++c) { | |||
final Method current = addTypeMethods.get(c); | |||
if (current.getParameterTypes()[0].equals(argClass)) { | |||
if (method.getName().equals("addConfigured")) { | |||
if ("addConfigured".equals(method.getName())) { | |||
// add configured replaces the add method | |||
addTypeMethods.set(c, method); | |||
} | |||
@@ -19,6 +19,7 @@ | |||
package org.apache.tools.ant; | |||
import java.io.Serializable; | |||
import java.util.Objects; | |||
import org.apache.tools.ant.util.FileUtils; | |||
import org.xml.sax.Locator; | |||
@@ -131,8 +132,9 @@ public class Location implements Serializable { | |||
* <code>"fileName: "</code> if only the file name is known, | |||
* and the empty string for unknown locations. | |||
*/ | |||
@Override | |||
public String toString() { | |||
StringBuffer buf = new StringBuffer(); | |||
StringBuilder buf = new StringBuilder(); | |||
if (fileName != null) { | |||
buf.append(fileName); | |||
@@ -155,6 +157,7 @@ public class Location implements Serializable { | |||
* as this object. | |||
* @since Ant 1.6.3 | |||
*/ | |||
@Override | |||
public boolean equals(Object other) { | |||
if (this == other) { | |||
return true; | |||
@@ -173,7 +176,8 @@ public class Location implements Serializable { | |||
* @return a hash code value for this location. | |||
* @since Ant 1.6.3 | |||
*/ | |||
@Override | |||
public int hashCode() { | |||
return toString().hashCode(); | |||
return Objects.hash(fileName, lineNumber); | |||
} | |||
} |
@@ -87,16 +87,16 @@ public class Main implements AntMain { | |||
private PrintStream err = System.err; | |||
/** The build targets. */ | |||
private final Vector<String> targets = new Vector<String>(); | |||
private final Vector<String> targets = new Vector<>(); | |||
/** Set of properties that can be used by tasks. */ | |||
private final Properties definedProps = new Properties(); | |||
/** Names of classes to add as listeners to project. */ | |||
private final Vector<String> listeners = new Vector<String>(1); | |||
private final Vector<String> listeners = new Vector<>(1); | |||
/** File names of property files to load on startup. */ | |||
private final Vector<String> propertyFiles = new Vector<String>(1); | |||
private final Vector<String> propertyFiles = new Vector<>(1); | |||
/** Indicates whether this build is to support interactive input */ | |||
private boolean allowInput = true; | |||
@@ -155,17 +155,9 @@ public class Main implements AntMain { | |||
*/ | |||
private boolean proxy = false; | |||
private final Map<Class<?>, List<String>> extraArguments = new HashMap<Class<?>, List<String>>(); | |||
private static final GetProperty NOPROPERTIES = new GetProperty() { | |||
public Object getProperty(final String aName) { | |||
// No existing property takes precedence | |||
return null; | |||
} | |||
}; | |||
private final Map<Class<?>, List<String>> extraArguments = new HashMap<>(); | |||
private static final GetProperty NOPROPERTIES = aName -> null; | |||
/** | |||
* Prints the message of the Throwable if it (the message) is not | |||
@@ -569,8 +561,8 @@ public class Main implements AntMain { | |||
*/ | |||
final String arg = args[argPos]; | |||
String name = arg.substring(2, arg.length()); | |||
String value = null; | |||
final int posEq = name.indexOf("="); | |||
String value; | |||
final int posEq = name.indexOf('='); | |||
if (posEq > 0) { | |||
value = name.substring(posEq + 1); | |||
name = name.substring(0, posEq); | |||
@@ -1153,7 +1145,7 @@ public class Main implements AntMain { | |||
* @return the filtered targets. | |||
*/ | |||
private static Map<String, Target> removeDuplicateTargets(final Map<String, Target> targets) { | |||
final Map<Location, Target> locationMap = new HashMap<Location, Target>(); | |||
final Map<Location, Target> locationMap = new HashMap<>(); | |||
for (final Entry<String, Target> entry : targets.entrySet()) { | |||
final String name = entry.getKey(); | |||
final Target target = entry.getValue(); | |||
@@ -1168,7 +1160,7 @@ public class Main implements AntMain { | |||
target.getLocation(), target); // Smallest name wins | |||
} | |||
} | |||
final Map<String, Target> ret = new HashMap<String, Target>(); | |||
final Map<String, Target> ret = new HashMap<>(); | |||
for (final Target target : locationMap.values()) { | |||
ret.put(target.getName(), target); | |||
} | |||
@@ -1191,15 +1183,15 @@ public class Main implements AntMain { | |||
final Map<String, Target> ptargets = removeDuplicateTargets(project.getTargets()); | |||
// split the targets in top-level and sub-targets depending | |||
// on the presence of a description | |||
final Vector<String> topNames = new Vector<String>(); | |||
final Vector<String> topDescriptions = new Vector<String>(); | |||
final Vector<Enumeration<String>> topDependencies = new Vector<Enumeration<String>>(); | |||
final Vector<String> subNames = new Vector<String>(); | |||
final Vector<Enumeration<String>> subDependencies = new Vector<Enumeration<String>>(); | |||
final Vector<String> topNames = new Vector<>(); | |||
final Vector<String> topDescriptions = new Vector<>(); | |||
final Vector<Enumeration<String>> topDependencies = new Vector<>(); | |||
final Vector<String> subNames = new Vector<>(); | |||
final Vector<Enumeration<String>> subDependencies = new Vector<>(); | |||
for (final Target currentTarget : ptargets.values()) { | |||
final String targetName = currentTarget.getName(); | |||
if (targetName.equals("")) { | |||
if ("".equals(targetName)) { | |||
continue; | |||
} | |||
final String targetDescription = currentTarget.getDescription(); | |||
@@ -1227,7 +1219,7 @@ public class Main implements AntMain { | |||
"Main targets:", maxLength); | |||
//if there were no main targets, we list all subtargets | |||
//as it means nothing has a description | |||
if (topNames.size() == 0) { | |||
if (topNames.isEmpty()) { | |||
printSubTargets = true; | |||
} | |||
if (printSubTargets) { | |||
@@ -127,7 +127,7 @@ public class PathTokenizer { | |||
} else { | |||
// we are on NetWare, tokenizing is handled a little differently, | |||
// due to the fact that NetWare has multiple-character volume names. | |||
if (token.equals(File.pathSeparator) || token.equals(":")) { | |||
if (token.equals(File.pathSeparator) || ":".equals(token)) { | |||
// ignore ";" and get the next token | |||
token = tokenizer.nextToken().trim(); | |||
} | |||
@@ -138,7 +138,7 @@ public class PathTokenizer { | |||
// make sure we aren't going to get the path separator next | |||
if (!nextToken.equals(File.pathSeparator)) { | |||
if (nextToken.equals(":")) { | |||
if (":".equals(nextToken)) { | |||
if (!token.startsWith("/") && !token.startsWith("\\") | |||
&& !token.startsWith(".") | |||
&& !token.startsWith("..")) { | |||
@@ -163,4 +163,3 @@ public class PathTokenizer { | |||
return token; | |||
} | |||
} | |||
@@ -144,13 +144,13 @@ public class Project implements ResourceFactory { | |||
private final Hashtable<String, Object> references = new AntRefTable(); | |||
/** Map of id references - used for indicating broken build files */ | |||
private final HashMap<String, Object> idReferences = new HashMap<String, Object>(); | |||
private final HashMap<String, Object> idReferences = new HashMap<>(); | |||
/** Name of the project's default target. */ | |||
private String defaultTarget; | |||
/** Map from target names to targets (String to Target). */ | |||
private final Hashtable<String, Target> targets = new Hashtable<String, Target>(); | |||
private final Hashtable<String, Target> targets = new Hashtable<>(); | |||
/** Set of global filters. */ | |||
private final FilterSet globalFilterSet = new FilterSet(); | |||
@@ -193,11 +193,11 @@ public class Project implements ResourceFactory { | |||
/** Records the latest task to be executed on a thread. */ | |||
private final Map<Thread,Task> threadTasks = | |||
Collections.synchronizedMap(new WeakHashMap<Thread, Task>()); | |||
Collections.synchronizedMap(new WeakHashMap<>()); | |||
/** Records the latest task to be executed on a thread group. */ | |||
private final Map<ThreadGroup,Task> threadGroupTasks | |||
= Collections.synchronizedMap(new WeakHashMap<ThreadGroup,Task>()); | |||
= Collections.synchronizedMap(new WeakHashMap<>()); | |||
/** | |||
* Called to handle any input requests. | |||
@@ -437,7 +437,7 @@ public class Project implements ResourceFactory { | |||
*/ | |||
public Vector<BuildListener> getBuildListeners() { | |||
synchronized (listenersLock) { | |||
final Vector<BuildListener> r = new Vector<BuildListener>(listeners.length); | |||
final Vector<BuildListener> r = new Vector<>(listeners.length); | |||
for (int i = 0; i < listeners.length; i++) { | |||
r.add(listeners[i]); | |||
} | |||
@@ -1046,7 +1046,7 @@ public class Project implements ResourceFactory { | |||
* @since Ant 1.8.1 | |||
*/ | |||
public Map<String, Class<?>> getCopyOfTaskDefinitions() { | |||
return new HashMap<String, Class<?>>(getTaskDefinitions()); | |||
return new HashMap<>(getTaskDefinitions()); | |||
} | |||
/** | |||
@@ -1088,7 +1088,7 @@ public class Project implements ResourceFactory { | |||
* @since Ant 1.8.1 | |||
*/ | |||
public Map<String, Class<?>> getCopyOfDataTypeDefinitions() { | |||
return new HashMap<String, Class<?>>(getDataTypeDefinitions()); | |||
return new HashMap<>(getDataTypeDefinitions()); | |||
} | |||
/** | |||
@@ -1168,7 +1168,7 @@ public class Project implements ResourceFactory { | |||
* @since Ant 1.8.1 | |||
*/ | |||
public Map<String, Target> getCopyOfTargets() { | |||
return new HashMap<String, Target>(targets); | |||
return new HashMap<>(targets); | |||
} | |||
/** | |||
@@ -1273,12 +1273,10 @@ public class Project implements ResourceFactory { | |||
final Task task = getThreadTask(Thread.currentThread()); | |||
if (task == null) { | |||
log(output, isWarning ? MSG_WARN : MSG_INFO); | |||
} else if (isWarning) { | |||
task.handleErrorOutput(output); | |||
} else { | |||
if (isWarning) { | |||
task.handleErrorOutput(output); | |||
} else { | |||
task.handleOutput(output); | |||
} | |||
task.handleOutput(output); | |||
} | |||
} | |||
@@ -1297,12 +1295,11 @@ public class Project implements ResourceFactory { | |||
*/ | |||
public int defaultInput(final byte[] buffer, final int offset, final int length) | |||
throws IOException { | |||
if (defaultInputStream != null) { | |||
System.out.flush(); | |||
return defaultInputStream.read(buffer, offset, length); | |||
} else { | |||
if (defaultInputStream == null) { | |||
throw new EOFException("No input provided for project"); | |||
} | |||
System.out.flush(); | |||
return defaultInputStream.read(buffer, offset, length); | |||
} | |||
/** | |||
@@ -1322,9 +1319,8 @@ public class Project implements ResourceFactory { | |||
final Task task = getThreadTask(Thread.currentThread()); | |||
if (task == null) { | |||
return defaultInput(buffer, offset, length); | |||
} else { | |||
return task.handleInput(buffer, offset, length); | |||
} | |||
return task.handleInput(buffer, offset, length); | |||
} | |||
/** | |||
@@ -1342,12 +1338,10 @@ public class Project implements ResourceFactory { | |||
final Task task = getThreadTask(Thread.currentThread()); | |||
if (task == null) { | |||
fireMessageLogged(this, output, isError ? MSG_ERR : MSG_INFO); | |||
} else if (isError) { | |||
task.handleErrorFlush(output); | |||
} else { | |||
if (isError) { | |||
task.handleErrorFlush(output); | |||
} else { | |||
task.handleFlush(output); | |||
} | |||
task.handleFlush(output); | |||
} | |||
} | |||
@@ -1383,7 +1377,7 @@ public class Project implements ResourceFactory { | |||
*/ | |||
public void executeSortedTargets(final Vector<Target> sortedTargets) | |||
throws BuildException { | |||
final Set<String> succeededTargets = new HashSet<String>(); | |||
final Set<String> succeededTargets = new HashSet<>(); | |||
BuildException buildException = null; // first build exception | |||
for (final Target curtarget : sortedTargets) { | |||
boolean canExecute = true; | |||
@@ -1749,9 +1743,9 @@ public class Project implements ResourceFactory { | |||
return ((ProjectComponent) o).getProject(); | |||
} | |||
try { | |||
final Method m = o.getClass().getMethod("getProject", (Class[]) null); | |||
if (Project.class == m.getReturnType()) { | |||
return (Project) m.invoke(o, (Object[]) null); | |||
final Method m = o.getClass().getMethod("getProject"); | |||
if (Project.class.equals(m.getReturnType())) { | |||
return (Project) m.invoke(o); | |||
} | |||
} catch (final Exception e) { | |||
//too bad | |||
@@ -1819,9 +1813,9 @@ public class Project implements ResourceFactory { | |||
*/ | |||
public final Vector<Target> topoSort(final String[] root, final Hashtable<String, Target> targetTable, | |||
final boolean returnAll) throws BuildException { | |||
final Vector<Target> ret = new VectorSet<Target>(); | |||
final Hashtable<String, String> state = new Hashtable<String, String>(); | |||
final Stack<String> visiting = new Stack<String>(); | |||
final Vector<Target> ret = new VectorSet<>(); | |||
final Hashtable<String, String> state = new Hashtable<>(); | |||
final Stack<String> visiting = new Stack<>(); | |||
// We first run a DFS based sort using each root as a starting node. | |||
// This creates the minimum sequence of Targets to the root node(s). | |||
@@ -1832,7 +1826,7 @@ public class Project implements ResourceFactory { | |||
// build Target. | |||
for (int i = 0; i < root.length; i++) { | |||
final String st = (state.get(root[i])); | |||
final String st = state.get(root[i]); | |||
if (st == null) { | |||
tsort(root[i], targetTable, state, visiting, ret); | |||
} else if (st == VISITING) { | |||
@@ -1840,7 +1834,7 @@ public class Project implements ResourceFactory { | |||
+ root[i]); | |||
} | |||
} | |||
final StringBuffer buf = new StringBuffer("Build sequence for target(s)"); | |||
final StringBuilder buf = new StringBuilder("Build sequence for target(s)"); | |||
for (int j = 0; j < root.length; j++) { | |||
buf.append((j == 0) ? " `" : ", `").append(root[j]).append('\''); | |||
@@ -1848,7 +1842,7 @@ public class Project implements ResourceFactory { | |||
buf.append(" is ").append(ret); | |||
log(buf.toString(), MSG_VERBOSE); | |||
final Vector<Target> complete = (returnAll) ? ret : new Vector<Target>(ret); | |||
final Vector<Target> complete = (returnAll) ? ret : new Vector<>(ret); | |||
for (final Enumeration<String> en = targetTable.keys(); en.hasMoreElements();) { | |||
final String curTarget = en.nextElement(); | |||
final String st = state.get(curTarget); | |||
@@ -2035,7 +2029,7 @@ public class Project implements ResourceFactory { | |||
* @since Ant 1.8.1 | |||
*/ | |||
public Map<String, Object> getCopyOfReferences() { | |||
return new HashMap<String, Object>(references); | |||
return new HashMap<>(references); | |||
} | |||
/** | |||
@@ -2488,6 +2482,7 @@ public class Project implements ResourceFactory { | |||
* @return the file resource. | |||
* @since Ant 1.7 | |||
*/ | |||
@Override | |||
public Resource getResource(final String name) { | |||
return new FileResource(getBaseDir(), name); | |||
} | |||
@@ -160,6 +160,7 @@ public abstract class ProjectComponent implements Cloneable { | |||
* @throws CloneNotSupportedException does not happen, | |||
* but is declared to allow subclasses to do so. | |||
*/ | |||
@Override | |||
public Object clone() throws CloneNotSupportedException { | |||
ProjectComponent pc = (ProjectComponent) super.clone(); | |||
pc.setLocation(getLocation()); | |||
@@ -146,16 +146,12 @@ public class ProjectHelper { | |||
} | |||
} | |||
/** Default constructor */ | |||
public ProjectHelper() { | |||
} | |||
// -------------------- Common properties -------------------- | |||
// The following properties are required by import ( and other tasks | |||
// that read build files using ProjectHelper ). | |||
private Vector<Object> importStack = new Vector<Object>(); | |||
private List<String[]> extensionStack = new LinkedList<String[]>(); | |||
private Vector<Object> importStack = new Vector<>(); | |||
private List<String[]> extensionStack = new LinkedList<>(); | |||
/** | |||
* Import stack. | |||
@@ -181,7 +177,7 @@ public class ProjectHelper { | |||
return extensionStack; | |||
} | |||
private static final ThreadLocal<String> targetPrefix = new ThreadLocal<String>(); | |||
private static final ThreadLocal<String> targetPrefix = new ThreadLocal<>(); | |||
/** | |||
* The prefix to prepend to imported target names. | |||
@@ -292,7 +288,7 @@ public class ProjectHelper { | |||
* @see org.apache.tools.ant.ProjectHelperRepository#getHelpers() | |||
*/ | |||
public static ProjectHelper getProjectHelper() { | |||
return (ProjectHelper) ProjectHelperRepository.getInstance().getHelpers().next(); | |||
return ProjectHelperRepository.getInstance().getHelpers().next(); | |||
} | |||
/** | |||
@@ -496,7 +492,7 @@ public class ProjectHelper { | |||
* @return The stringified form of the ns name | |||
*/ | |||
public static String genComponentName(String uri, String name) { | |||
if (uri == null || uri.equals("") || uri.equals(ANT_CORE_URI)) { | |||
if (uri == null || "".equals(uri) || uri.equals(ANT_CORE_URI)) { | |||
return name; | |||
} | |||
return uri + ":" + name; | |||
@@ -27,6 +27,7 @@ import java.util.ArrayList; | |||
import java.util.Enumeration; | |||
import java.util.Iterator; | |||
import java.util.List; | |||
import java.util.stream.Stream; | |||
import org.apache.tools.ant.helper.ProjectHelper2; | |||
import org.apache.tools.ant.types.Resource; | |||
@@ -53,7 +54,7 @@ public class ProjectHelperRepository { | |||
private static ProjectHelperRepository instance = | |||
new ProjectHelperRepository(); | |||
private List<Constructor<? extends ProjectHelper>> helpers = new ArrayList<Constructor<? extends ProjectHelper>>(); | |||
private List<Constructor<? extends ProjectHelper>> helpers = new ArrayList<>(); | |||
private static Constructor<ProjectHelper2> PROJECTHELPER2_CONSTRUCTOR; | |||
@@ -298,40 +299,15 @@ public class ProjectHelperRepository { | |||
* @return an iterator of {@link ProjectHelper} | |||
*/ | |||
public Iterator<ProjectHelper> getHelpers() { | |||
return new ConstructingIterator(helpers.iterator()); | |||
} | |||
private static class ConstructingIterator implements Iterator<ProjectHelper> { | |||
private final Iterator<Constructor<? extends ProjectHelper>> nested; | |||
private boolean empty = false; | |||
ConstructingIterator(Iterator<Constructor<? extends ProjectHelper>> nested) { | |||
this.nested = nested; | |||
} | |||
public boolean hasNext() { | |||
return nested.hasNext() || !empty; | |||
} | |||
public ProjectHelper next() { | |||
Constructor<? extends ProjectHelper> c; | |||
if (nested.hasNext()) { | |||
c = nested.next(); | |||
} else { | |||
// last but not least, ant default project helper | |||
empty = true; | |||
c = PROJECTHELPER2_CONSTRUCTOR; | |||
} | |||
Stream.Builder<Constructor<? extends ProjectHelper>> b = Stream.builder(); | |||
helpers.forEach(b::add); | |||
return b.add(PROJECTHELPER2_CONSTRUCTOR).build().map(c -> { | |||
try { | |||
return c.newInstance(); | |||
} catch (Exception e) { | |||
throw new BuildException("Failed to invoke no-arg constructor" | |||
+ " on " + c.getName()); | |||
+ " on " + c.getName()); | |||
} | |||
} | |||
public void remove() { | |||
throw new UnsupportedOperationException("remove is not supported"); | |||
} | |||
}).map(ProjectHelper.class::cast).iterator(); | |||
} | |||
} |
@@ -17,7 +17,6 @@ | |||
*/ | |||
package org.apache.tools.ant; | |||
import java.text.ParsePosition; | |||
import java.util.ArrayList; | |||
import java.util.Collection; | |||
import java.util.Collections; | |||
@@ -30,7 +29,6 @@ import java.util.Vector; | |||
import org.apache.tools.ant.property.GetProperty; | |||
import org.apache.tools.ant.property.NullReturn; | |||
import org.apache.tools.ant.property.ParseNextProperty; | |||
import org.apache.tools.ant.property.ParseProperties; | |||
import org.apache.tools.ant.property.PropertyExpander; | |||
@@ -184,52 +182,41 @@ public class PropertyHelper implements GetProperty { | |||
} | |||
}; | |||
private static final PropertyExpander DEFAULT_EXPANDER = new PropertyExpander() { | |||
public String parsePropertyName( | |||
String s, ParsePosition pos, ParseNextProperty notUsed) { | |||
private static final PropertyExpander DEFAULT_EXPANDER = | |||
(s, pos, notUsed) -> { | |||
int index = pos.getIndex(); | |||
//directly check near, triggering characters: | |||
if (s.length() - index >= 3 | |||
&& '$' == s.charAt(index) && '{' == s.charAt(index + 1)) { | |||
if (s.length() - index >= 3 && '$' == s.charAt(index) | |||
&& '{' == s.charAt(index + 1)) { | |||
int start = index + 2; | |||
//defer to String.indexOf() for protracted check: | |||
int end = s.indexOf('}', start); | |||
if (end < 0) { | |||
throw new BuildException("Syntax error in property: " | |||
+ s.substring(index)); | |||
throw new BuildException( | |||
"Syntax error in property: " + s.substring(index)); | |||
} | |||
pos.setIndex(end + 1); | |||
return start == end ? "" : s.substring(start, end); | |||
return start == end ? "" : s.substring(start, end); | |||
} | |||
return null; | |||
} | |||
}; | |||
}; | |||
/** dummy */ | |||
private static final PropertyExpander SKIP_DOUBLE_DOLLAR | |||
= new PropertyExpander() { | |||
// CheckStyle:LineLengthCheck OFF see too long | |||
/** | |||
* {@inheritDoc} | |||
* @see org.apache.tools.ant.property.PropertyExpander#parsePropertyName(java.lang.String, java.text.ParsePosition, org.apache.tools.ant.PropertyHelper) | |||
*/ | |||
// CheckStyle:LineLengthCheck ON | |||
public String parsePropertyName( | |||
String s, ParsePosition pos, ParseNextProperty notUsed) { | |||
int index = pos.getIndex(); | |||
if (s.length() - index >= 2) { | |||
/* check for $$; if found, advance by one-- | |||
* this expander is at the bottom of the stack | |||
* and will thus be the last consulted, | |||
* so the next thing that ParseProperties will do | |||
* is advance the parse position beyond the second $ | |||
*/ | |||
if ('$' == s.charAt(index) && '$' == s.charAt(++index)) { | |||
pos.setIndex(index); | |||
} | |||
private static final PropertyExpander SKIP_DOUBLE_DOLLAR = | |||
(s, pos, notUsed) -> { | |||
int index = pos.getIndex(); | |||
if (s.length() - index >= 2) { | |||
/* check for $$; if found, advance by one-- | |||
* this expander is at the bottom of the stack | |||
* and will thus be the last consulted, | |||
* so the next thing that ParseProperties will do | |||
* is advance the parse position beyond the second $ | |||
*/ | |||
if ('$' == s.charAt(index) && '$' == s.charAt(++index)) { | |||
pos.setIndex(index); | |||
} | |||
return null; | |||
} | |||
return null; | |||
}; | |||
/** | |||
@@ -248,24 +235,24 @@ public class PropertyHelper implements GetProperty { | |||
private Project project; | |||
private PropertyHelper next; | |||
private final Hashtable<Class<? extends Delegate>, List<Delegate>> delegates = new Hashtable<Class<? extends Delegate>, List<Delegate>>(); | |||
private final Hashtable<Class<? extends Delegate>, List<Delegate>> delegates = new Hashtable<>(); | |||
/** Project properties map (usually String to String). */ | |||
private Hashtable<String, Object> properties = new Hashtable<String, Object>(); | |||
private Hashtable<String, Object> properties = new Hashtable<>(); | |||
/** | |||
* Map of "user" properties (as created in the Ant task, for example). | |||
* Note that these key/value pairs are also always put into the | |||
* project properties, so only the project properties need to be queried. | |||
*/ | |||
private Hashtable<String, Object> userProperties = new Hashtable<String, Object>(); | |||
private Hashtable<String, Object> userProperties = new Hashtable<>(); | |||
/** | |||
* Map of inherited "user" properties - that are those "user" | |||
* properties that have been created by tasks and not been set | |||
* from the command line or a GUI tool. | |||
*/ | |||
private Hashtable<String, Object> inheritedProperties = new Hashtable<String, Object>(); | |||
private Hashtable<String, Object> inheritedProperties = new Hashtable<>(); | |||
/** | |||
* Default constructor. | |||
@@ -900,7 +887,7 @@ public class PropertyHelper implements GetProperty { | |||
public Hashtable<String, Object> getProperties() { | |||
//avoid concurrent modification: | |||
synchronized (properties) { | |||
return new Hashtable<String, Object>(properties); | |||
return new Hashtable<>(properties); | |||
} | |||
// There is a better way to save the context. This shouldn't | |||
// delegate to next, it's for backward compatibility only. | |||
@@ -917,7 +904,7 @@ public class PropertyHelper implements GetProperty { | |||
public Hashtable<String, Object> getUserProperties() { | |||
//avoid concurrent modification: | |||
synchronized (userProperties) { | |||
return new Hashtable<String, Object>(userProperties); | |||
return new Hashtable<>(userProperties); | |||
} | |||
} | |||
@@ -932,7 +919,7 @@ public class PropertyHelper implements GetProperty { | |||
public Hashtable<String, Object> getInheritedProperties() { | |||
//avoid concurrent modification: | |||
synchronized (inheritedProperties) { | |||
return new Hashtable<String, Object>(inheritedProperties); | |||
return new Hashtable<>(inheritedProperties); | |||
} | |||
} | |||
@@ -982,7 +969,7 @@ public class PropertyHelper implements GetProperty { | |||
synchronized (inheritedProperties) { | |||
Enumeration<String> e = inheritedProperties.keys(); | |||
while (e.hasMoreElements()) { | |||
String arg = e.nextElement().toString(); | |||
String arg = e.nextElement(); | |||
if (other.getUserProperty(arg) != null) { | |||
continue; | |||
} | |||
@@ -1036,7 +1023,7 @@ public class PropertyHelper implements GetProperty { | |||
int prev = 0; | |||
int pos; | |||
//search for the next instance of $ from the 'prev' position | |||
while ((pos = value.indexOf("$", prev)) >= 0) { | |||
while ((pos = value.indexOf('$', prev)) >= 0) { | |||
//if there was any text before this, add it as a fragment | |||
//TODO, this check could be modified to go if pos>prev; | |||
@@ -1096,10 +1083,10 @@ public class PropertyHelper implements GetProperty { | |||
for (Class<? extends Delegate> key : getDelegateInterfaces(delegate)) { | |||
List<Delegate> list = delegates.get(key); | |||
if (list == null) { | |||
list = new ArrayList<Delegate>(); | |||
list = new ArrayList<>(); | |||
} else { | |||
//copy on write, top priority | |||
list = new ArrayList<Delegate>(list); | |||
list = new ArrayList<>(list); | |||
list.remove(delegate); | |||
} | |||
list.add(0, delegate); | |||
@@ -1129,7 +1116,7 @@ public class PropertyHelper implements GetProperty { | |||
* @since Ant 1.8.0 | |||
*/ | |||
protected static Set<Class<? extends Delegate>> getDelegateInterfaces(Delegate d) { | |||
final HashSet<Class<? extends Delegate>> result = new HashSet<Class<? extends Delegate>>(); | |||
final HashSet<Class<? extends Delegate>> result = new HashSet<>(); | |||
Class<?> c = d.getClass(); | |||
while (c != null) { | |||
Class<?>[] ifs = c.getInterfaces(); | |||
@@ -25,12 +25,11 @@ import java.util.Enumeration; | |||
import java.util.Hashtable; | |||
import java.util.LinkedHashMap; | |||
import java.util.List; | |||
import java.util.Map.Entry; | |||
import java.util.Map; | |||
import org.apache.tools.ant.attribute.EnableAttribute; | |||
import org.apache.tools.ant.taskdefs.MacroDef.Attribute; | |||
import org.apache.tools.ant.taskdefs.MacroInstance; | |||
import org.apache.tools.ant.util.CollectionUtils; | |||
import org.xml.sax.AttributeList; | |||
import org.xml.sax.helpers.AttributeListImpl; | |||
@@ -46,14 +45,14 @@ public class RuntimeConfigurable implements Serializable { | |||
/** Empty Hashtable. */ | |||
private static final Hashtable<String, Object> EMPTY_HASHTABLE = | |||
new Hashtable<String, Object>(0); | |||
new Hashtable<>(0); | |||
/** Name of the element to configure. */ | |||
private String elementTag = null; | |||
/** List of child element wrappers. */ | |||
// picking ArrayList rather than List as arrayList is Serializable | |||
private ArrayList<RuntimeConfigurable> children = null; | |||
private List<RuntimeConfigurable> children = null; | |||
/** The element to configure. It is only used during | |||
* maybeConfigure. | |||
@@ -303,17 +302,17 @@ public class RuntimeConfigurable implements Serializable { | |||
this.polyType = value == null ? null : value.toString(); | |||
} else { | |||
if (attributeMap == null) { | |||
attributeMap = new LinkedHashMap<String, Object>(); | |||
attributeMap = new LinkedHashMap<>(); | |||
} | |||
if (name.equalsIgnoreCase("refid") && !attributeMap.isEmpty()) { | |||
LinkedHashMap<String, Object> newAttributeMap = new LinkedHashMap<String, Object>(); | |||
if ("refid".equalsIgnoreCase(name) && !attributeMap.isEmpty()) { | |||
LinkedHashMap<String, Object> newAttributeMap = new LinkedHashMap<>(); | |||
newAttributeMap.put(name, value); | |||
newAttributeMap.putAll(attributeMap); | |||
attributeMap = newAttributeMap; | |||
} else { | |||
attributeMap.put(name, value); | |||
} | |||
if (name.equals("id")) { | |||
if ("id".equals(name)) { | |||
this.id = value == null ? null : value.toString(); | |||
} | |||
} | |||
@@ -335,7 +334,7 @@ public class RuntimeConfigurable implements Serializable { | |||
*/ | |||
public synchronized Hashtable<String, Object> getAttributeMap() { | |||
return (attributeMap == null) | |||
? EMPTY_HASHTABLE : new Hashtable<String, Object>(attributeMap); | |||
? EMPTY_HASHTABLE : new Hashtable<>(attributeMap); | |||
} | |||
/** | |||
@@ -356,7 +355,7 @@ public class RuntimeConfigurable implements Serializable { | |||
* Must not be <code>null</code>. | |||
*/ | |||
public synchronized void addChild(RuntimeConfigurable child) { | |||
children = (children == null) ? new ArrayList<RuntimeConfigurable>() : children; | |||
children = (children == null) ? new ArrayList<>() : children; | |||
children.add(child); | |||
} | |||
@@ -378,7 +377,7 @@ public class RuntimeConfigurable implements Serializable { | |||
* @since Ant 1.6 | |||
*/ | |||
public synchronized Enumeration<RuntimeConfigurable> getChildren() { | |||
return (children == null) ? new CollectionUtils.EmptyEnumeration<RuntimeConfigurable>() | |||
return (children == null) ? Collections.emptyEnumeration() | |||
: Collections.enumeration(children); | |||
} | |||
@@ -497,7 +496,7 @@ public class RuntimeConfigurable implements Serializable { | |||
IntrospectionHelper.getHelper(p, target.getClass()); | |||
ComponentHelper componentHelper = ComponentHelper.getComponentHelper(p); | |||
if (attributeMap != null) { | |||
for (Entry<String, Object> entry : attributeMap.entrySet()) { | |||
for (Map.Entry<String, Object> entry : attributeMap.entrySet()) { | |||
String name = entry.getKey(); | |||
// skip restricted attributes such as if:set | |||
AttributeComponentInformation attributeComponentInformation = isRestrictedAttribute(name, componentHelper); | |||
@@ -509,8 +508,8 @@ public class RuntimeConfigurable implements Serializable { | |||
// MacroInstance where properties are expanded for the | |||
// nested sequential | |||
Object attrValue; | |||
if (value instanceof Evaluable) { | |||
attrValue = ((Evaluable) value).eval(); | |||
if (value instanceof Evaluable<?>) { | |||
attrValue = ((Evaluable<?>) value).eval(); | |||
} else { | |||
attrValue = PropertyHelper.getPropertyHelper(p).parseProperties(value.toString()); | |||
} | |||
@@ -528,7 +527,7 @@ public class RuntimeConfigurable implements Serializable { | |||
ih.setAttribute(p, target, name, attrValue); | |||
} catch (UnsupportedAttributeException be) { | |||
// id attribute must be set externally | |||
if (name.equals("id")) { | |||
if ("id".equals(name)) { | |||
// Do nothing | |||
} else if (getElementTag() == null) { | |||
throw be; | |||
@@ -538,7 +537,7 @@ public class RuntimeConfigurable implements Serializable { | |||
+ be.getAttribute() + "\" attribute", be); | |||
} | |||
} catch (BuildException be) { | |||
if (name.equals("id")) { | |||
if ("id".equals(name)) { | |||
// Assume that this is an not supported attribute type | |||
// thrown for example by a dymanic attribute task | |||
// Do nothing | |||
@@ -590,7 +589,7 @@ public class RuntimeConfigurable implements Serializable { | |||
// Children (this is a shadow of UnknownElement#children) | |||
if (r.children != null) { | |||
ArrayList<RuntimeConfigurable> newChildren = new ArrayList<RuntimeConfigurable>(); | |||
List<RuntimeConfigurable> newChildren = new ArrayList<>(); | |||
newChildren.addAll(r.children); | |||
if (children != null) { | |||
newChildren.addAll(children); | |||
@@ -601,7 +600,7 @@ public class RuntimeConfigurable implements Serializable { | |||
// Text | |||
if (r.characters != null) { | |||
if (characters == null | |||
|| characters.toString().trim().length() == 0) { | |||
|| characters.toString().trim().isEmpty()) { | |||
characters = new StringBuffer(r.characters.toString()); | |||
} | |||
} | |||
@@ -55,7 +55,7 @@ public class Target implements TaskContainer { | |||
private List<String> dependencies = null; | |||
/** Children of this target (tasks and data types). */ | |||
private List<Object> children = new ArrayList<Object>(); | |||
private List<Object> children = new ArrayList<>(); | |||
/** Since Ant 1.6.2 */ | |||
private Location location = Location.UNKNOWN_LOCATION; | |||
@@ -145,7 +145,7 @@ public class Target implements TaskContainer { | |||
public static List<String> parseDepends(String depends, | |||
String targetName, | |||
String attributeName) { | |||
List<String> list = new ArrayList<String>(); | |||
List<String> list = new ArrayList<>(); | |||
if (depends.length() > 0) { | |||
StringTokenizer tok = | |||
new StringTokenizer(depends, ",", true); | |||
@@ -225,7 +225,7 @@ public class Target implements TaskContainer { | |||
* @return an array of the tasks currently within this target | |||
*/ | |||
public Task[] getTasks() { | |||
List<Task> tasks = new ArrayList<Task>(children.size()); | |||
List<Task> tasks = new ArrayList<>(children.size()); | |||
for (Object o : children) { | |||
if (o instanceof Task) { | |||
tasks.add((Task) o); | |||
@@ -242,7 +242,7 @@ public class Target implements TaskContainer { | |||
*/ | |||
public void addDependency(String dependency) { | |||
if (dependencies == null) { | |||
dependencies = new ArrayList<String>(2); | |||
dependencies = new ArrayList<>(2); | |||
} | |||
dependencies.add(dependency); | |||
} | |||
@@ -253,8 +253,8 @@ public class Target implements TaskContainer { | |||
* @return an enumeration of the dependencies of this target (enumeration of String) | |||
*/ | |||
public Enumeration<String> getDependencies() { | |||
return Collections | |||
.enumeration(dependencies == null ? Collections.<String> emptyList() : dependencies); | |||
return dependencies == null ? Collections.emptyEnumeration() | |||
: Collections.enumeration(dependencies); | |||
} | |||
/** | |||
@@ -284,7 +284,12 @@ public class Target implements TaskContainer { | |||
*/ | |||
public void setIf(String property) { | |||
ifString = property == null ? "" : property; | |||
setIf(new IfStringCondition(ifString)); | |||
setIf(() -> { | |||
PropertyHelper propertyHelper = | |||
PropertyHelper.getPropertyHelper(getProject()); | |||
Object o = propertyHelper.parseProperties(ifString); | |||
return propertyHelper.testIfCondition(o); | |||
}); | |||
} | |||
/** | |||
@@ -331,7 +336,12 @@ public class Target implements TaskContainer { | |||
*/ | |||
public void setUnless(String property) { | |||
unlessString = property == null ? "" : property; | |||
setUnless(new UnlessStringCondition(unlessString)); | |||
setUnless(() -> { | |||
PropertyHelper propertyHelper = | |||
PropertyHelper.getPropertyHelper(getProject()); | |||
Object o = propertyHelper.parseProperties(unlessString); | |||
return !propertyHelper.testUnlessCondition(o); | |||
}); | |||
} | |||
/** | |||
@@ -390,6 +400,7 @@ public class Target implements TaskContainer { | |||
* @return the name of this target, or <code>null</code> if the | |||
* name has not been set yet. | |||
*/ | |||
@Override | |||
public String toString() { | |||
return name; | |||
} | |||
@@ -491,42 +502,4 @@ public class Target implements TaskContainer { | |||
children.set(index, o); | |||
} | |||
} | |||
/** | |||
* Condition evaluating the 'if' attribute with the PropertyHelper. | |||
*/ | |||
private class IfStringCondition implements Condition { | |||
private String condition; | |||
public IfStringCondition(String condition) { | |||
this.condition = condition; | |||
} | |||
public boolean eval() throws BuildException { | |||
PropertyHelper propertyHelper = PropertyHelper.getPropertyHelper(getProject()); | |||
Object o = propertyHelper.parseProperties(condition); | |||
return propertyHelper.testIfCondition(o); | |||
} | |||
} | |||
/** | |||
* Condition evaluating the 'unless' attribute with the PropertyHelper. | |||
*/ | |||
private class UnlessStringCondition implements Condition { | |||
private String condition; | |||
public UnlessStringCondition(String condition) { | |||
this.condition = condition; | |||
} | |||
public boolean eval() throws BuildException { | |||
PropertyHelper propertyHelper = PropertyHelper.getPropertyHelper(getProject()); | |||
Object o = propertyHelper.parseProperties(condition); | |||
return !propertyHelper.testUnlessCondition(o); | |||
} | |||
} | |||
} |
@@ -81,10 +81,6 @@ public abstract class Task extends ProjectComponent { | |||
*/ | |||
private boolean invalid; | |||
/** Sole constructor. */ | |||
public Task() { | |||
} | |||
/** | |||
* Sets the target container of this task. | |||
* | |||
@@ -197,12 +193,10 @@ public abstract class Task extends ProjectComponent { | |||
* @exception BuildException if the task cannot be configured. | |||
*/ | |||
public void maybeConfigure() throws BuildException { | |||
if (!invalid) { | |||
if (wrapper != null) { | |||
wrapper.maybeConfigure(getProject()); | |||
} | |||
} else { | |||
if (invalid) { | |||
getReplacement(); | |||
} else if (wrapper != null) { | |||
wrapper.maybeConfigure(getProject()); | |||
} | |||
} | |||
@@ -290,10 +284,10 @@ public abstract class Task extends ProjectComponent { | |||
* be logged. | |||
*/ | |||
public void log(String msg, int msgLevel) { | |||
if (getProject() != null) { | |||
getProject().log(this, msg, msgLevel); | |||
} else { | |||
if (getProject() == null) { | |||
super.log(msg, msgLevel); | |||
} else { | |||
getProject().log(this, msg, msgLevel); | |||
} | |||
} | |||
@@ -323,10 +317,10 @@ public abstract class Task extends ProjectComponent { | |||
* @since 1.7 | |||
*/ | |||
public void log(String msg, Throwable t, int msgLevel) { | |||
if (getProject() != null) { | |||
getProject().log(this, msg, t, msgLevel); | |||
} else { | |||
if (getProject() == null) { | |||
super.log(msg, msgLevel); | |||
} else { | |||
getProject().log(this, msg, t, msgLevel); | |||
} | |||
} | |||
@@ -340,7 +334,11 @@ public abstract class Task extends ProjectComponent { | |||
* is still fired, but with the exception as the cause. | |||
*/ | |||
public final void perform() { | |||
if (!invalid) { | |||
if (invalid) { | |||
UnknownElement ue = getReplacement(); | |||
Task task = ue.getTask(); | |||
task.perform(); | |||
} else { | |||
getProject().fireTaskStarted(this); | |||
Throwable reason = null; | |||
try { | |||
@@ -363,10 +361,6 @@ public abstract class Task extends ProjectComponent { | |||
} finally { | |||
getProject().fireTaskFinished(this, reason); | |||
} | |||
} else { | |||
UnknownElement ue = getReplacement(); | |||
Task task = ue.getTask(); | |||
task.perform(); | |||
} | |||
} | |||
@@ -81,7 +81,7 @@ public class TaskAdapter extends Task implements TypeAdapter { | |||
// don't have to check for interface, since then | |||
// taskClass would be abstract too. | |||
try { | |||
final Method executeM = taskClass.getMethod("execute", (Class[]) null); | |||
final Method executeM = taskClass.getMethod("execute"); | |||
// don't have to check for public, since | |||
// getMethod finds public method only. | |||
// don't have to check for abstract, since then | |||
@@ -122,10 +122,10 @@ public class TaskAdapter extends Task implements TypeAdapter { | |||
*/ | |||
public void execute() throws BuildException { | |||
try { | |||
Method setLocationM = proxy.getClass().getMethod( | |||
"setLocation", new Class[] {Location.class}); | |||
Method setLocationM = | |||
proxy.getClass().getMethod("setLocation", Location.class); | |||
if (setLocationM != null) { | |||
setLocationM.invoke(proxy, new Object[] {getLocation()}); | |||
setLocationM.invoke(proxy, getLocation()); | |||
} | |||
} catch (NoSuchMethodException e) { | |||
// ignore this if the class being used as a task does not have | |||
@@ -137,10 +137,10 @@ public class TaskAdapter extends Task implements TypeAdapter { | |||
} | |||
try { | |||
Method setProjectM = proxy.getClass().getMethod( | |||
"setProject", new Class[] {Project.class}); | |||
Method setProjectM = | |||
proxy.getClass().getMethod("setProject", Project.class); | |||
if (setProjectM != null) { | |||
setProjectM.invoke(proxy, new Object[] {getProject()}); | |||
setProjectM.invoke(proxy, getProject()); | |||
} | |||
} catch (NoSuchMethodException e) { | |||
// ignore this if the class being used as a task does not have | |||
@@ -55,7 +55,7 @@ import java.util.List; | |||
public class TaskConfigurationChecker { | |||
/** List of all collected error messages. */ | |||
private List<String> errors = new ArrayList<String>(); | |||
private List<String> errors = new ArrayList<>(); | |||
/** Task for which the configuration should be checked. */ | |||
private final Task task; | |||
@@ -94,8 +94,7 @@ public class TaskConfigurationChecker { | |||
*/ | |||
public void checkErrors() throws BuildException { | |||
if (!errors.isEmpty()) { | |||
StringBuffer sb = new StringBuffer(); | |||
sb.append("Configurationerror on <"); | |||
StringBuilder sb = new StringBuilder("Configurationerror on <"); | |||
sb.append(task.getTaskName()); | |||
sb.append(">:"); | |||
sb.append(System.getProperty("line.separator")); | |||
@@ -24,6 +24,7 @@ import java.util.Enumeration; | |||
import java.util.Iterator; | |||
import java.util.List; | |||
import java.util.Map; | |||
import java.util.Objects; | |||
import org.apache.tools.ant.taskdefs.PreSetDef; | |||
@@ -234,10 +235,8 @@ public class UnknownElement extends Task { | |||
throws IOException { | |||
if (realThing instanceof Task) { | |||
return ((Task) realThing).handleInput(buffer, offset, length); | |||
} else { | |||
return super.handleInput(buffer, offset, length); | |||
} | |||
return super.handleInput(buffer, offset, length); | |||
} | |||
/** | |||
@@ -311,7 +310,7 @@ public class UnknownElement extends Task { | |||
*/ | |||
public void addChild(UnknownElement child) { | |||
if (children == null) { | |||
children = new ArrayList<UnknownElement>(); | |||
children = new ArrayList<>(); | |||
} | |||
children.add(child); | |||
} | |||
@@ -341,7 +340,6 @@ public class UnknownElement extends Task { | |||
Class<?> parentClass = parent.getClass(); | |||
IntrospectionHelper ih = IntrospectionHelper.getHelper(getProject(), parentClass); | |||
if (children != null) { | |||
Iterator<UnknownElement> it = children.iterator(); | |||
for (int i = 0; it.hasNext(); i++) { | |||
@@ -400,7 +398,7 @@ public class UnknownElement extends Task { | |||
// Do the runtime | |||
getWrapper().applyPreSet(u.getWrapper()); | |||
if (u.children != null) { | |||
List<UnknownElement> newChildren = new ArrayList<UnknownElement>(); | |||
List<UnknownElement> newChildren = new ArrayList<>(); | |||
newChildren.addAll(u.children); | |||
if (children != null) { | |||
newChildren.addAll(children); | |||
@@ -506,7 +504,6 @@ public class UnknownElement extends Task { | |||
* @return the name to use in logging messages. | |||
*/ | |||
public String getTaskName() { | |||
//return elementName; | |||
return realThing == null | |||
|| !(realThing instanceof Task) ? super.getTaskName() | |||
: ((Task) realThing).getTaskName(); | |||
@@ -612,7 +609,7 @@ public class UnknownElement extends Task { | |||
} | |||
UnknownElement other = (UnknownElement) obj; | |||
// Are the names the same ? | |||
if (!equalsString(elementName, other.elementName)) { | |||
if (!Objects.equals(elementName, other.elementName)) { | |||
return false; | |||
} | |||
if (!namespace.equals(other.namespace)) { | |||
@@ -637,7 +634,7 @@ public class UnknownElement extends Task { | |||
// Are the sub elements the same ? | |||
final int childrenSize = children == null ? 0 : children.size(); | |||
if (childrenSize == 0) { | |||
return other.children == null || other.children.size() == 0; | |||
return other.children == null || other.children.isEmpty(); | |||
} | |||
if (other.children == null) { | |||
return false; | |||
@@ -655,10 +652,6 @@ public class UnknownElement extends Task { | |||
return true; | |||
} | |||
private static boolean equalsString(String a, String b) { | |||
return (a == null) ? (b == null) : a.equals(b); | |||
} | |||
/** | |||
* Make a copy of the unknown element and set it in the new project. | |||
* @param newProject the project to create the UE in. | |||
@@ -32,7 +32,6 @@ import javax.xml.parsers.DocumentBuilder; | |||
import javax.xml.parsers.DocumentBuilderFactory; | |||
import org.apache.tools.ant.util.DOMElementWriter; | |||
import org.apache.tools.ant.util.FileUtils; | |||
import org.apache.tools.ant.util.StringUtils; | |||
import org.w3c.dom.Document; | |||
import org.w3c.dom.Element; | |||
@@ -109,16 +108,16 @@ public class XmlLogger implements BuildLogger { | |||
private Document doc = builder.newDocument(); | |||
/** Mapping for when tasks started (Task to TimedElement). */ | |||
private Hashtable<Task, TimedElement> tasks = new Hashtable<Task, TimedElement>(); | |||
private Hashtable<Task, TimedElement> tasks = new Hashtable<>(); | |||
/** Mapping for when targets started (Target to TimedElement). */ | |||
private Hashtable<Target, TimedElement> targets = new Hashtable<Target, XmlLogger.TimedElement>(); | |||
private Hashtable<Target, TimedElement> targets = new Hashtable<>(); | |||
/** | |||
* Mapping of threads to stacks of elements | |||
* (Thread to Stack of TimedElement). | |||
*/ | |||
private Hashtable<Thread, Stack<TimedElement>> threadStacks = new Hashtable<Thread, Stack<TimedElement>>(); | |||
private Hashtable<Thread, Stack<TimedElement>> threadStacks = new Hashtable<>(); | |||
/** | |||
* When the build started. | |||
@@ -134,23 +133,20 @@ public class XmlLogger implements BuildLogger { | |||
private long startTime; | |||
/** Element created at the start time. */ | |||
private Element element; | |||
@Override | |||
public String toString() { | |||
return element.getTagName() + ":" + element.getAttribute("name"); | |||
} | |||
} | |||
/** | |||
* Constructs a new BuildListener that logs build events to an XML file. | |||
*/ | |||
public XmlLogger() { | |||
} | |||
/** | |||
* Fired when the build starts, this builds the top-level element for the | |||
* document and remembers the time of the start of the build. | |||
* | |||
* @param event Ignored. | |||
*/ | |||
@Override | |||
public void buildStarted(BuildEvent event) { | |||
buildElement = new TimedElement(); | |||
buildElement.startTime = System.currentTimeMillis(); | |||
@@ -164,6 +160,7 @@ public class XmlLogger implements BuildLogger { | |||
* @param event An event with any relevant extra information. | |||
* Will not be <code>null</code>. | |||
*/ | |||
@Override | |||
public void buildFinished(BuildEvent event) { | |||
long totalTime = System.currentTimeMillis() - buildElement.startTime; | |||
buildElement.element.setAttribute(TIME_ATTR, DefaultLogger.formatTime(totalTime)); | |||
@@ -180,25 +177,19 @@ public class XmlLogger implements BuildLogger { | |||
} | |||
String outFilename = getProperty(event, "XmlLogger.file", "log.xml"); | |||
String xslUri = getProperty(event, "ant.XmlLogger.stylesheet.uri", "log.xsl"); | |||
Writer out = null; | |||
try { | |||
// specify output in UTF8 otherwise accented characters will blow | |||
// up everything | |||
OutputStream stream = outStream; | |||
if (stream == null) { | |||
stream = Files.newOutputStream(Paths.get(outFilename)); | |||
} | |||
out = new OutputStreamWriter(stream, "UTF8"); | |||
try (OutputStream stream = | |||
outStream == null ? Files.newOutputStream(Paths.get(outFilename)) : outStream; | |||
Writer out = new OutputStreamWriter(stream, "UTF8")) { | |||
out.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); | |||
if (xslUri.length() > 0) { | |||
out.write("<?xml-stylesheet type=\"text/xsl\" href=\"" + xslUri + "\"?>\n\n"); | |||
out.write("<?xml-stylesheet type=\"text/xsl\" href=\"" + xslUri | |||
+ "\"?>\n\n"); | |||
} | |||
new DOMElementWriter().write(buildElement.element, out, 0, "\t"); | |||
out.flush(); | |||
} catch (IOException exc) { | |||
throw new BuildException("Unable to write log file", exc); | |||
} finally { | |||
FileUtils.close(out); | |||
} | |||
buildElement = null; | |||
} | |||
@@ -218,7 +209,7 @@ public class XmlLogger implements BuildLogger { | |||
private Stack<TimedElement> getStack() { | |||
Stack<TimedElement> threadStack = threadStacks.get(Thread.currentThread()); | |||
if (threadStack == null) { | |||
threadStack = new Stack<TimedElement>(); | |||
threadStack = new Stack<>(); | |||
threadStacks.put(Thread.currentThread(), threadStack); | |||
} | |||
/* For debugging purposes uncomment: | |||
@@ -236,6 +227,7 @@ public class XmlLogger implements BuildLogger { | |||
* @param event An event with any relevant extra information. | |||
* Will not be <code>null</code>. | |||
*/ | |||
@Override | |||
public void targetStarted(BuildEvent event) { | |||
Target target = event.getTarget(); | |||
TimedElement targetElement = new TimedElement(); | |||
@@ -253,6 +245,7 @@ public class XmlLogger implements BuildLogger { | |||
* @param event An event with any relevant extra information. | |||
* Will not be <code>null</code>. | |||
*/ | |||
@Override | |||
public void targetFinished(BuildEvent event) { | |||
Target target = event.getTarget(); | |||
TimedElement targetElement = targets.get(target); | |||
@@ -290,6 +283,7 @@ public class XmlLogger implements BuildLogger { | |||
* @param event An event with any relevant extra information. | |||
* Will not be <code>null</code>. | |||
*/ | |||
@Override | |||
public void taskStarted(BuildEvent event) { | |||
TimedElement taskElement = new TimedElement(); | |||
taskElement.startTime = System.currentTimeMillis(); | |||
@@ -313,6 +307,7 @@ public class XmlLogger implements BuildLogger { | |||
* @param event An event with any relevant extra information. | |||
* Will not be <code>null</code>. | |||
*/ | |||
@Override | |||
public void taskFinished(BuildEvent event) { | |||
Task task = event.getTask(); | |||
TimedElement taskElement = tasks.get(task); | |||
@@ -355,10 +350,9 @@ public class XmlLogger implements BuildLogger { | |||
} | |||
for (Enumeration<Task> e = tasks.keys(); e.hasMoreElements();) { | |||
Task key = e.nextElement(); | |||
if (key instanceof UnknownElement) { | |||
if (((UnknownElement) key).getTask() == task) { | |||
return tasks.get(key); | |||
} | |||
if (key instanceof UnknownElement | |||
&& ((UnknownElement) key).getTask() == task) { | |||
return tasks.get(key); | |||
} | |||
} | |||
return null; | |||
@@ -372,6 +366,7 @@ public class XmlLogger implements BuildLogger { | |||
* @param event An event with any relevant extra information. | |||
* Will not be <code>null</code>. | |||
*/ | |||
@Override | |||
public void messageLogged(BuildEvent event) { | |||
int priority = event.getPriority(); | |||
if (priority > msgOutputLevel) { | |||
@@ -379,7 +374,7 @@ public class XmlLogger implements BuildLogger { | |||
} | |||
Element messageElement = doc.createElement(MESSAGE_TAG); | |||
String name = "debug"; | |||
String name; | |||
switch (priority) { | |||
case Project.MSG_ERR: | |||
name = "error"; | |||
@@ -433,6 +428,7 @@ public class XmlLogger implements BuildLogger { | |||
* see {@link org.apache.tools.ant.Project#MSG_ERR Project} | |||
* class for level definitions | |||
*/ | |||
@Override | |||
public void setMessageOutputLevel(int level) { | |||
msgOutputLevel = level; | |||
} | |||
@@ -443,6 +439,7 @@ public class XmlLogger implements BuildLogger { | |||
* | |||
* @param output the output PrintStream. | |||
*/ | |||
@Override | |||
public void setOutputPrintStream(PrintStream output) { | |||
this.outStream = new PrintStream(output, true); | |||
} | |||
@@ -453,6 +450,7 @@ public class XmlLogger implements BuildLogger { | |||
* @param emacsMode true if logger should produce emacs compatible | |||
* output | |||
*/ | |||
@Override | |||
public void setEmacsMode(boolean emacsMode) { | |||
} | |||
@@ -463,6 +461,7 @@ public class XmlLogger implements BuildLogger { | |||
* | |||
* @param err the stream we are going to ignore. | |||
*/ | |||
@Override | |||
public void setErrorPrintStream(PrintStream err) { | |||
} | |||
@@ -19,6 +19,7 @@ | |||
package org.apache.tools.ant.attribute; | |||
import java.util.HashMap; | |||
import java.util.Hashtable; | |||
import java.util.Iterator; | |||
import java.util.Map; | |||
@@ -67,18 +68,19 @@ public abstract class BaseIfAttribute | |||
* @param el the element this attribute is in. | |||
* @return a map of attributes. | |||
*/ | |||
protected Map getParams(UnknownElement el) { | |||
Map ret = new HashMap(); | |||
protected Map<String, String> getParams(UnknownElement el) { | |||
Map<String, String> ret = new HashMap<>(); | |||
RuntimeConfigurable rc = el.getWrapper(); | |||
Map attributes = rc.getAttributeMap(); // This does a copy! | |||
for (Iterator i = attributes.entrySet().iterator(); i.hasNext();) { | |||
Map.Entry entry = (Map.Entry) i.next(); | |||
String key = (String) entry.getKey(); | |||
Hashtable<String, Object> attributes = rc.getAttributeMap(); // This does a copy! | |||
for (Iterator<Map.Entry<String, Object>> i = | |||
attributes.entrySet().iterator(); i.hasNext();) { | |||
Map.Entry<String, Object> entry = i.next(); | |||
String key = entry.getKey(); | |||
String value = (String) entry.getValue(); | |||
if (key.startsWith("ant-attribute:param")) { | |||
int pos = key.lastIndexOf(':'); | |||
ret.put(key.substring(pos + 1), | |||
el.getProject().replaceProperties(value)); | |||
el.getProject().replaceProperties(value)); | |||
} | |||
} | |||
return ret; | |||
@@ -37,6 +37,7 @@ public abstract class DispatchTask extends Task implements Dispatchable { | |||
* Get the action parameter name. | |||
* @return the <code>String</code> "action" by default (can be overridden). | |||
*/ | |||
@Override | |||
public String getActionParameterName() { | |||
return "action"; | |||
} | |||
@@ -98,12 +98,12 @@ public class DispatchUtils { | |||
} | |||
} else { | |||
Method executeM = null; | |||
executeM = task.getClass().getMethod(methodName, new Class[0]); | |||
executeM = task.getClass().getMethod(methodName); | |||
if (executeM == null) { | |||
throw new BuildException("No public " + methodName + "() in " | |||
+ task.getClass()); | |||
} | |||
executeM.invoke(task, (Object[]) null); | |||
executeM.invoke(task); | |||
if (task instanceof UnknownElement) { | |||
((UnknownElement) task).setRealThing(null); | |||
} | |||
@@ -23,9 +23,13 @@ import java.io.Reader; | |||
import java.lang.reflect.Constructor; | |||
import java.lang.reflect.InvocationTargetException; | |||
import java.util.ArrayList; | |||
import java.util.Iterator; | |||
import java.util.Collection; | |||
import java.util.List; | |||
import java.util.Optional; | |||
import java.util.Vector; | |||
import java.util.function.Consumer; | |||
import java.util.stream.Collectors; | |||
import java.util.stream.Stream; | |||
import org.apache.tools.ant.AntClassLoader; | |||
import org.apache.tools.ant.BuildException; | |||
@@ -34,7 +38,6 @@ import org.apache.tools.ant.filters.BaseFilterReader; | |||
import org.apache.tools.ant.filters.ChainableReader; | |||
import org.apache.tools.ant.types.AntFilterReader; | |||
import org.apache.tools.ant.types.FilterChain; | |||
import org.apache.tools.ant.types.Parameter; | |||
import org.apache.tools.ant.types.Parameterizable; | |||
import org.apache.tools.ant.types.Path; | |||
import org.apache.tools.ant.util.FileUtils; | |||
@@ -44,6 +47,37 @@ import org.apache.tools.ant.util.FileUtils; | |||
* | |||
*/ | |||
public final class ChainReaderHelper { | |||
/** | |||
* Created type. | |||
*/ | |||
public class ChainReader extends FilterReader { | |||
private List<AntClassLoader> cleanupLoaders; | |||
private ChainReader(Reader in, List<AntClassLoader> cleanupLoaders) { | |||
super(in); | |||
this.cleanupLoaders = cleanupLoaders; | |||
} | |||
public String readFully() throws IOException { | |||
return ChainReaderHelper.this.readFully(this); | |||
} | |||
@Override | |||
public void close() throws IOException { | |||
cleanUpClassLoaders(cleanupLoaders); | |||
super.close(); | |||
} | |||
@Override | |||
protected void finalize() throws Throwable { | |||
try { | |||
close(); | |||
} finally { | |||
super.finalize(); | |||
} | |||
} | |||
} | |||
// default buffer size | |||
private static final int DEFAULT_BUFFER_SIZE = 8192; | |||
@@ -61,7 +95,7 @@ public final class ChainReaderHelper { | |||
/** | |||
* Chain of filters | |||
*/ | |||
public Vector<FilterChain> filterChains = new Vector<FilterChain>(); | |||
public Vector<FilterChain> filterChains = new Vector<>(); | |||
/** The Ant project */ | |||
private Project project = null; | |||
@@ -69,13 +103,41 @@ public final class ChainReaderHelper { | |||
// CheckStyle:VisibilityModifier ON | |||
/** | |||
* Sets the primary reader | |||
* Default constructor. | |||
*/ | |||
public ChainReaderHelper() { | |||
} | |||
/** | |||
* Convenience constructor. | |||
* @param project | |||
* @param primaryReader | |||
* @param filterChains | |||
*/ | |||
public ChainReaderHelper(Project project, Reader primaryReader, | |||
Iterable<FilterChain> filterChains) { | |||
withProject(project).withPrimaryReader(primaryReader) | |||
.withFilterChains(filterChains); | |||
} | |||
/** | |||
* Sets the primary {@link Reader} | |||
* @param rdr the reader object | |||
*/ | |||
public void setPrimaryReader(Reader rdr) { | |||
primaryReader = rdr; | |||
} | |||
/** | |||
* Fluent primary {@link Reader} mutator. | |||
* @param rdr | |||
* @return {@code this} | |||
*/ | |||
public ChainReaderHelper withPrimaryReader(Reader rdr) { | |||
setPrimaryReader(rdr); | |||
return this; | |||
} | |||
/** | |||
* Set the project to work with | |||
* @param project the current project | |||
@@ -84,6 +146,16 @@ public final class ChainReaderHelper { | |||
this.project = project; | |||
} | |||
/** | |||
* Fluent {@link Project} mutator. | |||
* @param project | |||
* @return {@code this} | |||
*/ | |||
public ChainReaderHelper withProject(Project project) { | |||
setProject(project); | |||
return this; | |||
} | |||
/** | |||
* Get the project | |||
* | |||
@@ -102,6 +174,16 @@ public final class ChainReaderHelper { | |||
bufferSize = size; | |||
} | |||
/** | |||
* Fluent buffer size mutator. | |||
* @param size | |||
* @return {@code this} | |||
*/ | |||
public ChainReaderHelper withBufferSize(int size) { | |||
setBufferSize(size); | |||
return this; | |||
} | |||
/** | |||
* Sets the collection of filter reader sets | |||
* | |||
@@ -111,43 +193,57 @@ public final class ChainReaderHelper { | |||
filterChains = fchain; | |||
} | |||
/** | |||
* Fluent {@code filterChains} mutator. | |||
* @param filterChains | |||
* @return {@code this} | |||
*/ | |||
public ChainReaderHelper withFilterChains(Iterable<FilterChain> filterChains) { | |||
final Vector<FilterChain> fcs; | |||
if (filterChains instanceof Vector<?>) { | |||
fcs = (Vector<FilterChain>) filterChains; | |||
} else { | |||
fcs = new Vector<>(); | |||
filterChains.forEach(fcs::add); | |||
} | |||
setFilterChains(fcs); | |||
return this; | |||
} | |||
/** | |||
* Fluent mechanism to apply some {@link Consumer}. | |||
* @param consumer | |||
* @return {@code this} | |||
*/ | |||
public ChainReaderHelper with(Consumer<ChainReaderHelper> consumer) { | |||
consumer.accept(this); | |||
return this; | |||
} | |||
/** | |||
* Assemble the reader | |||
* @return the assembled reader | |||
* @exception BuildException if an error occurs | |||
*/ | |||
public Reader getAssembledReader() throws BuildException { | |||
public ChainReader getAssembledReader() throws BuildException { | |||
if (primaryReader == null) { | |||
throw new BuildException("primaryReader must not be null."); | |||
} | |||
Reader instream = primaryReader; | |||
final int filterReadersCount = filterChains.size(); | |||
final Vector<Object> finalFilters = new Vector<Object>(); | |||
final ArrayList<AntClassLoader> classLoadersToCleanUp = | |||
new ArrayList<AntClassLoader>(); | |||
for (int i = 0; i < filterReadersCount; i++) { | |||
final FilterChain filterchain = | |||
filterChains.elementAt(i); | |||
final Vector<Object> filterReaders = filterchain.getFilterReaders(); | |||
final int readerCount = filterReaders.size(); | |||
for (int j = 0; j < readerCount; j++) { | |||
finalFilters.addElement(filterReaders.elementAt(j)); | |||
} | |||
} | |||
final List<AntClassLoader> classLoadersToCleanUp = new ArrayList<>(); | |||
final int filtersCount = finalFilters.size(); | |||
if (filtersCount > 0) { | |||
final List<Object> finalFilters = | |||
filterChains.stream().map(FilterChain::getFilterReaders) | |||
.flatMap(Collection::stream).collect(Collectors.toList()); | |||
if (!finalFilters.isEmpty()) { | |||
boolean success = false; | |||
try { | |||
for (int i = 0; i < filtersCount; i++) { | |||
Object o = finalFilters.elementAt(i); | |||
for (Object o : finalFilters) { | |||
if (o instanceof AntFilterReader) { | |||
instream = | |||
expandReader((AntFilterReader) finalFilters.elementAt(i), | |||
expandReader((AntFilterReader) o, | |||
instream, classLoadersToCleanUp); | |||
} else if (o instanceof ChainableReader) { | |||
setProjectOnObject(o); | |||
@@ -157,26 +253,12 @@ public final class ChainReaderHelper { | |||
} | |||
success = true; | |||
} finally { | |||
if (!success && classLoadersToCleanUp.size() > 0) { | |||
if (!(success || classLoadersToCleanUp.isEmpty())) { | |||
cleanUpClassLoaders(classLoadersToCleanUp); | |||
} | |||
} | |||
} | |||
final Reader finalReader = instream; | |||
return classLoadersToCleanUp.size() == 0 ? finalReader | |||
: new FilterReader(finalReader) { | |||
public void close() throws IOException { | |||
FileUtils.close(in); | |||
cleanUpClassLoaders(classLoadersToCleanUp); | |||
} | |||
protected void finalize() throws Throwable { | |||
try { | |||
close(); | |||
} finally { | |||
super.finalize(); | |||
} | |||
} | |||
}; | |||
return new ChainReader(instream, classLoadersToCleanUp); | |||
} | |||
/** | |||
@@ -199,9 +281,7 @@ public final class ChainReaderHelper { | |||
* Deregisters Classloaders from the project so GC can remove them later. | |||
*/ | |||
private static void cleanUpClassLoaders(List<AntClassLoader> loaders) { | |||
for (Iterator<AntClassLoader> it = loaders.iterator(); it.hasNext();) { | |||
it.next().cleanup(); | |||
} | |||
loaders.forEach(AntClassLoader::cleanup); | |||
} | |||
/** | |||
@@ -211,8 +291,7 @@ public final class ChainReaderHelper { | |||
* @return the contents of the file as a string | |||
* @exception IOException if an error occurs | |||
*/ | |||
public String readFully(Reader rdr) | |||
throws IOException { | |||
public String readFully(Reader rdr) throws IOException { | |||
return FileUtils.readFully(rdr, bufferSize); | |||
} | |||
@@ -227,57 +306,45 @@ public final class ChainReaderHelper { | |||
final List<AntClassLoader> classLoadersToCleanUp) { | |||
final String className = filter.getClassName(); | |||
final Path classpath = filter.getClasspath(); | |||
final Project pro = filter.getProject(); | |||
if (className != null) { | |||
try { | |||
Class<?> clazz = null; | |||
if (classpath == null) { | |||
clazz = Class.forName(className); | |||
} else { | |||
AntClassLoader al = pro.createClassLoader(classpath); | |||
classLoadersToCleanUp.add(al); | |||
clazz = Class.forName(className, true, al); | |||
} | |||
if (clazz != null) { | |||
if (!FilterReader.class.isAssignableFrom(clazz)) { | |||
throw new BuildException(className + " does not extend" | |||
+ " java.io.FilterReader"); | |||
} | |||
final Constructor<?>[] constructors = clazz.getConstructors(); | |||
int j = 0; | |||
boolean consPresent = false; | |||
for (; j < constructors.length; j++) { | |||
Class<?>[] types = constructors[j].getParameterTypes(); | |||
if (types.length == 1 | |||
&& types[0].isAssignableFrom(Reader.class)) { | |||
consPresent = true; | |||
break; | |||
} | |||
} | |||
if (!consPresent) { | |||
throw new BuildException(className + " does not define" | |||
+ " a public constructor" | |||
+ " that takes in a Reader" | |||
+ " as its single argument."); | |||
} | |||
final Reader[] rdr = {ancestor}; | |||
Reader instream = | |||
(Reader) constructors[j].newInstance((Object[]) rdr); | |||
setProjectOnObject(instream); | |||
if (Parameterizable.class.isAssignableFrom(clazz)) { | |||
final Parameter[] params = filter.getParams(); | |||
((Parameterizable) instream).setParameters(params); | |||
Class<? extends FilterReader> clazz; | |||
try { | |||
if (classpath == null) { | |||
clazz = Class.forName(className) | |||
.asSubclass(FilterReader.class); | |||
} else { | |||
AntClassLoader al = | |||
filter.getProject().createClassLoader(classpath); | |||
classLoadersToCleanUp.add(al); | |||
clazz = Class.forName(className, true, al) | |||
.asSubclass(FilterReader.class); | |||
} | |||
return instream; | |||
} catch (ClassCastException ex) { | |||
throw new BuildException("%s does not extend %s", className, | |||
FilterReader.class.getName()); | |||
} | |||
Optional<Constructor<?>> ctor = | |||
Stream.of(clazz.getConstructors()) | |||
.filter(c -> c.getParameterCount() == 1 | |||
&& c.getParameterTypes()[0] | |||
.isAssignableFrom(Reader.class)) | |||
.findFirst(); | |||
Object instream = ctor | |||
.orElseThrow(() -> new BuildException( | |||
"%s does not define a public constructor that takes in a %s as its single argument.", | |||
className, Reader.class.getSimpleName())) | |||
.newInstance(ancestor); | |||
setProjectOnObject(instream); | |||
if (Parameterizable.class.isAssignableFrom(clazz)) { | |||
((Parameterizable) instream).setParameters(filter.getParams()); | |||
} | |||
} catch (final ClassNotFoundException cnfe) { | |||
throw new BuildException(cnfe); | |||
} catch (final InstantiationException ie) { | |||
throw new BuildException(ie); | |||
} catch (final IllegalAccessException iae) { | |||
throw new BuildException(iae); | |||
} catch (final InvocationTargetException ite) { | |||
throw new BuildException(ite); | |||
return (Reader) instream; | |||
} catch (ClassNotFoundException | InstantiationException | |||
| IllegalAccessException | InvocationTargetException ex) { | |||
throw new BuildException(ex); | |||
} | |||
} | |||
// Ant 1.7.1 and earlier ignore <filterreader> without a | |||
@@ -88,6 +88,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* | |||
* @since Ant 1.8.0 | |||
*/ | |||
@Override | |||
public boolean canParseAntlibDescriptor(Resource resource) { | |||
return true; | |||
} | |||
@@ -102,6 +103,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* | |||
* @since Ant 1.8.0 | |||
*/ | |||
@Override | |||
public UnknownElement parseAntlibDescriptor(Project containingProject, | |||
Resource resource) { | |||
URLProvider up = resource.as(URLProvider.class); | |||
@@ -143,6 +145,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @param source the xml source | |||
* @exception BuildException if an error occurs | |||
*/ | |||
@Override | |||
public void parse(Project project, Object source) throws BuildException { | |||
getImportStack().addElement(source); | |||
AntXMLContext context = null; | |||
@@ -256,7 +259,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
zf = new ZipFile(org.apache.tools.ant.launch.Locator | |||
.fromJarURI(uri), "UTF-8"); | |||
inputStream = | |||
zf.getInputStream(zf.getEntry(uri.substring(pling + 1))); | |||
zf.getInputStream(zf.getEntry(uri.substring(pling + 2))); | |||
} else { | |||
URLConnection conn = url.openConnection(); | |||
conn.setUseCaches(false); | |||
@@ -521,6 +524,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* document. Will not be <code>null</code>. | |||
* @return an inputsource for this identifier | |||
*/ | |||
@Override | |||
public InputSource resolveEntity(String publicId, String systemId) { | |||
context.getProject().log("resolving systemId: " + systemId, Project.MSG_VERBOSE); | |||
@@ -566,6 +570,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @exception org.xml.sax.SAXParseException if the tag given is not | |||
* <code>"project"</code> | |||
*/ | |||
@Override | |||
public void startElement(String uri, String tag, String qname, Attributes attrs) | |||
throws SAXParseException { | |||
AntHandler next = currentHandler.onStartChild(uri, tag, qname, attrs, context); | |||
@@ -580,6 +585,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @param locator The locator used by the parser. | |||
* Will not be <code>null</code>. | |||
*/ | |||
@Override | |||
public void setDocumentLocator(Locator locator) { | |||
context.setLocator(locator); | |||
} | |||
@@ -595,9 +601,10 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* | |||
* @exception SAXException in case of error (not thrown in this implementation) | |||
*/ | |||
@Override | |||
public void endElement(String uri, String name, String qName) throws SAXException { | |||
currentHandler.onEndElement(uri, name, context); | |||
AntHandler prev = (AntHandler) antHandlers.pop(); | |||
AntHandler prev = antHandlers.pop(); | |||
currentHandler = prev; | |||
if (currentHandler != null) { | |||
currentHandler.onEndChild(uri, name, qName, context); | |||
@@ -612,6 +619,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @param count The number of characters to read. | |||
* @exception SAXParseException if an error occurs | |||
*/ | |||
@Override | |||
public void characters(char[] buf, int start, int count) throws SAXParseException { | |||
currentHandler.characters(buf, start, count, context); | |||
} | |||
@@ -622,6 +630,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @param prefix the namespace prefix | |||
* @param uri the namespace uri | |||
*/ | |||
@Override | |||
public void startPrefixMapping(String prefix, String uri) { | |||
context.startPrefixMapping(prefix, uri); | |||
} | |||
@@ -631,6 +640,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* | |||
* @param prefix the prefix that is not mapped anymore | |||
*/ | |||
@Override | |||
public void endPrefixMapping(String prefix) { | |||
context.endPrefixMapping(prefix); | |||
} | |||
@@ -654,6 +664,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @return The project handler that handles subelements of project | |||
* @exception SAXParseException if the qualified name is not "project". | |||
*/ | |||
@Override | |||
public AntHandler onStartChild(String uri, String name, String qname, Attributes attrs, | |||
AntXMLContext context) throws SAXParseException { | |||
if (name.equals("project") | |||
@@ -693,6 +704,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* encountered or if the <code>"default"</code> attribute | |||
* is missing. | |||
*/ | |||
@Override | |||
public void onStartElement(String uri, String tag, String qname, Attributes attrs, | |||
AntXMLContext context) throws SAXParseException { | |||
String baseDir = null; | |||
@@ -849,6 +861,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* <code>"extension-point"</code> | |||
* or a data type definition | |||
*/ | |||
@Override | |||
public AntHandler onStartChild(String uri, String name, String qname, Attributes attrs, | |||
AntXMLContext context) throws SAXParseException { | |||
return (name.equals("target") || name.equals("extension-point")) | |||
@@ -882,6 +895,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @exception SAXParseException if an unexpected attribute is encountered | |||
* or if the <code>"name"</code> attribute is missing. | |||
*/ | |||
@Override | |||
public void onStartElement(String uri, String tag, String qname, Attributes attrs, | |||
AntXMLContext context) throws SAXParseException { | |||
String name = null; | |||
@@ -1062,6 +1076,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @exception SAXParseException if an error occurs when initialising | |||
* the appropriate child handler | |||
*/ | |||
@Override | |||
public AntHandler onStartChild(String uri, String name, String qname, Attributes attrs, | |||
AntXMLContext context) throws SAXParseException { | |||
return ProjectHelper2.elementHandler; | |||
@@ -1075,6 +1090,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @param tag The name of the element. | |||
* @param context The current context. | |||
*/ | |||
@Override | |||
public void onEndElement(String uri, String tag, AntXMLContext context) { | |||
context.setCurrentTarget(context.getImplicitTarget()); | |||
} | |||
@@ -1109,6 +1125,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @exception SAXParseException in case of error (not thrown in | |||
* this implementation) | |||
*/ | |||
@Override | |||
public void onStartElement(String uri, String tag, String qname, Attributes attrs, | |||
AntXMLContext context) throws SAXParseException { | |||
RuntimeConfigurable parentWrapper = context.currentWrapper(); | |||
@@ -1195,6 +1212,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* | |||
* @see ProjectHelper#addText(Project,java.lang.Object,char[],int,int) | |||
*/ | |||
@Override | |||
public void characters(char[] buf, int start, int count, | |||
AntXMLContext context) throws SAXParseException { | |||
RuntimeConfigurable wrapper = context.currentWrapper(); | |||
@@ -1218,6 +1236,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @exception SAXParseException if an error occurs when initialising | |||
* the appropriate child handler | |||
*/ | |||
@Override | |||
public AntHandler onStartChild(String uri, String tag, String qname, Attributes attrs, | |||
AntXMLContext context) throws SAXParseException { | |||
return ProjectHelper2.elementHandler; | |||
@@ -1231,6 +1250,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
* @param tag The name of the element. | |||
* @param context The current context. | |||
*/ | |||
@Override | |||
public void onEndElement(String uri, String tag, AntXMLContext context) { | |||
context.popWrapper(); | |||
} | |||
@@ -18,6 +18,7 @@ | |||
package org.apache.tools.ant.input; | |||
import java.util.Collection; | |||
import java.util.LinkedHashSet; | |||
import java.util.Vector; | |||
@@ -33,26 +34,39 @@ public class MultipleChoiceInputRequest extends InputRequest { | |||
* @param prompt The prompt to show to the user. Must not be null. | |||
* @param choices holds all input values that are allowed. | |||
* Must not be null. | |||
* @deprecated Use {@link #MultipleChoiceInputRequest(String,Collection)} instead | |||
*/ | |||
@Deprecated | |||
public MultipleChoiceInputRequest(String prompt, Vector<String> choices) { | |||
this(prompt, (Collection<String>) choices); | |||
} | |||
/** | |||
* @param prompt The prompt to show to the user. Must not be null. | |||
* @param choices holds all input values that are allowed. | |||
* Must not be null. | |||
*/ | |||
public MultipleChoiceInputRequest(String prompt, Collection<String> choices) { | |||
super(prompt); | |||
if (choices == null) { | |||
throw new IllegalArgumentException("choices must not be null"); | |||
} | |||
this.choices = new LinkedHashSet<String>(choices); | |||
this.choices = new LinkedHashSet<>(choices); | |||
} | |||
/** | |||
* @return The possible values. | |||
*/ | |||
public Vector<String> getChoices() { | |||
return new Vector<String>(choices); | |||
return new Vector<>(choices); | |||
} | |||
/** | |||
* @return true if the input is one of the allowed values. | |||
*/ | |||
@Override | |||
public boolean isInputValid() { | |||
return choices.contains(getInput()) || ("".equals(getInput()) && getDefaultValue() != null); | |||
return choices.contains(getInput()) | |||
|| ("".equals(getInput()) && getDefaultValue() != null); | |||
} | |||
} |
@@ -25,9 +25,6 @@ import java.util.ArrayList; | |||
import java.util.List; | |||
import java.util.StringTokenizer; | |||
/** | |||
* This is a launcher for Ant. | |||
* | |||
@@ -35,9 +32,6 @@ import java.util.StringTokenizer; | |||
*/ | |||
public class Launcher { | |||
private Launcher() { | |||
} | |||
/** | |||
* The Ant Home (installation) Directory property. | |||
* {@value} | |||
@@ -62,11 +56,6 @@ public class Launcher { | |||
*/ | |||
public static final String ANT_PRIVATELIB = "lib"; | |||
/** | |||
* launch diagnostics flag; for debugging trouble at launch time. | |||
*/ | |||
public boolean launchDiag = false; | |||
/** | |||
* The location of a per-user library directory. | |||
* <p> | |||
@@ -127,6 +116,13 @@ public class Launcher { | |||
} | |||
} | |||
/** | |||
* launch diagnostics flag; for debugging trouble at launch time. | |||
*/ | |||
public boolean launchDiag = false; | |||
private Launcher() { | |||
} | |||
/** | |||
* Add a CLASSPATH or -lib to lib path urls. | |||
@@ -156,7 +152,7 @@ public class Launcher { | |||
} | |||
} | |||
final URL url = Locator.fileToURL(element); | |||
final URL url = new URL(element.toURI().toASCIIString()); | |||
if (launchDiag) { | |||
System.out.println("adding library URL: " + url); | |||
} | |||
@@ -193,44 +189,45 @@ public class Launcher { | |||
} | |||
if (!antHome.exists()) { | |||
throw new LaunchException("Ant home is set incorrectly or " | |||
+ "ant could not be located (estimated value="+antHome.getAbsolutePath()+")"); | |||
throw new LaunchException( | |||
"Ant home is set incorrectly or ant could not be located (estimated value=" | |||
+ antHome.getAbsolutePath() + ")"); | |||
} | |||
final List<String> libPaths = new ArrayList<String>(); | |||
final List<String> libPaths = new ArrayList<>(); | |||
String cpString = null; | |||
final List<String> argList = new ArrayList<String>(); | |||
final List<String> argList = new ArrayList<>(); | |||
String[] newArgs; | |||
boolean noUserLib = false; | |||
boolean noClassPath = false; | |||
for (int i = 0; i < args.length; ++i) { | |||
if (args[i].equals("-lib")) { | |||
if ("-lib".equals(args[i])) { | |||
if (i == args.length - 1) { | |||
throw new LaunchException("The -lib argument must " | |||
+ "be followed by a library location"); | |||
throw new LaunchException( | |||
"The -lib argument must be followed by a library location"); | |||
} | |||
libPaths.add(args[++i]); | |||
} else if (args[i].equals("-cp")) { | |||
} else if ("-cp".equals(args[i])) { | |||
if (i == args.length - 1) { | |||
throw new LaunchException("The -cp argument must " | |||
+ "be followed by a classpath expression"); | |||
throw new LaunchException( | |||
"The -cp argument must be followed by a classpath expression"); | |||
} | |||
if (cpString != null) { | |||
throw new LaunchException("The -cp argument must " | |||
+ "not be repeated"); | |||
throw new LaunchException( | |||
"The -cp argument must not be repeated"); | |||
} | |||
cpString = args[++i]; | |||
} else if (args[i].equals("--nouserlib") || args[i].equals("-nouserlib")) { | |||
} else if ("--nouserlib".equals(args[i]) || "-nouserlib".equals(args[i])) { | |||
noUserLib = true; | |||
} else if (args[i].equals("--launchdiag")) { | |||
} else if ("--launchdiag".equals(args[i])) { | |||
launchDiag = true; | |||
} else if (args[i].equals("--noclasspath") || args[i].equals("-noclasspath")) { | |||
} else if ("--noclasspath".equals(args[i]) || "-noclasspath".equals(args[i])) { | |||
noClassPath = true; | |||
} else if (args[i].equals("-main")) { | |||
} else if ("-main".equals(args[i])) { | |||
if (i == args.length - 1) { | |||
throw new LaunchException("The -main argument must " | |||
+ "be followed by a library location"); | |||
throw new LaunchException( | |||
"The -main argument must be followed by a library location"); | |||
} | |||
mainClassname = args[++i]; | |||
} else { | |||
@@ -262,8 +259,8 @@ public class Launcher { | |||
libURLs, userURLs, systemURLs, toolsJAR); | |||
// now update the class.path property | |||
final StringBuffer baseClassPath | |||
= new StringBuffer(System.getProperty(JAVA_CLASS_PATH)); | |||
final StringBuilder baseClassPath | |||
= new StringBuilder(System.getProperty(JAVA_CLASS_PATH)); | |||
if (baseClassPath.charAt(baseClassPath.length() - 1) | |||
== File.pathSeparatorChar) { | |||
baseClassPath.setLength(baseClassPath.length() - 1); | |||
@@ -278,12 +275,12 @@ public class Launcher { | |||
final URLClassLoader loader = new URLClassLoader(jars, Launcher.class.getClassLoader()); | |||
Thread.currentThread().setContextClassLoader(loader); | |||
Class<?> mainClass = null; | |||
Class<? extends AntMain> mainClass = null; | |||
int exitCode = 0; | |||
Throwable thrown=null; | |||
try { | |||
mainClass = loader.loadClass(mainClassname); | |||
final AntMain main = (AntMain) mainClass.newInstance(); | |||
mainClass = loader.loadClass(mainClassname).asSubclass(AntMain.class); | |||
final AntMain main = mainClass.newInstance(); | |||
main.startAnt(newArgs, null, null); | |||
} catch (final InstantiationException ex) { | |||
System.err.println( | |||
@@ -320,7 +317,7 @@ public class Launcher { | |||
*/ | |||
private URL[] getLibPathURLs(final String cpString, final List<String> libPaths) | |||
throws MalformedURLException { | |||
final List<URL> libPathURLs = new ArrayList<URL>(); | |||
final List<URL> libPathURLs = new ArrayList<>(); | |||
if (cpString != null) { | |||
addPath(cpString, false, libPathURLs); | |||
@@ -389,7 +386,7 @@ public class Launcher { | |||
systemJars.length); | |||
if (toolsJar != null) { | |||
jars[jars.length - 1] = Locator.fileToURL(toolsJar); | |||
jars[jars.length - 1] = new URL(toolsJar.toURI().toASCIIString()); | |||
} | |||
return jars; | |||
} | |||
@@ -407,8 +404,8 @@ public class Launcher { | |||
} | |||
private void logPath(final String name,final File path) { | |||
if(launchDiag) { | |||
System.out.println(name+"= \""+path+"\""); | |||
if (launchDiag) { | |||
System.out.println(name + "= \"" + path + "\""); | |||
} | |||
} | |||
} |
@@ -19,7 +19,6 @@ package org.apache.tools.ant.launch; | |||
import java.io.ByteArrayOutputStream; | |||
import java.io.File; | |||
import java.io.FilenameFilter; | |||
import java.io.UnsupportedEncodingException; | |||
import java.net.MalformedURLException; | |||
import java.net.URL; | |||
@@ -27,6 +26,7 @@ import java.nio.charset.StandardCharsets; | |||
import java.text.CharacterIterator; | |||
import java.text.StringCharacterIterator; | |||
import java.util.Locale; | |||
import java.util.stream.Stream; | |||
// CheckStyle:LineLengthCheck OFF - urls are long! | |||
/** | |||
@@ -95,11 +95,6 @@ public final class Locator { | |||
gAfterEscaping2[ch] = gHexChs[ch & NIBBLE_MASK]; | |||
} | |||
} | |||
/** | |||
* Not instantiable | |||
*/ | |||
private Locator() { | |||
} | |||
/** | |||
* Find the directory or jar file the class has been loaded from. | |||
@@ -130,7 +125,7 @@ public final class Locator { | |||
if (c == null) { | |||
c = Locator.class.getClassLoader(); | |||
} | |||
URL url = null; | |||
URL url; | |||
if (c == null) { | |||
url = ClassLoader.getSystemResource(resource); | |||
} else { | |||
@@ -141,21 +136,19 @@ public final class Locator { | |||
try { | |||
if (u.startsWith("jar:file:")) { | |||
return new File(fromJarURI(u)); | |||
} else if (u.startsWith("file:")) { | |||
} | |||
if (u.startsWith("file:")) { | |||
int tail = u.indexOf(resource); | |||
String dirName = u.substring(0, tail); | |||
return new File(fromURI(dirName)); | |||
} | |||
} catch (IllegalArgumentException e) { | |||
//unable to determine the URI for reasons unknown. | |||
return null; | |||
} | |||
} | |||
return null; | |||
} | |||
/** | |||
* Constructs a file path from a <code>file:</code> URI. | |||
* | |||
@@ -234,7 +227,7 @@ public final class Locator { | |||
if (url == null || !("file".equals(url.getProtocol()))) { | |||
throw new IllegalArgumentException(ERROR_NOT_FILE_URI + uri); | |||
} | |||
StringBuffer buf = new StringBuffer(url.getHost()); | |||
StringBuilder buf = new StringBuilder(url.getHost()); | |||
if (buf.length() > 0) { | |||
buf.insert(0, File.separatorChar).insert(0, File.separatorChar); | |||
} | |||
@@ -330,7 +323,7 @@ public final class Locator { | |||
int i = 0; | |||
int len = path.length(); | |||
int ch = 0; | |||
StringBuffer sb = null; | |||
StringBuilder sb = null; | |||
for (; i < len; i++) { | |||
ch = path.charAt(i); | |||
// if it's not an ASCII character, break here, and use UTF-8 encoding | |||
@@ -339,7 +332,7 @@ public final class Locator { | |||
} | |||
if (gNeedEscaping[ch]) { | |||
if (sb == null) { | |||
sb = new StringBuffer(path.substring(0, i)); | |||
sb = new StringBuilder(path.substring(0, i)); | |||
} | |||
sb.append('%'); | |||
sb.append(gAfterEscaping1[ch]); | |||
@@ -353,17 +346,15 @@ public final class Locator { | |||
// we saw some non-ascii character | |||
if (i < len) { | |||
if (sb == null) { | |||
sb = new StringBuffer(path.substring(0, i)); | |||
sb = new StringBuilder(path.substring(0, i)); | |||
} | |||
// get UTF-8 bytes for the remaining sub-string | |||
byte[] bytes = null; | |||
byte b; | |||
bytes = path.substring(i).getBytes(StandardCharsets.UTF_8); | |||
byte[] bytes = path.substring(i).getBytes(StandardCharsets.UTF_8); | |||
len = bytes.length; | |||
// for each byte | |||
for (i = 0; i < len; i++) { | |||
b = bytes[i]; | |||
byte b = bytes[i]; | |||
// for non-ascii character: make it positive, then escape | |||
if (b < 0) { | |||
ch = b + BYTE_SIZE; | |||
@@ -466,7 +457,7 @@ public final class Locator { | |||
*/ | |||
public static URL[] getLocationURLs(File location) | |||
throws MalformedURLException { | |||
return getLocationURLs(location, new String[]{".jar"}); | |||
return getLocationURLs(location, ".jar"); | |||
} | |||
/** | |||
@@ -484,7 +475,7 @@ public final class Locator { | |||
* formed. | |||
*/ | |||
public static URL[] getLocationURLs(File location, | |||
final String[] extensions) | |||
final String... extensions) | |||
throws MalformedURLException { | |||
URL[] urls = new URL[0]; | |||
@@ -503,22 +494,21 @@ public final class Locator { | |||
} | |||
return urls; | |||
} | |||
File[] matches = location.listFiles( | |||
new FilenameFilter() { | |||
public boolean accept(File dir, String name) { | |||
String littleName = name.toLowerCase(Locale.ENGLISH); | |||
for (int i = 0; i < extensions.length; ++i) { | |||
if (littleName.endsWith(extensions[i])) { | |||
return true; | |||
} | |||
} | |||
return false; | |||
} | |||
}); | |||
File[] matches = location.listFiles((dir, name) -> { | |||
String littleName = name.toLowerCase(Locale.ENGLISH); | |||
return Stream.of(extensions).anyMatch(x -> littleName.endsWith(x)); | |||
}); | |||
urls = new URL[matches.length]; | |||
for (int i = 0; i < matches.length; ++i) { | |||
urls[i] = fileToURL(matches[i]); | |||
} | |||
return urls; | |||
} | |||
/** | |||
* Not instantiable | |||
*/ | |||
private Locator() { | |||
} | |||
} |
@@ -213,7 +213,7 @@ public class AnsiColorLogger extends DefaultLogger { | |||
colorsSet = true; | |||
} | |||
final StringBuffer msg = new StringBuffer(message); | |||
final StringBuilder msg = new StringBuilder(message); | |||
switch (priority) { | |||
case Project.MSG_ERR: | |||
msg.insert(0, errColor); | |||
@@ -102,6 +102,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
} | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void buildStarted(final BuildEvent event) { | |||
final String categoryString = PROJECT_LOG; | |||
final Log log = getLog(categoryString, null); | |||
@@ -112,6 +113,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
} | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void buildFinished(final BuildEvent event) { | |||
if (initialized) { | |||
final String categoryString = PROJECT_LOG; | |||
@@ -130,6 +132,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
* @see BuildListener#targetStarted | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void targetStarted(final BuildEvent event) { | |||
if (initialized) { | |||
final Log log = getLog(TARGET_LOG, | |||
@@ -145,6 +148,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
* @see BuildListener#targetFinished | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void targetFinished(final BuildEvent event) { | |||
if (initialized) { | |||
final String targetName = event.getTarget().getName(); | |||
@@ -164,6 +168,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
* @see BuildListener#taskStarted | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void taskStarted(final BuildEvent event) { | |||
if (initialized) { | |||
final Task task = event.getTask(); | |||
@@ -186,6 +191,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
* @see BuildListener#taskFinished | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void taskFinished(final BuildEvent event) { | |||
if (initialized) { | |||
final Task task = event.getTask(); | |||
@@ -215,16 +221,16 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
* @see BuildListener#messageLogged | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void messageLogged(final BuildEvent event) { | |||
if (initialized) { | |||
Object categoryObject = event.getTask(); | |||
String categoryString = null; | |||
String categoryString; | |||
String categoryDetail = null; | |||
if (categoryObject == null) { | |||
categoryObject = event.getTarget(); | |||
if (categoryObject == null) { | |||
categoryObject = event.getProject(); | |||
categoryString = PROJECT_LOG; | |||
categoryDetail = event.getProject().getName(); | |||
} else { | |||
@@ -300,6 +306,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
* This is not used, the logger config is used instead. | |||
* @param level ignored | |||
*/ | |||
@Override | |||
public void setMessageOutputLevel(final int level) { | |||
// Use the logger config | |||
} | |||
@@ -308,6 +315,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
* Set the output print stream. | |||
* @param output the output stream | |||
*/ | |||
@Override | |||
public void setOutputPrintStream(final PrintStream output) { | |||
this.out = output; | |||
} | |||
@@ -317,6 +325,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
* This is ignored. | |||
* @param emacsMode ignored | |||
*/ | |||
@Override | |||
public void setEmacsMode(final boolean emacsMode) { | |||
// Doesn't make sense for c-l. Use the logger config | |||
} | |||
@@ -325,6 +334,7 @@ public class CommonsLoggingListener implements BuildListener, BuildLogger { | |||
* Set the error print stream. | |||
* @param err the error stream | |||
*/ | |||
@Override | |||
public void setErrorPrintStream(final PrintStream err) { | |||
this.err = err; | |||
} | |||
@@ -33,14 +33,14 @@ import org.apache.tools.ant.Task; | |||
*/ | |||
public class Log4jListener implements BuildListener { | |||
/** Indicates if the listener was initialized. */ | |||
private final boolean initialized; | |||
/** | |||
* log category we log into | |||
*/ | |||
public static final String LOG_ANT = "org.apache.tools.ant"; | |||
/** Indicates if the listener was initialized. */ | |||
private final boolean initialized; | |||
/** | |||
* Construct the listener and make sure there is a valid appender. | |||
*/ | |||
@@ -57,6 +57,7 @@ public class Log4jListener implements BuildListener { | |||
* @see BuildListener#buildStarted | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void buildStarted(final BuildEvent event) { | |||
if (initialized) { | |||
final Logger log = Logger.getLogger(Project.class.getName()); | |||
@@ -68,6 +69,7 @@ public class Log4jListener implements BuildListener { | |||
* @see BuildListener#buildFinished | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void buildFinished(final BuildEvent event) { | |||
if (initialized) { | |||
final Logger log = Logger.getLogger(Project.class.getName()); | |||
@@ -83,6 +85,7 @@ public class Log4jListener implements BuildListener { | |||
* @see BuildListener#targetStarted | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void targetStarted(final BuildEvent event) { | |||
if (initialized) { | |||
final Logger log = Logger.getLogger(Target.class.getName()); | |||
@@ -94,6 +97,7 @@ public class Log4jListener implements BuildListener { | |||
* @see BuildListener#targetFinished | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void targetFinished(final BuildEvent event) { | |||
if (initialized) { | |||
final String targetName = event.getTarget().getName(); | |||
@@ -111,6 +115,7 @@ public class Log4jListener implements BuildListener { | |||
* @see BuildListener#taskStarted | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void taskStarted(final BuildEvent event) { | |||
if (initialized) { | |||
final Task task = event.getTask(); | |||
@@ -123,6 +128,7 @@ public class Log4jListener implements BuildListener { | |||
* @see BuildListener#taskFinished | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void taskFinished(final BuildEvent event) { | |||
if (initialized) { | |||
final Task task = event.getTask(); | |||
@@ -140,6 +146,7 @@ public class Log4jListener implements BuildListener { | |||
* @see BuildListener#messageLogged | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public void messageLogged(final BuildEvent event) { | |||
if (initialized) { | |||
Object categoryObject = event.getTask(); | |||
@@ -24,10 +24,12 @@ import java.io.PrintStream; | |||
import java.nio.file.Files; | |||
import java.nio.file.Paths; | |||
import java.util.Enumeration; | |||
import java.util.Hashtable; | |||
import java.util.Map; | |||
import java.util.Properties; | |||
import java.util.StringTokenizer; | |||
import java.util.Vector; | |||
import java.util.stream.Collectors; | |||
import java.util.stream.Stream; | |||
import org.apache.tools.ant.BuildEvent; | |||
import org.apache.tools.ant.BuildException; | |||
@@ -97,21 +99,22 @@ import org.apache.tools.mail.MailMessage; | |||
* | |||
*/ | |||
public class MailLogger extends DefaultLogger { | |||
private static final String DEFAULT_MIME_TYPE = "text/plain"; | |||
/** Buffer in which the message is constructed prior to sending */ | |||
private StringBuffer buffer = new StringBuffer(); | |||
private static final String DEFAULT_MIME_TYPE = "text/plain"; | |||
/** | |||
* Sends an e-mail with the log results. | |||
* | |||
* @param event the build finished event | |||
*/ | |||
@Override | |||
public void buildFinished(BuildEvent event) { | |||
super.buildFinished(event); | |||
Project project = event.getProject(); | |||
Hashtable<String, Object> properties = project.getProperties(); | |||
Map<String, Object> properties = project.getProperties(); | |||
// overlay specified properties file (if any), which overrides project | |||
// settings | |||
@@ -168,8 +171,8 @@ public class MailLogger extends DefaultLogger { | |||
.subject(getValue( | |||
properties, prefix + ".subject", | |||
(success) ? "Build Success" : "Build Failure")); | |||
if (values.user().equals("") | |||
&& values.password().equals("") | |||
if (values.user().isEmpty() | |||
&& values.password().isEmpty() | |||
&& !values.ssl() && !values.starttls()) { | |||
sendMail(values, buffer.substring(0)); | |||
} else { | |||
@@ -310,6 +313,7 @@ public class MailLogger extends DefaultLogger { | |||
* | |||
* @param message the message being logger | |||
*/ | |||
@Override | |||
protected void log(String message) { | |||
buffer.append(message).append(StringUtils.LINE_SEP); | |||
} | |||
@@ -327,7 +331,7 @@ public class MailLogger extends DefaultLogger { | |||
* @exception Exception thrown if no default value is specified and the | |||
* property is not present in properties. | |||
*/ | |||
private String getValue(Hashtable<String, Object> properties, String name, | |||
private String getValue(Map<String, Object> properties, String name, | |||
String defaultValue) { | |||
String propertyName = "MailLogger." + name; | |||
String value = (String) properties.get(propertyName); | |||
@@ -356,7 +360,7 @@ public class MailLogger extends DefaultLogger { | |||
mailMessage.setHeader("Date", DateUtils.getDateForHeader()); | |||
mailMessage.from(values.from()); | |||
if (!values.replytoList().equals("")) { | |||
if (!values.replytoList().isEmpty()) { | |||
StringTokenizer t = new StringTokenizer( | |||
values.replytoList(), ", ", false); | |||
while (t.hasMoreTokens()) { | |||
@@ -391,7 +395,7 @@ public class MailLogger extends DefaultLogger { | |||
private void sendMimeMail(Project project, Values values, String message) { | |||
Mailer mailer = null; | |||
try { | |||
mailer = (Mailer) ClasspathUtils.newInstance( | |||
mailer = ClasspathUtils.newInstance( | |||
"org.apache.tools.ant.taskdefs.email.MimeMailer", | |||
MailLogger.class.getClassLoader(), Mailer.class); | |||
} catch (BuildException e) { | |||
@@ -400,7 +404,7 @@ public class MailLogger extends DefaultLogger { | |||
return; | |||
} | |||
// convert the replyTo string into a vector of emailaddresses | |||
Vector<EmailAddress> replyToList = vectorizeEmailAddresses(values.replytoList()); | |||
Vector<EmailAddress> replyToList = splitEmailAddresses(values.replytoList()); | |||
mailer.setHost(values.mailhost()); | |||
mailer.setPort(values.port()); | |||
mailer.setUser(values.user()); | |||
@@ -417,25 +421,20 @@ public class MailLogger extends DefaultLogger { | |||
mailer.setMessage(mymessage); | |||
mailer.setFrom(new EmailAddress(values.from())); | |||
mailer.setReplyToList(replyToList); | |||
Vector<EmailAddress> toList = vectorizeEmailAddresses(values.toList()); | |||
Vector<EmailAddress> toList = splitEmailAddresses(values.toList()); | |||
mailer.setToList(toList); | |||
Vector<EmailAddress> toCcList = vectorizeEmailAddresses(values.toCcList()); | |||
Vector<EmailAddress> toCcList = splitEmailAddresses(values.toCcList()); | |||
mailer.setCcList(toCcList); | |||
Vector<EmailAddress> toBccList = vectorizeEmailAddresses(values.toBccList()); | |||
Vector<EmailAddress> toBccList = splitEmailAddresses(values.toBccList()); | |||
mailer.setBccList(toBccList); | |||
mailer.setFiles(new Vector<File>()); | |||
mailer.setSubject(values.subject()); | |||
mailer.setHeaders(new Vector<Header>()); | |||
mailer.send(); | |||
} | |||
private Vector<EmailAddress> vectorizeEmailAddresses(String listString) { | |||
Vector<EmailAddress> emailList = new Vector<EmailAddress>(); | |||
StringTokenizer tokens = new StringTokenizer(listString, ","); | |||
while (tokens.hasMoreTokens()) { | |||
emailList.addElement(new EmailAddress(tokens.nextToken())); | |||
} | |||
return emailList; | |||
private Vector<EmailAddress> splitEmailAddresses(String listString) { | |||
return Stream.of(listString.split(",")).map(EmailAddress::new) | |||
.collect(Collectors.toCollection(Vector::new)); | |||
} | |||
} | |||
@@ -32,7 +32,7 @@ import org.apache.tools.ant.util.StringUtils; | |||
*/ | |||
public class ProfileLogger extends DefaultLogger { | |||
private Map<Object, Date> profileData = new ConcurrentHashMap<Object, Date>(); | |||
private Map<Object, Date> profileData = new ConcurrentHashMap<>(); | |||
/** | |||
* Logs a message to say that the target has started. | |||
@@ -41,6 +41,7 @@ public class ProfileLogger extends DefaultLogger { | |||
* An event with any relevant extra information. Must not be | |||
* <code>null</code>. | |||
*/ | |||
@Override | |||
public void targetStarted(BuildEvent event) { | |||
Date now = new Date(); | |||
String name = "Target " + event.getTarget().getName(); | |||
@@ -55,8 +56,9 @@ public class ProfileLogger extends DefaultLogger { | |||
* An event with any relevant extra information. Must not be | |||
* <code>null</code>. | |||
*/ | |||
@Override | |||
public void targetFinished(BuildEvent event) { | |||
Date start = (Date) profileData.remove(event.getTarget()); | |||
Date start = profileData.remove(event.getTarget()); | |||
String name = "Target " + event.getTarget().getName(); | |||
logFinish(event, start, name); | |||
} | |||
@@ -68,6 +70,7 @@ public class ProfileLogger extends DefaultLogger { | |||
* An event with any relevant extra information. Must not be | |||
* <code>null</code>. | |||
*/ | |||
@Override | |||
public void taskStarted(BuildEvent event) { | |||
String name = event.getTask().getTaskName(); | |||
Date now = new Date(); | |||
@@ -82,15 +85,16 @@ public class ProfileLogger extends DefaultLogger { | |||
* An event with any relevant extra information. Must not be | |||
* <code>null</code>. | |||
*/ | |||
@Override | |||
public void taskFinished(BuildEvent event) { | |||
Date start = (Date) profileData.remove(event.getTask()); | |||
Date start = profileData.remove(event.getTask()); | |||
String name = event.getTask().getTaskName(); | |||
logFinish(event, start, name); | |||
} | |||
private void logFinish(BuildEvent event, Date start, String name) { | |||
Date now = new Date(); | |||
String msg = null; | |||
String msg; | |||
if (start != null) { | |||
long diff = now.getTime() - start.getTime(); | |||
msg = StringUtils.LINE_SEP + name + ": finished " + now + " (" | |||
@@ -33,14 +33,14 @@ public class SimpleBigProjectLogger extends NoBannerLogger { | |||
* @param event the event to work on | |||
* @return the target name -including the owning project name (if non-null) | |||
*/ | |||
@Override | |||
protected String extractTargetName(BuildEvent event) { | |||
String targetName = super.extractTargetName(event); | |||
String projectName = extractProjectName(event); | |||
if (projectName != null && targetName != null) { | |||
return projectName + '.' + targetName; | |||
} else { | |||
if (projectName == null || targetName == null) { | |||
return targetName; | |||
} | |||
return projectName + '.' + targetName; | |||
} | |||
} |
@@ -30,13 +30,13 @@ public class TimestampedLogger extends DefaultLogger { | |||
*/ | |||
public static final String SPACER = " - at "; | |||
/** | |||
* This is an override point: the message that indicates whether a build failed. | |||
* Subclasses can change/enhance the message. | |||
* | |||
* @return The classic "BUILD FAILED" plus a timestamp | |||
*/ | |||
@Override | |||
protected String getBuildFailedMessage() { | |||
return super.getBuildFailedMessage() + SPACER + getTimestamp(); | |||
} | |||
@@ -47,6 +47,7 @@ public class TimestampedLogger extends DefaultLogger { | |||
* | |||
* @return The classic "BUILD SUCCESSFUL" plus a timestamp | |||
*/ | |||
@Override | |||
protected String getBuildSuccessfulMessage() { | |||
return super.getBuildSuccessfulMessage() + SPACER + getTimestamp(); | |||
} | |||
@@ -36,8 +36,8 @@ public class LocalProperties | |||
* @return the localproperties. | |||
*/ | |||
public static synchronized LocalProperties get(Project project) { | |||
LocalProperties l = (LocalProperties) project.getReference( | |||
MagicNames.REFID_LOCAL_PROPERTIES); | |||
LocalProperties l = | |||
project.getReference(MagicNames.REFID_LOCAL_PROPERTIES); | |||
if (l == null) { | |||
l = new LocalProperties(); | |||
project.addReference(MagicNames.REFID_LOCAL_PROPERTIES, l); | |||
@@ -62,14 +62,11 @@ public class LocalProperties | |||
* Get the initial value. | |||
* @return a new localproperties stack. | |||
*/ | |||
@Override | |||
protected synchronized LocalPropertyStack initialValue() { | |||
return new LocalPropertyStack(); | |||
} | |||
private LocalPropertyStack current() { | |||
return (LocalPropertyStack) get(); | |||
} | |||
// -------------------------------------------------- | |||
// | |||
// Local property adding and scoping | |||
@@ -81,17 +78,17 @@ public class LocalProperties | |||
* @param property the property name to add. | |||
*/ | |||
public void addLocal(String property) { | |||
current().addLocal(property); | |||
get().addLocal(property); | |||
} | |||
/** enter the scope */ | |||
public void enterScope() { | |||
current().enterScope(); | |||
get().enterScope(); | |||
} | |||
/** exit the scope */ | |||
public void exitScope() { | |||
current().exitScope(); | |||
get().exitScope(); | |||
} | |||
// -------------------------------------------------- | |||
@@ -105,7 +102,7 @@ public class LocalProperties | |||
* To be called from the parallel thread itself. | |||
*/ | |||
public void copy() { | |||
set(current().copy()); | |||
set(get().copy()); | |||
} | |||
// -------------------------------------------------- | |||
@@ -120,8 +117,9 @@ public class LocalProperties | |||
* @param helper the invoking PropertyHelper. | |||
* @return Object value. | |||
*/ | |||
@Override | |||
public Object evaluate(String property, PropertyHelper helper) { | |||
return current().evaluate(property, helper); | |||
return get().evaluate(property, helper); | |||
} | |||
/** | |||
@@ -131,9 +129,10 @@ public class LocalProperties | |||
* @param propertyHelper the invoking PropertyHelper. | |||
* @return true if this entity 'owns' the property. | |||
*/ | |||
@Override | |||
public boolean setNew( | |||
String property, Object value, PropertyHelper propertyHelper) { | |||
return current().setNew(property, value, propertyHelper); | |||
return get().setNew(property, value, propertyHelper); | |||
} | |||
/** | |||
@@ -143,10 +142,9 @@ public class LocalProperties | |||
* @param propertyHelper the invoking PropertyHelper. | |||
* @return true if this entity 'owns' the property. | |||
*/ | |||
@Override | |||
public boolean set( | |||
String property, Object value, PropertyHelper propertyHelper) { | |||
return current().set(property, value, propertyHelper); | |||
return get().set(property, value, propertyHelper); | |||
} | |||
} | |||
@@ -17,6 +17,7 @@ | |||
*/ | |||
package org.apache.tools.ant.property; | |||
import java.util.Deque; | |||
import java.util.LinkedList; | |||
import java.util.Map; | |||
import java.util.concurrent.ConcurrentHashMap; | |||
@@ -29,7 +30,7 @@ import org.apache.tools.ant.PropertyHelper; | |||
* @since Ant 1.8.0 | |||
*/ | |||
public class LocalPropertyStack { | |||
private final LinkedList<Map<String, Object>> stack = new LinkedList<Map<String, Object>>(); | |||
private final Deque<Map<String, Object>> stack = new LinkedList<>(); | |||
private final Object LOCK = new Object(); | |||
// -------------------------------------------------- | |||
@@ -32,6 +32,7 @@ public final class NullReturn { | |||
/** | |||
* {@inheritDoc} | |||
*/ | |||
@Override | |||
public String toString() { | |||
return "null"; | |||
} | |||
@@ -19,6 +19,7 @@ package org.apache.tools.ant.property; | |||
import java.text.ParsePosition; | |||
import java.util.Collection; | |||
import java.util.Objects; | |||
import org.apache.tools.ant.Project; | |||
@@ -49,6 +50,7 @@ public class ParseProperties implements ParseNextProperty { | |||
* Get the project. | |||
* @return the current Ant project. | |||
*/ | |||
@Override | |||
public Project getProject() { | |||
return project; | |||
} | |||
@@ -90,7 +92,7 @@ public class ParseProperties implements ParseNextProperty { | |||
* <code>null</code> if the original string is <code>null</code>. | |||
*/ | |||
public Object parseProperties(String value) { | |||
if (value == null || "".equals(value)) { | |||
if (value == null || value.isEmpty()) { | |||
return value; | |||
} | |||
final int len = value.length(); | |||
@@ -99,7 +101,7 @@ public class ParseProperties implements ParseNextProperty { | |||
if (o != null && pos.getIndex() >= len) { | |||
return o; | |||
} | |||
StringBuffer sb = new StringBuffer(len * 2); | |||
StringBuilder sb = new StringBuilder(len * 2); | |||
if (o == null) { | |||
sb.append(value.charAt(pos.getIndex())); | |||
pos.setIndex(pos.getIndex() + 1); | |||
@@ -157,6 +159,7 @@ public class ParseProperties implements ParseNextProperty { | |||
* property doesn't expand to a value, the property's name is | |||
* returned. | |||
*/ | |||
@Override | |||
public Object parseNextProperty(String value, ParsePosition pos) { | |||
final int start = pos.getIndex(); | |||
@@ -183,14 +186,9 @@ public class ParseProperties implements ParseNextProperty { | |||
} | |||
private String parsePropertyName(String value, ParsePosition pos) { | |||
for (PropertyExpander propertyExpander : expanders) { | |||
String propertyName = propertyExpander.parsePropertyName(value, pos, this); | |||
if (propertyName == null) { | |||
continue; | |||
} | |||
return propertyName; | |||
} | |||
return null; | |||
return expanders.stream() | |||
.map(xp -> xp.parsePropertyName(value, pos, this)) | |||
.filter(Objects::nonNull).findFirst().orElse(null); | |||
} | |||
private Object getProperty(String propertyName) { | |||
@@ -30,7 +30,7 @@ import org.apache.tools.ant.Project; | |||
* @since Ant 1.8.0 | |||
*/ | |||
public class ResolvePropertyMap implements GetProperty { | |||
private final Set<String> seen = new HashSet<String>(); | |||
private final Set<String> seen = new HashSet<>(); | |||
private final ParseProperties parseProperties; | |||
private final GetProperty master; | |||
private Map<String, Object> map; | |||
@@ -58,10 +58,11 @@ public class ResolvePropertyMap implements GetProperty { | |||
* @param name name of the property. | |||
* @return the property value, or null for no match or for name being null. | |||
*/ | |||
@Override | |||
public Object getProperty(String name) { | |||
if (seen.contains(name)) { | |||
throw new BuildException( | |||
"Property " + name + " was circularly " + "defined."); | |||
throw new BuildException("Property %s was circularly defined.", | |||
name); | |||
} | |||
try { | |||
@@ -110,6 +111,7 @@ public class ResolvePropertyMap implements GetProperty { | |||
* @param map the map to resolve properties in. | |||
* @deprecated since Ant 1.8.2, use the three-arg method instead. | |||
*/ | |||
@Deprecated | |||
public void resolveAllProperties(Map<String, Object> map) { | |||
resolveAllProperties(map, null, false); | |||
} | |||
@@ -121,6 +123,7 @@ public class ResolvePropertyMap implements GetProperty { | |||
* will finally receive - may be null. | |||
* @deprecated since Ant 1.8.2, use the three-arg method instead. | |||
*/ | |||
@Deprecated | |||
public void resolveAllProperties(Map<String, Object> map, String prefix) { | |||
resolveAllProperties(map, null, false); | |||
} | |||
@@ -55,10 +55,10 @@ public abstract class AbstractCvsTask extends Task { | |||
private Commandline cmd = new Commandline(); | |||
private ArrayList<Module> modules = new ArrayList<Module>(); | |||
private List<Module> modules = new ArrayList<>(); | |||
/** list of Commandline children */ | |||
private Vector<Commandline> vecCommandlines = new Vector<Commandline>(); | |||
private List<Commandline> commandlines = new Vector<>(); | |||
/** | |||
* the CVSROOT variable. | |||
@@ -149,11 +149,6 @@ public abstract class AbstractCvsTask extends Task { | |||
private OutputStream outputStream; | |||
private OutputStream errorStream; | |||
/** empty no-arg constructor*/ | |||
public AbstractCvsTask() { | |||
super(); | |||
} | |||
/** | |||
* sets the handler | |||
* @param handler a handler able of processing the output and error streams from the cvs exe | |||
@@ -385,11 +380,12 @@ public abstract class AbstractCvsTask extends Task { | |||
* @throws BuildException if failonerror is set to true and the | |||
* cvs command fails. | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
String savedCommand = getCommand(); | |||
if (this.getCommand() == null && vecCommandlines.size() == 0) { | |||
if (this.getCommand() == null && commandlines.isEmpty()) { | |||
// re-implement legacy behaviour: | |||
this.setCommand(AbstractCvsTask.DEFAULT_COMMAND); | |||
} | |||
@@ -397,16 +393,13 @@ public abstract class AbstractCvsTask extends Task { | |||
String c = this.getCommand(); | |||
Commandline cloned = null; | |||
if (c != null) { | |||
cloned = (Commandline) cmd.clone(); | |||
cloned = cmd.clone(); | |||
cloned.createArgument(true).setLine(c); | |||
this.addConfiguredCommandline(cloned, true); | |||
} | |||
try { | |||
final int size = vecCommandlines.size(); | |||
for (int i = 0; i < size; i++) { | |||
this.runCommand((Commandline) vecCommandlines.elementAt(i)); | |||
} | |||
commandlines.forEach(this::runCommand); | |||
} finally { | |||
if (cloned != null) { | |||
removeCommandline(cloned); | |||
@@ -421,24 +414,24 @@ public abstract class AbstractCvsTask extends Task { | |||
String cmdLine = Commandline.describeCommand(execute | |||
.getCommandline()); | |||
StringBuffer stringBuffer = removeCvsPassword(cmdLine); | |||
StringBuilder buf = removeCvsPassword(cmdLine); | |||
String newLine = StringUtils.LINE_SEP; | |||
String[] variableArray = execute.getEnvironment(); | |||
if (variableArray != null) { | |||
stringBuffer.append(newLine); | |||
stringBuffer.append(newLine); | |||
stringBuffer.append("environment:"); | |||
stringBuffer.append(newLine); | |||
buf.append(newLine); | |||
buf.append(newLine); | |||
buf.append("environment:"); | |||
buf.append(newLine); | |||
for (int z = 0; z < variableArray.length; z++) { | |||
stringBuffer.append(newLine); | |||
stringBuffer.append("\t"); | |||
stringBuffer.append(variableArray[z]); | |||
buf.append(newLine); | |||
buf.append("\t"); | |||
buf.append(variableArray[z]); | |||
} | |||
} | |||
return stringBuffer.toString(); | |||
return buf.toString(); | |||
} | |||
/** | |||
@@ -449,24 +442,24 @@ public abstract class AbstractCvsTask extends Task { | |||
* @param cmdLine the CVS command line | |||
* @return a StringBuffer where the password has been removed (if available) | |||
*/ | |||
private StringBuffer removeCvsPassword(String cmdLine) { | |||
StringBuffer stringBuffer = new StringBuffer(cmdLine); | |||
private StringBuilder removeCvsPassword(String cmdLine) { | |||
StringBuilder buf = new StringBuilder(cmdLine); | |||
int start = cmdLine.indexOf("-d:"); | |||
if (start >= 0) { | |||
int stop = cmdLine.indexOf("@", start); | |||
int startproto = cmdLine.indexOf(":", start); | |||
int startuser = cmdLine.indexOf(":", startproto + 1); | |||
int startpass = cmdLine.indexOf(":", startuser + 1); | |||
stop = cmdLine.indexOf("@", start); | |||
int stop = cmdLine.indexOf('@', start); | |||
int startproto = cmdLine.indexOf(':', start); | |||
int startuser = cmdLine.indexOf(':', startproto + 1); | |||
int startpass = cmdLine.indexOf(':', startuser + 1); | |||
stop = cmdLine.indexOf('@', start); | |||
if (stop >= 0 && startpass > startproto && startpass < stop) { | |||
for (int i = startpass + 1; i < stop; i++) { | |||
stringBuffer.replace(i, i + 1, "*"); | |||
buf.replace(i, i + 1, "*"); | |||
} | |||
} | |||
} | |||
return stringBuffer; | |||
return buf; | |||
} | |||
/** | |||
@@ -478,10 +471,8 @@ public abstract class AbstractCvsTask extends Task { | |||
public void setCvsRoot(String root) { | |||
// Check if not real cvsroot => set it to null | |||
if (root != null) { | |||
if (root.trim().equals("")) { | |||
root = null; | |||
} | |||
if (root != null && root.trim().isEmpty()) { | |||
root = null; | |||
} | |||
this.cvsRoot = root; | |||
@@ -502,11 +493,8 @@ public abstract class AbstractCvsTask extends Task { | |||
* @param rsh the CVS_RSH variable | |||
*/ | |||
public void setCvsRsh(String rsh) { | |||
// Check if not real cvsrsh => set it to null | |||
if (rsh != null) { | |||
if (rsh.trim().equals("")) { | |||
rsh = null; | |||
} | |||
if (rsh != null && rsh.trim().isEmpty()) { | |||
rsh = null; | |||
} | |||
this.cvsRsh = rsh; | |||
@@ -535,7 +523,6 @@ public abstract class AbstractCvsTask extends Task { | |||
* @return the port of CVS | |||
*/ | |||
public int getPort() { | |||
return this.port; | |||
} | |||
@@ -553,7 +540,6 @@ public abstract class AbstractCvsTask extends Task { | |||
* @return password file | |||
*/ | |||
public File getPassFile() { | |||
return this.passFile; | |||
} | |||
@@ -576,7 +562,6 @@ public abstract class AbstractCvsTask extends Task { | |||
* @return directory where the checked out files should be placed | |||
*/ | |||
public File getDest() { | |||
return this.dest; | |||
} | |||
@@ -595,7 +580,6 @@ public abstract class AbstractCvsTask extends Task { | |||
* @return package/module | |||
*/ | |||
public String getPackage() { | |||
return this.cvsPackage; | |||
} | |||
/** | |||
@@ -613,7 +597,7 @@ public abstract class AbstractCvsTask extends Task { | |||
*/ | |||
public void setTag(String p) { | |||
// Check if not real tag => set it to null | |||
if (p != null && p.trim().length() > 0) { | |||
if (!(p == null || p.trim().isEmpty())) { | |||
tag = p; | |||
addCommandArgument("-r" + p); | |||
} | |||
@@ -649,7 +633,7 @@ public abstract class AbstractCvsTask extends Task { | |||
* can understand see man cvs | |||
*/ | |||
public void setDate(String p) { | |||
if (p != null && p.trim().length() > 0) { | |||
if (!(p == null || p.trim().isEmpty())) { | |||
addCommandArgument("-D"); | |||
addCommandArgument(p); | |||
} | |||
@@ -695,7 +679,6 @@ public abstract class AbstractCvsTask extends Task { | |||
reallyquiet = q; | |||
} | |||
/** | |||
* If true, report only and don't change any files. | |||
* | |||
@@ -794,7 +777,7 @@ public abstract class AbstractCvsTask extends Task { | |||
* @param c command line which should be removed | |||
*/ | |||
protected void removeCommandline(Commandline c) { | |||
vecCommandlines.removeElement(c); | |||
commandlines.remove(c); | |||
} | |||
/** | |||
@@ -818,9 +801,9 @@ public abstract class AbstractCvsTask extends Task { | |||
} | |||
this.configureCommandline(c); | |||
if (insertAtStart) { | |||
vecCommandlines.insertElementAt(c, 0); | |||
commandlines.add(0, c); | |||
} else { | |||
vecCommandlines.addElement(c); | |||
commandlines.add(c); | |||
} | |||
} | |||
@@ -854,13 +837,12 @@ public abstract class AbstractCvsTask extends Task { | |||
} | |||
protected List<Module> getModules() { | |||
@SuppressWarnings("unchecked") | |||
final List<Module> clone = (List<Module>) modules.clone(); | |||
return clone; | |||
return new ArrayList<>(modules); | |||
} | |||
public static final class Module { | |||
private String name; | |||
public void setName(String s) { | |||
name = s; | |||
} | |||
@@ -37,6 +37,17 @@ import org.apache.tools.ant.util.JavaEnvUtils; | |||
*/ | |||
public abstract class AbstractJarSignerTask extends Task { | |||
/** | |||
* error string for unit test verification: {@value} | |||
*/ | |||
public static final String ERROR_NO_SOURCE = | |||
"jar must be set through jar attribute or nested filesets"; | |||
/** | |||
* name of JDK program we are looking for | |||
*/ | |||
protected static final String JARSIGNER_COMMAND = "jarsigner"; | |||
// CheckStyle:VisibilityModifier OFF - bc | |||
/** | |||
* The name of the jar file. | |||
@@ -78,12 +89,7 @@ public abstract class AbstractJarSignerTask extends Task { | |||
/** | |||
* the filesets of the jars to sign | |||
*/ | |||
protected Vector<FileSet> filesets = new Vector<FileSet>(); | |||
/** | |||
* name of JDK program we are looking for | |||
*/ | |||
protected static final String JARSIGNER_COMMAND = "jarsigner"; | |||
protected Vector<FileSet> filesets = new Vector<>(); | |||
// CheckStyle:VisibilityModifier ON | |||
/** | |||
@@ -96,12 +102,6 @@ public abstract class AbstractJarSignerTask extends Task { | |||
*/ | |||
private Environment sysProperties = new Environment(); | |||
/** | |||
* error string for unit test verification: {@value} | |||
*/ | |||
public static final String ERROR_NO_SOURCE = "jar must be set through jar attribute " | |||
+ "or nested filesets"; | |||
/** | |||
* Path holding all non-filesets of filesystem resources we want to sign. | |||
* | |||
@@ -253,7 +253,7 @@ public abstract class AbstractJarSignerTask extends Task { | |||
private RedirectorElement createRedirector() { | |||
RedirectorElement result = new RedirectorElement(); | |||
if (storepass != null) { | |||
StringBuffer input = new StringBuffer(storepass).append('\n'); | |||
StringBuilder input = new StringBuilder(storepass).append('\n'); | |||
if (keypass != null) { | |||
input.append(keypass).append('\n'); | |||
} | |||
@@ -324,7 +324,6 @@ public abstract class AbstractJarSignerTask extends Task { | |||
addValue(cmd, "-J-D" + property.getContent()); | |||
} | |||
/** | |||
* bind to a keystore if the attributes are there | |||
* @param cmd command to configure | |||
@@ -373,8 +372,7 @@ public abstract class AbstractJarSignerTask extends Task { | |||
* @return a vector of FileSet instances | |||
*/ | |||
protected Vector<FileSet> createUnifiedSources() { | |||
@SuppressWarnings("unchecked") | |||
Vector<FileSet> sources = (Vector<FileSet>) filesets.clone(); | |||
Vector<FileSet> sources = new Vector<>(filesets); | |||
if (jar != null) { | |||
//we create a fileset with the source file. | |||
//this lets us combine our logic for handling output directories, | |||
@@ -408,7 +406,7 @@ public abstract class AbstractJarSignerTask extends Task { | |||
* @since Ant 1.7 | |||
*/ | |||
protected boolean hasResources() { | |||
return path != null || filesets.size() > 0; | |||
return !(path == null && filesets.isEmpty()); | |||
} | |||
/** | |||
@@ -22,11 +22,13 @@ import java.io.File; | |||
import java.io.IOException; | |||
import java.io.PrintStream; | |||
import java.lang.reflect.Method; | |||
import java.util.HashMap; | |||
import java.nio.file.Files; | |||
import java.util.Enumeration; | |||
import java.util.HashSet; | |||
import java.util.Hashtable; | |||
import java.util.Iterator; | |||
import java.util.List; | |||
import java.util.Map; | |||
import java.util.Objects; | |||
import java.util.Set; | |||
import java.util.Vector; | |||
@@ -88,10 +90,10 @@ public class Ant extends Task { | |||
private boolean inheritRefs = false; | |||
/** the properties to pass to the new project */ | |||
private Vector<Property> properties = new Vector<Property>(); | |||
private List<Property> properties = new Vector<>(); | |||
/** the references to pass to the new project */ | |||
private Vector<Reference> references = new Vector<Reference>(); | |||
private List<Reference> references = new Vector<>(); | |||
/** the temporary project created to run the build file */ | |||
private Project newProject; | |||
@@ -100,10 +102,10 @@ public class Ant extends Task { | |||
private PrintStream out = null; | |||
/** the sets of properties to pass to the new project */ | |||
private Vector<PropertySet> propertySets = new Vector<PropertySet>(); | |||
private List<PropertySet> propertySets = new Vector<>(); | |||
/** the targets to call on the new project */ | |||
private Vector<String> targets = new Vector<String>(); | |||
private List<String> targets = new Vector<>(); | |||
/** whether the target attribute was specified **/ | |||
private boolean targetAttributeSet = false; | |||
@@ -164,6 +166,7 @@ public class Ant extends Task { | |||
/** | |||
* Creates a Project instance for the project to call. | |||
*/ | |||
@Override | |||
public void init() { | |||
newProject = getProject().createSubProject(); | |||
newProject.setJavaVersionProperty(); | |||
@@ -195,11 +198,11 @@ public class Ant extends Task { | |||
Iterator<BuildListener> iter = getBuildListeners(); | |||
while (iter.hasNext()) { | |||
newProject.addBuildListener((BuildListener) iter.next()); | |||
newProject.addBuildListener(iter.next()); | |||
} | |||
if (output != null) { | |||
File outfile = null; | |||
File outfile; | |||
if (dir != null) { | |||
outfile = FILE_UTILS.resolveFile(dir, output); | |||
} else { | |||
@@ -246,6 +249,7 @@ public class Ant extends Task { | |||
* @see Task#handleOutput(String) | |||
* @since Ant 1.5 | |||
*/ | |||
@Override | |||
public void handleOutput(String outputToHandle) { | |||
if (newProject != null) { | |||
newProject.demuxOutput(outputToHandle, false); | |||
@@ -268,6 +272,7 @@ public class Ant extends Task { | |||
* @see Task#handleInput(byte[], int, int) | |||
* @since Ant 1.6 | |||
*/ | |||
@Override | |||
public int handleInput(byte[] buffer, int offset, int length) | |||
throws IOException { | |||
if (newProject != null) { | |||
@@ -284,6 +289,7 @@ public class Ant extends Task { | |||
* @see Task#handleFlush(String) | |||
* @since Ant 1.5.2 | |||
*/ | |||
@Override | |||
public void handleFlush(String toFlush) { | |||
if (newProject != null) { | |||
newProject.demuxFlush(toFlush, false); | |||
@@ -301,6 +307,7 @@ public class Ant extends Task { | |||
* @see Task#handleErrorOutput(String) | |||
* @since Ant 1.5 | |||
*/ | |||
@Override | |||
public void handleErrorOutput(String errorOutputToHandle) { | |||
if (newProject != null) { | |||
newProject.demuxOutput(errorOutputToHandle, true); | |||
@@ -317,6 +324,7 @@ public class Ant extends Task { | |||
* @see Task#handleErrorFlush(String) | |||
* @since Ant 1.5.2 | |||
*/ | |||
@Override | |||
public void handleErrorFlush(String errorOutputToFlush) { | |||
if (newProject != null) { | |||
newProject.demuxFlush(errorOutputToFlush, true); | |||
@@ -330,10 +338,11 @@ public class Ant extends Task { | |||
* @throws BuildException if a target tries to call itself; | |||
* probably also if a BuildException is thrown by the new project. | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
File savedDir = dir; | |||
String savedAntFile = antFile; | |||
Vector<String> locals = new VectorSet<String>(targets); | |||
Vector<String> locals = new VectorSet<>(targets); | |||
try { | |||
getNewProject(); | |||
@@ -366,7 +375,7 @@ public class Ant extends Task { | |||
antFile = file.getAbsolutePath(); | |||
log("calling target(s) " | |||
+ ((locals.size() > 0) ? locals.toString() : "[default]") | |||
+ (!locals.isEmpty() ? locals.toString() : "[default]") | |||
+ " in build file " + antFile, Project.MSG_VERBOSE); | |||
newProject.setUserProperty(MagicNames.ANT_FILE , antFile); | |||
@@ -377,14 +386,14 @@ public class Ant extends Task { | |||
&& file.equals(getProject().resolveFile(thisAntFile)) | |||
&& getOwningTarget() != null) { | |||
if (getOwningTarget().getName().equals("")) { | |||
if (getTaskName().equals("antcall")) { | |||
throw new BuildException("antcall must not be used at" | |||
+ " the top level."); | |||
if ("".equals(getOwningTarget().getName())) { | |||
if ("antcall".equals(getTaskName())) { | |||
throw new BuildException( | |||
"antcall must not be used at the top level."); | |||
} | |||
throw new BuildException(getTaskName() + " task at the" | |||
+ " top level must not invoke" | |||
+ " its own build file."); | |||
throw new BuildException( | |||
"%s task at the top level must not invoke its own build file.", | |||
getTaskName()); | |||
} | |||
} | |||
@@ -395,7 +404,7 @@ public class Ant extends Task { | |||
ex, getLocation()); | |||
} | |||
if (locals.size() == 0) { | |||
if (locals.isEmpty()) { | |||
String defaultTarget = newProject.getDefaultTarget(); | |||
if (defaultTarget != null) { | |||
locals.add(defaultTarget); | |||
@@ -409,30 +418,25 @@ public class Ant extends Task { | |||
String owningTargetName = getOwningTarget().getName(); | |||
if (locals.contains(owningTargetName)) { | |||
throw new BuildException(getTaskName() + " task calling " | |||
+ "its own parent target."); | |||
throw new BuildException( | |||
"%s task calling its own parent target.", | |||
getTaskName()); | |||
} | |||
boolean circular = false; | |||
for (Iterator<String> it = locals.iterator(); | |||
!circular && it.hasNext();) { | |||
Target other = | |||
getProject().getTargets().get(it.next()); | |||
circular |= (other != null | |||
&& other.dependsOn(owningTargetName)); | |||
} | |||
if (circular) { | |||
throw new BuildException(getTaskName() | |||
+ " task calling a target" | |||
+ " that depends on" | |||
+ " its parent target \'" | |||
+ owningTargetName | |||
+ "\'."); | |||
final Map<String, Target> targetsMap = getProject().getTargets(); | |||
if (locals.stream().map(targetsMap::get) | |||
.filter(Objects::nonNull) | |||
.anyMatch(other -> other.dependsOn(owningTargetName))) { | |||
throw new BuildException( | |||
"%s task calling a target that depends on its parent target '%s'.", | |||
getTaskName(), owningTargetName); | |||
} | |||
} | |||
addReferences(); | |||
if (locals.size() > 0 && !(locals.size() == 1 | |||
if (!locals.isEmpty() && !(locals.size() == 1 | |||
&& "".equals(locals.get(0)))) { | |||
BuildException be = null; | |||
try { | |||
@@ -484,10 +488,10 @@ public class Ant extends Task { | |||
private void overrideProperties() throws BuildException { | |||
// remove duplicate properties - last property wins | |||
// Needed for backward compatibility | |||
Set<String> set = new HashSet<String>(); | |||
Set<String> set = new HashSet<>(); | |||
for (int i = properties.size() - 1; i >= 0; --i) { | |||
Property p = properties.get(i); | |||
if (p.getName() != null && !p.getName().equals("")) { | |||
if (p.getName() != null && !"".equals(p.getName())) { | |||
if (set.contains(p.getName())) { | |||
properties.remove(i); | |||
} else { | |||
@@ -495,12 +499,9 @@ public class Ant extends Task { | |||
} | |||
} | |||
} | |||
Enumeration<Property> e = properties.elements(); | |||
while (e.hasMoreElements()) { | |||
Property p = e.nextElement(); | |||
p.setProject(newProject); | |||
p.execute(); | |||
} | |||
properties.stream().peek(p -> p.setProject(newProject)) | |||
.forEach(Property::execute); | |||
if (useNativeBasedir) { | |||
addAlmostAll(getProject().getInheritedProperties(), | |||
PropertyType.INHERITED); | |||
@@ -517,14 +518,13 @@ public class Ant extends Task { | |||
* @throws BuildException if a reference does not have a refid. | |||
*/ | |||
private void addReferences() throws BuildException { | |||
@SuppressWarnings("unchecked") | |||
Hashtable<String, Object> thisReferences | |||
= (Hashtable<String, Object>) getProject().getReferences().clone(); | |||
Map<String, Object> thisReferences = | |||
new HashMap<>(getProject().getReferences()); | |||
for (Reference ref : references) { | |||
String refid = ref.getRefId(); | |||
if (refid == null) { | |||
throw new BuildException("the refid attribute is required" | |||
+ " for reference elements"); | |||
throw new BuildException( | |||
"the refid attribute is required for reference elements"); | |||
} | |||
if (!thisReferences.containsKey(refid)) { | |||
log("Parent project doesn't contain any reference '" | |||
@@ -544,7 +544,7 @@ public class Ant extends Task { | |||
// Now add all references that are not defined in the | |||
// subproject, if inheritRefs is true | |||
if (inheritRefs) { | |||
Hashtable<String, Object> newReferences = newProject.getReferences(); | |||
Map<String, Object> newReferences = newProject.getReferences(); | |||
for (String key : thisReferences.keySet()) { | |||
if (newReferences.containsKey(key)) { | |||
continue; | |||
@@ -576,32 +576,32 @@ public class Ant extends Task { | |||
Class<?> c = orig.getClass(); | |||
Object copy = orig; | |||
try { | |||
Method cloneM = c.getMethod("clone", new Class[0]); | |||
Method cloneM = c.getMethod("clone"); | |||
if (cloneM != null) { | |||
copy = cloneM.invoke(orig, new Object[0]); | |||
copy = cloneM.invoke(orig); | |||
log("Adding clone of reference " + oldKey, Project.MSG_DEBUG); | |||
} | |||
} catch (Exception e) { | |||
// not Clonable | |||
} | |||
if (copy instanceof ProjectComponent) { | |||
((ProjectComponent) copy).setProject(newProject); | |||
} else { | |||
try { | |||
Method setProjectM = | |||
c.getMethod("setProject", new Class[] {Project.class}); | |||
c.getMethod("setProject", Project.class); | |||
if (setProjectM != null) { | |||
setProjectM.invoke(copy, new Object[] {newProject}); | |||
setProjectM.invoke(copy, newProject); | |||
} | |||
} catch (NoSuchMethodException e) { | |||
// ignore this if the class being referenced does not have | |||
// a set project method. | |||
} catch (Exception e2) { | |||
String msg = "Error setting new project instance for " | |||
+ "reference with id " + oldKey; | |||
throw new BuildException(msg, e2, getLocation()); | |||
throw new BuildException( | |||
"Error setting new project instance for " | |||
+ "reference with id " + oldKey, | |||
e2, getLocation()); | |||
} | |||
} | |||
newProject.addReference(newKey, copy); | |||
@@ -617,29 +617,31 @@ public class Ant extends Task { | |||
* user property or an inherited property). | |||
* @since Ant 1.8.0 | |||
*/ | |||
private void addAlmostAll(Hashtable<?, ?> props, PropertyType type) { | |||
Enumeration<?> e = props.keys(); | |||
while (e.hasMoreElements()) { | |||
String key = e.nextElement().toString(); | |||
private void addAlmostAll(Map<?, ?> props, PropertyType type) { | |||
props.forEach((k, v) -> { | |||
String key = k.toString(); | |||
if (MagicNames.PROJECT_BASEDIR.equals(key) | |||
|| MagicNames.ANT_FILE.equals(key)) { | |||
|| MagicNames.ANT_FILE.equals(key)) { | |||
// basedir and ant.file get special treatment in execute() | |||
continue; | |||
return; | |||
} | |||
String value = props.get(key).toString(); | |||
if (type == PropertyType.PLAIN) { | |||
String value = v.toString(); | |||
switch (type) { | |||
case PLAIN: | |||
// don't re-set user properties, avoid the warning message | |||
if (newProject.getProperty(key) == null) { | |||
// no user property | |||
newProject.setNewProperty(key, value); | |||
} | |||
} else if (type == PropertyType.USER) { | |||
break; | |||
case USER: | |||
newProject.setUserProperty(key, value); | |||
} else if (type == PropertyType.INHERITED) { | |||
break; | |||
case INHERITED: | |||
newProject.setInheritedProperty(key, value); | |||
break; | |||
} | |||
} | |||
}); | |||
} | |||
/** | |||
@@ -671,7 +673,7 @@ public class Ant extends Task { | |||
* @param targetToAdd the name of the target to invoke. | |||
*/ | |||
public void setTarget(String targetToAdd) { | |||
if (targetToAdd.equals("")) { | |||
if ("".equals(targetToAdd)) { | |||
throw new BuildException("target attribute must not be empty"); | |||
} | |||
targets.add(targetToAdd); | |||
@@ -697,7 +699,7 @@ public class Ant extends Task { | |||
Property p = new Property(true, getProject()); | |||
p.setProject(getNewProject()); | |||
p.setTaskName("property"); | |||
properties.addElement(p); | |||
properties.add(p); | |||
return p; | |||
} | |||
@@ -707,7 +709,7 @@ public class Ant extends Task { | |||
* @param ref <code>Reference</code> to add. | |||
*/ | |||
public void addReference(Reference ref) { | |||
references.addElement(ref); | |||
references.add(ref); | |||
} | |||
/** | |||
@@ -721,7 +723,7 @@ public class Ant extends Task { | |||
"nested target is incompatible with the target attribute"); | |||
} | |||
String name = t.getName(); | |||
if (name.equals("")) { | |||
if ("".equals(name)) { | |||
throw new BuildException("target name must not be empty"); | |||
} | |||
targets.add(name); | |||
@@ -734,7 +736,7 @@ public class Ant extends Task { | |||
* @since Ant 1.6 | |||
*/ | |||
public void addPropertyset(PropertySet ps) { | |||
propertySets.addElement(ps); | |||
propertySets.add(ps); | |||
} | |||
/** | |||
@@ -760,14 +762,10 @@ public class Ant extends Task { | |||
* Helper class that implements the nested <reference> | |||
* element of <ant> and <antcall>. | |||
*/ | |||
@SuppressWarnings("deprecation") | |||
public static class Reference | |||
extends org.apache.tools.ant.types.Reference { | |||
/** Creates a reference to be configured by Ant. */ | |||
public Reference() { | |||
super(); | |||
} | |||
private String targetid = null; | |||
/** | |||
@@ -823,10 +821,7 @@ public class Ant extends Task { | |||
} | |||
} | |||
private static final class PropertyType { | |||
private PropertyType() {} | |||
private static final PropertyType PLAIN = new PropertyType(); | |||
private static final PropertyType INHERITED = new PropertyType(); | |||
private static final PropertyType USER = new PropertyType(); | |||
private enum PropertyType { | |||
PLAIN, INHERITED, USER; | |||
} | |||
} |
@@ -25,10 +25,15 @@ import java.io.OutputStream; | |||
import java.io.OutputStreamWriter; | |||
import java.io.PrintWriter; | |||
import java.io.UnsupportedEncodingException; | |||
import java.util.ArrayList; | |||
import java.nio.file.Files; | |||
import java.util.Enumeration; | |||
import java.util.Hashtable; | |||
import java.util.Vector; | |||
import java.util.List; | |||
import java.util.Set; | |||
import java.util.stream.Collector; | |||
import java.util.stream.Collectors; | |||
import java.util.stream.Stream; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.IntrospectionHelper; | |||
@@ -122,8 +127,8 @@ public class AntStructure extends Task { | |||
printer.printTail(out); | |||
if (out.checkError()) { | |||
throw new IOException("Encountered an error writing Ant" | |||
+ " structure"); | |||
throw new IOException( | |||
"Encountered an error writing Ant structure"); | |||
} | |||
} catch (final IOException ioe) { | |||
throw new BuildException("Error writing " | |||
@@ -187,13 +192,15 @@ public class AntStructure extends Task { | |||
private final Hashtable<String, String> visited = new Hashtable<String, String>(); | |||
@Override | |||
public void printTail(final PrintWriter out) { | |||
visited.clear(); | |||
} | |||
@Override | |||
public void printHead(final PrintWriter out, final Project p, final Hashtable<String, Class<?>> tasks, | |||
final Hashtable<String, Class<?>> types) { | |||
printHead(out, tasks.keys(), types.keys()); | |||
printHead(out, tasks.keySet(), types.keySet()); | |||
} | |||
@@ -203,36 +210,18 @@ public class AntStructure extends Task { | |||
* <p>Basically this prints the XML declaration, defines some | |||
* entities and the project element.</p> | |||
*/ | |||
private void printHead(final PrintWriter out, final Enumeration<String> tasks, | |||
final Enumeration<String> types) { | |||
private void printHead(final PrintWriter out, final Set<String> tasks, | |||
final Set<String> types) { | |||
out.println("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"); | |||
out.println("<!ENTITY % boolean \"(true|false|on|off|yes|no)\">"); | |||
out.print("<!ENTITY % tasks \""); | |||
boolean first = true; | |||
while (tasks.hasMoreElements()) { | |||
final String tName = tasks.nextElement(); | |||
if (!first) { | |||
out.print(" | "); | |||
} else { | |||
first = false; | |||
} | |||
out.print(tName); | |||
} | |||
out.println("\">"); | |||
out.print("<!ENTITY % types \""); | |||
first = true; | |||
while (types.hasMoreElements()) { | |||
final String typeName = types.nextElement(); | |||
if (!first) { | |||
out.print(" | "); | |||
} else { | |||
first = false; | |||
} | |||
out.print(typeName); | |||
} | |||
out.println("\">"); | |||
out.println(tasks.stream().collect( | |||
Collectors.joining(" | ", "<!ENTITY % tasks \"", "\">"))); | |||
out.println(""); | |||
out.println(types.stream().collect( | |||
Collectors.joining(" | ", "<!ENTITY % types \"", "\">"))); | |||
out.println(); | |||
out.print("<!ELEMENT project (target | extension-point | "); | |||
out.print(TASKS); | |||
@@ -249,6 +238,7 @@ public class AntStructure extends Task { | |||
/** | |||
* Prints the definition for the target element. | |||
*/ | |||
@Override | |||
public void printTargetDecl(final PrintWriter out) { | |||
out.print("<!ELEMENT target ("); | |||
out.print(TASKS); | |||
@@ -282,6 +272,7 @@ public class AntStructure extends Task { | |||
/** | |||
* Print the definition for a given element. | |||
*/ | |||
@Override | |||
public void printElementDecl(final PrintWriter out, final Project p, | |||
final String name, final Class<?> element) { | |||
@@ -290,7 +281,7 @@ public class AntStructure extends Task { | |||
} | |||
visited.put(name, ""); | |||
IntrospectionHelper ih = null; | |||
IntrospectionHelper ih; | |||
try { | |||
ih = IntrospectionHelper.getHelper(p, element); | |||
} catch (final Throwable t) { | |||
@@ -302,10 +293,10 @@ public class AntStructure extends Task { | |||
return; | |||
} | |||
StringBuffer sb = new StringBuffer("<!ELEMENT "); | |||
sb.append(name).append(" "); | |||
StringBuilder sb = | |||
new StringBuilder("<!ELEMENT ").append(name).append(" "); | |||
if (org.apache.tools.ant.types.Reference.class.equals(element)) { | |||
if (Reference.class.equals(element)) { | |||
sb.append("EMPTY>").append(LINE_SEP); | |||
sb.append("<!ATTLIST ").append(name); | |||
sb.append(LINE_SEP).append(" id ID #IMPLIED"); | |||
@@ -315,40 +306,35 @@ public class AntStructure extends Task { | |||
return; | |||
} | |||
final Vector<String> v = new Vector<String>(); | |||
final List<String> v = new ArrayList<>(); | |||
if (ih.supportsCharacters()) { | |||
v.addElement("#PCDATA"); | |||
v.add("#PCDATA"); | |||
} | |||
if (TaskContainer.class.isAssignableFrom(element)) { | |||
v.addElement(TASKS); | |||
v.add(TASKS); | |||
} | |||
Enumeration<String> e = ih.getNestedElements(); | |||
while (e.hasMoreElements()) { | |||
v.addElement(e.nextElement()); | |||
v.add(e.nextElement()); | |||
} | |||
final Collector<CharSequence, ?, String> joinAlts = | |||
Collectors.joining(" | ", "(", ")"); | |||
if (v.isEmpty()) { | |||
sb.append("EMPTY"); | |||
} else { | |||
sb.append("("); | |||
final int count = v.size(); | |||
for (int i = 0; i < count; i++) { | |||
if (i != 0) { | |||
sb.append(" | "); | |||
} | |||
sb.append(v.elementAt(i)); | |||
} | |||
sb.append(")"); | |||
if (count > 1 || !v.elementAt(0).equals("#PCDATA")) { | |||
sb.append(v.stream().collect(joinAlts)); | |||
if (v.size() > 1 || !"#PCDATA".equals(v.get(0))) { | |||
sb.append("*"); | |||
} | |||
} | |||
sb.append(">"); | |||
out.println(sb); | |||
sb = new StringBuffer("<!ATTLIST "); | |||
sb = new StringBuilder("<!ATTLIST "); | |||
sb.append(name); | |||
sb.append(LINE_SEP).append(" id ID #IMPLIED"); | |||
@@ -362,29 +348,23 @@ public class AntStructure extends Task { | |||
sb.append(LINE_SEP).append(" ") | |||
.append(attrName).append(" "); | |||
final Class<?> type = ih.getAttributeType(attrName); | |||
if (type.equals(java.lang.Boolean.class) | |||
|| type.equals(java.lang.Boolean.TYPE)) { | |||
if (type.equals(Boolean.class) | |||
|| type.equals(Boolean.TYPE)) { | |||
sb.append(BOOLEAN).append(" "); | |||
} else if (Reference.class.isAssignableFrom(type)) { | |||
sb.append("IDREF "); | |||
} else if (EnumeratedAttribute.class.isAssignableFrom(type)) { | |||
try { | |||
final EnumeratedAttribute ea = | |||
(EnumeratedAttribute) type.newInstance(); | |||
type.asSubclass(EnumeratedAttribute.class) | |||
.newInstance(); | |||
final String[] values = ea.getValues(); | |||
if (values == null | |||
|| values.length == 0 | |||
|| !areNmtokens(values)) { | |||
sb.append("CDATA "); | |||
} else { | |||
sb.append("("); | |||
for (int i = 0; i < values.length; i++) { | |||
if (i != 0) { | |||
sb.append(" | "); | |||
} | |||
sb.append(values[i]); | |||
} | |||
sb.append(") "); | |||
sb.append(Stream.of(values).collect(joinAlts)); | |||
} | |||
} catch (final InstantiationException ie) { | |||
sb.append("CDATA "); | |||
@@ -393,20 +373,13 @@ public class AntStructure extends Task { | |||
} | |||
} else if (Enum.class.isAssignableFrom(type)) { | |||
try { | |||
final Object[] values = (Object[]) type.getMethod("values", (Class[]) null) | |||
.invoke(null, (Object[]) null); | |||
final Enum<?>[] values = | |||
(Enum<?>[]) type.getMethod("values").invoke(null); | |||
if (values.length == 0) { | |||
sb.append("CDATA "); | |||
} else { | |||
sb.append('('); | |||
for (int i = 0; i < values.length; i++) { | |||
if (i != 0) { | |||
sb.append(" | "); | |||
} | |||
sb.append(type.getMethod("name", (Class[]) null) | |||
.invoke(values[i], (Object[]) null)); | |||
} | |||
sb.append(") "); | |||
sb.append(Stream.of(values).map(Enum::name) | |||
.collect(joinAlts)); | |||
} | |||
} catch (final Exception x) { | |||
sb.append("CDATA "); | |||
@@ -419,9 +392,7 @@ public class AntStructure extends Task { | |||
sb.append(">").append(LINE_SEP); | |||
out.println(sb); | |||
final int count = v.size(); | |||
for (int i = 0; i < count; i++) { | |||
final String nestedName = v.elementAt(i); | |||
for (String nestedName : v) { | |||
if (!"#PCDATA".equals(nestedName) | |||
&& !TASKS.equals(nestedName) | |||
&& !TYPES.equals(nestedName)) { | |||
@@ -22,9 +22,7 @@ import java.io.IOException; | |||
import java.net.URL; | |||
import java.net.URLConnection; | |||
import java.util.ArrayList; | |||
import java.util.Iterator; | |||
import java.util.List; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.ComponentHelper; | |||
import org.apache.tools.ant.Project; | |||
@@ -94,7 +92,7 @@ public class Antlib extends Task implements TaskContainer { | |||
UnknownElement ue = | |||
parser.parseAntlibDescriptor(project, antlibResource); | |||
// Check name is "antlib" | |||
if (!(ue.getTag().equals(TAG))) { | |||
if (!(TAG.equals(ue.getTag()))) { | |||
throw new BuildException( | |||
"Unexpected tag " + ue.getTag() + " expecting " | |||
+ TAG, ue.getLocation()); | |||
@@ -116,7 +114,7 @@ public class Antlib extends Task implements TaskContainer { | |||
// | |||
private ClassLoader classLoader; | |||
private String uri = ""; | |||
private List<Object> tasks = new ArrayList<Object>(); | |||
private List<Task> tasks = new ArrayList<>(); | |||
/** | |||
* Set the class loader for this antlib. | |||
@@ -149,6 +147,7 @@ public class Antlib extends Task implements TaskContainer { | |||
* | |||
* @param nestedTask Nested task to execute in antlib | |||
*/ | |||
@Override | |||
public void addTask(Task nestedTask) { | |||
tasks.add(nestedTask); | |||
} | |||
@@ -157,10 +156,12 @@ public class Antlib extends Task implements TaskContainer { | |||
* Execute the nested tasks, setting the classloader for | |||
* any tasks that derive from Definer. | |||
*/ | |||
@Override | |||
public void execute() { | |||
//TODO handle tasks added via #addTask() | |||
for (Iterator<Object> i = tasks.iterator(); i.hasNext();) { | |||
UnknownElement ue = (UnknownElement) i.next(); | |||
for (Task task : tasks) { | |||
UnknownElement ue = (UnknownElement) task; | |||
setLocation(ue.getLocation()); | |||
ue.maybeConfigure(); | |||
Object configuredObject = ue.getRealThing(); | |||
@@ -169,9 +170,9 @@ public class Antlib extends Task implements TaskContainer { | |||
} | |||
if (!(configuredObject instanceof AntlibDefinition)) { | |||
throw new BuildException( | |||
"Invalid task in antlib " + ue.getTag() | |||
+ " " + configuredObject.getClass() + " does not " | |||
+ "extend org.apache.tools.ant.taskdefs.AntlibDefinition"); | |||
"Invalid task in antlib %s %s does not extend %s", | |||
ue.getTag(), configuredObject.getClass(), | |||
AntlibDefinition.class.getName()); | |||
} | |||
AntlibDefinition def = (AntlibDefinition) configuredObject; | |||
def.setURI(uri); | |||
@@ -44,11 +44,11 @@ public class AntlibDefinition extends Task { | |||
* @throws BuildException if a reserved URI is used | |||
*/ | |||
public void setURI(String uri) throws BuildException { | |||
if (uri.equals(ProjectHelper.ANT_CORE_URI)) { | |||
if (ProjectHelper.ANT_CORE_URI.equals(uri)) { | |||
uri = ""; | |||
} | |||
if (uri.startsWith("ant:")) { | |||
throw new BuildException("Attempt to use a reserved URI " + uri); | |||
throw new BuildException("Attempt to use a reserved URI %s", uri); | |||
} | |||
this.uri = uri; | |||
} | |||
@@ -193,9 +193,9 @@ public class Available extends Task implements Condition { | |||
* the type in its own class. | |||
* @param type the type of resource | |||
*/ | |||
@Deprecated | |||
public void setType(String type) { | |||
log("DEPRECATED - The setType(String) method has been deprecated." | |||
+ " Use setType(Available.FileDir) instead.", | |||
log("DEPRECATED - The setType(String) method has been deprecated. Use setType(Available.FileDir) instead.", | |||
Project.MSG_WARN); | |||
this.type = new FileDir(); | |||
this.type.setValue(type); | |||
@@ -227,6 +227,7 @@ public class Available extends Task implements Condition { | |||
* | |||
* @exception BuildException if the task is not configured correctly. | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
if (property == null) { | |||
throw new BuildException("property attribute is required", | |||
@@ -261,17 +262,19 @@ public class Available extends Task implements Condition { | |||
* @return boolean is the resource is available. | |||
* @exception BuildException if the condition is not configured correctly | |||
*/ | |||
@Override | |||
public boolean eval() throws BuildException { | |||
try { | |||
if (classname == null && file == null && resource == null) { | |||
throw new BuildException("At least one of (classname|file|" | |||
+ "resource) is required", getLocation()); | |||
throw new BuildException( | |||
"At least one of (classname|file|resource) is required", | |||
getLocation()); | |||
} | |||
if (type != null) { | |||
if (file == null) { | |||
throw new BuildException("The type attribute is only valid " | |||
+ "when specifying the file " | |||
+ "attribute.", getLocation()); | |||
throw new BuildException( | |||
"The type attribute is only valid when specifying the file attribute.", | |||
getLocation()); | |||
} | |||
} | |||
if (classpath != null) { | |||
@@ -284,13 +287,13 @@ public class Available extends Task implements Condition { | |||
} else { | |||
setTaskName("available"); | |||
} | |||
if ((classname != null) && !checkClass(classname)) { | |||
if (!(classname == null || checkClass(classname))) { | |||
log("Unable to load class " + classname + appendix, | |||
Project.MSG_VERBOSE); | |||
return false; | |||
} | |||
if ((file != null) && !checkFile()) { | |||
StringBuffer buf = new StringBuffer("Unable to find "); | |||
StringBuilder buf = new StringBuilder("Unable to find "); | |||
if (type != null) { | |||
buf.append(type).append(' '); | |||
} | |||
@@ -334,62 +337,64 @@ public class Available extends Task implements Condition { | |||
private boolean checkFile() { | |||
if (filepath == null) { | |||
return checkFile(file, filename); | |||
} else { | |||
String[] paths = filepath.list(); | |||
for (int i = 0; i < paths.length; ++i) { | |||
log("Searching " + paths[i], Project.MSG_VERBOSE); | |||
File path = new File(paths[i]); | |||
// ** full-pathname specified == path in list | |||
// ** simple name specified == path in list | |||
if (path.exists() | |||
&& (filename.equals(paths[i]) | |||
|| filename.equals(path.getName()))) { | |||
if (type == null) { | |||
log("Found: " + path, Project.MSG_VERBOSE); | |||
return true; | |||
} else if (type.isDir() | |||
&& path.isDirectory()) { | |||
log("Found directory: " + path, Project.MSG_VERBOSE); | |||
return true; | |||
} else if (type.isFile() | |||
&& path.isFile()) { | |||
log("Found file: " + path, Project.MSG_VERBOSE); | |||
return true; | |||
} | |||
// not the requested type | |||
return false; | |||
} | |||
String[] paths = filepath.list(); | |||
for (String p : paths) { | |||
log("Searching " + p, Project.MSG_VERBOSE); | |||
File path = new File(p); | |||
// ** full-pathname specified == path in list | |||
// ** simple name specified == path in list | |||
if (path.exists() | |||
&& (filename.equals(p) | |||
|| filename.equals(path.getName()))) { | |||
if (type == null) { | |||
log("Found: " + path, Project.MSG_VERBOSE); | |||
return true; | |||
} | |||
File parent = path.getParentFile(); | |||
// ** full-pathname specified == parent dir of path in list | |||
if (parent != null && parent.exists() | |||
&& filename.equals(parent.getAbsolutePath())) { | |||
if (type == null) { | |||
log("Found: " + parent, Project.MSG_VERBOSE); | |||
return true; | |||
} else if (type.isDir()) { | |||
log("Found directory: " + parent, Project.MSG_VERBOSE); | |||
return true; | |||
} | |||
// not the requested type | |||
return false; | |||
if (type.isDir() | |||
&& path.isDirectory()) { | |||
log("Found directory: " + path, Project.MSG_VERBOSE); | |||
return true; | |||
} | |||
// ** simple name specified == path in list + name | |||
if (path.exists() && path.isDirectory()) { | |||
if (checkFile(new File(path, filename), | |||
filename + " in " + path)) { | |||
return true; | |||
} | |||
if (type.isFile() | |||
&& path.isFile()) { | |||
log("Found file: " + path, Project.MSG_VERBOSE); | |||
return true; | |||
} | |||
// not the requested type | |||
return false; | |||
} | |||
File parent = path.getParentFile(); | |||
// ** full-pathname specified == parent dir of path in list | |||
if (parent != null && parent.exists() | |||
&& filename.equals(parent.getAbsolutePath())) { | |||
if (type == null) { | |||
log("Found: " + parent, Project.MSG_VERBOSE); | |||
return true; | |||
} | |||
if (type.isDir()) { | |||
log("Found directory: " + parent, Project.MSG_VERBOSE); | |||
return true; | |||
} | |||
// not the requested type | |||
return false; | |||
} | |||
// ** simple name specified == path in list + name | |||
if (path.exists() && path.isDirectory()) { | |||
if (checkFile(new File(path, filename), | |||
filename + " in " + path)) { | |||
return true; | |||
} | |||
} | |||
// ** simple name specified == parent dir + name | |||
while (searchParents && parent != null && parent.exists()) { | |||
if (checkFile(new File(parent, filename), | |||
filename + " in " + parent)) { | |||
return true; | |||
} | |||
parent = parent.getParentFile(); | |||
// ** simple name specified == parent dir + name | |||
while (searchParents && parent != null && parent.exists()) { | |||
if (checkFile(new File(parent, filename), | |||
filename + " in " + parent)) { | |||
return true; | |||
} | |||
parent = parent.getParentFile(); | |||
} | |||
} | |||
return false; | |||
@@ -405,7 +410,8 @@ public class Available extends Task implements Condition { | |||
log("Found directory: " + text, Project.MSG_VERBOSE); | |||
} | |||
return f.isDirectory(); | |||
} else if (type.isFile()) { | |||
} | |||
if (type.isFile()) { | |||
if (f.isFile()) { | |||
log("Found file: " + text, Project.MSG_VERBOSE); | |||
} | |||
@@ -488,12 +494,13 @@ public class Available extends Task implements Condition { | |||
*/ | |||
public static class FileDir extends EnumeratedAttribute { | |||
private static final String[] VALUES = {"file", "dir"}; | |||
private static final String[] VALUES = { "file", "dir" }; | |||
/** | |||
* @see EnumeratedAttribute#getValues | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public String[] getValues() { | |||
return VALUES; | |||
} | |||
@@ -85,6 +85,7 @@ public class Basename extends Task { | |||
* @throws BuildException if required attributes are not supplied | |||
* property and attribute are required attributes | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
if (property == null) { | |||
throw new BuildException("property attribute required", getLocation()); | |||
@@ -92,19 +93,21 @@ public class Basename extends Task { | |||
if (file == null) { | |||
throw new BuildException("file attribute required", getLocation()); | |||
} | |||
String value = file.getName(); | |||
if (suffix != null && value.endsWith(suffix)) { | |||
// if the suffix does not starts with a '.' and the | |||
// char preceding the suffix is a '.', we assume the user | |||
// wants to remove the '.' as well (see docs) | |||
int pos = value.length() - suffix.length(); | |||
if (pos > 0 && suffix.charAt(0) != '.' | |||
&& value.charAt(pos - 1) == '.') { | |||
pos--; | |||
} | |||
value = value.substring(0, pos); | |||
getProject().setNewProperty(property, | |||
removeExtension(file.getName(), suffix)); | |||
} | |||
private String removeExtension(String s, String ext) { | |||
if (ext == null || !s.endsWith(ext)) { | |||
return s; | |||
} | |||
getProject().setNewProperty(property, value); | |||
int clipFrom = s.length() - ext.length(); | |||
// if the suffix does not starts with a '.' and the | |||
// char preceding the suffix is a '.', we assume the user | |||
// wants to remove the '.' as well (see docs) | |||
if (ext.charAt(0) != '.' && clipFrom > 0 && s.charAt(clipFrom - 1) == '.') { | |||
clipFrom -= 1; | |||
} | |||
return s.substring(0, clipFrom); | |||
} | |||
} | |||
@@ -18,8 +18,8 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.util.ArrayList; | |||
import java.util.Iterator; | |||
import java.util.List; | |||
import java.util.stream.Stream; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.ProjectHelper; | |||
@@ -54,13 +54,8 @@ public class BindTargets extends Task { | |||
} | |||
public void setTargets(final String target) { | |||
final String[] inputs = target.split(","); | |||
for (int i = 0; i < inputs.length; i++) { | |||
final String input = inputs[i].trim(); | |||
if (input.length() > 0) { | |||
targets.add(input); | |||
} | |||
} | |||
Stream.of(target.split(",")).map(String::trim).filter(s -> !s.isEmpty()) | |||
.forEach(targets::add); | |||
} | |||
@Override | |||
@@ -81,11 +76,9 @@ public class BindTargets extends Task { | |||
final ProjectHelper helper = (ProjectHelper) getProject().getReference( | |||
ProjectHelper.PROJECTHELPER_REFERENCE); | |||
for (final Iterator<String> itTarget = targets.iterator(); itTarget.hasNext();) { | |||
helper.getExtensionStack().add( | |||
new String[] {extensionPoint, itTarget.next(), | |||
onMissingExtensionPoint.name()}); | |||
for (String target : targets) { | |||
helper.getExtensionStack().add(new String[] { extensionPoint, | |||
target, onMissingExtensionPoint.name() }); | |||
} | |||
} | |||
} |
@@ -25,7 +25,6 @@ import java.nio.file.Files; | |||
import java.util.Properties; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.Project; | |||
import org.apache.tools.ant.Task; | |||
import org.apache.tools.ant.util.FileUtils; | |||
@@ -40,8 +39,7 @@ import org.apache.tools.ant.util.FileUtils; | |||
* @since Ant 1.5 | |||
* @ant.task name="buildnumber" | |||
*/ | |||
public class BuildNumber | |||
extends Task { | |||
public class BuildNumber extends Task { | |||
/** | |||
* The name of the property in which the build number is stored. | |||
*/ | |||
@@ -55,7 +53,6 @@ public class BuildNumber | |||
/** The File in which the build number is stored. */ | |||
private File myFile; | |||
/** | |||
* The file in which the build number is stored. Defaults to | |||
* "build.number" if not specified. | |||
@@ -66,14 +63,13 @@ public class BuildNumber | |||
myFile = file; | |||
} | |||
/** | |||
* Run task. | |||
* | |||
* @exception BuildException if an error occurs | |||
*/ | |||
public void execute() | |||
throws BuildException { | |||
@Override | |||
public void execute() throws BuildException { | |||
File savedFile = myFile; // may be altered in validate | |||
validate(); | |||
@@ -85,26 +81,12 @@ public class BuildNumber | |||
String.valueOf(buildNumber + 1)); | |||
// Write the properties file back out | |||
OutputStream output = null; | |||
try { | |||
output = Files.newOutputStream(myFile.toPath()); | |||
final String header = "Build Number for ANT. Do not edit!"; | |||
properties.store(output, header); | |||
try (OutputStream output = Files.newOutputStream(myFile.toPath())) { | |||
properties.store(output, "Build Number for ANT. Do not edit!"); | |||
} catch (final IOException ioe) { | |||
final String message = "Error while writing " + myFile; | |||
throw new BuildException(message, ioe); | |||
throw new BuildException("Error while writing " + myFile, ioe); | |||
} finally { | |||
if (null != output) { | |||
try { | |||
output.close(); | |||
} catch (final IOException ioe) { | |||
log("error closing output stream " + ioe, Project.MSG_ERR); | |||
} | |||
} | |||
myFile = savedFile; | |||
} | |||
@@ -113,7 +95,6 @@ public class BuildNumber | |||
String.valueOf(buildNumber)); | |||
} | |||
/** | |||
* Utility method to retrieve build number from properties object. | |||
* | |||
@@ -130,43 +111,28 @@ public class BuildNumber | |||
try { | |||
return Integer.parseInt(buildNumber); | |||
} catch (final NumberFormatException nfe) { | |||
final String message = | |||
myFile + " contains a non integer build number: " + buildNumber; | |||
throw new BuildException(message, nfe); | |||
throw new BuildException( | |||
myFile + " contains a non integer build number: " + buildNumber, | |||
nfe); | |||
} | |||
} | |||
/** | |||
* Utility method to load properties from file. | |||
* | |||
* @return the loaded properties | |||
* @throws BuildException | |||
*/ | |||
private Properties loadProperties() | |||
throws BuildException { | |||
InputStream input = null; | |||
try { | |||
private Properties loadProperties() throws BuildException { | |||
try (InputStream input = Files.newInputStream(myFile.toPath())) { | |||
final Properties properties = new Properties(); | |||
input = Files.newInputStream(myFile.toPath()); | |||
properties.load(input); | |||
return properties; | |||
} catch (final IOException ioe) { | |||
throw new BuildException(ioe); | |||
} finally { | |||
if (null != input) { | |||
try { | |||
input.close(); | |||
} catch (final IOException ioe) { | |||
log("error closing input stream " + ioe, Project.MSG_ERR); | |||
} | |||
} | |||
} | |||
} | |||
/** | |||
* Validate that the task parameters are valid. | |||
* | |||
@@ -182,21 +148,18 @@ public class BuildNumber | |||
try { | |||
FILE_UTILS.createNewFile(myFile); | |||
} catch (final IOException ioe) { | |||
final String message = | |||
myFile + " doesn't exist and new file can't be created."; | |||
throw new BuildException(message, ioe); | |||
throw new BuildException( | |||
myFile + " doesn't exist and new file can't be created.", | |||
ioe); | |||
} | |||
} | |||
if (!myFile.canRead()) { | |||
final String message = "Unable to read from " + myFile + "."; | |||
throw new BuildException(message); | |||
throw new BuildException("Unable to read from " + myFile + "."); | |||
} | |||
if (!myFile.canWrite()) { | |||
final String message = "Unable to write to " + myFile + "."; | |||
throw new BuildException(message); | |||
throw new BuildException("Unable to write to " + myFile + "."); | |||
} | |||
} | |||
} | |||
@@ -82,6 +82,7 @@ public class CVSPass extends Task { | |||
* | |||
* @exception BuildException if something goes wrong with the build | |||
*/ | |||
@Override | |||
public final void execute() throws BuildException { | |||
if (cvsRoot == null) { | |||
throw new BuildException("cvsroot is required"); | |||
@@ -97,7 +98,7 @@ public class CVSPass extends Task { | |||
BufferedReader reader = null; | |||
BufferedWriter writer = null; | |||
try { | |||
StringBuffer buf = new StringBuffer(); | |||
StringBuilder buf = new StringBuilder(); | |||
if (passFile.exists()) { | |||
reader = new BufferedReader(new FileReader(passFile)); | |||
@@ -129,7 +130,7 @@ public class CVSPass extends Task { | |||
} | |||
private final String mangle(String password) { | |||
StringBuffer buf = new StringBuffer(); | |||
StringBuilder buf = new StringBuilder(); | |||
for (int i = 0; i < password.length(); i++) { | |||
buf.append(shifts[password.charAt(i)]); | |||
} | |||
@@ -71,6 +71,7 @@ public class Checksum extends MatchingTask implements Condition { | |||
super.add(u); | |||
super.add(Type.FILE); | |||
} | |||
@Override | |||
public void add(ResourceCollection rc) { | |||
u.add(rc); | |||
} | |||
@@ -110,14 +111,14 @@ public class Checksum extends MatchingTask implements Condition { | |||
* Key: java.util.File (source file) | |||
* Value: java.lang.String (digest) | |||
*/ | |||
private Map<File, byte[]> allDigests = new HashMap<File, byte[]>(); | |||
private Map<File, byte[]> allDigests = new HashMap<>(); | |||
/** | |||
* Holds relative file names for all files (always with a forward slash). | |||
* This is used to calculate the total hash. | |||
* Key: java.util.File (source file) | |||
* Value: java.lang.String (relative file name) | |||
*/ | |||
private Map<File, String> relativeFilePaths = new HashMap<File, String>(); | |||
private Map<File, String> relativeFilePaths = new HashMap<>(); | |||
/** | |||
* Property where totalChecksum gets set. | |||
*/ | |||
@@ -138,7 +139,7 @@ public class Checksum extends MatchingTask implements Condition { | |||
/** | |||
* Stores SourceFile, DestFile pairs and SourceFile, Property String pairs. | |||
*/ | |||
private Hashtable<File, Object> includeFileMap = new Hashtable<File, Object>(); | |||
private Hashtable<File, Object> includeFileMap = new Hashtable<>(); | |||
/** | |||
* Message Digest instance | |||
*/ | |||
@@ -294,13 +295,13 @@ public class Checksum extends MatchingTask implements Condition { | |||
* Calculate the checksum(s). | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
isCondition = false; | |||
boolean value = validateAndExecute(); | |||
if (verifyProperty != null) { | |||
getProject().setNewProperty( | |||
verifyProperty, | |||
(value ? Boolean.TRUE.toString() : Boolean.FALSE.toString())); | |||
getProject().setNewProperty(verifyProperty, | |||
Boolean.toString(value)); | |||
} | |||
} | |||
@@ -311,6 +312,7 @@ public class Checksum extends MatchingTask implements Condition { | |||
* false otherwise. | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
public boolean eval() throws BuildException { | |||
isCondition = true; | |||
return validateAndExecute(); | |||
@@ -386,7 +388,7 @@ public class Checksum extends MatchingTask implements Condition { | |||
} | |||
if (fileext == null) { | |||
fileext = "." + algorithm; | |||
} else if (fileext.trim().length() == 0) { | |||
} else if (fileext.trim().isEmpty()) { | |||
throw new BuildException("File extension when specified must not be an empty string"); | |||
} | |||
try { | |||
@@ -463,8 +465,7 @@ public class Checksum extends MatchingTask implements Condition { | |||
// This directory will exist | |||
directory = file.getParentFile(); | |||
} | |||
File checksumFile = new File(directory, file.getName() + fileext); | |||
return checksumFile; | |||
return new File(directory, file.getName() + fileext); | |||
} | |||
/** | |||
@@ -498,7 +499,7 @@ public class Checksum extends MatchingTask implements Condition { | |||
String checksum = createDigestString(fileDigest); | |||
//can either be a property name string or a file | |||
Object destination = e.getValue(); | |||
if (destination instanceof java.lang.String) { | |||
if (destination instanceof String) { | |||
String prop = (String) destination; | |||
if (isCondition) { | |||
checksumMatches | |||
@@ -506,7 +507,7 @@ public class Checksum extends MatchingTask implements Condition { | |||
} else { | |||
getProject().setNewProperty(prop, checksum); | |||
} | |||
} else if (destination instanceof java.io.File) { | |||
} else if (destination instanceof File) { | |||
if (isCondition) { | |||
File existingFile = (File) destination; | |||
if (existingFile.exists()) { | |||
@@ -550,14 +551,9 @@ public class Checksum extends MatchingTask implements Condition { | |||
File[] keyArray = allDigests.keySet().toArray(new File[allDigests.size()]); | |||
// File is Comparable, but sort-order is platform | |||
// dependent (case-insensitive on Windows) | |||
Arrays.sort(keyArray, new Comparator<File>() { | |||
public int compare(File f1, File f2) { | |||
return f1 == null ? (f2 == null ? 0 : -1) | |||
: (f2 == null ? 1 | |||
: getRelativeFilePath(f1) | |||
.compareTo(getRelativeFilePath(f2))); | |||
} | |||
}); | |||
Arrays.sort(keyArray, Comparator.nullsFirst( | |||
Comparator.comparing(this::getRelativeFilePath))); | |||
// Loop over the checksums and generate a total hash. | |||
messageDigest.reset(); | |||
for (File src : keyArray) { | |||
@@ -582,11 +578,11 @@ public class Checksum extends MatchingTask implements Condition { | |||
} | |||
private String createDigestString(byte[] fileDigest) { | |||
StringBuffer checksumSb = new StringBuffer(); | |||
StringBuilder checksumSb = new StringBuilder(); | |||
for (int i = 0; i < fileDigest.length; i++) { | |||
String hexStr = Integer.toHexString(BYTE_MASK & fileDigest[i]); | |||
if (hexStr.length() < 2) { | |||
checksumSb.append("0"); | |||
checksumSb.append('0'); | |||
} | |||
checksumSb.append(hexStr); | |||
} | |||
@@ -630,20 +626,15 @@ public class Checksum extends MatchingTask implements Condition { | |||
* @since 1.7 | |||
*/ | |||
private String readChecksum(File f) { | |||
BufferedReader diskChecksumReader = null; | |||
try { | |||
diskChecksumReader = new BufferedReader(new FileReader(f)); | |||
try (BufferedReader diskChecksumReader = | |||
new BufferedReader(new FileReader(f))) { | |||
Object[] result = format.parse(diskChecksumReader.readLine()); | |||
if (result == null || result.length == 0 || result[0] == null) { | |||
throw new BuildException("failed to find a checksum"); | |||
} | |||
return (String) result[0]; | |||
} catch (IOException e) { | |||
throw new BuildException("Couldn't read checksum file " + f, e); | |||
} catch (ParseException e) { | |||
} catch (IOException | ParseException e) { | |||
throw new BuildException("Couldn't read checksum file " + f, e); | |||
} finally { | |||
FileUtils.close(diskChecksumReader); | |||
} | |||
} | |||
@@ -651,13 +642,12 @@ public class Checksum extends MatchingTask implements Condition { | |||
* @since Ant 1.8.2 | |||
*/ | |||
private String getRelativeFilePath(File f) { | |||
String path = (String) relativeFilePaths.get(f); | |||
String path = relativeFilePaths.get(f); | |||
if (path == null) { | |||
//bug 37386. this should not occur, but it has, once. | |||
throw new BuildException("Internal error: " | |||
+ "relativeFilePaths could not match file " | |||
+ f + "\n" | |||
+ "please file a bug report on this"); | |||
throw new BuildException( | |||
"Internal error: relativeFilePaths could not match file %s\nplease file a bug report on this", | |||
f); | |||
} | |||
return path; | |||
} | |||
@@ -679,11 +669,6 @@ public class Checksum extends MatchingTask implements Condition { | |||
formatMap.put(SVF, new MessageFormat("MD5 ({1}) = {0}")); | |||
} | |||
/** Constructor for FormatElement */ | |||
public FormatElement() { | |||
super(); | |||
} | |||
/** | |||
* Get the default value - CHECKSUM. | |||
* @return the defaul value. | |||
@@ -699,15 +684,16 @@ public class Checksum extends MatchingTask implements Condition { | |||
* @return a <code>MessageFormat</code> object. | |||
*/ | |||
public MessageFormat getFormat() { | |||
return (MessageFormat) formatMap.get(getValue()); | |||
return formatMap.get(getValue()); | |||
} | |||
/** | |||
* Get the valid values. | |||
* @return an array of values. | |||
*/ | |||
@Override | |||
public String[] getValues() { | |||
return new String[] {CHECKSUM, MD5SUM, SVF}; | |||
return new String[] { CHECKSUM, MD5SUM, SVF }; | |||
} | |||
} | |||
} |
@@ -58,6 +58,7 @@ public class Chmod extends ExecuteOn { | |||
* @param project the project for this task. | |||
* @see org.apache.tools.ant.ProjectComponent#setProject | |||
*/ | |||
@Override | |||
public void setProject(Project project) { | |||
super.setProject(project); | |||
defaultSet.setProject(project); | |||
@@ -77,6 +78,7 @@ public class Chmod extends ExecuteOn { | |||
* The directory which holds the files whose permissions must be changed. | |||
* @param src the directory. | |||
*/ | |||
@Override | |||
public void setDir(File src) { | |||
defaultSet.setDir(src); | |||
} | |||
@@ -154,6 +156,7 @@ public class Chmod extends ExecuteOn { | |||
/** | |||
* Check the attributes and nested elements. | |||
*/ | |||
@Override | |||
protected void checkConfiguration() { | |||
if (!havePerm) { | |||
throw new BuildException("Required attribute perm not set in chmod", | |||
@@ -170,6 +173,7 @@ public class Chmod extends ExecuteOn { | |||
* Carry out the chmoding. | |||
* @throws BuildException on error. | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
/* | |||
* In Ant 1.1, <chmod dir="foo" /> means, change the permissions | |||
@@ -188,7 +192,7 @@ public class Chmod extends ExecuteOn { | |||
} else if (isValidOs()) { | |||
// we are chmodding the given directory | |||
Execute execute = prepareExec(); | |||
Commandline cloned = (Commandline) cmdl.clone(); | |||
Commandline cloned = cmdl.clone(); | |||
cloned.createArgument().setValue(defaultSet.getDir(getProject()) | |||
.getPath()); | |||
try { | |||
@@ -210,6 +214,7 @@ public class Chmod extends ExecuteOn { | |||
* @throws BuildException always. | |||
* @ant.attribute ignore="true" | |||
*/ | |||
@Override | |||
public void setExecutable(String e) { | |||
throw new BuildException(getTaskType() | |||
+ " doesn\'t support the executable attribute", getLocation()); | |||
@@ -222,6 +227,7 @@ public class Chmod extends ExecuteOn { | |||
* @throws BuildException always. | |||
* @ant.attribute ignore="true" | |||
*/ | |||
@Override | |||
public void setCommand(Commandline cmdl) { | |||
throw new BuildException(getTaskType() | |||
+ " doesn\'t support the command attribute", getLocation()); | |||
@@ -233,6 +239,7 @@ public class Chmod extends ExecuteOn { | |||
* @throws BuildException always. | |||
* @ant.attribute ignore="true" | |||
*/ | |||
@Override | |||
public void setSkipEmptyFilesets(boolean skip) { | |||
throw new BuildException(getTaskType() | |||
+ " doesn\'t support the skipemptyfileset attribute", getLocation()); | |||
@@ -244,6 +251,7 @@ public class Chmod extends ExecuteOn { | |||
* @throws BuildException always. | |||
* @ant.attribute ignore="true" | |||
*/ | |||
@Override | |||
public void setAddsourcefile(boolean b) { | |||
throw new BuildException(getTaskType() | |||
+ " doesn\'t support the addsourcefile attribute", getLocation()); | |||
@@ -254,6 +262,7 @@ public class Chmod extends ExecuteOn { | |||
* Always include unix. | |||
* @return true if the os is valid. | |||
*/ | |||
@Override | |||
protected boolean isValidOs() { | |||
return getOs() == null && getOsFamily() == null | |||
? Os.isFamily(Os.FAMILY_UNIX) : super.isValidOs(); | |||
@@ -70,12 +70,6 @@ public class Classloader extends Task { | |||
private boolean parentFirst = true; | |||
private String parentName = null; | |||
/** | |||
* Default constructor | |||
*/ | |||
public Classloader() { | |||
} | |||
/** Name of the loader. If none, the default loader will be modified | |||
* | |||
* @param name the name of this loader | |||
@@ -101,6 +95,7 @@ public class Classloader extends Task { | |||
* @param b if true reverse the normal classloader lookup. | |||
* @deprecated use setParentFirst with a negated argument instead | |||
*/ | |||
@Deprecated | |||
public void setReverse(boolean b) { | |||
this.parentFirst = !b; | |||
} | |||
@@ -156,17 +151,17 @@ public class Classloader extends Task { | |||
return this.classpath.createPath(); | |||
} | |||
/** | |||
* do the classloader manipulation. | |||
*/ | |||
@Override | |||
public void execute() { | |||
try { | |||
// Gump friendly - don't mess with the core loader if only classpath | |||
if ("only".equals(getProject().getProperty("build.sysclasspath")) | |||
&& (name == null || SYSTEM_LOADER_REF.equals(name))) { | |||
log("Changing the system loader is disabled " | |||
+ "by build.sysclasspath=only", Project.MSG_WARN); | |||
log("Changing the system loader is disabled by build.sysclasspath=only", | |||
Project.MSG_WARN); | |||
return; | |||
} | |||
@@ -186,6 +181,7 @@ public class Classloader extends Task { | |||
return; | |||
} | |||
@SuppressWarnings("resource") | |||
AntClassLoader acl = (AntClassLoader) obj; | |||
boolean existingLoader = acl != null; | |||
@@ -130,7 +130,7 @@ public class Concat extends Task implements ResourceCollection { | |||
public void setFile(File file) throws BuildException { | |||
// non-existing files are not allowed | |||
if (!file.exists()) { | |||
throw new BuildException("File " + file + " does not exist."); | |||
throw new BuildException("File %s does not exist.", file); | |||
} | |||
BufferedReader reader = null; | |||
@@ -181,12 +181,12 @@ public class Concat extends Task implements ResourceCollection { | |||
if (value == null) { | |||
value = ""; | |||
} | |||
if (value.trim().length() == 0) { | |||
if (value.trim().isEmpty()) { | |||
value = ""; | |||
} | |||
if (trimLeading) { | |||
char[] current = value.toCharArray(); | |||
StringBuffer b = new StringBuffer(current.length); | |||
StringBuilder b = new StringBuilder(current.length); | |||
boolean startOfLine = true; | |||
int pos = 0; | |||
while (pos < current.length) { | |||
@@ -253,6 +253,7 @@ public class Concat extends Task implements ResourceCollection { | |||
* @exception IOException - possibly thrown by the read for a reader | |||
* object. | |||
*/ | |||
@Override | |||
public int read() throws IOException { | |||
if (needAddSeparator) { | |||
if (lastPos >= eolString.length()) { | |||
@@ -287,6 +288,7 @@ public class Concat extends Task implements ResourceCollection { | |||
* @exception IOException - possibly thrown by the reads to the | |||
* reader objects. | |||
*/ | |||
@Override | |||
public int read(char[] cbuf, int off, int len) | |||
throws IOException { | |||
@@ -334,14 +336,14 @@ public class Concat extends Task implements ResourceCollection { | |||
} | |||
if (amountRead == 0) { | |||
return -1; | |||
} else { | |||
return amountRead; | |||
} | |||
return amountRead; | |||
} | |||
/** | |||
* Close the current reader | |||
*/ | |||
@Override | |||
public void close() throws IOException { | |||
if (reader != null) { | |||
reader.close(); | |||
@@ -383,6 +385,7 @@ public class Concat extends Task implements ResourceCollection { | |||
private ConcatResource(ResourceCollection c) { | |||
this.c = c; | |||
} | |||
@Override | |||
public InputStream getInputStream() { | |||
if (binary) { | |||
ConcatResourceInputStream result = new ConcatResourceInputStream(c); | |||
@@ -424,6 +427,7 @@ public class Concat extends Task implements ResourceCollection { | |||
return outputEncoding == null ? new ReaderInputStream(rdr) | |||
: new ReaderInputStream(rdr, outputEncoding); | |||
} | |||
@Override | |||
public String getName() { | |||
return resourceName == null | |||
? "concat (" + String.valueOf(c) + ")" : resourceName; | |||
@@ -492,6 +496,7 @@ public class Concat extends Task implements ResourceCollection { | |||
private String resourceName; | |||
private ReaderFactory<Resource> resourceReaderFactory = new ReaderFactory<Resource>() { | |||
@Override | |||
public Reader getReader(Resource o) throws IOException { | |||
InputStream is = o.getInputStream(); | |||
return new BufferedReader(encoding == null | |||
@@ -501,6 +506,7 @@ public class Concat extends Task implements ResourceCollection { | |||
}; | |||
private ReaderFactory<Reader> identityReaderFactory = new ReaderFactory<Reader>() { | |||
@Override | |||
public Reader getReader(Reader o) { | |||
return o; | |||
} | |||
@@ -594,6 +600,7 @@ public class Concat extends Task implements ResourceCollection { | |||
* @since Ant 1.6 | |||
* @deprecated use #setOverwrite instead | |||
*/ | |||
@Deprecated | |||
public void setForce(boolean forceOverwrite) { | |||
this.forceOverwrite = forceOverwrite; | |||
} | |||
@@ -752,11 +759,11 @@ public class Concat extends Task implements ResourceCollection { | |||
*/ | |||
public void setEol(FixCRLF.CrLf crlf) { | |||
String s = crlf.getValue(); | |||
if (s.equals("cr") || s.equals("mac")) { | |||
if ("cr".equals(s) || "mac".equals(s)) { | |||
eolString = "\r"; | |||
} else if (s.equals("lf") || s.equals("unix")) { | |||
} else if ("lf".equals(s) || "unix".equals(s)) { | |||
eolString = "\n"; | |||
} else if (s.equals("crlf") || s.equals("dos")) { | |||
} else if ("crlf".equals(s) || "dos".equals(s)) { | |||
eolString = "\r\n"; | |||
} | |||
} | |||
@@ -785,6 +792,7 @@ public class Concat extends Task implements ResourceCollection { | |||
/** | |||
* Execute the concat task. | |||
*/ | |||
@Override | |||
public void execute() { | |||
validate(); | |||
if (binary && dest == null) { | |||
@@ -796,7 +804,7 @@ public class Concat extends Task implements ResourceCollection { | |||
log(dest + " is up-to-date.", Project.MSG_VERBOSE); | |||
return; | |||
} | |||
if (c.size() == 0 && ignoreEmpty) { | |||
if (c.isEmpty() && ignoreEmpty) { | |||
return; | |||
} | |||
try { | |||
@@ -815,15 +823,19 @@ public class Concat extends Task implements ResourceCollection { | |||
* Implement ResourceCollection. | |||
* @return Iterator<Resource>. | |||
*/ | |||
@Override | |||
public Iterator<Resource> iterator() { | |||
validate(); | |||
return Collections.<Resource>singletonList(new ConcatResource(getResources())).iterator(); | |||
return Collections | |||
.<Resource> singletonList(new ConcatResource(getResources())) | |||
.iterator(); | |||
} | |||
/** | |||
* Implement ResourceCollection. | |||
* @return 1. | |||
*/ | |||
@Override | |||
public int size() { | |||
return 1; | |||
} | |||
@@ -832,6 +844,7 @@ public class Concat extends Task implements ResourceCollection { | |||
* Implement ResourceCollection. | |||
* @return false. | |||
*/ | |||
@Override | |||
public boolean isFilesystemOnly() { | |||
return false; | |||
} | |||
@@ -852,8 +865,7 @@ public class Concat extends Task implements ResourceCollection { | |||
} | |||
if (encoding != null || outputEncoding != null) { | |||
throw new BuildException( | |||
"Setting input or output encoding is incompatible with binary" | |||
+ " concatenation"); | |||
"Setting input or output encoding is incompatible with binary concatenation"); | |||
} | |||
if (filterChains != null) { | |||
throw new BuildException( | |||
@@ -899,8 +911,9 @@ public class Concat extends Task implements ResourceCollection { | |||
checkDestNotInSources.add(rc); | |||
checkDestNotInSources.add(dest); | |||
if (checkDestNotInSources.size() > 0) { | |||
throw new BuildException("Destination resource " + dest | |||
+ " was specified as an input resource."); | |||
throw new BuildException( | |||
"Destination resource %s was specified as an input resource.", | |||
dest); | |||
} | |||
} | |||
Restrict noexistRc = new Restrict(); | |||
@@ -919,12 +932,8 @@ public class Concat extends Task implements ResourceCollection { | |||
if (dest == null || forceOverwrite) { | |||
return false; | |||
} | |||
for (Resource r : c) { | |||
if (SelectorUtils.isOutOfDate(r, dest, FILE_UTILS.getFileTimestampGranularity())) { | |||
return false; | |||
} | |||
} | |||
return true; | |||
return c.stream().noneMatch(r -> SelectorUtils.isOutOfDate(r, dest, | |||
FILE_UTILS.getFileTimestampGranularity())); | |||
} | |||
/** | |||
@@ -934,7 +943,7 @@ public class Concat extends Task implements ResourceCollection { | |||
* for "ignorable whitespace" as well.</p> | |||
*/ | |||
private void sanitizeText() { | |||
if (textBuffer != null && "".equals(textBuffer.toString().trim())) { | |||
if (textBuffer != null && textBuffer.toString().trim().isEmpty()) { | |||
textBuffer = null; | |||
} | |||
} | |||
@@ -107,16 +107,18 @@ public class ConditionTask extends ConditionBase { | |||
*/ | |||
public void execute() throws BuildException { | |||
if (countConditions() > 1) { | |||
throw new BuildException("You must not nest more than one condition into <" | |||
+ getTaskName() + ">"); | |||
throw new BuildException( | |||
"You must not nest more than one condition into <%s>", | |||
getTaskName()); | |||
} | |||
if (countConditions() < 1) { | |||
throw new BuildException("You must nest a condition into <" + getTaskName() + ">"); | |||
throw new BuildException("You must nest a condition into <%s>", | |||
getTaskName()); | |||
} | |||
if (property == null) { | |||
throw new BuildException("The property attribute is required."); | |||
} | |||
Condition c = (Condition) getConditions().nextElement(); | |||
Condition c = getConditions().nextElement(); | |||
if (c.eval()) { | |||
log("Condition true; setting " + property + " to " + value, Project.MSG_DEBUG); | |||
PropertyHelper.getPropertyHelper(getProject()).setNewProperty(property, value); | |||
@@ -26,6 +26,7 @@ import java.util.HashSet; | |||
import java.util.Hashtable; | |||
import java.util.List; | |||
import java.util.Map; | |||
import java.util.Set; | |||
import java.util.Vector; | |||
import org.apache.tools.ant.BuildException; | |||
@@ -75,7 +76,7 @@ public class Copy extends Task { | |||
protected File file = null; // the source file | |||
protected File destFile = null; // the destination file | |||
protected File destDir = null; // the destination directory | |||
protected Vector<ResourceCollection> rcs = new Vector<ResourceCollection>(); | |||
protected Vector<ResourceCollection> rcs = new Vector<>(); | |||
// here to provide API backwards compatibility | |||
protected Vector<ResourceCollection> filesets = rcs; | |||
@@ -88,15 +89,15 @@ public class Copy extends Task { | |||
protected boolean includeEmpty = true; | |||
protected boolean failonerror = true; | |||
protected Hashtable<String, String[]> fileCopyMap = new LinkedHashtable<String, String[]>(); | |||
protected Hashtable<String, String[]> dirCopyMap = new LinkedHashtable<String, String[]>(); | |||
protected Hashtable<File, File> completeDirMap = new LinkedHashtable<File, File>(); | |||
protected Hashtable<String, String[]> fileCopyMap = new LinkedHashtable<>(); | |||
protected Hashtable<String, String[]> dirCopyMap = new LinkedHashtable<>(); | |||
protected Hashtable<File, File> completeDirMap = new LinkedHashtable<>(); | |||
protected Mapper mapperElement = null; | |||
protected FileUtils fileUtils; | |||
//CheckStyle:VisibilityModifier ON | |||
private final Vector<FilterChain> filterChains = new Vector<FilterChain>(); | |||
private final Vector<FilterSet> filterSets = new Vector<FilterSet>(); | |||
private final Vector<FilterChain> filterChains = new Vector<>(); | |||
private final Vector<FilterSet> filterSets = new Vector<>(); | |||
private String inputEncoding = null; | |||
private String outputEncoding = null; | |||
private long granularity = 0; | |||
@@ -474,18 +475,17 @@ public class Copy extends Task { | |||
separate lists and then each list is handled in one go. | |||
*/ | |||
final HashMap<File, List<String>> filesByBasedir = new HashMap<File, List<String>>(); | |||
final HashMap<File, List<String>> dirsByBasedir = new HashMap<File, List<String>>(); | |||
final HashSet<File> baseDirs = new HashSet<File>(); | |||
final ArrayList<Resource> nonFileResources = new ArrayList<Resource>(); | |||
final int size = rcs.size(); | |||
for (int i = 0; i < size; i++) { | |||
final ResourceCollection rc = rcs.elementAt(i); | |||
final Map<File, List<String>> filesByBasedir = new HashMap<>(); | |||
final Map<File, List<String>> dirsByBasedir = new HashMap<>(); | |||
final Set<File> baseDirs = new HashSet<>(); | |||
final List<Resource> nonFileResources = new ArrayList<>(); | |||
for (ResourceCollection rc : rcs) { | |||
// Step (1) - beware of the ZipFileSet | |||
if (rc instanceof FileSet && rc.isFilesystemOnly()) { | |||
final FileSet fs = (FileSet) rc; | |||
DirectoryScanner ds = null; | |||
DirectoryScanner ds; | |||
try { | |||
ds = fs.getDirectoryScanner(getProject()); | |||
} catch (final BuildException e) { | |||
@@ -493,12 +493,11 @@ public class Copy extends Task { | |||
|| !getMessage(e).endsWith(DirectoryScanner | |||
.DOES_NOT_EXIST_POSTFIX)) { | |||
throw e; | |||
} else { | |||
if (!quiet) { | |||
log("Warning: " + getMessage(e), Project.MSG_ERR); | |||
} | |||
continue; | |||
} | |||
if (!quiet) { | |||
log("Warning: " + getMessage(e), Project.MSG_ERR); | |||
} | |||
continue; | |||
} | |||
final File fromDir = fs.getDir(getProject()); | |||
@@ -574,7 +573,7 @@ public class Copy extends Task { | |||
} | |||
} | |||
if (nonFileResources.size() > 0 || singleResource != null) { | |||
if (!nonFileResources.isEmpty() || singleResource != null) { | |||
final Resource[] nonFiles = | |||
nonFileResources.toArray(new Resource[nonFileResources.size()]); | |||
// restrict to out-of-date resources | |||
@@ -645,8 +644,9 @@ public class Copy extends Task { | |||
} | |||
} | |||
private void iterateOverBaseDirs( | |||
final HashSet<File> baseDirs, final HashMap<File, List<String>> dirsByBasedir, final HashMap<File, List<String>> filesByBasedir) { | |||
private void iterateOverBaseDirs(final Set<File> baseDirs, | |||
final Map<File, List<String>> dirsByBasedir, | |||
final Map<File, List<String>> filesByBasedir) { | |||
for (final File f : baseDirs) { | |||
final List<String> files = filesByBasedir.get(f); | |||
@@ -672,7 +672,7 @@ public class Copy extends Task { | |||
* @exception BuildException if an error occurs. | |||
*/ | |||
protected void validateAttributes() throws BuildException { | |||
if (file == null && rcs.size() == 0) { | |||
if (file == null && rcs.isEmpty()) { | |||
throw new BuildException( | |||
"Specify at least one source--a file or a resource collection."); | |||
} | |||
@@ -686,36 +686,36 @@ public class Copy extends Task { | |||
if (file != null && file.isDirectory()) { | |||
throw new BuildException("Use a resource collection to copy directories."); | |||
} | |||
if (destFile != null && rcs.size() > 0) { | |||
if (destFile != null && !rcs.isEmpty()) { | |||
if (rcs.size() > 1) { | |||
throw new BuildException( | |||
"Cannot concatenate multiple files into a single file."); | |||
} else { | |||
final ResourceCollection rc = rcs.elementAt(0); | |||
if (!rc.isFilesystemOnly() && !supportsNonFileResources()) { | |||
throw new BuildException("Only FileSystem resources are" | |||
+ " supported."); | |||
} | |||
if (rc.size() == 0) { | |||
throw new BuildException(MSG_WHEN_COPYING_EMPTY_RC_TO_FILE); | |||
} else if (rc.size() == 1) { | |||
final Resource res = rc.iterator().next(); | |||
final FileProvider r = res.as(FileProvider.class); | |||
if (file == null) { | |||
if (r != null) { | |||
file = r.getFile(); | |||
} else { | |||
singleResource = res; | |||
} | |||
rcs.removeElementAt(0); | |||
} | |||
final ResourceCollection rc = rcs.elementAt(0); | |||
if (!rc.isFilesystemOnly() && !supportsNonFileResources()) { | |||
throw new BuildException( | |||
"Only FileSystem resources are supported."); | |||
} | |||
if (rc.isEmpty()) { | |||
throw new BuildException(MSG_WHEN_COPYING_EMPTY_RC_TO_FILE); | |||
} | |||
if (rc.size() == 1) { | |||
final Resource res = rc.iterator().next(); | |||
final FileProvider r = res.as(FileProvider.class); | |||
if (file == null) { | |||
if (r != null) { | |||
file = r.getFile(); | |||
} else { | |||
throw new BuildException( | |||
"Cannot concatenate multiple files into a single file."); | |||
singleResource = res; | |||
} | |||
rcs.removeElementAt(0); | |||
} else { | |||
throw new BuildException( | |||
"Cannot concatenate multiple files into a single file."); | |||
} | |||
} else { | |||
throw new BuildException( | |||
"Cannot concatenate multiple files into a single file."); | |||
} | |||
} | |||
if (destFile != null) { | |||
@@ -811,34 +811,28 @@ public class Copy extends Task { | |||
*/ | |||
protected Map<Resource, String[]> buildMap(final Resource[] fromResources, final File toDir, | |||
final FileNameMapper mapper) { | |||
final HashMap<Resource, String[]> map = new HashMap<Resource, String[]>(); | |||
Resource[] toCopy = null; | |||
final Map<Resource, String[]> map = new HashMap<>(); | |||
Resource[] toCopy; | |||
if (forceOverwrite) { | |||
final Vector<Resource> v = new Vector<Resource>(); | |||
final List<Resource> v = new ArrayList<>(); | |||
for (int i = 0; i < fromResources.length; i++) { | |||
if (mapper.mapFileName(fromResources[i].getName()) != null) { | |||
v.addElement(fromResources[i]); | |||
v.add(fromResources[i]); | |||
} | |||
} | |||
toCopy = new Resource[v.size()]; | |||
v.copyInto(toCopy); | |||
toCopy = v.toArray(new Resource[v.size()]); | |||
} else { | |||
toCopy = ResourceUtils.selectOutOfDateSources(this, fromResources, | |||
mapper, | |||
new ResourceFactory() { | |||
public Resource getResource(final String name) { | |||
return new FileResource(toDir, name); | |||
} | |||
}, | |||
(ResourceFactory) name -> new FileResource(toDir, name), | |||
granularity); | |||
} | |||
for (int i = 0; i < toCopy.length; i++) { | |||
final String[] mappedFiles = mapper.mapFileName(toCopy[i].getName()); | |||
for (int j = 0; j < mappedFiles.length; j++) { | |||
if (mappedFiles[j] == null) { | |||
throw new BuildException("Can't copy a resource without a" | |||
+ " name if the mapper doesn't" | |||
+ " provide one."); | |||
for (String mappedFile : mappedFiles) { | |||
if (mappedFile == null) { | |||
throw new BuildException( | |||
"Can't copy a resource without a name if the mapper doesn't provide one."); | |||
} | |||
} | |||
@@ -861,7 +855,7 @@ public class Copy extends Task { | |||
* This is a good method for subclasses to override. | |||
*/ | |||
protected void doFileOperations() { | |||
if (fileCopyMap.size() > 0) { | |||
if (!fileCopyMap.isEmpty()) { | |||
log("Copying " + fileCopyMap.size() | |||
+ " file" + (fileCopyMap.size() == 1 ? "" : "s") | |||
+ " to " + destDir.getAbsolutePath()); | |||
@@ -870,9 +864,7 @@ public class Copy extends Task { | |||
final String fromFile = e.getKey(); | |||
final String[] toFiles = e.getValue(); | |||
for (int i = 0; i < toFiles.length; i++) { | |||
final String toFile = toFiles[i]; | |||
for (final String toFile : toFiles) { | |||
if (fromFile.equals(toFile)) { | |||
log("Skipping self-copy of " + fromFile, verbosity); | |||
continue; | |||
@@ -916,8 +908,8 @@ public class Copy extends Task { | |||
if (includeEmpty) { | |||
int createCount = 0; | |||
for (final String[] dirs : dirCopyMap.values()) { | |||
for (int i = 0; i < dirs.length; i++) { | |||
final File d = new File(dirs[i]); | |||
for (String dir : dirs) { | |||
final File d = new File(dir); | |||
if (!d.exists()) { | |||
if (!(d.mkdirs() || d.isDirectory())) { | |||
log("Unable to create directory " | |||
@@ -947,7 +939,7 @@ public class Copy extends Task { | |||
* @since Ant 1.7 | |||
*/ | |||
protected void doResourceOperations(final Map<Resource, String[]> map) { | |||
if (map.size() > 0) { | |||
if (!map.isEmpty()) { | |||
log("Copying " + map.size() | |||
+ " resource" + (map.size() == 1 ? "" : "s") | |||
+ " to " + destDir.getAbsolutePath()); | |||
@@ -1026,7 +1018,7 @@ public class Copy extends Task { | |||
baseDir = getKeyFile(baseDir); | |||
List<String> l = m.get(baseDir); | |||
if (l == null) { | |||
l = new ArrayList<String>(names.length); | |||
l = new ArrayList<>(names.length); | |||
m.put(baseDir, l); | |||
} | |||
l.addAll(java.util.Arrays.asList(names)); | |||
@@ -1085,7 +1077,7 @@ public class Copy extends Task { | |||
*/ | |||
private String getDueTo(final Exception ex) { | |||
final boolean baseIOException = ex.getClass() == IOException.class; | |||
final StringBuffer message = new StringBuffer(); | |||
final StringBuilder message = new StringBuilder(); | |||
if (!baseIOException || ex.getMessage() == null) { | |||
message.append(ex.getClass().getName()); | |||
} | |||
@@ -35,6 +35,7 @@ import org.apache.tools.ant.Project; | |||
* @deprecated The copydir task is deprecated since Ant 1.2. Use copy instead. | |||
*/ | |||
@Deprecated | |||
public class Copydir extends MatchingTask { | |||
private File srcDir; | |||
@@ -42,7 +43,7 @@ public class Copydir extends MatchingTask { | |||
private boolean filtering = false; | |||
private boolean flatten = false; | |||
private boolean forceOverwrite = false; | |||
private Hashtable<String, String> filecopyList = new Hashtable<String, String>(); | |||
private Map<String, String> filecopyList = new Hashtable<>(); | |||
/** | |||
* The src attribute | |||
@@ -94,6 +95,7 @@ public class Copydir extends MatchingTask { | |||
* Execute the task. | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
log("DEPRECATED - The copydir task is deprecated. Use copy instead."); | |||
@@ -34,6 +34,7 @@ import org.apache.tools.ant.Task; | |||
* copy instead. | |||
*/ | |||
@Deprecated | |||
public class Copyfile extends Task { | |||
private File srcFile; | |||
@@ -80,6 +81,7 @@ public class Copyfile extends Task { | |||
* Execute the task. | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
log("DEPRECATED - The copyfile task is deprecated. Use copy instead."); | |||
@@ -107,9 +109,9 @@ public class Copyfile extends Task { | |||
try { | |||
getProject().copyFile(srcFile, destFile, filtering, forceOverwrite); | |||
} catch (IOException ioe) { | |||
String msg = "Error copying file: " + srcFile.getAbsolutePath() | |||
+ " due to " + ioe.getMessage(); | |||
throw new BuildException(msg); | |||
throw new BuildException( | |||
"Error copying file: " + srcFile.getAbsolutePath() | |||
+ " due to " + ioe.getMessage()); | |||
} | |||
} | |||
} | |||
@@ -45,29 +45,28 @@ public class DefaultExcludes extends Task { | |||
* | |||
* @exception BuildException if something goes wrong with the build | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
if (!defaultrequested && add.equals("") && remove.equals("") && !echo) { | |||
throw new BuildException("<defaultexcludes> task must set " | |||
+ "at least one attribute (echo=\"false\"" | |||
+ " doesn't count since that is the default"); | |||
if (!defaultrequested && "".equals(add) && "".equals(remove) && !echo) { | |||
throw new BuildException( | |||
"<defaultexcludes> task must set at least one attribute (echo=\"false\" doesn't count since that is the default"); | |||
} | |||
if (defaultrequested) { | |||
DirectoryScanner.resetDefaultExcludes(); | |||
} | |||
if (!add.equals("")) { | |||
if (!"".equals(add)) { | |||
DirectoryScanner.addDefaultExclude(add); | |||
} | |||
if (!remove.equals("")) { | |||
if (!"".equals(remove)) { | |||
DirectoryScanner.removeDefaultExclude(remove); | |||
} | |||
if (echo) { | |||
StringBuffer message | |||
= new StringBuffer("Current Default Excludes:"); | |||
StringBuilder message | |||
= new StringBuilder("Current Default Excludes:"); | |||
message.append(StringUtils.LINE_SEP); | |||
String[] excludes = DirectoryScanner.getDefaultExcludes(); | |||
for (int i = 0; i < excludes.length; i++) { | |||
for (String exclude : DirectoryScanner.getDefaultExcludes()) { | |||
message.append(" "); | |||
message.append(excludes[i]); | |||
message.append(exclude); | |||
message.append(StringUtils.LINE_SEP); | |||
} | |||
log(message.toString(), logLevel); | |||
@@ -111,5 +110,4 @@ public class DefaultExcludes extends Task { | |||
this.echo = echo; | |||
} | |||
} |
@@ -50,13 +50,14 @@ public abstract class Definer extends DefBase { | |||
/** | |||
* the extension of an antlib file for autoloading. | |||
* {@value[ | |||
* {@value /antlib.xml} | |||
*/ | |||
private static final String ANTLIB_XML = "/antlib.xml"; | |||
private static final ThreadLocal<Map<URL, Location>> RESOURCE_STACK = new ThreadLocal<Map<URL, Location>>() { | |||
@Override | |||
protected Map<URL, Location> initialValue() { | |||
return new HashMap<URL, Location>(); | |||
return new HashMap<>(); | |||
} | |||
}; | |||
@@ -120,8 +121,10 @@ public abstract class Definer extends DefBase { | |||
* get the values | |||
* @return an array of the allowed values for this attribute. | |||
*/ | |||
@Override | |||
public String[] getValues() { | |||
return new String[] {POLICY_FAIL, POLICY_REPORT, POLICY_IGNORE, POLICY_FAILALL}; | |||
return new String[] { POLICY_FAIL, POLICY_REPORT, POLICY_IGNORE, | |||
POLICY_FAILALL }; | |||
} | |||
} | |||
@@ -138,8 +141,9 @@ public abstract class Definer extends DefBase { | |||
* get the values | |||
* @return an array of the allowed values for this attribute. | |||
*/ | |||
@Override | |||
public String[] getValues() { | |||
return new String[] {"properties", "xml"}; | |||
return new String[] { "properties", "xml" }; | |||
} | |||
} | |||
@@ -202,6 +206,7 @@ public abstract class Definer extends DefBase { | |||
* | |||
* @exception BuildException if an error occurs | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
ClassLoader al = createLoader(); | |||
@@ -223,23 +228,22 @@ public abstract class Definer extends DefBase { | |||
setResource(makeResourceFromURI(uri1)); | |||
} else { | |||
throw new BuildException( | |||
"Only antlib URIs can be located from the URI alone," | |||
+ " not the URI '" + getURI() + "'"); | |||
"Only antlib URIs can be located from the URI alone, not the URI '" | |||
+ getURI() + "'"); | |||
} | |||
} | |||
if (name != null) { | |||
if (classname == null) { | |||
throw new BuildException( | |||
"classname attribute of " + getTaskName() + " element " | |||
+ "is undefined", getLocation()); | |||
throw new BuildException("classname attribute of " | |||
+ getTaskName() + " element is undefined", getLocation()); | |||
} | |||
addDefinition(al, name, classname); | |||
} else { | |||
if (classname != null) { | |||
String msg = "You must not specify classname " | |||
+ "together with file or resource."; | |||
throw new BuildException(msg, getLocation()); | |||
throw new BuildException( | |||
"You must not specify classname together with file or resource.", | |||
getLocation()); | |||
} | |||
final Enumeration<URL> urls; | |||
if (file == null) { | |||
@@ -263,21 +267,19 @@ public abstract class Definer extends DefBase { | |||
if (fmt == Format.PROPERTIES) { | |||
loadProperties(al, url); | |||
break; | |||
} else if (RESOURCE_STACK.get().get(url) != null) { | |||
log("Warning: Recursive loading of " + url | |||
+ " ignored" | |||
+ " at " + getLocation() | |||
+ " originally loaded at " | |||
+ RESOURCE_STACK.get().get(url), | |||
Project.MSG_WARN); | |||
} else { | |||
if (RESOURCE_STACK.get().get(url) != null) { | |||
log("Warning: Recursive loading of " + url | |||
+ " ignored" | |||
+ " at " + getLocation() | |||
+ " originally loaded at " | |||
+ RESOURCE_STACK.get().get(url), | |||
Project.MSG_WARN); | |||
} else { | |||
try { | |||
RESOURCE_STACK.get().put(url, getLocation()); | |||
loadAntlib(al, url); | |||
} finally { | |||
RESOURCE_STACK.get().remove(url); | |||
} | |||
try { | |||
RESOURCE_STACK.get().put(url, getLocation()); | |||
loadAntlib(al, url); | |||
} finally { | |||
RESOURCE_STACK.get().remove(url); | |||
} | |||
} | |||
} | |||
@@ -290,7 +292,6 @@ public abstract class Definer extends DefBase { | |||
* @param uri the xml namespace uri that to convert. | |||
* @return the name of a resource. It may not exist | |||
*/ | |||
public static String makeResourceFromURI(String uri) { | |||
String path = uri.substring(MagicNames.ANTLIB_PREFIX.length()); | |||
String resource; | |||
@@ -391,9 +392,7 @@ public abstract class Definer extends DefBase { | |||
* @param url the url to get the definitions from | |||
*/ | |||
protected void loadProperties(ClassLoader al, URL url) { | |||
InputStream is = null; | |||
try { | |||
is = url.openStream(); | |||
try (InputStream is = url.openStream()) { | |||
if (is == null) { | |||
log("Could not load definitions from " + url, | |||
Project.MSG_WARN); | |||
@@ -401,16 +400,13 @@ public abstract class Definer extends DefBase { | |||
} | |||
Properties props = new Properties(); | |||
props.load(is); | |||
Enumeration<?> keys = props.keys(); | |||
while (keys.hasMoreElements()) { | |||
name = ((String) keys.nextElement()); | |||
for (String key : props.stringPropertyNames()) { | |||
name = key; | |||
classname = props.getProperty(name); | |||
addDefinition(al, name, classname); | |||
} | |||
} catch (IOException ex) { | |||
throw new BuildException(ex, getLocation()); | |||
} finally { | |||
FileUtils.close(is); | |||
} | |||
} | |||
@@ -559,7 +555,6 @@ public abstract class Definer extends DefBase { | |||
this.adaptToClass = adaptToClass; | |||
} | |||
/** | |||
* Add a definition using the attributes of Definer | |||
* | |||
@@ -601,15 +596,16 @@ public abstract class Definer extends DefBase { | |||
ComponentHelper.getComponentHelper(getProject()) | |||
.addDataTypeDefinition(def); | |||
} catch (ClassNotFoundException cnfe) { | |||
String msg = getTaskName() + " class " + classname | |||
+ " cannot be found" | |||
+ "\n using the classloader " + al; | |||
throw new BuildException(msg, cnfe, getLocation()); | |||
throw new BuildException( | |||
getTaskName() + " class " + classname | |||
+ " cannot be found\n using the classloader " + al, | |||
cnfe, getLocation()); | |||
} catch (NoClassDefFoundError ncdfe) { | |||
String msg = getTaskName() + " A class needed by class " | |||
+ classname + " cannot be found: " + ncdfe.getMessage() | |||
+ "\n using the classloader " + al; | |||
throw new BuildException(msg, ncdfe, getLocation()); | |||
throw new BuildException( | |||
getTaskName() + " A class needed by class " + classname | |||
+ " cannot be found: " + ncdfe.getMessage() | |||
+ "\n using the classloader " + al, | |||
ncdfe, getLocation()); | |||
} | |||
} catch (BuildException ex) { | |||
switch (onError) { | |||
@@ -633,7 +629,7 @@ public abstract class Definer extends DefBase { | |||
*/ | |||
private void tooManyDefinitions() { | |||
throw new BuildException( | |||
"Only one of the attributes name, file and resource" | |||
+ " can be set", getLocation()); | |||
"Only one of the attributes name, file and resource can be set", | |||
getLocation()); | |||
} | |||
} |
@@ -19,6 +19,7 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.File; | |||
import java.io.IOException; | |||
import java.util.Arrays; | |||
import java.util.Comparator; | |||
import java.util.Iterator; | |||
@@ -79,33 +80,43 @@ import org.apache.tools.ant.util.SymbolicLinkUtils; | |||
public class Delete extends MatchingTask { | |||
private static final ResourceComparator REVERSE_FILESYSTEM = new Reverse(new FileSystem()); | |||
private static final ResourceSelector EXISTS = new Exists(); | |||
private static FileUtils FILE_UTILS = FileUtils.getFileUtils(); | |||
private static SymbolicLinkUtils SYMLINK_UTILS = | |||
SymbolicLinkUtils.getSymbolicLinkUtils(); | |||
private static class ReverseDirs implements ResourceCollection { | |||
static final Comparator<Comparable<?>> REVERSE = new Comparator<Comparable<?>>() { | |||
public int compare(Comparable<?> foo, Comparable<?> bar) { | |||
return ((Comparable) foo).compareTo(bar) * -1; | |||
} | |||
}; | |||
private Project project; | |||
private File basedir; | |||
private String[] dirs; | |||
ReverseDirs(Project project, File basedir, String[] dirs) { | |||
this.project = project; | |||
this.basedir = basedir; | |||
this.dirs = dirs; | |||
Arrays.sort(this.dirs, REVERSE); | |||
Arrays.sort(this.dirs, Comparator.reverseOrder()); | |||
} | |||
@Override | |||
public Iterator<Resource> iterator() { | |||
return new FileResourceIterator(project, basedir, dirs); | |||
} | |||
public boolean isFilesystemOnly() { return true; } | |||
public int size() { return dirs.length; } | |||
@Override | |||
public boolean isFilesystemOnly() { | |||
return true; | |||
} | |||
@Override | |||
public int size() { | |||
return dirs.length; | |||
} | |||
} | |||
// CheckStyle:VisibilityModifier OFF - bc | |||
protected File file = null; | |||
protected File dir = null; | |||
protected Vector<FileSet> filesets = new Vector<FileSet>(); | |||
protected Vector<FileSet> filesets = new Vector<>(); | |||
protected boolean usedMatchingTask = false; | |||
// by default, remove matching empty dirs | |||
protected boolean includeEmpty = false; | |||
@@ -117,9 +128,6 @@ public class Delete extends MatchingTask { | |||
private boolean deleteOnExit = false; | |||
private boolean removeNotFollowedSymlinks = false; | |||
private Resources rcs = null; | |||
private static FileUtils FILE_UTILS = FileUtils.getFileUtils(); | |||
private static SymbolicLinkUtils SYMLINK_UTILS = | |||
SymbolicLinkUtils.getSymbolicLinkUtils(); | |||
private boolean performGc = Os.isFamily("windows"); | |||
/** | |||
@@ -175,9 +183,9 @@ public class Delete extends MatchingTask { | |||
* | |||
* @param failonerror true or false | |||
*/ | |||
public void setFailOnError(boolean failonerror) { | |||
this.failonerror = failonerror; | |||
} | |||
public void setFailOnError(boolean failonerror) { | |||
this.failonerror = failonerror; | |||
} | |||
/** | |||
* If true, on failure to delete, note the error and set | |||
@@ -185,10 +193,9 @@ public class Delete extends MatchingTask { | |||
* | |||
* @param deleteOnExit true or false | |||
*/ | |||
public void setDeleteOnExit(boolean deleteOnExit) { | |||
this.deleteOnExit = deleteOnExit; | |||
} | |||
public void setDeleteOnExit(boolean deleteOnExit) { | |||
this.deleteOnExit = deleteOnExit; | |||
} | |||
/** | |||
* If true, delete empty directories. | |||
@@ -212,10 +219,10 @@ public class Delete extends MatchingTask { | |||
performGc = b; | |||
} | |||
/** | |||
* Adds a set of files to be deleted. | |||
* @param set the set of files to be deleted | |||
*/ | |||
/** | |||
* Adds a set of files to be deleted. | |||
* @param set the set of files to be deleted | |||
*/ | |||
public void addFileset(FileSet set) { | |||
filesets.addElement(set); | |||
} | |||
@@ -239,6 +246,7 @@ public class Delete extends MatchingTask { | |||
* add a name entry on the include list | |||
* @return a NameEntry object to be configured | |||
*/ | |||
@Override | |||
public PatternSet.NameEntry createInclude() { | |||
usedMatchingTask = true; | |||
return super.createInclude(); | |||
@@ -248,6 +256,7 @@ public class Delete extends MatchingTask { | |||
* add a name entry on the include files list | |||
* @return an NameEntry object to be configured | |||
*/ | |||
@Override | |||
public PatternSet.NameEntry createIncludesFile() { | |||
usedMatchingTask = true; | |||
return super.createIncludesFile(); | |||
@@ -257,6 +266,7 @@ public class Delete extends MatchingTask { | |||
* add a name entry on the exclude list | |||
* @return an NameEntry object to be configured | |||
*/ | |||
@Override | |||
public PatternSet.NameEntry createExclude() { | |||
usedMatchingTask = true; | |||
return super.createExclude(); | |||
@@ -266,6 +276,7 @@ public class Delete extends MatchingTask { | |||
* add a name entry on the include files list | |||
* @return an NameEntry object to be configured | |||
*/ | |||
@Override | |||
public PatternSet.NameEntry createExcludesFile() { | |||
usedMatchingTask = true; | |||
return super.createExcludesFile(); | |||
@@ -275,6 +286,7 @@ public class Delete extends MatchingTask { | |||
* add a set of patterns | |||
* @return PatternSet object to be configured | |||
*/ | |||
@Override | |||
public PatternSet createPatternSet() { | |||
usedMatchingTask = true; | |||
return super.createPatternSet(); | |||
@@ -286,6 +298,7 @@ public class Delete extends MatchingTask { | |||
* | |||
* @param includes the string containing the include patterns | |||
*/ | |||
@Override | |||
public void setIncludes(String includes) { | |||
usedMatchingTask = true; | |||
super.setIncludes(includes); | |||
@@ -297,6 +310,7 @@ public class Delete extends MatchingTask { | |||
* | |||
* @param excludes the string containing the exclude patterns | |||
*/ | |||
@Override | |||
public void setExcludes(String excludes) { | |||
usedMatchingTask = true; | |||
super.setExcludes(excludes); | |||
@@ -309,6 +323,7 @@ public class Delete extends MatchingTask { | |||
* should be used, "false"|"off"|"no" when they | |||
* shouldn't be used. | |||
*/ | |||
@Override | |||
public void setDefaultexcludes(boolean useDefaultExcludes) { | |||
usedMatchingTask = true; | |||
super.setDefaultexcludes(useDefaultExcludes); | |||
@@ -320,6 +335,7 @@ public class Delete extends MatchingTask { | |||
* @param includesfile A string containing the filename to fetch | |||
* the include patterns from. | |||
*/ | |||
@Override | |||
public void setIncludesfile(File includesfile) { | |||
usedMatchingTask = true; | |||
super.setIncludesfile(includesfile); | |||
@@ -331,6 +347,7 @@ public class Delete extends MatchingTask { | |||
* @param excludesfile A string containing the filename to fetch | |||
* the include patterns from. | |||
*/ | |||
@Override | |||
public void setExcludesfile(File excludesfile) { | |||
usedMatchingTask = true; | |||
super.setExcludesfile(excludesfile); | |||
@@ -342,6 +359,7 @@ public class Delete extends MatchingTask { | |||
* @param isCaseSensitive "true"|"on"|"yes" if file system is case | |||
* sensitive, "false"|"off"|"no" when not. | |||
*/ | |||
@Override | |||
public void setCaseSensitive(boolean isCaseSensitive) { | |||
usedMatchingTask = true; | |||
super.setCaseSensitive(isCaseSensitive); | |||
@@ -352,6 +370,7 @@ public class Delete extends MatchingTask { | |||
* | |||
* @param followSymlinks whether or not symbolic links should be followed | |||
*/ | |||
@Override | |||
public void setFollowSymlinks(boolean followSymlinks) { | |||
usedMatchingTask = true; | |||
super.setFollowSymlinks(followSymlinks); | |||
@@ -371,6 +390,7 @@ public class Delete extends MatchingTask { | |||
* add a "Select" selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addSelector(SelectSelector selector) { | |||
usedMatchingTask = true; | |||
super.addSelector(selector); | |||
@@ -380,6 +400,7 @@ public class Delete extends MatchingTask { | |||
* add an "And" selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addAnd(AndSelector selector) { | |||
usedMatchingTask = true; | |||
super.addAnd(selector); | |||
@@ -389,6 +410,7 @@ public class Delete extends MatchingTask { | |||
* add an "Or" selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addOr(OrSelector selector) { | |||
usedMatchingTask = true; | |||
super.addOr(selector); | |||
@@ -398,6 +420,7 @@ public class Delete extends MatchingTask { | |||
* add a "Not" selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addNot(NotSelector selector) { | |||
usedMatchingTask = true; | |||
super.addNot(selector); | |||
@@ -407,6 +430,7 @@ public class Delete extends MatchingTask { | |||
* add a "None" selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addNone(NoneSelector selector) { | |||
usedMatchingTask = true; | |||
super.addNone(selector); | |||
@@ -416,6 +440,7 @@ public class Delete extends MatchingTask { | |||
* add a majority selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addMajority(MajoritySelector selector) { | |||
usedMatchingTask = true; | |||
super.addMajority(selector); | |||
@@ -425,6 +450,7 @@ public class Delete extends MatchingTask { | |||
* add a selector date entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addDate(DateSelector selector) { | |||
usedMatchingTask = true; | |||
super.addDate(selector); | |||
@@ -434,6 +460,7 @@ public class Delete extends MatchingTask { | |||
* add a selector size entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addSize(SizeSelector selector) { | |||
usedMatchingTask = true; | |||
super.addSize(selector); | |||
@@ -443,6 +470,7 @@ public class Delete extends MatchingTask { | |||
* add a selector filename entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addFilename(FilenameSelector selector) { | |||
usedMatchingTask = true; | |||
super.addFilename(selector); | |||
@@ -452,6 +480,7 @@ public class Delete extends MatchingTask { | |||
* add an extended selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addCustom(ExtendSelector selector) { | |||
usedMatchingTask = true; | |||
super.addCustom(selector); | |||
@@ -461,6 +490,7 @@ public class Delete extends MatchingTask { | |||
* add a contains selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addContains(ContainsSelector selector) { | |||
usedMatchingTask = true; | |||
super.addContains(selector); | |||
@@ -470,6 +500,7 @@ public class Delete extends MatchingTask { | |||
* add a present selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addPresent(PresentSelector selector) { | |||
usedMatchingTask = true; | |||
super.addPresent(selector); | |||
@@ -479,6 +510,7 @@ public class Delete extends MatchingTask { | |||
* add a depth selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addDepth(DepthSelector selector) { | |||
usedMatchingTask = true; | |||
super.addDepth(selector); | |||
@@ -488,6 +520,7 @@ public class Delete extends MatchingTask { | |||
* add a depends selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addDepend(DependSelector selector) { | |||
usedMatchingTask = true; | |||
super.addDepend(selector); | |||
@@ -497,6 +530,7 @@ public class Delete extends MatchingTask { | |||
* add a regular expression selector entry on the selector list | |||
* @param selector the selector to be added | |||
*/ | |||
@Override | |||
public void addContainsRegexp(ContainsRegexpSelector selector) { | |||
usedMatchingTask = true; | |||
super.addContainsRegexp(selector); | |||
@@ -507,6 +541,7 @@ public class Delete extends MatchingTask { | |||
* @param selector the selector to add | |||
* @since ant 1.6 | |||
*/ | |||
@Override | |||
public void addModified(ModifiedSelector selector) { | |||
usedMatchingTask = true; | |||
super.addModified(selector); | |||
@@ -517,6 +552,7 @@ public class Delete extends MatchingTask { | |||
* @param selector the selector to be added | |||
* @since Ant 1.6 | |||
*/ | |||
@Override | |||
public void add(FileSelector selector) { | |||
usedMatchingTask = true; | |||
super.add(selector); | |||
@@ -526,21 +562,22 @@ public class Delete extends MatchingTask { | |||
* Delete the file(s). | |||
* @exception BuildException if an error occurs | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
if (usedMatchingTask) { | |||
log("DEPRECATED - Use of the implicit FileSet is deprecated. " | |||
+ "Use a nested fileset element instead.", quiet ? Project.MSG_VERBOSE : verbosity); | |||
log("DEPRECATED - Use of the implicit FileSet is deprecated. Use a nested fileset element instead.", | |||
quiet ? Project.MSG_VERBOSE : verbosity); | |||
} | |||
if (file == null && dir == null && filesets.size() == 0 && rcs == null) { | |||
throw new BuildException("At least one of the file or dir " | |||
+ "attributes, or a nested resource collection, " | |||
+ "must be set."); | |||
if (file == null && dir == null && filesets.isEmpty() && rcs == null) { | |||
throw new BuildException( | |||
"At least one of the file or dir attributes, or a nested resource collection, must be set."); | |||
} | |||
if (quiet && failonerror) { | |||
throw new BuildException("quiet and failonerror cannot both be " | |||
+ "set to true", getLocation()); | |||
throw new BuildException( | |||
"quiet and failonerror cannot both be set to true", | |||
getLocation()); | |||
} | |||
// delete the single file | |||
@@ -548,8 +585,8 @@ public class Delete extends MatchingTask { | |||
if (file.exists()) { | |||
if (file.isDirectory()) { | |||
log("Directory " + file.getAbsolutePath() | |||
+ " cannot be removed using the file attribute. " | |||
+ "Use dir instead.", quiet ? Project.MSG_VERBOSE : verbosity); | |||
+ " cannot be removed using the file attribute. Use dir instead.", | |||
quiet ? Project.MSG_VERBOSE : verbosity); | |||
} else { | |||
log("Deleting: " + file.getAbsolutePath()); | |||
@@ -610,11 +647,11 @@ public class Delete extends MatchingTask { | |||
final int size = filesets.size(); | |||
for (int i = 0; i < size; i++) { | |||
FileSet fs = (FileSet) filesets.get(i); | |||
FileSet fs = filesets.get(i); | |||
if (fs.getProject() == null) { | |||
log("Deleting fileset with no project specified;" | |||
+ " assuming executing project", Project.MSG_VERBOSE); | |||
fs = (FileSet) fs.clone(); | |||
log("Deleting fileset with no project specified; assuming executing project", | |||
Project.MSG_VERBOSE); | |||
fs = fs.clone(); | |||
fs.setProject(getProject()); | |||
} | |||
final File fsDir = fs.getDir(); | |||
@@ -634,12 +671,15 @@ public class Delete extends MatchingTask { | |||
// iterating, capture the results now and store them | |||
final String[] files = ds.getIncludedFiles(); | |||
resourcesToDelete.add(new ResourceCollection() { | |||
@Override | |||
public boolean isFilesystemOnly() { | |||
return true; | |||
} | |||
@Override | |||
public int size() { | |||
return files.length; | |||
} | |||
@Override | |||
public Iterator<Resource> iterator() { | |||
return new FileResourceIterator(getProject(), | |||
fsDir, files); | |||
@@ -656,7 +696,7 @@ public class Delete extends MatchingTask { | |||
if (n.length > 0) { | |||
String[] links = new String[n.length]; | |||
System.arraycopy(n, 0, links, 0, n.length); | |||
Arrays.sort(links, ReverseDirs.REVERSE); | |||
Arrays.sort(links, Comparator.reverseOrder()); | |||
for (int l = 0; l < links.length; l++) { | |||
try { | |||
SYMLINK_UTILS | |||
@@ -826,7 +866,7 @@ public class Delete extends MatchingTask { | |||
private boolean isDanglingSymlink(File f) { | |||
try { | |||
return SYMLINK_UTILS.isDanglingSymbolicLink(f); | |||
} catch (java.io.IOException e) { | |||
} catch (IOException e) { | |||
log("Error while trying to detect " + f.getAbsolutePath() | |||
+ " as broken symbolic link. " + e.getMessage(), | |||
quiet ? Project.MSG_VERBOSE : verbosity); | |||
@@ -102,12 +102,15 @@ public class DependSet extends MatchingTask { | |||
private HideMissingBasedir(FileSet fs) { | |||
this.fs = fs; | |||
} | |||
@Override | |||
public Iterator<Resource> iterator() { | |||
return basedirExists() ? fs.iterator() : Resources.EMPTY_ITERATOR; | |||
} | |||
@Override | |||
public int size() { | |||
return basedirExists() ? fs.size() : 0; | |||
} | |||
@Override | |||
public boolean isFilesystemOnly() { | |||
return true; | |||
} | |||
@@ -190,6 +193,7 @@ public class DependSet extends MatchingTask { | |||
* Execute the task. | |||
* @throws BuildException if errors occur. | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
if (sources == null) { | |||
throw new BuildException( | |||
@@ -200,12 +204,11 @@ public class DependSet extends MatchingTask { | |||
"At least one set of target files must be specified"); | |||
} | |||
//no sources = nothing to compare; no targets = nothing to delete: | |||
if (sources.size() > 0 && targets.size() > 0 && !uptodate(sources, targets)) { | |||
if (!(sources.isEmpty() || targets.isEmpty() || uptodate(sources, targets))) { | |||
log("Deleting all target files.", Project.MSG_VERBOSE); | |||
if (verbose) { | |||
String[] t = targets.list(); | |||
for (int i = 0; i < t.length; i++) { | |||
log("Deleting " + t[i]); | |||
for (String t : targets.list()) { | |||
log("Deleting " + t); | |||
} | |||
} | |||
Delete delete = new Delete(); | |||
@@ -244,7 +247,7 @@ public class DependSet extends MatchingTask { | |||
logMissing(missingSources, "source"); | |||
return false; | |||
} | |||
Resource newestSource = (Resource) getNewest(sources); | |||
Resource newestSource = getNewest(sources); | |||
logWithModificationTime(newestSource, "newest source"); | |||
return oldestTarget.getLastModified() >= newestSource.getLastModified(); | |||
} | |||
@@ -262,7 +265,6 @@ public class DependSet extends MatchingTask { | |||
Iterator<Resource> i = rc.iterator(); | |||
if (!i.hasNext()) { | |||
return null; | |||
} | |||
Resource xest = i.next(); | |||
while (i.hasNext()) { | |||
@@ -68,15 +68,14 @@ public class Dirname extends Task { | |||
* Execute this task. | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
if (property == null) { | |||
throw new BuildException("property attribute required", getLocation()); | |||
} | |||
if (file == null) { | |||
throw new BuildException("file attribute required", getLocation()); | |||
} else { | |||
String value = file.getParent(); | |||
getProject().setNewProperty(property, value); | |||
} | |||
getProject().setNewProperty(property, file.getParent()); | |||
} | |||
} |
@@ -55,6 +55,7 @@ public class Ear extends Jar { | |||
* @deprecated since 1.5.x. | |||
* Use setDestFile(destfile) instead. | |||
*/ | |||
@Deprecated | |||
public void setEarfile(File earFile) { | |||
setDestFile(earFile); | |||
} | |||
@@ -66,9 +67,9 @@ public class Ear extends Jar { | |||
public void setAppxml(File descr) { | |||
deploymentDescriptor = descr; | |||
if (!deploymentDescriptor.exists()) { | |||
throw new BuildException("Deployment descriptor: " | |||
+ deploymentDescriptor | |||
+ " does not exist."); | |||
throw new BuildException( | |||
"Deployment descriptor: %s does not exist.", | |||
deploymentDescriptor); | |||
} | |||
// Create a ZipFileSet for this file, and pass it up. | |||
@@ -78,7 +79,6 @@ public class Ear extends Jar { | |||
super.addFileset(fs); | |||
} | |||
/** | |||
* Adds zipfileset. | |||
* | |||
@@ -91,13 +91,13 @@ public class Ear extends Jar { | |||
super.addFileset(fs); | |||
} | |||
/** | |||
* Initialize the output stream. | |||
* @param zOut the zip output stream. | |||
* @throws IOException on I/O errors | |||
* @throws BuildException on other errors | |||
*/ | |||
@Override | |||
protected void initZipOutputStream(ZipOutputStream zOut) | |||
throws IOException, BuildException { | |||
// If no webxml file is specified, it's an error. | |||
@@ -116,6 +116,7 @@ public class Ear extends Jar { | |||
* @param mode the Unix permissions to set. | |||
* @throws IOException on error | |||
*/ | |||
@Override | |||
protected void zipFile(File file, ZipOutputStream zOut, String vPath, | |||
int mode) | |||
throws IOException { | |||
@@ -147,6 +148,7 @@ public class Ear extends Jar { | |||
* Make sure we don't think we already have a application.xml next | |||
* time this task gets executed. | |||
*/ | |||
@Override | |||
protected void cleanUp() { | |||
descriptorAdded = false; | |||
super.cleanUp(); | |||
@@ -113,24 +113,26 @@ public class EchoXML extends XMLFragment { | |||
public NamespacePolicy(String s) { | |||
setValue(s); | |||
} | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public String[] getValues() { | |||
return new String[] {IGNORE, ELEMENTS, ALL}; | |||
return new String[] { IGNORE, ELEMENTS, ALL }; | |||
} | |||
public DOMElementWriter.XmlNamespacePolicy getPolicy() { | |||
String s = getValue(); | |||
if (IGNORE.equalsIgnoreCase(s)) { | |||
return DOMElementWriter.XmlNamespacePolicy.IGNORE; | |||
} else if (ELEMENTS.equalsIgnoreCase(s)) { | |||
} | |||
if (ELEMENTS.equalsIgnoreCase(s)) { | |||
return | |||
DOMElementWriter.XmlNamespacePolicy.ONLY_QUALIFY_ELEMENTS; | |||
} else if (ALL.equalsIgnoreCase(s)) { | |||
} | |||
if (ALL.equalsIgnoreCase(s)) { | |||
return DOMElementWriter.XmlNamespacePolicy.QUALIFY_ALL; | |||
} else { | |||
throw new BuildException("Invalid namespace policy: " + s); | |||
} | |||
throw new BuildException("Invalid namespace policy: " + s); | |||
} | |||
} | |||
} |
@@ -44,6 +44,7 @@ import org.apache.tools.ant.Task; | |||
* delegate to {@link org.apache.tools.ant.taskdefs.Execute Execute} | |||
* instead. | |||
*/ | |||
@Deprecated | |||
public class Exec extends Task { | |||
private String os; | |||
private String out; | |||
@@ -70,6 +71,7 @@ public class Exec extends Task { | |||
* Execute the task. | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
run(command); | |||
} | |||
@@ -160,9 +162,8 @@ public class Exec extends Task { | |||
if (err != 0) { | |||
if (failOnError) { | |||
throw new BuildException("Exec returned: " + err, getLocation()); | |||
} else { | |||
log("Result: " + err, Project.MSG_ERR); | |||
} | |||
log("Result: " + err, Project.MSG_ERR); | |||
} | |||
} catch (IOException ioe) { | |||
throw new BuildException("Error exec: " + command, ioe, getLocation()); | |||
@@ -262,6 +263,7 @@ public class Exec extends Task { | |||
} | |||
} | |||
@Override | |||
public void run() { | |||
try { | |||
try { | |||
@@ -125,7 +125,7 @@ public class ExecTask extends Task { | |||
*/ | |||
public void setTimeout(Integer value) { | |||
setTimeout( | |||
(Long) ((value == null) ? null : new Long(value.intValue()))); | |||
(value == null) ? null : Long.valueOf(value.intValue())); | |||
} | |||
/** | |||
@@ -167,8 +167,7 @@ public class ExecTask extends Task { | |||
* @ant.attribute ignore="true" | |||
*/ | |||
public void setCommand(Commandline cmdl) { | |||
log("The command attribute is deprecated.\n" | |||
+ "Please use the executable attribute and nested arg elements.", | |||
log("The command attribute is deprecated.\nPlease use the executable attribute and nested arg elements.", | |||
Project.MSG_WARN); | |||
this.cmdl = cmdl; | |||
} | |||
@@ -191,8 +190,8 @@ public class ExecTask extends Task { | |||
*/ | |||
public void setInput(File input) { | |||
if (inputString != null) { | |||
throw new BuildException("The \"input\" and \"inputstring\" " | |||
+ "attributes cannot both be specified"); | |||
throw new BuildException( | |||
"The \"input\" and \"inputstring\" attributes cannot both be specified"); | |||
} | |||
this.input = input; | |||
incompatibleWithSpawn = true; | |||
@@ -205,8 +204,8 @@ public class ExecTask extends Task { | |||
*/ | |||
public void setInputString(String inputString) { | |||
if (input != null) { | |||
throw new BuildException("The \"input\" and \"inputstring\" " | |||
+ "attributes cannot both be specified"); | |||
throw new BuildException( | |||
"The \"input\" and \"inputstring\" attributes cannot both be specified"); | |||
} | |||
this.inputString = inputString; | |||
incompatibleWithSpawn = true; | |||
@@ -484,6 +483,7 @@ public class ExecTask extends Task { | |||
* <li>this list is not exhaustive or limitative</li> | |||
* </ul> | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
// Quick fail if this is not a valid OS for the command | |||
if (!isValidOs()) { | |||
@@ -633,9 +633,8 @@ public class ExecTask extends Task { | |||
String msg = "Timeout: killed the sub-process"; | |||
if (failOnError) { | |||
throw new BuildException(msg); | |||
} else { | |||
log(msg, Project.MSG_WARN); | |||
} | |||
log(msg, Project.MSG_WARN); | |||
} | |||
maybeSetResultPropertyValue(returnCode); | |||
redirector.complete(); | |||
@@ -643,9 +642,8 @@ public class ExecTask extends Task { | |||
if (failOnError) { | |||
throw new BuildException(getTaskType() + " returned: " | |||
+ returnCode, getLocation()); | |||
} else { | |||
log("Result: " + returnCode, Project.MSG_ERR); | |||
} | |||
log("Result: " + returnCode, Project.MSG_ERR); | |||
} | |||
} else { | |||
exe.spawn(); | |||
@@ -672,9 +670,8 @@ public class ExecTask extends Task { | |||
if (failIfExecFails) { | |||
throw new BuildException("Execute failed: " + e.toString(), e, | |||
getLocation()); | |||
} else { | |||
log("Execute failed: " + e.toString(), Project.MSG_ERR); | |||
} | |||
log("Execute failed: " + e.toString(), Project.MSG_ERR); | |||
} finally { | |||
// close the output file if required | |||
logFlush(); | |||
@@ -24,7 +24,7 @@ import java.io.File; | |||
import java.io.IOException; | |||
import java.io.OutputStream; | |||
import java.io.StringReader; | |||
import java.util.ArrayList; | |||
import java.io.UnsupportedEncodingException; | |||
import java.util.HashMap; | |||
import java.util.LinkedHashMap; | |||
import java.util.Map; | |||
@@ -54,18 +54,6 @@ public class Execute { | |||
*/ | |||
public static final int INVALID = Integer.MAX_VALUE; | |||
private String[] cmdl = null; | |||
private String[] env = null; | |||
private int exitValue = INVALID; | |||
private ExecuteStreamHandler streamHandler; | |||
private final ExecuteWatchdog watchdog; | |||
private File workingDirectory = null; | |||
private Project project = null; | |||
private boolean newEnvironment = false; | |||
/** Controls whether the VM is used to launch commands, where possible. */ | |||
private boolean useVMLauncher = true; | |||
private static String antWorkingDirectory = System.getProperty("user.dir"); | |||
private static Map<String, String> procEnvironment = null; | |||
@@ -81,6 +69,18 @@ public class Execute { | |||
} | |||
} | |||
private String[] cmdl = null; | |||
private String[] env = null; | |||
private int exitValue = INVALID; | |||
private ExecuteStreamHandler streamHandler; | |||
private final ExecuteWatchdog watchdog; | |||
private File workingDirectory = null; | |||
private Project project = null; | |||
private boolean newEnvironment = false; | |||
/** Controls whether the VM is used to launch commands, where possible. */ | |||
private boolean useVMLauncher = true; | |||
/** | |||
* Set whether or not you want the process to be spawned. | |||
* Default is not spawned. | |||
@@ -104,7 +104,7 @@ public class Execute { | |||
* @return a map containing the environment variables. | |||
* @since Ant 1.8.2 | |||
*/ | |||
public static synchronized Map<String,String> getEnvironmentVariables() { | |||
public static synchronized Map<String, String> getEnvironmentVariables() { | |||
if (procEnvironment != null) { | |||
return procEnvironment; | |||
} | |||
@@ -117,7 +117,7 @@ public class Execute { | |||
} | |||
} | |||
procEnvironment = new LinkedHashMap<String, String>(); | |||
procEnvironment = new LinkedHashMap<>(); | |||
try { | |||
ByteArrayOutputStream out = new ByteArrayOutputStream(); | |||
Execute exe = new Execute(new PumpStreamHandler(out)); | |||
@@ -149,7 +149,7 @@ public class Execute { | |||
} else { | |||
// New env var...append the previous one if we have it. | |||
if (var != null) { | |||
int eq = var.indexOf("="); | |||
int eq = var.indexOf('='); | |||
procEnvironment.put(var.substring(0, eq), | |||
var.substring(eq + 1)); | |||
} | |||
@@ -158,10 +158,10 @@ public class Execute { | |||
} | |||
// Since we "look ahead" before adding, there's one last env var. | |||
if (var != null) { | |||
int eq = var.indexOf("="); | |||
int eq = var.indexOf('='); | |||
procEnvironment.put(var.substring(0, eq), var.substring(eq + 1)); | |||
} | |||
} catch (java.io.IOException exc) { | |||
} catch (IOException exc) { | |||
exc.printStackTrace(); //NOSONAR | |||
// Just try to see how much we got | |||
} | |||
@@ -177,7 +177,7 @@ public class Execute { | |||
*/ | |||
@Deprecated | |||
public static synchronized Vector<String> getProcEnvironment() { | |||
Vector<String> v = new Vector<String>(); | |||
Vector<String> v = new Vector<>(); | |||
for (Entry<String, String> entry : getEnvironmentVariables().entrySet()) { | |||
v.add(entry.getKey() + "=" + entry.getValue()); | |||
} | |||
@@ -194,17 +194,18 @@ public class Execute { | |||
private static String[] getProcEnvCommand() { | |||
if (Os.isFamily("os/2")) { | |||
// OS/2 - use same mechanism as Windows 2000 | |||
return new String[] {"cmd", "/c", "set"}; | |||
} else if (Os.isFamily("windows")) { | |||
return new String[] { "cmd", "/c", "set" }; | |||
} | |||
if (Os.isFamily("windows")) { | |||
// Determine if we're running under XP/2000/NT or 98/95 | |||
if (Os.isFamily("win9x")) { | |||
// Windows 98/95 | |||
return new String[] {"command.com", "/c", "set"}; | |||
} else { | |||
// Windows XP/2000/NT/2003 | |||
return new String[] {"cmd", "/c", "set"}; | |||
return new String[] { "command.com", "/c", "set" }; | |||
} | |||
} else if (Os.isFamily("z/os") || Os.isFamily("unix")) { | |||
// Windows XP/2000/NT/2003 | |||
return new String[] { "cmd", "/c", "set" }; | |||
} | |||
if (Os.isFamily("z/os") || Os.isFamily("unix")) { | |||
// On most systems one could use: /bin/sh -c env | |||
// Some systems have /bin/env, others /usr/bin/env, just try | |||
@@ -218,16 +219,17 @@ public class Execute { | |||
cmd[0] = "env"; | |||
} | |||
return cmd; | |||
} else if (Os.isFamily("netware") || Os.isFamily("os/400")) { | |||
} | |||
if (Os.isFamily("netware") || Os.isFamily("os/400")) { | |||
// rely on PATH | |||
return new String[] {"env"}; | |||
} else if (Os.isFamily("openvms")) { | |||
return new String[] {"show", "logical"}; | |||
} else { | |||
// MAC OS 9 and previous | |||
// TODO: I have no idea how to get it, someone must fix it | |||
return null; | |||
return new String[] { "env" }; | |||
} | |||
if (Os.isFamily("openvms")) { | |||
return new String[] { "show", "logical" }; | |||
} | |||
// MAC OS 9 and previous | |||
// TODO: I have no idea how to get it, someone must fix it | |||
return null; | |||
} | |||
/** | |||
@@ -244,13 +246,13 @@ public class Execute { | |||
if (Os.isFamily("z/os")) { | |||
try { | |||
return bos.toString("Cp1047"); | |||
} catch (java.io.UnsupportedEncodingException e) { | |||
} catch (UnsupportedEncodingException e) { | |||
// noop default encoding used | |||
} | |||
} else if (Os.isFamily("os/400")) { | |||
try { | |||
return bos.toString("Cp500"); | |||
} catch (java.io.UnsupportedEncodingException e) { | |||
} catch (UnsupportedEncodingException e) { | |||
// noop default encoding used | |||
} | |||
} | |||
@@ -417,7 +419,7 @@ public class Execute { | |||
String[] env, File dir, boolean useVM) | |||
throws IOException { | |||
if (dir != null && !dir.exists()) { | |||
throw new BuildException(dir + " doesn't exist."); | |||
throw new BuildException("%s doesn't exist.", dir); | |||
} | |||
CommandLauncher vmLauncher = CommandLauncher.getVMLauncher(project); | |||
@@ -435,7 +437,7 @@ public class Execute { | |||
*/ | |||
public int execute() throws IOException { | |||
if (workingDirectory != null && !workingDirectory.exists()) { | |||
throw new BuildException(workingDirectory + " doesn't exist."); | |||
throw new BuildException("%s doesn't exist.", workingDirectory); | |||
} | |||
final Process process = launch(project, getCommandline(), | |||
getEnvironment(), workingDirectory, | |||
@@ -492,7 +494,7 @@ public class Execute { | |||
*/ | |||
public void spawn() throws IOException { | |||
if (workingDirectory != null && !workingDirectory.exists()) { | |||
throw new BuildException(workingDirectory + " doesn't exist."); | |||
throw new BuildException("%s doesn't exist.", workingDirectory); | |||
} | |||
final Process process = launch(project, getCommandline(), | |||
getEnvironment(), workingDirectory, | |||
@@ -611,7 +613,7 @@ public class Execute { | |||
return env; | |||
} | |||
Map<String, String> osEnv = | |||
new LinkedHashMap<String, String>(getEnvironmentVariables()); | |||
new LinkedHashMap<>(getEnvironmentVariables()); | |||
for (int i = 0; i < env.length; i++) { | |||
String keyValue = env[i]; | |||
String key = keyValue.substring(0, keyValue.indexOf('=')); | |||
@@ -624,7 +626,7 @@ public class Execute { | |||
for (String osEnvItem : osEnv.keySet()) { | |||
// Nb: using default locale as key is a env name | |||
if (osEnvItem.toLowerCase().equals(key.toLowerCase())) { | |||
if (osEnvItem.equalsIgnoreCase(key)) { | |||
// Use the original casiness of the key | |||
key = osEnvItem; | |||
break; | |||
@@ -636,11 +638,8 @@ public class Execute { | |||
osEnv.put(key, keyValue.substring(key.length() + 1)); | |||
} | |||
ArrayList<String> l = new ArrayList<String>(); | |||
for (Entry<String, String> entry : osEnv.entrySet()) { | |||
l.add(entry.getKey() + "=" + entry.getValue()); | |||
} | |||
return l.toArray(new String[osEnv.size()]); | |||
return osEnv.entrySet().stream() | |||
.map(e -> e.getKey() + "=" + e.getValue()).toArray(String[]::new); | |||
} | |||
/** | |||
@@ -651,7 +650,7 @@ public class Execute { | |||
* @param cmdline The command to execute. | |||
* @throws BuildException if the command does not exit successfully. | |||
*/ | |||
public static void runCommand(Task task, String[] cmdline) | |||
public static void runCommand(Task task, String... cmdline) | |||
throws BuildException { | |||
try { | |||
task.log(Commandline.describeCommand(cmdline), | |||
@@ -665,7 +664,7 @@ public class Execute { | |||
throw new BuildException(cmdline[0] | |||
+ " failed with return code " + retval, task.getLocation()); | |||
} | |||
} catch (java.io.IOException exc) { | |||
} catch (IOException exc) { | |||
throw new BuildException("Could not launch " + cmdline[0] + ": " | |||
+ exc, task.getLocation()); | |||
} | |||
@@ -695,9 +694,9 @@ public class Execute { | |||
*/ | |||
private static Map<String, String> getVMSLogicals(BufferedReader in) | |||
throws IOException { | |||
HashMap<String, String> logicals = new HashMap<String, String>(); | |||
Map<String, String> logicals = new HashMap<>(); | |||
String logName = null, logValue = null, newLogName; | |||
String line = null; | |||
String line; | |||
// CheckStyle:MagicNumber OFF | |||
while ((line = in.readLine()) != null) { | |||
// parse the VMS logicals into required format ("VAR=VAL[,VAL2]") | |||
@@ -97,6 +97,7 @@ public class ExecuteJava implements Runnable, TimeoutObserver { | |||
* @deprecated since 1.4.x. | |||
* manage output at the task level. | |||
*/ | |||
@Deprecated | |||
public void setOutput(PrintStream out) { | |||
} | |||
@@ -122,7 +123,7 @@ public class ExecuteJava implements Runnable, TimeoutObserver { | |||
if (sysProperties != null) { | |||
sysProperties.setSystem(); | |||
} | |||
Class<?> target = null; | |||
Class<?> target; | |||
try { | |||
if (classpath == null) { | |||
target = Class.forName(classname); | |||
@@ -137,18 +138,18 @@ public class ExecuteJava implements Runnable, TimeoutObserver { | |||
target = Class.forName(classname, true, loader); | |||
} | |||
} catch (ClassNotFoundException e) { | |||
throw new BuildException("Could not find " + classname + "." | |||
+ " Make sure you have it in your" | |||
+ " classpath"); | |||
throw new BuildException( | |||
"Could not find %s. Make sure you have it in your classpath", | |||
classname); | |||
} | |||
main = target.getMethod("main", new Class[] {String[].class}); | |||
if (main == null) { | |||
throw new BuildException("Could not find main() method in " | |||
+ classname); | |||
throw new BuildException("Could not find main() method in %s", | |||
classname); | |||
} | |||
if ((main.getModifiers() & Modifier.STATIC) == 0) { | |||
throw new BuildException("main() method in " + classname | |||
+ " is not declared static"); | |||
throw new BuildException( | |||
"main() method in %s is not declared static", classname); | |||
} | |||
if (timeout == null) { | |||
run(); //NOSONAR | |||
@@ -212,6 +213,7 @@ public class ExecuteJava implements Runnable, TimeoutObserver { | |||
* Run this ExecuteJava in a Thread. | |||
* @since Ant 1.5 | |||
*/ | |||
@Override | |||
public void run() { | |||
final Object[] argument = {javaCommand.getArguments()}; | |||
try { | |||
@@ -242,6 +244,7 @@ public class ExecuteJava implements Runnable, TimeoutObserver { | |||
* @param w the responsible Watchdog. | |||
* @since Ant 1.5 | |||
*/ | |||
@Override | |||
public synchronized void timeoutOccured(Watchdog w) { | |||
if (thread != null) { | |||
timedOut = true; | |||
@@ -318,7 +321,7 @@ public class ExecuteJava implements Runnable, TimeoutObserver { | |||
exe.setVMLauncher(true); | |||
File vmsJavaOptionFile = null; | |||
try { | |||
String [] args = new String[command.length - 1]; | |||
String[] args = new String[command.length - 1]; | |||
System.arraycopy(command, 1, args, 0, command.length - 1); | |||
vmsJavaOptionFile = JavaEnvUtils.createVmsJavaOptionFile(args); | |||
//we mark the file to be deleted on exit. | |||
@@ -326,7 +329,7 @@ public class ExecuteJava implements Runnable, TimeoutObserver { | |||
//after execution finished, which is much better for long-lived runtimes | |||
//though spawning complicates things... | |||
vmsJavaOptionFile.deleteOnExit(); | |||
String [] vmsCmd = {command[0], "-V", vmsJavaOptionFile.getPath()}; | |||
String[] vmsCmd = { command[0], "-V", vmsJavaOptionFile.getPath() }; | |||
exe.setCommandline(vmsCmd); | |||
} catch (IOException e) { | |||
throw new BuildException("Failed to create a temporary file for \"-V\" switch"); | |||
@@ -20,7 +20,10 @@ package org.apache.tools.ant.taskdefs; | |||
import java.io.File; | |||
import java.io.IOException; | |||
import java.util.ArrayList; | |||
import java.util.HashSet; | |||
import java.util.List; | |||
import java.util.Set; | |||
import java.util.Vector; | |||
import org.apache.tools.ant.BuildException; | |||
@@ -60,8 +63,9 @@ public class ExecuteOn extends ExecTask { | |||
// switching type to "dir" when we encounter a DirSet that would | |||
// be more difficult to achieve otherwise. | |||
protected Vector<AbstractFileSet> filesets = new Vector<AbstractFileSet>(); // contains AbstractFileSet | |||
// (both DirSet and FileSet) | |||
// (both DirSet and FileSet) | |||
protected Vector<AbstractFileSet> filesets = new Vector<>(); | |||
private Union resources = null; | |||
private boolean relative = false; | |||
private boolean parallel = false; | |||
@@ -296,6 +300,7 @@ public class ExecuteOn extends ExecTask { | |||
/** | |||
* Check the configuration of this ExecuteOn instance. | |||
*/ | |||
@Override | |||
protected void checkConfiguration() { | |||
// * @TODO using taskName here is brittle, as a user could override it. | |||
// * this should probably be modified to use the classname instead. | |||
@@ -303,7 +308,7 @@ public class ExecuteOn extends ExecTask { | |||
log("!! execon is deprecated. Use apply instead. !!"); | |||
} | |||
super.checkConfiguration(); | |||
if (filesets.size() == 0 && resources == null) { | |||
if (filesets.isEmpty() && resources == null) { | |||
throw new BuildException("no resources specified", | |||
getLocation()); | |||
} | |||
@@ -326,6 +331,7 @@ public class ExecuteOn extends ExecTask { | |||
* @return <code>ExecuteStreamHandler</code>. | |||
* @throws BuildException on error. | |||
*/ | |||
@Override | |||
protected ExecuteStreamHandler createHandler() throws BuildException { | |||
//if we have a RedirectorElement, return a decoy | |||
return (redirectorElement == null) | |||
@@ -335,6 +341,7 @@ public class ExecuteOn extends ExecTask { | |||
/** | |||
* Set up the I/O Redirector. | |||
*/ | |||
@Override | |||
protected void setupRedirector() { | |||
super.setupRedirector(); | |||
redirector.setAppendProperties(true); | |||
@@ -345,23 +352,21 @@ public class ExecuteOn extends ExecTask { | |||
* @param exe the Execute instance representing the external process. | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
protected void runExec(Execute exe) throws BuildException { | |||
int totalFiles = 0; | |||
int totalDirs = 0; | |||
boolean haveExecuted = false; | |||
try { | |||
Vector<String> fileNames = new Vector<String>(); | |||
Vector<File> baseDirs = new Vector<File>(); | |||
final int size = filesets.size(); | |||
for (int i = 0; i < size; i++) { | |||
Vector<String> fileNames = new Vector<>(); | |||
Vector<File> baseDirs = new Vector<>(); | |||
for (AbstractFileSet fs : filesets) { | |||
String currentType = type; | |||
AbstractFileSet fs = filesets.elementAt(i); | |||
if (fs instanceof DirSet) { | |||
if (!FileDirBoth.DIR.equals(type)) { | |||
log("Found a nested dirset but type is " + type + ". " | |||
+ "Temporarily switching to type=\"dir\" on the" | |||
+ " assumption that you really did mean" | |||
+ " <dirset> not <fileset>.", Project.MSG_DEBUG); | |||
+ "Temporarily switching to type=\"dir\" on the assumption that you really did mean <dirset> not <fileset>.", | |||
Project.MSG_DEBUG); | |||
currentType = FileDirBoth.DIR; | |||
} | |||
} | |||
@@ -373,34 +378,32 @@ public class ExecuteOn extends ExecTask { | |||
String[] s = getFiles(base, ds); | |||
for (int j = 0; j < s.length; j++) { | |||
totalFiles++; | |||
fileNames.addElement(s[j]); | |||
baseDirs.addElement(base); | |||
fileNames.add(s[j]); | |||
baseDirs.add(base); | |||
} | |||
} | |||
if (!FileDirBoth.FILE.equals(currentType)) { | |||
String[] s = getDirs(base, ds); | |||
for (int j = 0; j < s.length; j++) { | |||
totalDirs++; | |||
fileNames.addElement(s[j]); | |||
baseDirs.addElement(base); | |||
fileNames.add(s[j]); | |||
baseDirs.add(base); | |||
} | |||
} | |||
if (fileNames.size() == 0 && skipEmpty) { | |||
if (fileNames.isEmpty() && skipEmpty) { | |||
logSkippingFileset(currentType, ds, base); | |||
continue; | |||
} | |||
if (!parallel) { | |||
String[] s = new String[fileNames.size()]; | |||
fileNames.copyInto(s); | |||
for (int j = 0; j < s.length; j++) { | |||
String[] command = getCommandline(s[j], base); | |||
for (String srcFile : fileNames) { | |||
String[] command = getCommandline(srcFile, base); | |||
log(Commandline.describeCommand(command), | |||
Project.MSG_VERBOSE); | |||
exe.setCommandline(command); | |||
if (redirectorElement != null) { | |||
setupRedirector(); | |||
redirectorElement.configure(redirector, s[j]); | |||
redirectorElement.configure(redirector, srcFile); | |||
} | |||
if (redirectorElement != null || haveExecuted) { | |||
// need to reset the stream handler to restart | |||
@@ -411,8 +414,8 @@ public class ExecuteOn extends ExecTask { | |||
runExecute(exe); | |||
haveExecuted = true; | |||
} | |||
fileNames.removeAllElements(); | |||
baseDirs.removeAllElements(); | |||
fileNames.clear(); | |||
baseDirs.clear(); | |||
} | |||
} | |||
@@ -469,12 +472,12 @@ public class ExecuteOn extends ExecTask { | |||
} | |||
runExecute(exe); | |||
haveExecuted = true; | |||
fileNames.removeAllElements(); | |||
baseDirs.removeAllElements(); | |||
fileNames.clear(); | |||
baseDirs.clear(); | |||
} | |||
} | |||
} | |||
if (parallel && (fileNames.size() > 0 || !skipEmpty)) { | |||
if (parallel && (!fileNames.isEmpty() || !skipEmpty)) { | |||
runParallel(exe, fileNames, baseDirs); | |||
haveExecuted = true; | |||
} | |||
@@ -524,31 +527,31 @@ public class ExecuteOn extends ExecTask { | |||
*/ | |||
protected String[] getCommandline(String[] srcFiles, File[] baseDirs) { | |||
final char fileSeparator = File.separatorChar; | |||
Vector<String> targets = new Vector<String>(); | |||
List<String> targets = new ArrayList<>(); | |||
if (targetFilePos != null) { | |||
HashSet<String> addedFiles = new HashSet<String>(); | |||
Set<String> addedFiles = new HashSet<>(); | |||
for (int i = 0; i < srcFiles.length; i++) { | |||
String[] subTargets = mapper.mapFileName(srcFiles[i]); | |||
if (subTargets != null) { | |||
for (int j = 0; j < subTargets.length; j++) { | |||
String name = null; | |||
if (!relative) { | |||
name = new File(destDir, subTargets[j]).getAbsolutePath(); | |||
for (String subTarget : subTargets) { | |||
String name; | |||
if (relative) { | |||
name = subTarget; | |||
} else { | |||
name = subTargets[j]; | |||
name = new File(destDir, subTarget).getAbsolutePath(); | |||
} | |||
if (forwardSlash && fileSeparator != '/') { | |||
name = name.replace(fileSeparator, '/'); | |||
} | |||
if (!addedFiles.contains(name)) { | |||
targets.addElement(name); | |||
targets.add(name); | |||
addedFiles.add(name); | |||
} | |||
} | |||
} | |||
} | |||
} | |||
String[] targetFiles = (String[]) targets.toArray(new String[targets.size()]); | |||
String[] targetFiles = targets.toArray(new String[targets.size()]); | |||
if (!addSourceFile) { | |||
srcFiles = new String[0]; | |||
@@ -642,7 +645,7 @@ public class ExecuteOn extends ExecTask { | |||
* @return the command line in the form of a String[]. | |||
*/ | |||
protected String[] getCommandline(String srcFile, File baseDir) { | |||
return getCommandline(new String[] {srcFile}, new File[] {baseDir}); | |||
return getCommandline(new String[] { srcFile }, new File[] { baseDir }); | |||
} | |||
/** | |||
@@ -697,10 +700,8 @@ public class ExecuteOn extends ExecTask { | |||
protected void runParallel(Execute exe, Vector<String> fileNames, | |||
Vector<File> baseDirs) | |||
throws IOException, BuildException { | |||
String[] s = new String[fileNames.size()]; | |||
fileNames.copyInto(s); | |||
File[] b = new File[baseDirs.size()]; | |||
baseDirs.copyInto(b); | |||
String[] s = fileNames.toArray(new String[fileNames.size()]); | |||
File[] b = baseDirs.toArray(new File[baseDirs.size()]); | |||
if (maxParallel <= 0 | |||
|| s.length == 0 /* this is skipEmpty == false */) { | |||
@@ -752,7 +753,7 @@ public class ExecuteOn extends ExecTask { | |||
String[] arguments, | |||
int insertPosition, | |||
String prefix, String suffix) { | |||
if (prefix.length() == 0 && suffix.length() == 0) { | |||
if (prefix.isEmpty() && suffix.isEmpty()) { | |||
System.arraycopy(targetFiles, 0, arguments, insertPosition, | |||
targetFiles.length); | |||
} else { | |||
@@ -772,12 +773,14 @@ public class ExecuteOn extends ExecTask { | |||
public static final String FILE = "file"; | |||
/** Dir value */ | |||
public static final String DIR = "dir"; | |||
/** | |||
* {@inheritDoc} | |||
* @see EnumeratedAttribute#getValues | |||
*/ | |||
/** {@inheritDoc}. */ | |||
public String[] getValues() { | |||
return new String[] {FILE, DIR, "both"}; | |||
@Override | |||
public String[] getValues() { | |||
return new String[] { FILE, DIR, "both" }; | |||
} | |||
} | |||
@@ -74,6 +74,7 @@ public class ExecuteWatchdog implements TimeoutObserver { | |||
* Use constructor with a long type instead. | |||
* (1.4.x compatibility) | |||
*/ | |||
@Deprecated | |||
public ExecuteWatchdog(int timeout) { | |||
this((long) timeout); | |||
} | |||
@@ -112,6 +113,7 @@ public class ExecuteWatchdog implements TimeoutObserver { | |||
* This can be called in the watchdog thread | |||
* @param w the watchdog | |||
*/ | |||
@Override | |||
public synchronized void timeoutOccured(Watchdog w) { | |||
try { | |||
try { | |||
@@ -174,4 +176,3 @@ public class ExecuteWatchdog implements TimeoutObserver { | |||
return killedProcess; | |||
} | |||
} | |||
@@ -50,12 +50,13 @@ import org.apache.tools.ant.taskdefs.condition.ConditionBase; | |||
public class Exit extends Task { | |||
private static class NestedCondition extends ConditionBase implements Condition { | |||
@Override | |||
public boolean eval() { | |||
if (countConditions() != 1) { | |||
throw new BuildException( | |||
"A single nested condition is required."); | |||
} | |||
return ((Condition) (getConditions().nextElement())).eval(); | |||
return getConditions().nextElement().eval(); | |||
} | |||
} | |||
@@ -131,12 +132,13 @@ public class Exit extends Task { | |||
* the if and unless parameters (if present). | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
boolean fail = (nestedConditionPresent()) ? testNestedCondition() | |||
: (testIfCondition() && testUnlessCondition()); | |||
if (fail) { | |||
String text = null; | |||
if (message != null && message.trim().length() > 0) { | |||
if (!(message == null || message.trim().isEmpty())) { | |||
text = message.trim(); | |||
} else { | |||
if (ifCondition != null && !"".equals(ifCondition) | |||
@@ -154,15 +156,13 @@ public class Exit extends Task { | |||
} | |||
if (nestedConditionPresent()) { | |||
text = "condition satisfied"; | |||
} else { | |||
if (text == null) { | |||
text = "No message"; | |||
} | |||
} else if (text == null) { | |||
text = "No message"; | |||
} | |||
} | |||
log("failing due to " + text, Project.MSG_DEBUG); | |||
throw ((status == null) ? new BuildException(text) | |||
: new ExitStatusException(text, status.intValue())); | |||
throw status == null ? new BuildException(text) | |||
: new ExitStatusException(text, status.intValue()); | |||
} | |||
} | |||
@@ -217,8 +217,8 @@ public class Exit extends Task { | |||
boolean result = nestedConditionPresent(); | |||
if (result && ifCondition != null || unlessCondition != null) { | |||
throw new BuildException("Nested conditions " | |||
+ "not permitted in conjunction with if/unless attributes"); | |||
throw new BuildException( | |||
"Nested conditions not permitted in conjunction with if/unless attributes"); | |||
} | |||
return result && nestedCondition.eval(); | |||
@@ -28,6 +28,7 @@ import java.util.Date; | |||
import java.util.Enumeration; | |||
import java.util.HashSet; | |||
import java.util.Iterator; | |||
import java.util.List; | |||
import java.util.Set; | |||
import java.util.Vector; | |||
@@ -59,25 +60,26 @@ import org.apache.tools.zip.ZipFile; | |||
* name="unwar" | |||
*/ | |||
public class Expand extends Task { | |||
public static final String NATIVE_ENCODING = "native-encoding"; | |||
/** Error message when more that one mapper is defined */ | |||
public static final String ERROR_MULTIPLE_MAPPERS = "Cannot define more than one mapper"; | |||
private static final FileUtils FILE_UTILS = FileUtils.getFileUtils(); | |||
private static final int BUFFER_SIZE = 1024; | |||
private File dest; //req | |||
private File source; // req | |||
private boolean overwrite = true; | |||
private Mapper mapperElement = null; | |||
private Vector<PatternSet> patternsets = new Vector<PatternSet>(); | |||
private List<PatternSet> patternsets = new Vector<>(); | |||
private Union resources = new Union(); | |||
private boolean resourcesSpecified = false; | |||
private boolean failOnEmptyArchive = false; | |||
private boolean stripAbsolutePathSpec = false; | |||
private boolean scanForUnicodeExtraFields = true; | |||
public static final String NATIVE_ENCODING = "native-encoding"; | |||
private String encoding; | |||
/** Error message when more that one mapper is defined */ | |||
public static final String ERROR_MULTIPLE_MAPPERS = "Cannot define more than one mapper"; | |||
private static final FileUtils FILE_UTILS = FileUtils.getFileUtils(); | |||
/** | |||
* Creates an Expand instance and sets encoding to UTF-8. | |||
@@ -118,14 +120,15 @@ public class Expand extends Task { | |||
* | |||
* @exception BuildException Thrown in unrecoverable error. | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
if ("expand".equals(getTaskType())) { | |||
log("!! expand is deprecated. Use unzip instead. !!"); | |||
} | |||
if (source == null && !resourcesSpecified) { | |||
throw new BuildException("src attribute and/or resources must be " | |||
+ "specified"); | |||
throw new BuildException( | |||
"src attribute and/or resources must be specified"); | |||
} | |||
if (dest == null) { | |||
@@ -141,13 +144,14 @@ public class Expand extends Task { | |||
if (source.isDirectory()) { | |||
throw new BuildException("Src must not be a directory." | |||
+ " Use nested filesets instead.", getLocation()); | |||
} else if (!source.exists()) { | |||
} | |||
if (!source.exists()) { | |||
throw new BuildException("src '" + source + "' doesn't exist."); | |||
} else if (!source.canRead()) { | |||
} | |||
if (!source.canRead()) { | |||
throw new BuildException("src '" + source + "' cannot be read."); | |||
} else { | |||
expandFile(FILE_UTILS, source, dest); | |||
} | |||
expandFile(FILE_UTILS, source, dest); | |||
} | |||
for (Resource r : resources) { | |||
if (!r.isExists()) { | |||
@@ -173,7 +177,6 @@ public class Expand extends Task { | |||
*/ | |||
protected void expandFile(FileUtils fileUtils, File srcF, File dir) { | |||
log("Expanding: " + srcF + " into " + dir, Project.MSG_INFO); | |||
ZipFile zf = null; | |||
FileNameMapper mapper = getMapper(); | |||
if (!srcF.exists()) { | |||
throw new BuildException("Unable to expand " | |||
@@ -181,8 +184,9 @@ public class Expand extends Task { | |||
+ " as the file does not exist", | |||
getLocation()); | |||
} | |||
try { | |||
zf = new ZipFile(srcF, encoding, scanForUnicodeExtraFields); | |||
try ( | |||
ZipFile | |||
zf = new ZipFile(srcF, encoding, scanForUnicodeExtraFields)){ | |||
boolean empty = true; | |||
Enumeration<ZipEntry> e = zf.getEntries(); | |||
while (e.hasMoreElements()) { | |||
@@ -200,7 +204,7 @@ public class Expand extends Task { | |||
} | |||
} | |||
if (empty && getFailOnEmptyArchive()) { | |||
throw new BuildException("archive '" + srcF + "' is empty"); | |||
throw new BuildException("archive '%s' is empty", srcF); | |||
} | |||
log("expand complete", Project.MSG_VERBOSE); | |||
} catch (IOException ioe) { | |||
@@ -208,8 +212,6 @@ public class Expand extends Task { | |||
"Error while expanding " + srcF.getPath() | |||
+ "\n" + ioe.toString(), | |||
ioe); | |||
} finally { | |||
ZipFile.closeQuietly(zf); | |||
} | |||
} | |||
@@ -220,8 +222,8 @@ public class Expand extends Task { | |||
* @param dir the destination directory | |||
*/ | |||
protected void expandResource(Resource srcR, File dir) { | |||
throw new BuildException("only filesystem based resources are" | |||
+ " supported by this task."); | |||
throw new BuildException( | |||
"only filesystem based resources are supported by this task."); | |||
} | |||
/** | |||
@@ -229,13 +231,10 @@ public class Expand extends Task { | |||
* @return a filenamemapper for a file | |||
*/ | |||
protected FileNameMapper getMapper() { | |||
FileNameMapper mapper = null; | |||
if (mapperElement != null) { | |||
mapper = mapperElement.getImplementation(); | |||
} else { | |||
mapper = new IdentityMapper(); | |||
return mapperElement.getImplementation(); | |||
} | |||
return mapper; | |||
return new IdentityMapper(); | |||
} | |||
// CheckStyle:ParameterNumberCheck OFF - bc | |||
@@ -257,7 +256,7 @@ public class Expand extends Task { | |||
boolean isDirectory, FileNameMapper mapper) | |||
throws IOException { | |||
if (stripAbsolutePathSpec && entryName.length() > 0 | |||
if (stripAbsolutePathSpec && !entryName.isEmpty() | |||
&& (entryName.charAt(0) == File.separatorChar | |||
|| entryName.charAt(0) == '/' | |||
|| entryName.charAt(0) == '\\')) { | |||
@@ -266,16 +265,16 @@ public class Expand extends Task { | |||
entryName = entryName.substring(1); | |||
} | |||
if (patternsets != null && patternsets.size() > 0) { | |||
if (!(patternsets == null || patternsets.isEmpty())) { | |||
String name = entryName.replace('/', File.separatorChar) | |||
.replace('\\', File.separatorChar); | |||
boolean included = false; | |||
Set<String> includePatterns = new HashSet<String>(); | |||
Set<String> excludePatterns = new HashSet<String>(); | |||
Set<String> includePatterns = new HashSet<>(); | |||
Set<String> excludePatterns = new HashSet<>(); | |||
final int size = patternsets.size(); | |||
for (int v = 0; v < size; v++) { | |||
PatternSet p = patternsets.elementAt(v); | |||
PatternSet p = patternsets.get(v); | |||
String[] incls = p.getIncludePatterns(getProject()); | |||
if (incls == null || incls.length == 0) { | |||
// no include pattern implicitly means includes="**" | |||
@@ -350,20 +349,11 @@ public class Expand extends Task { | |||
f.mkdirs(); | |||
} else { | |||
byte[] buffer = new byte[BUFFER_SIZE]; | |||
int length = 0; | |||
OutputStream fos = null; | |||
try { | |||
fos = Files.newOutputStream(f.toPath()); | |||
while ((length = | |||
compressedInputStream.read(buffer)) >= 0) { | |||
try (OutputStream fos = Files.newOutputStream(f.toPath())) { | |||
int length; | |||
while ((length = compressedInputStream.read(buffer)) >= 0) { | |||
fos.write(buffer, 0, length); | |||
} | |||
fos.close(); | |||
fos = null; | |||
} finally { | |||
FileUtils.close(fos); | |||
} | |||
} | |||
@@ -410,7 +400,7 @@ public class Expand extends Task { | |||
* @param set a pattern set | |||
*/ | |||
public void addPatternset(PatternSet set) { | |||
patternsets.addElement(set); | |||
patternsets.add(set); | |||
} | |||
/** | |||
@@ -69,6 +69,7 @@ public class Filter extends Task { | |||
* Execute the task. | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
boolean isFiltersFromFile = | |||
filtersFile != null && token == null && value == null; | |||
@@ -76,9 +77,9 @@ public class Filter extends Task { | |||
filtersFile == null && token != null && value != null; | |||
if (!isFiltersFromFile && !isSingleFilter) { | |||
throw new BuildException("both token and value parameters, or " | |||
+ "only a filtersFile parameter is " | |||
+ "required", getLocation()); | |||
throw new BuildException( | |||
"both token and value parameters, or only a filtersFile parameter is required", | |||
getLocation()); | |||
} | |||
if (isSingleFilter) { | |||
@@ -115,6 +115,7 @@ public class FixCRLF extends MatchingTask implements ChainableReader { | |||
* @return a Reader. | |||
* @since Ant 1.7? | |||
*/ | |||
@Override | |||
public final Reader chain(final Reader rdr) { | |||
return filter.chain(rdr); | |||
} | |||
@@ -181,15 +182,16 @@ public class FixCRLF extends MatchingTask implements ChainableReader { | |||
* @deprecated since 1.4.x. | |||
* Use {@link #setEol setEol} instead. | |||
*/ | |||
@Deprecated | |||
public void setCr(AddAsisRemove attr) { | |||
log("DEPRECATED: The cr attribute has been deprecated,", | |||
Project.MSG_WARN); | |||
log("Please use the eol attribute instead", Project.MSG_WARN); | |||
String option = attr.getValue(); | |||
CrLf c = new CrLf(); | |||
if (option.equals("remove")) { | |||
if ("remove".equals(option)) { | |||
c.setValue("lf"); | |||
} else if (option.equals("asis")) { | |||
} else if ("asis".equals(option)) { | |||
c.setValue("asis"); | |||
} else { | |||
// must be "add" | |||
@@ -282,6 +284,7 @@ public class FixCRLF extends MatchingTask implements ChainableReader { | |||
* Executes the task. | |||
* @throws BuildException on error. | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
// first off, make sure that we've got a srcdir and destdir | |||
validate(); | |||
@@ -322,22 +325,21 @@ public class FixCRLF extends MatchingTask implements ChainableReader { | |||
} | |||
if (!srcDir.exists()) { | |||
throw new BuildException( | |||
FIXCRLF_ERROR + "srcdir does not exist: '" + srcDir + "'"); | |||
FIXCRLF_ERROR + "srcdir does not exist: '%s'", srcDir); | |||
} | |||
if (!srcDir.isDirectory()) { | |||
throw new BuildException( | |||
FIXCRLF_ERROR + "srcdir is not a directory: '" + srcDir + "'"); | |||
FIXCRLF_ERROR + "srcdir is not a directory: '%s'", srcDir); | |||
} | |||
if (destDir != null) { | |||
if (!destDir.exists()) { | |||
throw new BuildException( | |||
FIXCRLF_ERROR + "destdir does not exist: '" | |||
+ destDir + "'"); | |||
FIXCRLF_ERROR + "destdir does not exist: '%s'", destDir); | |||
} | |||
if (!destDir.isDirectory()) { | |||
throw new BuildException( | |||
FIXCRLF_ERROR + "destdir is not a directory: '" | |||
+ destDir + "'"); | |||
FIXCRLF_ERROR + "destdir is not a directory: '%s'", | |||
destDir); | |||
} | |||
} | |||
} | |||
@@ -350,7 +352,7 @@ public class FixCRLF extends MatchingTask implements ChainableReader { | |||
if (fcv == null) { | |||
FilterChain fc = new FilterChain(); | |||
fc.add(filter); | |||
fcv = new Vector<FilterChain>(1); | |||
fcv = new Vector<>(1); | |||
fcv.add(fc); | |||
} | |||
File tmpFile = FILE_UTILS.createTempFile("fixcrlf", "", null, true, true); | |||
@@ -391,6 +393,7 @@ public class FixCRLF extends MatchingTask implements ChainableReader { | |||
* Deprecated, the functionality has been moved to filters.FixCrLfFilter. | |||
* @deprecated since 1.7.0. | |||
*/ | |||
@Deprecated | |||
protected class OneLiner implements Enumeration<Object> { | |||
private static final int UNDEF = -1; | |||
private static final int NOTJAVA = 0; | |||
@@ -549,6 +552,7 @@ public class FixCRLF extends MatchingTask implements ChainableReader { | |||
/** | |||
* @return true if there is more elements. | |||
*/ | |||
@Override | |||
public boolean hasMoreElements() { | |||
return !reachedEof; | |||
} | |||
@@ -558,6 +562,7 @@ public class FixCRLF extends MatchingTask implements ChainableReader { | |||
* @return the next element. | |||
* @throws NoSuchElementException if there is no more. | |||
*/ | |||
@Override | |||
public Object nextElement() | |||
throws NoSuchElementException { | |||
if (!hasMoreElements()) { | |||
@@ -673,22 +678,24 @@ public class FixCRLF extends MatchingTask implements ChainableReader { | |||
*/ | |||
public static class AddAsisRemove extends EnumeratedAttribute { | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public String[] getValues() { | |||
return new String[] {"add", "asis", "remove"}; | |||
return new String[] { "add", "asis", "remove" }; | |||
} | |||
} | |||
/** | |||
* Enumerated attribute with the values "asis", "cr", "lf" and "crlf". | |||
* Enumerated attribute with the values "asis", "cr", "lf", "crlf", "mac", "unix" and "dos. | |||
*/ | |||
public static class CrLf extends EnumeratedAttribute { | |||
/** | |||
* @see EnumeratedAttribute#getValues | |||
*/ | |||
/** {@inheritDoc}. */ | |||
@Override | |||
public String[] getValues() { | |||
return new String[] {"asis", "cr", "lf", "crlf", | |||
"mac", "unix", "dos"}; | |||
return new String[] { "asis", "cr", "lf", "crlf", "mac", "unix", | |||
"dos" }; | |||
} | |||
} | |||
@@ -19,13 +19,11 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.IOException; | |||
import java.io.InputStream; | |||
import java.io.OutputStream; | |||
import java.nio.file.Files; | |||
import java.util.zip.GZIPInputStream; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.util.FileUtils; | |||
/** | |||
* Expands a file that has been compressed with the GZIP | |||
@@ -45,6 +43,7 @@ public class GUnzip extends Unpack { | |||
* Get the default extension. | |||
* @return the value ".gz" | |||
*/ | |||
@Override | |||
protected String getDefaultExtension() { | |||
return DEFAULT_EXTENSION; | |||
} | |||
@@ -52,18 +51,14 @@ public class GUnzip extends Unpack { | |||
/** | |||
* Implement the gunzipping. | |||
*/ | |||
@Override | |||
protected void extract() { | |||
if (srcResource.getLastModified() > dest.lastModified()) { | |||
log("Expanding " + srcResource.getName() + " to " | |||
+ dest.getAbsolutePath()); | |||
OutputStream out = null; | |||
GZIPInputStream zIn = null; | |||
InputStream fis = null; | |||
try { | |||
out = Files.newOutputStream(dest.toPath()); | |||
fis = srcResource.getInputStream(); | |||
zIn = new GZIPInputStream(fis); | |||
try (OutputStream out = Files.newOutputStream(dest.toPath()); | |||
GZIPInputStream zIn = | |||
new GZIPInputStream(srcResource.getInputStream())) { | |||
byte[] buffer = new byte[BUFFER_SIZE]; | |||
int count = 0; | |||
do { | |||
@@ -73,10 +68,6 @@ public class GUnzip extends Unpack { | |||
} catch (IOException ioe) { | |||
String msg = "Problem expanding gzip " + ioe.getMessage(); | |||
throw new BuildException(msg, ioe, getLocation()); | |||
} finally { | |||
FileUtils.close(fis); | |||
FileUtils.close(out); | |||
FileUtils.close(zIn); | |||
} | |||
} | |||
} | |||
@@ -92,6 +83,7 @@ public class GUnzip extends Unpack { | |||
* @return true if this task supports non file resources. | |||
* @since Ant 1.7 | |||
*/ | |||
@Override | |||
protected boolean supportsNonFileResources() { | |||
return getClass().equals(GUnzip.class); | |||
} | |||
@@ -19,12 +19,10 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.IOException; | |||
import java.io.OutputStream; | |||
import java.nio.file.Files; | |||
import java.util.zip.GZIPOutputStream; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.util.FileUtils; | |||
/** | |||
* Compresses a file with the GZIP algorithm. Normally used to compress | |||
@@ -39,16 +37,14 @@ public class GZip extends Pack { | |||
/** | |||
* perform the GZip compression operation. | |||
*/ | |||
@Override | |||
protected void pack() { | |||
GZIPOutputStream zOut = null; | |||
try { | |||
zOut = new GZIPOutputStream(Files.newOutputStream(zipFile.toPath())); | |||
try (GZIPOutputStream zOut = | |||
new GZIPOutputStream(Files.newOutputStream(zipFile.toPath()))) { | |||
zipResource(getSrcResource(), zOut); | |||
} catch (IOException ioe) { | |||
String msg = "Problem creating gzip " + ioe.getMessage(); | |||
throw new BuildException(msg, ioe, getLocation()); | |||
} finally { | |||
FileUtils.close(zOut); | |||
} | |||
} | |||
@@ -63,6 +59,7 @@ public class GZip extends Pack { | |||
* @return true if this case supports non file resources. | |||
* @since Ant 1.7 | |||
*/ | |||
@Override | |||
protected boolean supportsNonFileResources() { | |||
return getClass().equals(GZip.class); | |||
} | |||
@@ -17,8 +17,12 @@ | |||
*/ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.util.Collections; | |||
import java.util.Enumeration; | |||
import java.util.List; | |||
import java.util.Vector; | |||
import java.util.stream.Collectors; | |||
import java.util.stream.Stream; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.Task; | |||
@@ -83,7 +87,7 @@ public class GenerateKey extends Task { | |||
* A class corresponding to the dname nested element. | |||
*/ | |||
public static class DistinguishedName { | |||
private Vector<DnameParam> params = new Vector<DnameParam>(); | |||
private List<DnameParam> params = new Vector<>(); | |||
/** | |||
* Create a param nested element. | |||
@@ -91,8 +95,7 @@ public class GenerateKey extends Task { | |||
*/ | |||
public Object createParam() { | |||
DnameParam param = new DnameParam(); | |||
params.addElement(param); | |||
params.add(param); | |||
return param; | |||
} | |||
@@ -101,7 +104,7 @@ public class GenerateKey extends Task { | |||
* @return an enumeration of the nested parameters. | |||
*/ | |||
public Enumeration<DnameParam> getParams() { | |||
return params.elements(); | |||
return Collections.enumeration(params); | |||
} | |||
/** | |||
@@ -111,26 +114,10 @@ public class GenerateKey extends Task { | |||
* This is used on the command line. | |||
* @return a string rep of this name | |||
*/ | |||
@Override | |||
public String toString() { | |||
final int size = params.size(); | |||
final StringBuffer sb = new StringBuffer(); | |||
boolean firstPass = true; | |||
for (int i = 0; i < size; i++) { | |||
if (!firstPass) { | |||
sb.append(" ,"); | |||
} | |||
firstPass = false; | |||
final DnameParam param = (DnameParam) params.elementAt(i); | |||
if (param.isComplete()) { | |||
sb.append(encode(param.getName())); | |||
sb.append('='); | |||
sb.append(encode(param.getValue())); | |||
} | |||
} | |||
return sb.toString(); | |||
return params.stream().map(p -> p.getName() + "=" + p.getValue()) | |||
.collect(Collectors.joining(", ")); | |||
} | |||
/** | |||
@@ -141,26 +128,8 @@ public class GenerateKey extends Task { | |||
* @return the encoded value. | |||
*/ | |||
public String encode(final String string) { | |||
int end = string.indexOf(','); | |||
if (-1 == end) { | |||
return string; | |||
} | |||
final StringBuffer sb = new StringBuffer(); | |||
int start = 0; | |||
while (-1 != end) { | |||
sb.append(string.substring(start, end)); | |||
sb.append("\\,"); | |||
start = end + 1; | |||
end = string.indexOf(',', start); | |||
} | |||
sb.append(string.substring(start)); | |||
return sb.toString(); | |||
return Stream.of(string.split(",")) | |||
.collect(Collectors.joining("\\,")); | |||
} | |||
} | |||
@@ -197,12 +166,11 @@ public class GenerateKey extends Task { | |||
*/ | |||
public DistinguishedName createDname() throws BuildException { | |||
if (null != expandedDname) { | |||
throw new BuildException("DName sub-element can only be " | |||
+ "specified once."); | |||
throw new BuildException("DName sub-element can only be specified once."); | |||
} | |||
if (null != dname) { | |||
throw new BuildException("It is not possible to specify dname " | |||
+ " both as attribute and element."); | |||
throw new BuildException( | |||
"It is not possible to specify dname both as attribute and element."); | |||
} | |||
expandedDname = new DistinguishedName(); | |||
return expandedDname; | |||
@@ -215,8 +183,8 @@ public class GenerateKey extends Task { | |||
*/ | |||
public void setDname(final String dname) { | |||
if (null != expandedDname) { | |||
throw new BuildException("It is not possible to specify dname " | |||
+ " both as attribute and element."); | |||
throw new BuildException( | |||
"It is not possible to specify dname both as attribute and element."); | |||
} | |||
this.dname = dname; | |||
} | |||
@@ -324,6 +292,7 @@ public class GenerateKey extends Task { | |||
* Execute the task. | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
if (null == alias) { | |||
@@ -338,7 +307,7 @@ public class GenerateKey extends Task { | |||
throw new BuildException("dname must be set"); | |||
} | |||
final StringBuffer sb = new StringBuffer(); | |||
final StringBuilder sb = new StringBuilder(); | |||
sb.append("-genkey "); | |||
@@ -400,7 +369,6 @@ public class GenerateKey extends Task { | |||
sb.append("\" "); | |||
} | |||
if (0 < keysize) { | |||
sb.append("-keysize \""); | |||
sb.append(keysize); | |||
@@ -96,7 +96,7 @@ public class Get extends Task { | |||
+ Main.getShortAntVersion()); | |||
// Store headers as key/value pair without duplicate in keyz | |||
private Map<String, String> headers = new LinkedHashMap<String, String>(); | |||
private Map<String, String> headers = new LinkedHashMap<>(); | |||
/** | |||
* Does the work. | |||
@@ -118,7 +118,7 @@ public class Get extends Task { | |||
if (path.endsWith("/")) { | |||
path = path.substring(0, path.length() - 1); | |||
} | |||
final int slash = path.lastIndexOf("/"); | |||
final int slash = path.lastIndexOf('/'); | |||
if (slash > -1) { | |||
path = path.substring(slash + 1); | |||
} | |||
@@ -130,11 +130,13 @@ public class Get extends Task { | |||
log("skipping " + r + " - mapper can't handle it", | |||
Project.MSG_WARN); | |||
continue; | |||
} else if (d.length == 0) { | |||
} | |||
if (d.length == 0) { | |||
log("skipping " + r + " - mapper returns no file name", | |||
Project.MSG_WARN); | |||
continue; | |||
} else if (d.length > 1) { | |||
} | |||
if (d.length > 1) { | |||
log("skipping " + r + " - mapper returns multiple file" | |||
+ " names", Project.MSG_WARN); | |||
continue; | |||
@@ -288,8 +290,8 @@ public class Get extends Task { | |||
for (final Resource r : sources) { | |||
final URLProvider up = r.as(URLProvider.class); | |||
if (up == null) { | |||
throw new BuildException("Only URLProvider resources are" | |||
+ " supported", getLocation()); | |||
throw new BuildException( | |||
"Only URLProvider resources are supported", getLocation()); | |||
} | |||
} | |||
@@ -299,9 +301,8 @@ public class Get extends Task { | |||
if (destination.exists() && sources.size() > 1 | |||
&& !destination.isDirectory()) { | |||
throw new BuildException("The specified destination is not a" | |||
+ " directory", | |||
getLocation()); | |||
throw new BuildException( | |||
"The specified destination is not a directory", getLocation()); | |||
} | |||
if (destination.exists() && !destination.canWrite()) { | |||
@@ -391,7 +392,6 @@ public class Get extends Task { | |||
useTimestamp = v; | |||
} | |||
/** | |||
* Username for basic auth. | |||
* | |||
@@ -566,6 +566,7 @@ public class Get extends Task { | |||
/** | |||
* begin a download | |||
*/ | |||
@Override | |||
public void beginDownload() { | |||
} | |||
@@ -573,12 +574,14 @@ public class Get extends Task { | |||
* tick handler | |||
* | |||
*/ | |||
@Override | |||
public void onTick() { | |||
} | |||
/** | |||
* end a download | |||
*/ | |||
@Override | |||
public void endDownload() { | |||
} | |||
} | |||
@@ -603,6 +606,7 @@ public class Get extends Task { | |||
/** | |||
* begin a download | |||
*/ | |||
@Override | |||
public void beginDownload() { | |||
dots = 0; | |||
} | |||
@@ -611,6 +615,7 @@ public class Get extends Task { | |||
* tick handler | |||
* | |||
*/ | |||
@Override | |||
public void onTick() { | |||
out.print("."); | |||
if (dots++ > DOTS_PER_LINE) { | |||
@@ -622,6 +627,7 @@ public class Get extends Task { | |||
/** | |||
* end a download | |||
*/ | |||
@Override | |||
public void endDownload() { | |||
out.println(); | |||
out.flush(); | |||
@@ -699,9 +705,8 @@ public class Get extends Task { | |||
if (ignoreErrors) { | |||
log(message, logLevel); | |||
return false; | |||
} else { | |||
throw new BuildException(message); | |||
} | |||
throw new BuildException(message); | |||
} | |||
redirections++; | |||
@@ -711,12 +716,9 @@ public class Get extends Task { | |||
if (ignoreErrors) { | |||
log(message, logLevel); | |||
return false; | |||
} else { | |||
throw new BuildException(message); | |||
} | |||
throw new BuildException(message); | |||
} | |||
return true; | |||
} | |||
@@ -749,14 +751,12 @@ public class Get extends Task { | |||
connection.setRequestProperty("Accept-Encoding", GZIP_CONTENT_ENCODING); | |||
} | |||
for (final Map.Entry<String, String> header : headers.entrySet()) { | |||
//we do not log the header value as it may contain sensitive data like passwords | |||
log(String.format("Adding header '%s' ", header.getKey())); | |||
connection.setRequestProperty(header.getKey(), header.getValue()); | |||
} | |||
if (connection instanceof HttpURLConnection) { | |||
((HttpURLConnection) connection) | |||
.setInstanceFollowRedirects(false); | |||
@@ -804,9 +804,8 @@ public class Get extends Task { | |||
if (ignoreErrors) { | |||
log(message, logLevel); | |||
return null; | |||
} else { | |||
throw new BuildException(message); | |||
} | |||
throw new BuildException(message); | |||
} | |||
} | |||
@@ -105,8 +105,9 @@ public class HostInfo extends Task { | |||
* @throws BuildException | |||
* on error. | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
if (host == null || "".equals(host)) { | |||
if (host == null || host.isEmpty()) { | |||
executeLocal(); | |||
} else { | |||
executeRemote(); | |||
@@ -115,7 +116,7 @@ public class HostInfo extends Task { | |||
private void executeLocal() { | |||
try { | |||
inetAddrs = new LinkedList<InetAddress>(); | |||
inetAddrs = new LinkedList<>(); | |||
Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); | |||
while (interfaces.hasMoreElements()) { | |||
NetworkInterface currentif = interfaces.nextElement(); | |||
@@ -175,34 +176,32 @@ public class HostInfo extends Task { | |||
if (best == null) { | |||
// none selected so far, so this one is better. | |||
best = current; | |||
} else if (current == null || current.isLoopbackAddress()) { | |||
// definitely not better than the previously selected address. | |||
} else if (current.isLinkLocalAddress()) { | |||
// link local considered better than loopback | |||
if (best.isLoopbackAddress()) { | |||
best = current; | |||
} | |||
} else if (current.isSiteLocalAddress()) { | |||
// site local considered better than link local (and loopback) | |||
// address with hostname resolved considered better than | |||
// address without hostname | |||
if (best.isLoopbackAddress() | |||
|| best.isLinkLocalAddress() | |||
|| (best.isSiteLocalAddress() && !hasHostName(best))) { | |||
best = current; | |||
} | |||
} else { | |||
if (current == null || current.isLoopbackAddress()) { | |||
// definitely not better than the previously selected address. | |||
} else if (current.isLinkLocalAddress()) { | |||
// link local considered better than loopback | |||
if (best.isLoopbackAddress()) { | |||
best = current; | |||
} | |||
} else if (current.isSiteLocalAddress()) { | |||
// site local considered better than link local (and loopback) | |||
// address with hostname resolved considered better than | |||
// address without hostname | |||
if (best.isLoopbackAddress() | |||
|| best.isLinkLocalAddress() | |||
|| (best.isSiteLocalAddress() && !hasHostName(best))) { | |||
best = current; | |||
} | |||
} else { | |||
// current is a "Global address", considered better than | |||
// site local (and better than link local, loopback) | |||
// address with hostname resolved considered better than | |||
// address without hostname | |||
if (best.isLoopbackAddress() | |||
|| best.isLinkLocalAddress() | |||
|| best.isSiteLocalAddress() | |||
|| !hasHostName(best)) { | |||
best = current; | |||
} | |||
// current is a "Global address", considered better than | |||
// site local (and better than link local, loopback) | |||
// address with hostname resolved considered better than | |||
// address without hostname | |||
if (best.isLoopbackAddress() | |||
|| best.isLinkLocalAddress() | |||
|| best.isSiteLocalAddress() | |||
|| !hasHostName(best)) { | |||
best = current; | |||
} | |||
} | |||
return best; | |||
@@ -63,12 +63,13 @@ import org.apache.tools.ant.util.FileUtils; | |||
* @ant.task category="control" | |||
*/ | |||
public class ImportTask extends Task { | |||
private static final FileUtils FILE_UTILS = FileUtils.getFileUtils(); | |||
private String file; | |||
private boolean optional; | |||
private String targetPrefix = ProjectHelper.USE_PROJECT_NAME_AS_TARGET_PREFIX; | |||
private String prefixSeparator = "."; | |||
private final Union resources = new Union(); | |||
private static final FileUtils FILE_UTILS = FileUtils.getFileUtils(); | |||
public ImportTask() { | |||
resources.setCache(true); | |||
@@ -123,18 +124,18 @@ public class ImportTask extends Task { | |||
resources.add(r); | |||
} | |||
@Override | |||
public void execute() { | |||
if (file == null && resources.size() == 0) { | |||
throw new BuildException("import requires file attribute or" | |||
+ " at least one nested resource"); | |||
if (file == null && resources.isEmpty()) { | |||
throw new BuildException( | |||
"import requires file attribute or at least one nested resource"); | |||
} | |||
if (getOwningTarget() == null | |||
|| !"".equals(getOwningTarget().getName())) { | |||
|| !getOwningTarget().getName().isEmpty()) { | |||
throw new BuildException("import only allowed as a top-level task"); | |||
} | |||
ProjectHelper helper = | |||
(ProjectHelper) getProject(). | |||
ProjectHelper helper = getProject(). | |||
getReference(ProjectHelper.PROJECTHELPER_REFERENCE); | |||
if (helper == null) { | |||
@@ -142,9 +143,7 @@ public class ImportTask extends Task { | |||
throw new BuildException("import requires support in ProjectHelper"); | |||
} | |||
Vector<Object> importStack = helper.getImportStack(); | |||
if (importStack.size() == 0) { | |||
if (helper.getImportStack().isEmpty()) { | |||
// this happens if ant is used with a project | |||
// helper that doesn't set the import. | |||
throw new BuildException("import requires support in ProjectHelper"); | |||
@@ -166,8 +165,6 @@ public class ImportTask extends Task { | |||
private void importResource(ProjectHelper helper, | |||
Resource importedResource) { | |||
Vector<Object> importStack = helper.getImportStack(); | |||
getProject().log("Importing file " + importedResource + " from " | |||
+ getLocation().getFileName(), Project.MSG_VERBOSE); | |||
@@ -178,13 +175,12 @@ public class ImportTask extends Task { | |||
if (optional) { | |||
getProject().log(message, Project.MSG_VERBOSE); | |||
return; | |||
} else { | |||
throw new BuildException(message); | |||
} | |||
throw new BuildException(message); | |||
} | |||
if (!isInIncludeMode() && | |||
hasAlreadyBeenImported(importedResource, importStack)) { | |||
if (!isInIncludeMode() && hasAlreadyBeenImported(importedResource, | |||
helper.getImportStack())) { | |||
getProject().log( | |||
"Skipped already imported file:\n " | |||
+ importedResource + "\n", Project.MSG_VERBOSE); | |||
@@ -203,10 +199,10 @@ public class ImportTask extends Task { | |||
prefix = oldPrefix + oldSep + targetPrefix; | |||
} else if (isInIncludeMode()) { | |||
prefix = targetPrefix; | |||
} else if (!ProjectHelper.USE_PROJECT_NAME_AS_TARGET_PREFIX.equals(targetPrefix)) { | |||
prefix = targetPrefix; | |||
} else { | |||
} else if (ProjectHelper.USE_PROJECT_NAME_AS_TARGET_PREFIX.equals(targetPrefix)) { | |||
prefix = oldPrefix; | |||
} else { | |||
prefix = targetPrefix; | |||
} | |||
setProjectHelperProps(prefix, prefixSeparator, | |||
isInIncludeMode()); | |||
@@ -260,9 +256,8 @@ public class ImportTask extends Task { | |||
} catch (MalformedURLException ex) { | |||
log(ex.toString(), Project.MSG_VERBOSE); | |||
} | |||
throw new BuildException("failed to resolve " + file | |||
+ " relative to " | |||
+ getLocation().getFileName()); | |||
throw new BuildException("failed to resolve %s relative to %s", | |||
file, getLocation().getFileName()); | |||
} | |||
return null; | |||
} | |||
@@ -274,22 +269,14 @@ public class ImportTask extends Task { | |||
private boolean hasAlreadyBeenImported(Resource importedResource, | |||
Vector<Object> importStack) { | |||
File importedFile = null; | |||
FileProvider fp = importedResource.as(FileProvider.class); | |||
if (fp != null) { | |||
importedFile = fp.getFile(); | |||
} | |||
URL importedURL = null; | |||
URLProvider up = importedResource.as(URLProvider.class); | |||
if (up != null) { | |||
importedURL = up.getURL(); | |||
} | |||
for (Object o : importStack) { | |||
if (isOneOf(o, importedResource, importedFile, importedURL)) { | |||
return true; | |||
} | |||
} | |||
return false; | |||
File importedFile = importedResource.asOptional(FileProvider.class) | |||
.map(FileProvider::getFile).orElse(null); | |||
URL importedURL = importedResource.asOptional(URLProvider.class) | |||
.map(URLProvider::getURL).orElse(null); | |||
return importStack.stream().anyMatch( | |||
o -> isOneOf(o, importedResource, importedFile, importedURL)); | |||
} | |||
private boolean isOneOf(Object o, Resource importedResource, | |||
@@ -18,8 +18,7 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.util.Vector; | |||
import java.util.List; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.Task; | |||
import org.apache.tools.ant.input.DefaultInputHandler; | |||
@@ -59,6 +58,7 @@ public class Input extends Task { | |||
public void setRefid(final String refid) { | |||
this.refid = refid; | |||
} | |||
/** | |||
* Get the refid of this Handler. | |||
* @return String refid. | |||
@@ -66,6 +66,7 @@ public class Input extends Task { | |||
public String getRefid() { | |||
return refid; | |||
} | |||
/** | |||
* Set the InputHandler classname. | |||
* @param classname the String classname. | |||
@@ -73,6 +74,7 @@ public class Input extends Task { | |||
public void setClassname(final String classname) { | |||
this.classname = classname; | |||
} | |||
/** | |||
* Get the classname of the InputHandler. | |||
* @return String classname. | |||
@@ -80,6 +82,7 @@ public class Input extends Task { | |||
public String getClassname() { | |||
return classname; | |||
} | |||
/** | |||
* Set the handler type. | |||
* @param type a HandlerType. | |||
@@ -87,6 +90,7 @@ public class Input extends Task { | |||
public void setType(final HandlerType type) { | |||
this.type = type; | |||
} | |||
/** | |||
* Get the handler type. | |||
* @return a HandlerType object. | |||
@@ -94,6 +98,7 @@ public class Input extends Task { | |||
public HandlerType getType() { | |||
return type; | |||
} | |||
private InputHandler getInputHandler() { | |||
if (type != null) { | |||
return type.getInputHandler(); | |||
@@ -107,8 +112,8 @@ public class Input extends Task { | |||
} | |||
} | |||
if (classname != null) { | |||
return (InputHandler) (ClasspathUtils.newInstance(classname, | |||
createLoader(), InputHandler.class)); | |||
return ClasspathUtils.newInstance(classname, | |||
createLoader(), InputHandler.class); | |||
} | |||
throw new BuildException( | |||
"Must specify refid, classname or type"); | |||
@@ -120,19 +125,21 @@ public class Input extends Task { | |||
* "default", "propertyfile", "greedy", "secure" (since Ant 1.8). | |||
*/ | |||
public static class HandlerType extends EnumeratedAttribute { | |||
private static final String[] VALUES = {"default", "propertyfile", "greedy", "secure"}; | |||
private static final String[] VALUES = | |||
{ "default", "propertyfile", "greedy", "secure" }; | |||
private static final InputHandler[] HANDLERS | |||
= {new DefaultInputHandler(), | |||
new PropertyFileInputHandler(), | |||
new GreedyInputHandler(), | |||
new SecureInputHandler()}; | |||
= { new DefaultInputHandler(), | |||
new PropertyFileInputHandler(), | |||
new GreedyInputHandler(), | |||
new SecureInputHandler() }; | |||
/** {@inheritDoc} */ | |||
@Override | |||
public String[] getValues() { | |||
return VALUES; | |||
} | |||
private InputHandler getInputHandler() { | |||
return HANDLERS[getIndex()]; | |||
} | |||
@@ -193,18 +200,12 @@ public class Input extends Task { | |||
* @param msg The message to be displayed. | |||
*/ | |||
public void addText(final String msg) { | |||
if (messageAttribute && "".equals(msg.trim())) { | |||
if (messageAttribute && msg.trim().isEmpty()) { | |||
return; | |||
} | |||
message += getProject().replaceProperties(msg); | |||
} | |||
/** | |||
* No arg constructor. | |||
*/ | |||
public Input () { | |||
} | |||
/** | |||
* Actual method executed by ant. | |||
* @throws BuildException on error | |||
@@ -220,7 +221,7 @@ public class Input extends Task { | |||
InputRequest request = null; | |||
if (validargs != null) { | |||
final Vector<String> accept = StringUtils.split(validargs, ','); | |||
final List<String> accept = StringUtils.split(validargs, ','); | |||
request = new MultipleChoiceInputRequest(message, accept); | |||
} else { | |||
request = new InputRequest(message); | |||
@@ -234,7 +235,7 @@ public class Input extends Task { | |||
h.handleInput(request); | |||
String value = request.getInput(); | |||
if ((value == null || value.trim().length() == 0) | |||
if ((value == null || value.trim().isEmpty()) | |||
&& defaultvalue != null) { | |||
value = defaultvalue; | |||
} | |||
@@ -24,7 +24,6 @@ import java.sql.Driver; | |||
import java.sql.SQLException; | |||
import java.util.ArrayList; | |||
import java.util.Hashtable; | |||
import java.util.Iterator; | |||
import java.util.List; | |||
import java.util.Locale; | |||
import java.util.Properties; | |||
@@ -98,7 +97,7 @@ public abstract class JDBCTask extends Task { | |||
* getting an OutOfMemoryError when calling this task | |||
* multiple times in a row. | |||
*/ | |||
private static Hashtable<String, AntClassLoader> LOADER_MAP = new Hashtable<String, AntClassLoader>(HASH_TABLE_SIZE); | |||
private static Hashtable<String, AntClassLoader> LOADER_MAP = new Hashtable<>(HASH_TABLE_SIZE); | |||
private boolean caching = true; | |||
@@ -152,7 +151,7 @@ public abstract class JDBCTask extends Task { | |||
* | |||
* @since Ant 1.8.0 | |||
*/ | |||
private List<Property> connectionProperties = new ArrayList<Property>(); | |||
private List<Property> connectionProperties = new ArrayList<>(); | |||
/** | |||
* Sets the classpath for loading the driver. | |||
@@ -342,20 +341,17 @@ public abstract class JDBCTask extends Task { | |||
throw new BuildException("Url attribute must be set!", getLocation()); | |||
} | |||
try { | |||
log("connecting to " + getUrl(), Project.MSG_VERBOSE); | |||
Properties info = new Properties(); | |||
info.put("user", getUserId()); | |||
info.put("password", getPassword()); | |||
for (Iterator<Property> props = connectionProperties.iterator(); | |||
props.hasNext();) { | |||
Property p = props.next(); | |||
String name = p.getName(); | |||
String value = p.getValue(); | |||
for (Property p : connectionProperties) { | |||
String name = p.getName(); | |||
String value = p.getValue(); | |||
if (name == null || value == null) { | |||
log("Only name/value pairs are supported as connection" | |||
+ " properties.", Project.MSG_WARN); | |||
log("Only name/value pairs are supported as connection properties.", | |||
Project.MSG_WARN); | |||
} else { | |||
log("Setting connection property " + name + " to " + value, | |||
Project.MSG_VERBOSE); | |||
@@ -374,14 +370,12 @@ public abstract class JDBCTask extends Task { | |||
return conn; | |||
} catch (SQLException e) { | |||
// failed to connect | |||
if (!failOnConnectionError) { | |||
log("Failed to connect: " + e.getMessage(), Project.MSG_WARN); | |||
return null; | |||
} else { | |||
if (failOnConnectionError) { | |||
throw new BuildException(e, getLocation()); | |||
} | |||
log("Failed to connect: " + e.getMessage(), Project.MSG_WARN); | |||
return null; | |||
} | |||
} | |||
/** | |||
@@ -395,9 +389,9 @@ public abstract class JDBCTask extends Task { | |||
throw new BuildException("Driver attribute must be set!", getLocation()); | |||
} | |||
Driver driverInstance = null; | |||
Driver driverInstance; | |||
try { | |||
Class<?> dc; | |||
Class<? extends Driver> dc; | |||
if (classpath != null) { | |||
// check first that it is not already loaded otherwise | |||
// consecutive runs seems to end into an OutOfMemoryError | |||
@@ -423,13 +417,13 @@ public abstract class JDBCTask extends Task { | |||
Project.MSG_VERBOSE); | |||
} | |||
} | |||
dc = loader.loadClass(driver); | |||
dc = loader.loadClass(driver).asSubclass(Driver.class); | |||
} else { | |||
log("Loading " + driver + " using system loader.", | |||
Project.MSG_VERBOSE); | |||
dc = Class.forName(driver); | |||
dc = Class.forName(driver).asSubclass(Driver.class); | |||
} | |||
driverInstance = (Driver) dc.newInstance(); | |||
driverInstance = dc.newInstance(); | |||
} catch (ClassNotFoundException e) { | |||
throw new BuildException( | |||
"Class Not Found: JDBC driver " + driver + " could not be loaded", | |||
@@ -449,7 +443,6 @@ public abstract class JDBCTask extends Task { | |||
return driverInstance; | |||
} | |||
/** | |||
* Set the caching attribute. | |||
* @param value a <code>boolean</code> value | |||
@@ -28,6 +28,7 @@ import java.io.OutputStreamWriter; | |||
import java.io.PrintWriter; | |||
import java.io.Reader; | |||
import java.io.UnsupportedEncodingException; | |||
import java.nio.charset.Charset; | |||
import java.nio.file.Files; | |||
import java.util.ArrayList; | |||
import java.util.Collections; | |||
@@ -35,6 +36,8 @@ import java.util.Comparator; | |||
import java.util.Enumeration; | |||
import java.util.HashSet; | |||
import java.util.List; | |||
import java.util.Set; | |||
import java.util.SortedMap; | |||
import java.util.StringTokenizer; | |||
import java.util.TreeMap; | |||
import java.util.Vector; | |||
@@ -74,7 +77,7 @@ public class Jar extends Zip { | |||
/** | |||
* List of all known SPI Services | |||
*/ | |||
private List<Service> serviceList = new ArrayList<Service>(); | |||
private List<Service> serviceList = new ArrayList<>(); | |||
/** merged manifests added through addConfiguredManifest */ | |||
private Manifest configuredManifest; | |||
@@ -138,7 +141,7 @@ public class Jar extends Zip { | |||
* | |||
* @since Ant 1.6 | |||
*/ | |||
private Vector<String> rootEntries; | |||
private List<String> rootEntries; | |||
/** | |||
* Path containing jars that shall be indexed in addition to this archive. | |||
@@ -182,7 +185,7 @@ public class Jar extends Zip { | |||
emptyBehavior = "create"; | |||
setEncoding("UTF8"); | |||
setZip64Mode(Zip64ModeAttribute.NEVER); | |||
rootEntries = new Vector<String>(); | |||
rootEntries = new Vector<>(); | |||
} | |||
/** | |||
@@ -190,6 +193,7 @@ public class Jar extends Zip { | |||
* @param we not used | |||
* @ant.attribute ignore="true" | |||
*/ | |||
@Override | |||
public void setWhenempty(WhenEmpty we) { | |||
log("JARs are never empty, they contain at least a manifest file", | |||
Project.MSG_WARN); | |||
@@ -225,6 +229,7 @@ public class Jar extends Zip { | |||
* @deprecated since 1.5.x. | |||
* Use setDestFile(File) instead. | |||
*/ | |||
@Deprecated | |||
public void setJarfile(File jarFile) { | |||
setDestFile(jarFile); | |||
} | |||
@@ -301,29 +306,13 @@ public class Jar extends Zip { | |||
} | |||
private Manifest getManifest(File manifestFile) { | |||
Manifest newManifest = null; | |||
InputStream fis = null; | |||
InputStreamReader isr = null; | |||
try { | |||
fis = Files.newInputStream(manifestFile.toPath()); | |||
if (manifestEncoding == null) { | |||
isr = new InputStreamReader(fis); | |||
} else { | |||
isr = new InputStreamReader(fis, manifestEncoding); | |||
} | |||
newManifest = getManifest(isr); | |||
} catch (UnsupportedEncodingException e) { | |||
throw new BuildException("Unsupported encoding while reading manifest: " | |||
+ e.getMessage(), e); | |||
try (InputStreamReader isr = new InputStreamReader( | |||
Files.newInputStream(manifestFile.toPath()), getManifestCharset())) { | |||
return getManifest(isr); | |||
} catch (IOException e) { | |||
throw new BuildException("Unable to read manifest file: " | |||
+ manifestFile | |||
+ " (" + e.getMessage() + ")", e); | |||
} finally { | |||
FileUtils.close(isr); | |||
+ manifestFile + " (" + e.getMessage() + ")", e); | |||
} | |||
return newManifest; | |||
} | |||
/** | |||
@@ -332,32 +321,27 @@ public class Jar extends Zip { | |||
* @since Ant 1.5.2 | |||
*/ | |||
private Manifest getManifestFromJar(File jarFile) throws IOException { | |||
ZipFile zf = null; | |||
try { | |||
zf = new ZipFile(jarFile); | |||
try (ZipFile zf = new ZipFile(jarFile)) { | |||
// must not use getEntry as "well behaving" applications | |||
// must accept the manifest in any capitalization | |||
Enumeration<? extends ZipEntry> e = zf.entries(); | |||
while (e.hasMoreElements()) { | |||
ZipEntry ze = e.nextElement(); | |||
if (ze.getName().equalsIgnoreCase(MANIFEST_NAME)) { | |||
InputStreamReader isr = | |||
new InputStreamReader(zf.getInputStream(ze), "UTF-8"); | |||
return getManifest(isr); | |||
if (MANIFEST_NAME.equalsIgnoreCase(ze.getName())) { | |||
try (InputStreamReader isr = | |||
new InputStreamReader(zf.getInputStream(ze), "UTF-8")) { | |||
return getManifest(isr); | |||
} | |||
} | |||
} | |||
return null; | |||
} finally { | |||
FileUtils.close(zf); | |||
} | |||
} | |||
private Manifest getManifest(Reader r) { | |||
Manifest newManifest = null; | |||
try { | |||
newManifest = new Manifest(r); | |||
return new Manifest(r); | |||
} catch (ManifestException e) { | |||
log("Manifest is invalid: " + e.getMessage(), Project.MSG_ERR); | |||
throw new BuildException("Invalid Manifest: " + manifestFile, | |||
@@ -366,23 +350,18 @@ public class Jar extends Zip { | |||
throw new BuildException("Unable to read manifest file" | |||
+ " (" + e.getMessage() + ")", e); | |||
} | |||
return newManifest; | |||
} | |||
private boolean jarHasIndex(File jarFile) throws IOException { | |||
ZipFile zf = null; | |||
try { | |||
zf = new ZipFile(jarFile); | |||
try (ZipFile zf = new ZipFile(jarFile)) { | |||
Enumeration<? extends ZipEntry> e = zf.entries(); | |||
while (e.hasMoreElements()) { | |||
ZipEntry ze = e.nextElement(); | |||
if (ze.getName().equalsIgnoreCase(INDEX_NAME)) { | |||
if (INDEX_NAME.equalsIgnoreCase(ze.getName())) { | |||
return true; | |||
} | |||
} | |||
return false; | |||
} finally { | |||
FileUtils.close(zf); | |||
} | |||
} | |||
@@ -404,7 +383,7 @@ public class Jar extends Zip { | |||
mergeManifestsMain = config != null && "merge".equals(config.getValue()); | |||
if (filesetManifestConfig != null | |||
&& !filesetManifestConfig.getValue().equals("skip")) { | |||
&& !"skip".equals(filesetManifestConfig.getValue())) { | |||
doubleFilePass = true; | |||
} | |||
@@ -449,19 +428,12 @@ public class Jar extends Zip { | |||
*/ | |||
private void writeServices(ZipOutputStream zOut) throws IOException { | |||
for (Service service : serviceList) { | |||
InputStream is = null; | |||
try { | |||
is = service.getAsStream(); | |||
//stolen from writeManifest | |||
try (InputStream is = service.getAsStream()) { | |||
//stolen from writeManifest | |||
super.zipFile(is, zOut, | |||
"META-INF/services/" + service.getType(), | |||
System.currentTimeMillis(), null, | |||
ZipFileSet.DEFAULT_FILE_MODE); | |||
} finally { | |||
// technically this is unnecessary since | |||
// Service.getAsStream returns a ByteArrayInputStream | |||
// and not closing it wouldn't do any harm. | |||
FileUtils.close(is); | |||
} | |||
} | |||
} | |||
@@ -491,6 +463,7 @@ public class Jar extends Zip { | |||
* @throws IOException on I/O errors | |||
* @throws BuildException on other errors | |||
*/ | |||
@Override | |||
protected void initZipOutputStream(ZipOutputStream zOut) | |||
throws IOException, BuildException { | |||
@@ -504,12 +477,10 @@ public class Jar extends Zip { | |||
private Manifest createManifest() | |||
throws BuildException { | |||
try { | |||
if (manifest == null) { | |||
if (manifestFile != null) { | |||
// if we haven't got the manifest yet, attempt to | |||
// get it now and have manifest be the final merge | |||
manifest = getManifest(manifestFile); | |||
} | |||
if (manifest == null && manifestFile != null) { | |||
// if we haven't got the manifest yet, attempt to | |||
// get it now and have manifest be the final merge | |||
manifest = getManifest(manifestFile); | |||
} | |||
// fileset manifest must come even before the default | |||
@@ -598,6 +569,7 @@ public class Jar extends Zip { | |||
* @throws IOException on I/O errors | |||
* @throws BuildException on other errors | |||
*/ | |||
@Override | |||
protected void finalizeZipOutputStream(ZipOutputStream zOut) | |||
throws IOException, BuildException { | |||
@@ -667,14 +639,10 @@ public class Jar extends Zip { | |||
throw new IOException("Encountered an error writing jar index"); | |||
} | |||
writer.close(); | |||
ByteArrayInputStream bais = | |||
new ByteArrayInputStream(baos.toByteArray()); | |||
try { | |||
try (ByteArrayInputStream bais = | |||
new ByteArrayInputStream(baos.toByteArray())) { | |||
super.zipFile(bais, zOut, INDEX_NAME, System.currentTimeMillis(), | |||
null, ZipFileSet.DEFAULT_FILE_MODE); | |||
} finally { | |||
// not really required | |||
FileUtils.close(bais); | |||
} | |||
} | |||
@@ -690,6 +658,7 @@ public class Jar extends Zip { | |||
* @param mode the Unix permissions to set. | |||
* @throws IOException on error | |||
*/ | |||
@Override | |||
protected void zipFile(InputStream is, ZipOutputStream zOut, String vPath, | |||
long lastModified, File fromArchive, int mode) | |||
throws IOException { | |||
@@ -703,8 +672,8 @@ public class Jar extends Zip { | |||
+ " be replaced by a newly generated one.", | |||
Project.MSG_WARN); | |||
} else { | |||
if (index && vPath.indexOf("/") == -1) { | |||
rootEntries.addElement(vPath); | |||
if (index && vPath.indexOf('/') == -1) { | |||
rootEntries.add(vPath); | |||
} | |||
super.zipFile(is, zOut, vPath, lastModified, fromArchive, mode); | |||
} | |||
@@ -715,40 +684,29 @@ public class Jar extends Zip { | |||
// If this is the same name specified in 'manifest', this | |||
// is the manifest to use | |||
log("Found manifest " + file, Project.MSG_VERBOSE); | |||
try { | |||
if (is != null) { | |||
InputStreamReader isr; | |||
if (manifestEncoding == null) { | |||
isr = new InputStreamReader(is); | |||
} else { | |||
isr = new InputStreamReader(is, manifestEncoding); | |||
} | |||
if (is == null) { | |||
manifest = getManifest(file); | |||
} else { | |||
try (InputStreamReader isr = | |||
new InputStreamReader(is, getManifestCharset())) { | |||
manifest = getManifest(isr); | |||
} else { | |||
manifest = getManifest(file); | |||
} | |||
} catch (UnsupportedEncodingException e) { | |||
throw new BuildException("Unsupported encoding while reading " | |||
+ "manifest: " + e.getMessage(), e); | |||
} | |||
} else if (filesetManifestConfig != null | |||
&& !filesetManifestConfig.getValue().equals("skip")) { | |||
&& !"skip".equals(filesetManifestConfig.getValue())) { | |||
// we add this to our group of fileset manifests | |||
logWhenWriting("Found manifest to merge in file " + file, | |||
Project.MSG_VERBOSE); | |||
try { | |||
Manifest newManifest = null; | |||
if (is != null) { | |||
InputStreamReader isr; | |||
if (manifestEncoding == null) { | |||
isr = new InputStreamReader(is); | |||
} else { | |||
isr = new InputStreamReader(is, manifestEncoding); | |||
} | |||
newManifest = getManifest(isr); | |||
} else { | |||
Manifest newManifest; | |||
if (is == null) { | |||
newManifest = getManifest(file); | |||
} else { | |||
try (InputStreamReader isr = | |||
new InputStreamReader(is, getManifestCharset())) { | |||
newManifest = getManifest(isr); | |||
} | |||
} | |||
if (filesetManifest == null) { | |||
@@ -804,6 +762,7 @@ public class Jar extends Zip { | |||
* | |||
* @exception BuildException if it likes | |||
*/ | |||
@Override | |||
protected ArchiveState getResourcesToAdd(ResourceCollection[] rcs, | |||
File zipFile, | |||
boolean needsUpdate) | |||
@@ -874,33 +833,32 @@ public class Jar extends Zip { | |||
* @return true for historic reasons | |||
* @throws BuildException on error | |||
*/ | |||
@Override | |||
protected boolean createEmptyZip(File zipFile) throws BuildException { | |||
if (!createEmpty) { | |||
return true; | |||
} | |||
if (emptyBehavior.equals("skip")) { | |||
if ("skip".equals(emptyBehavior)) { | |||
if (!skipWriting) { | |||
log("Warning: skipping " + archiveType + " archive " | |||
+ zipFile + " because no files were included.", | |||
Project.MSG_WARN); | |||
} | |||
return true; | |||
} else if (emptyBehavior.equals("fail")) { | |||
} | |||
if ("fail".equals(emptyBehavior)) { | |||
throw new BuildException("Cannot create " + archiveType | |||
+ " archive " + zipFile | |||
+ ": no files were included.", | |||
getLocation()); | |||
} | |||
ZipOutputStream zOut = null; | |||
try { | |||
if (!skipWriting) { | |||
log("Building MANIFEST-only jar: " | |||
if (!skipWriting) { | |||
log("Building MANIFEST-only jar: " | |||
+ getDestFile().getAbsolutePath()); | |||
} | |||
zOut = new ZipOutputStream(getDestFile()); | |||
} | |||
try (ZipOutputStream zOut = new ZipOutputStream(getDestFile())) { | |||
zOut.setEncoding(getEncoding()); | |||
zOut.setUseZip64(getZip64Mode().getMode()); | |||
if (isCompress()) { | |||
@@ -915,8 +873,6 @@ public class Jar extends Zip { | |||
+ " (" + ioe.getMessage() + ")", ioe, | |||
getLocation()); | |||
} finally { | |||
// Close the output stream. | |||
FileUtils.close(zOut); | |||
createEmpty = false; | |||
} | |||
return true; | |||
@@ -928,6 +884,7 @@ public class Jar extends Zip { | |||
* | |||
* @see Zip#cleanUp | |||
*/ | |||
@Override | |||
protected void cleanUp() { | |||
super.cleanUp(); | |||
checkJarSpec(); | |||
@@ -939,7 +896,7 @@ public class Jar extends Zip { | |||
filesetManifest = null; | |||
originalManifest = null; | |||
} | |||
rootEntries.removeAllElements(); | |||
rootEntries.clear(); | |||
} | |||
// CheckStyle:LineLength OFF - Link is too long. | |||
@@ -950,7 +907,7 @@ public class Jar extends Zip { | |||
// CheckStyle:LineLength ON | |||
private void checkJarSpec() { | |||
String br = System.getProperty("line.separator"); | |||
StringBuffer message = new StringBuffer(); | |||
StringBuilder message = new StringBuilder(); | |||
Section mainSection = (configuredManifest == null) | |||
? null | |||
: configuredManifest.getMainSection(); | |||
@@ -975,11 +932,10 @@ public class Jar extends Zip { | |||
message.append(br); | |||
message.append("Location: ").append(getLocation()); | |||
message.append(br); | |||
if (strict.getValue().equalsIgnoreCase("fail")) { | |||
if ("fail".equalsIgnoreCase(strict.getValue())) { | |||
throw new BuildException(message.toString(), getLocation()); | |||
} else { | |||
logWhenWriting(message.toString(), strict.getLogLevel()); | |||
} | |||
logWhenWriting(message.toString(), strict.getLogLevel()); | |||
} | |||
} | |||
@@ -990,6 +946,7 @@ public class Jar extends Zip { | |||
* | |||
* @since 1.44, Ant 1.5 | |||
*/ | |||
@Override | |||
public void reset() { | |||
super.reset(); | |||
emptyBehavior = "create"; | |||
@@ -1008,8 +965,9 @@ public class Jar extends Zip { | |||
* Get the list of valid strings. | |||
* @return the list of values - "skip", "merge" and "mergewithoutmain" | |||
*/ | |||
@Override | |||
public String[] getValues() { | |||
return new String[] {"skip", "merge", "mergewithoutmain"}; | |||
return new String[] { "skip", "merge", "mergewithoutmain" }; | |||
} | |||
} | |||
@@ -1056,9 +1014,7 @@ public class Jar extends Zip { | |||
writer.println(dir); | |||
} | |||
for (String file : files) { | |||
writer.println(file); | |||
} | |||
files.forEach(writer::println); | |||
} | |||
/** | |||
@@ -1084,39 +1040,27 @@ public class Jar extends Zip { | |||
protected static String findJarName(String fileName, | |||
String[] classpath) { | |||
if (classpath == null) { | |||
return (new File(fileName)).getName(); | |||
return new File(fileName).getName(); | |||
} | |||
fileName = fileName.replace(File.separatorChar, '/'); | |||
TreeMap<String, String> matches = new TreeMap<String, String>(new Comparator<Object>() { | |||
// longest match comes first | |||
public int compare(Object o1, Object o2) { | |||
if (o1 instanceof String && o2 instanceof String) { | |||
return ((String) o2).length() | |||
- ((String) o1).length(); | |||
} | |||
return 0; | |||
SortedMap<String, String> matches = new TreeMap<>(Comparator | |||
.<String> comparingInt(s -> s == null ? 0 : s.length()).reversed()); | |||
for (String element : classpath) { | |||
String candidate = element; | |||
while (true) { | |||
if (fileName.endsWith(candidate)) { | |||
matches.put(candidate, element); | |||
break; | |||
} | |||
}); | |||
for (int i = 0; i < classpath.length; i++) { | |||
if (fileName.endsWith(classpath[i])) { | |||
matches.put(classpath[i], classpath[i]); | |||
} else { | |||
int slash = classpath[i].indexOf("/"); | |||
String candidate = classpath[i]; | |||
while (slash > -1) { | |||
candidate = candidate.substring(slash + 1); | |||
if (fileName.endsWith(candidate)) { | |||
matches.put(candidate, classpath[i]); | |||
break; | |||
} | |||
slash = candidate.indexOf("/"); | |||
int slash = candidate.indexOf('/'); | |||
if (slash < 0) { | |||
break; | |||
} | |||
candidate = candidate.substring(slash + 1); | |||
} | |||
} | |||
return matches.size() == 0 | |||
? null : (String) matches.get(matches.firstKey()); | |||
return matches.isEmpty() ? null : matches.get(matches.firstKey()); | |||
} | |||
/** | |||
@@ -1133,21 +1077,21 @@ public class Jar extends Zip { | |||
throws IOException { | |||
try (org.apache.tools.zip.ZipFile zf = new org.apache.tools.zip.ZipFile(file, "utf-8")) { | |||
Enumeration<org.apache.tools.zip.ZipEntry> entries = zf.getEntries(); | |||
HashSet<String> dirSet = new HashSet<String>(); | |||
Set<String> dirSet = new HashSet<>(); | |||
while (entries.hasMoreElements()) { | |||
org.apache.tools.zip.ZipEntry ze = | |||
entries.nextElement(); | |||
String name = ze.getName(); | |||
if (ze.isDirectory()) { | |||
dirSet.add(name); | |||
} else if (name.indexOf("/") == -1) { | |||
} else if (name.indexOf('/') == -1) { | |||
files.add(name); | |||
} else { | |||
// a file, not in the root | |||
// since the jar may be one without directory | |||
// entries, add the parent dir of this file as | |||
// well. | |||
dirSet.add(name.substring(0, name.lastIndexOf("/") + 1)); | |||
dirSet.add(name.substring(0, name.lastIndexOf('/') + 1)); | |||
} | |||
} | |||
dirs.addAll(dirSet); | |||
@@ -1157,13 +1101,12 @@ public class Jar extends Zip { | |||
private Resource[][] grabManifests(ResourceCollection[] rcs) { | |||
Resource[][] manifests = new Resource[rcs.length][]; | |||
for (int i = 0; i < rcs.length; i++) { | |||
Resource[][] resources = null; | |||
Resource[][] resources; | |||
if (rcs[i] instanceof FileSet) { | |||
resources = grabResources(new FileSet[] {(FileSet) rcs[i]}); | |||
resources = grabResources(new FileSet[] { (FileSet) rcs[i] }); | |||
} else { | |||
resources = grabNonFileSetResources(new ResourceCollection[] { | |||
rcs[i] | |||
}); | |||
resources = grabNonFileSetResources( | |||
new ResourceCollection[] { rcs[i] }); | |||
} | |||
for (int j = 0; j < resources[0].length; j++) { | |||
String name = resources[0][j].getName().replace('\\', '/'); | |||
@@ -1179,7 +1122,7 @@ public class Jar extends Zip { | |||
name = prefix + name; | |||
} | |||
} | |||
if (name.equalsIgnoreCase(MANIFEST_NAME)) { | |||
if (MANIFEST_NAME.equalsIgnoreCase(name)) { | |||
manifests[i] = new Resource[] {resources[0][j]}; | |||
break; | |||
} | |||
@@ -1191,11 +1134,26 @@ public class Jar extends Zip { | |||
return manifests; | |||
} | |||
private Charset getManifestCharset() { | |||
if (manifestEncoding == null) { | |||
return Charset.defaultCharset(); | |||
} | |||
try { | |||
return Charset.forName(manifestEncoding); | |||
} catch (IllegalArgumentException e) { | |||
throw new BuildException( | |||
"Unsupported encoding while reading manifest: " | |||
+ e.getMessage(), | |||
e); | |||
} | |||
} | |||
/** The strict enumerated type. */ | |||
public static class StrictMode extends EnumeratedAttribute { | |||
/** Public no arg constructor. */ | |||
public StrictMode() { | |||
} | |||
/** | |||
* Constructor with an arg. | |||
* @param value the enumerated value as a string. | |||
@@ -1203,18 +1161,21 @@ public class Jar extends Zip { | |||
public StrictMode(String value) { | |||
setValue(value); | |||
} | |||
/** | |||
* Get List of valid strings. | |||
* @return the list of values. | |||
*/ | |||
@Override | |||
public String[] getValues() { | |||
return new String[]{"fail", "warn", "ignore"}; | |||
return new String[] { "fail", "warn", "ignore" }; | |||
} | |||
/** | |||
* @return The log level according to the strict mode. | |||
*/ | |||
public int getLogLevel() { | |||
return (getValue().equals("ignore")) ? Project.MSG_VERBOSE : Project.MSG_WARN; | |||
return "ignore".equals(getValue()) ? Project.MSG_VERBOSE : Project.MSG_WARN; | |||
} | |||
} | |||
} |
@@ -20,8 +20,6 @@ package org.apache.tools.ant.taskdefs; | |||
import java.io.File; | |||
import java.io.IOException; | |||
import java.io.PrintWriter; | |||
import java.io.StringWriter; | |||
import java.util.Vector; | |||
import org.apache.tools.ant.BuildException; | |||
@@ -52,6 +50,8 @@ import org.apache.tools.ant.util.StringUtils; | |||
* @ant.task category="java" | |||
*/ | |||
public class Java extends Task { | |||
private static final String TIMEOUT_MESSAGE = | |||
"Timeout: killed the sub-process"; | |||
private CommandlineJava cmdl = new CommandlineJava(); | |||
private Environment env = new Environment(); | |||
@@ -78,9 +78,6 @@ public class Java extends Task { | |||
private boolean spawn = false; | |||
private boolean incompatibleWithSpawn = false; | |||
private static final String TIMEOUT_MESSAGE = | |||
"Timeout: killed the sub-process"; | |||
/** | |||
* Normal constructor | |||
*/ | |||
@@ -100,6 +97,7 @@ public class Java extends Task { | |||
* @throws BuildException if failOnError is set to true and the application | |||
* returns a nonzero result code. | |||
*/ | |||
@Override | |||
public void execute() throws BuildException { | |||
File savedDir = dir; | |||
Permissions savedPermissions = perm; | |||
@@ -148,30 +146,32 @@ public class Java extends Task { | |||
throw new BuildException("Classname must not be null."); | |||
} | |||
if (!fork && getCommandLine().getJar() != null) { | |||
throw new BuildException("Cannot execute a jar in non-forked mode." | |||
+ " Please set fork='true'. "); | |||
throw new BuildException( | |||
"Cannot execute a jar in non-forked mode. Please set fork='true'. "); | |||
} | |||
if (!fork && getCommandLine().getModule() != null) { | |||
throw new BuildException("Cannot execute a module in non-forked mode." | |||
+ " Please set fork='true'. "); | |||
throw new BuildException( | |||
"Cannot execute a module in non-forked mode. Please set fork='true'. "); | |||
} | |||
if (spawn && !fork) { | |||
throw new BuildException("Cannot spawn a java process in non-forked mode." | |||
+ " Please set fork='true'. "); | |||
throw new BuildException( | |||
"Cannot spawn a java process in non-forked mode. Please set fork='true'. "); | |||
} | |||
if (getCommandLine().getClasspath() != null | |||
&& getCommandLine().getJar() != null) { | |||
log("When using 'jar' attribute classpath-settings are ignored. " | |||
+ "See the manual for more information.", Project.MSG_VERBOSE); | |||
log("When using 'jar' attribute classpath-settings are ignored. See the manual for more information.", | |||
Project.MSG_VERBOSE); | |||
} | |||
if (spawn && incompatibleWithSpawn) { | |||
getProject().log("spawn does not allow attributes related to input, " | |||
+ "output, error, result", Project.MSG_ERR); | |||
getProject().log( | |||
"spawn does not allow attributes related to input, output, error, result", | |||
Project.MSG_ERR); | |||
getProject().log("spawn also does not allow timeout", Project.MSG_ERR); | |||
getProject().log("finally, spawn is not compatible " | |||
+ "with a nested I/O <redirector>", Project.MSG_ERR); | |||
throw new BuildException("You have used an attribute " | |||
+ "or nested element which is not compatible with spawn"); | |||
getProject().log( | |||
"finally, spawn is not compatible with a nested I/O <redirector>", | |||
Project.MSG_ERR); | |||
throw new BuildException( | |||
"You have used an attribute or nested element which is not compatible with spawn"); | |||
} | |||
if (getCommandLine().getAssertions() != null && !fork) { | |||
log("Assertion statements are currently ignored in non-forked mode"); | |||
@@ -191,8 +191,8 @@ public class Java extends Task { | |||
Project.MSG_WARN); | |||
} | |||
if (newEnvironment || null != env.getVariables()) { | |||
log("Changes to environment variables are ignored when same " | |||
+ "JVM is used.", Project.MSG_WARN); | |||
log("Changes to environment variables are ignored when same JVM is used.", | |||
Project.MSG_WARN); | |||
} | |||
if (getCommandLine().getBootclasspath() != null) { | |||
log("bootclasspath ignored when same JVM is used.", | |||
@@ -217,19 +217,17 @@ public class Java extends Task { | |||
protected int executeJava(CommandlineJava commandLine) { | |||
try { | |||
if (fork) { | |||
if (!spawn) { | |||
return fork(commandLine.getCommandline()); | |||
} else { | |||
if (spawn) { | |||
spawn(commandLine.getCommandline()); | |||
return 0; | |||
} | |||
} else { | |||
try { | |||
run(commandLine); | |||
return 0; | |||
} catch (ExitException ex) { | |||
return ex.getStatus(); | |||
} | |||
return fork(commandLine.getCommandline()); | |||
} | |||
try { | |||
run(commandLine); | |||
return 0; | |||
} catch (ExitException ex) { | |||
return ex.getStatus(); | |||
} | |||
} catch (BuildException e) { | |||
if (e.getLocation() == null && getLocation() != null) { | |||
@@ -237,23 +235,21 @@ public class Java extends Task { | |||
} | |||
if (failOnError) { | |||
throw e; | |||
} | |||
if (TIMEOUT_MESSAGE.equals(e.getMessage())) { | |||
log(TIMEOUT_MESSAGE); | |||
} else { | |||
if (TIMEOUT_MESSAGE.equals(e.getMessage())) { | |||
log(TIMEOUT_MESSAGE); | |||
} else { | |||
log(e); | |||
} | |||
return -1; | |||
log(e); | |||
} | |||
return -1; | |||
} catch (ThreadDeath t) { | |||
throw t; // cf. NB #47191 | |||
} catch (Throwable t) { | |||
if (failOnError) { | |||
throw new BuildException(t, getLocation()); | |||
} else { | |||
log(t); | |||
return -1; | |||
} | |||
log(t); | |||
return -1; | |||
} | |||
} | |||
@@ -363,8 +359,8 @@ public class Java extends Task { | |||
*/ | |||
public void setJar(File jarfile) throws BuildException { | |||
if (getCommandLine().getClassname() != null || getCommandLine().getModule() != null) { | |||
throw new BuildException("Cannot use 'jar' with 'classname' or 'module' " | |||
+ "attributes in same command."); | |||
throw new BuildException( | |||
"Cannot use 'jar' with 'classname' or 'module' attributes in same command."); | |||
} | |||
getCommandLine().setJar(jarfile.getAbsolutePath()); | |||
} | |||
@@ -378,8 +374,8 @@ public class Java extends Task { | |||
*/ | |||
public void setClassname(String s) throws BuildException { | |||
if (getCommandLine().getJar() != null) { | |||
throw new BuildException("Cannot use 'jar' and 'classname' " | |||
+ "attributes in same command"); | |||
throw new BuildException( | |||
"Cannot use 'jar' and 'classname' attributes in same command"); | |||
} | |||
getCommandLine().setClassname(s); | |||
} | |||
@@ -394,8 +390,8 @@ public class Java extends Task { | |||
*/ | |||
public void setModule(String module) throws BuildException { | |||
if (getCommandLine().getJar() != null) { | |||
throw new BuildException("Cannot use 'jar' and 'module' " | |||
+ "attributes in same command"); | |||
throw new BuildException( | |||
"Cannot use 'jar' and 'module' attributes in same command"); | |||
} | |||
getCommandLine().setModule(module); | |||
} | |||
@@ -409,8 +405,8 @@ public class Java extends Task { | |||
* @ant.attribute ignore="true" | |||
*/ | |||
public void setArgs(String s) { | |||
log("The args attribute is deprecated. " | |||
+ "Please use nested arg elements.", Project.MSG_WARN); | |||
log("The args attribute is deprecated. Please use nested arg elements.", | |||
Project.MSG_WARN); | |||
getCommandLine().createArgument().setLine(s); | |||
} | |||
@@ -477,8 +473,8 @@ public class Java extends Task { | |||
* @param s jvmargs. | |||
*/ | |||
public void setJvmargs(String s) { | |||
log("The jvmargs attribute is deprecated. " | |||
+ "Please use nested jvmarg elements.", Project.MSG_WARN); | |||
log("The jvmargs attribute is deprecated. Please use nested jvmarg elements.", | |||
Project.MSG_WARN); | |||
getCommandLine().createVmArgument().setLine(s); | |||
} | |||
@@ -559,8 +555,8 @@ public class Java extends Task { | |||
*/ | |||
public void setInput(File input) { | |||
if (inputString != null) { | |||
throw new BuildException("The \"input\" and \"inputstring\" " | |||
+ "attributes cannot both be specified"); | |||
throw new BuildException( | |||
"The \"input\" and \"inputstring\" attributes cannot both be specified"); | |||
} | |||
this.input = input; | |||
incompatibleWithSpawn = true; | |||
@@ -573,8 +569,8 @@ public class Java extends Task { | |||
*/ | |||
public void setInputString(String inputString) { | |||
if (input != null) { | |||
throw new BuildException("The \"input\" and \"inputstring\" " | |||
+ "attributes cannot both be specified"); | |||
throw new BuildException( | |||
"The \"input\" and \"inputstring\" attributes cannot both be specified"); | |||
} | |||
this.inputString = inputString; | |||
incompatibleWithSpawn = true; | |||
@@ -728,6 +724,7 @@ public class Java extends Task { | |||
* | |||
* @since Ant 1.5 | |||
*/ | |||
@Override | |||
protected void handleOutput(String output) { | |||
if (redirector.getOutputStream() != null) { | |||
redirector.handleOutput(output); | |||
@@ -748,6 +745,7 @@ public class Java extends Task { | |||
* @exception IOException if the data cannot be read. | |||
* @since Ant 1.6 | |||
*/ | |||
@Override | |||
public int handleInput(byte[] buffer, int offset, int length) | |||
throws IOException { | |||
// Should work whether or not redirector.inputStream == null: | |||
@@ -761,6 +759,7 @@ public class Java extends Task { | |||
* | |||
* @since Ant 1.5.2 | |||
*/ | |||
@Override | |||
protected void handleFlush(String output) { | |||
if (redirector.getOutputStream() != null) { | |||
redirector.handleFlush(output); | |||
@@ -776,6 +775,7 @@ public class Java extends Task { | |||
* | |||
* @since Ant 1.5 | |||
*/ | |||
@Override | |||
protected void handleErrorOutput(String output) { | |||
if (redirector.getErrorStream() != null) { | |||
redirector.handleErrorOutput(output); | |||
@@ -791,6 +791,7 @@ public class Java extends Task { | |||
* | |||
* @since Ant 1.5.2 | |||
*/ | |||
@Override | |||
protected void handleErrorFlush(String output) { | |||
if (redirector.getErrorStream() != null) { | |||
redirector.handleErrorFlush(output); | |||
@@ -897,8 +898,8 @@ public class Java extends Task { | |||
private void setupEnvironment(Execute exe) { | |||
String[] environment = env.getVariables(); | |||
if (environment != null) { | |||
for (int i = 0; i < environment.length; i++) { | |||
log("Setting environment variable: " + environment[i], | |||
for (String element : environment) { | |||
log("Setting environment variable: " + element, | |||
Project.MSG_VERBOSE); | |||
} | |||
} | |||
@@ -914,7 +915,7 @@ public class Java extends Task { | |||
private void setupWorkingDir(Execute exe) { | |||
if (dir == null) { | |||
dir = getProject().getBaseDir(); | |||
} else if (!dir.exists() || !dir.isDirectory()) { | |||
} else if (!dir.isDirectory()) { | |||
throw new BuildException(dir.getAbsolutePath() | |||
+ " is not a valid directory", | |||
getLocation()); | |||
@@ -962,10 +963,7 @@ public class Java extends Task { | |||
protected void run(String classname, Vector<String> args) throws BuildException { | |||
CommandlineJava cmdj = new CommandlineJava(); | |||
cmdj.setClassname(classname); | |||
final int size = args.size(); | |||
for (int i = 0; i < size; i++) { | |||
cmdj.createArgument().setValue(args.elementAt(i)); | |||
} | |||
args.forEach(arg -> cmdj.createArgument().setValue(arg)); | |||
run(cmdj); | |||
} | |||
@@ -19,7 +19,6 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.File; | |||
import java.io.FileFilter; | |||
import java.io.IOException; | |||
import java.io.OutputStream; | |||
import java.nio.file.Files; | |||
@@ -28,7 +27,6 @@ import java.util.Collection; | |||
import java.util.HashMap; | |||
import java.util.List; | |||
import java.util.Map; | |||
import java.util.Map.Entry; | |||
import java.util.TreeMap; | |||
import org.apache.tools.ant.BuildException; | |||
@@ -138,7 +136,7 @@ public class Javac extends MatchingTask { | |||
protected boolean failOnError = true; | |||
protected boolean listFiles = false; | |||
protected File[] compileList = new File[0]; | |||
private Map<String, Long> packageInfos = new HashMap<String, Long>(); | |||
private Map<String, Long> packageInfos = new HashMap<>(); | |||
// CheckStyle:VisibilityModifier ON | |||
private String source; | |||
@@ -162,19 +160,23 @@ public class Javac extends MatchingTask { | |||
private String assumedJavaVersion() { | |||
if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_4)) { | |||
return JAVAC14; | |||
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5)) { | |||
} | |||
if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5)) { | |||
return JAVAC15; | |||
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6)) { | |||
} | |||
if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6)) { | |||
return JAVAC16; | |||
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_7)) { | |||
} | |||
if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_7)) { | |||
return JAVAC17; | |||
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_8)) { | |||
} | |||
if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_8)) { | |||
return JAVAC18; | |||
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_9)) { | |||
} | |||
if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_9)) { | |||
return JAVAC9; | |||
} else { | |||
return CLASSIC; | |||
} | |||
return CLASSIC; | |||
} | |||
/** | |||
@@ -1083,8 +1085,8 @@ public class Javac extends MatchingTask { | |||
*/ | |||
public void add(final CompilerAdapter adapter) { | |||
if (nestedAdapter != null) { | |||
throw new BuildException("Can't have more than one compiler" | |||
+ " adapter"); | |||
throw new BuildException( | |||
"Can't have more than one compiler adapter"); | |||
} | |||
nestedAdapter = adapter; | |||
} | |||
@@ -1131,7 +1133,7 @@ public class Javac extends MatchingTask { | |||
*/ | |||
protected void resetFileLists() { | |||
compileList = new File[0]; | |||
packageInfos = new HashMap<String, Long>(); | |||
packageInfos = new HashMap<>(); | |||
} | |||
/** | |||
@@ -1146,8 +1148,8 @@ public class Javac extends MatchingTask { | |||
final GlobPatternMapper m = new GlobPatternMapper(); | |||
final String[] extensions = findSupportedFileExtensions(); | |||
for (int i = 0; i < extensions.length; i++) { | |||
m.setFrom(extensions[i]); | |||
for (String extension : extensions) { | |||
m.setFrom(extension); | |||
m.setTo("*.class"); | |||
final SourceFileScanner sfs = new SourceFileScanner(this); | |||
final File[] newFiles = sfs.restrictAsFiles(files, srcDir, destDir, m); | |||
@@ -1186,7 +1188,8 @@ public class Javac extends MatchingTask { | |||
final FileUtils fu = FileUtils.getFileUtils(); | |||
for (String pathElement : moduleSourcepath.list()) { | |||
boolean valid = false; | |||
for (Map.Entry<String,Collection<File>> modules : resolveModuleSourcePathElement(getProject().getBaseDir(), pathElement).entrySet()) { | |||
for (Map.Entry<String, Collection<File>> modules : resolveModuleSourcePathElement( | |||
getProject().getBaseDir(), pathElement).entrySet()) { | |||
final String moduleName = modules.getKey(); | |||
for (File srcDir : modules.getValue()) { | |||
if (srcDir.exists()) { | |||
@@ -1218,7 +1221,7 @@ public class Javac extends MatchingTask { | |||
} | |||
if (extensions == null) { | |||
extensions = new String[] {"java"}; | |||
extensions = new String[] { "java" }; | |||
} | |||
// now process the extensions to ensure that they are the | |||
@@ -1297,8 +1300,8 @@ public class Javac extends MatchingTask { | |||
if (isJdkCompiler(compilerImpl)) { | |||
compilerImpl = EXTJAVAC; | |||
} else { | |||
log("Since compiler setting isn't classic or modern, " | |||
+ "ignoring fork setting.", Project.MSG_WARN); | |||
log("Since compiler setting isn't classic or modern, ignoring fork setting.", | |||
Project.MSG_WARN); | |||
} | |||
} | |||
return compilerImpl; | |||
@@ -1353,13 +1356,12 @@ public class Javac extends MatchingTask { | |||
if (destDir != null && !destDir.isDirectory()) { | |||
throw new BuildException("destination directory \"" | |||
+ destDir | |||
+ "\" does not exist " | |||
+ "or is not a directory", getLocation()); | |||
+ "\" does not exist or is not a directory", getLocation()); | |||
} | |||
if (includeAntRuntime == null && getProject().getProperty("build.sysclasspath") == null) { | |||
log(getLocation() + "warning: 'includeantruntime' was not set, " + | |||
"defaulting to build.sysclasspath=last; set to false for repeatable builds", | |||
Project.MSG_WARN); | |||
log(getLocation() | |||
+ "warning: 'includeantruntime' was not set, defaulting to build.sysclasspath=last; set to false for repeatable builds", | |||
Project.MSG_WARN); | |||
} | |||
} | |||
@@ -1377,9 +1379,8 @@ public class Javac extends MatchingTask { | |||
+ (destDir != null ? " to " + destDir : "")); | |||
if (listFiles) { | |||
for (int i = 0; i < compileList.length; i++) { | |||
final String filename = compileList[i].getAbsolutePath(); | |||
log(filename); | |||
for (File element : compileList) { | |||
log(element.getAbsolutePath()); | |||
} | |||
} | |||
@@ -1414,9 +1415,8 @@ public class Javac extends MatchingTask { | |||
} | |||
if (failOnError) { | |||
throw new BuildException(FAIL_MSG, getLocation()); | |||
} else { | |||
log(FAIL_MSG, Project.MSG_ERR); | |||
} | |||
log(FAIL_MSG, Project.MSG_ERR); | |||
} | |||
} | |||
} | |||
@@ -1438,9 +1438,8 @@ public class Javac extends MatchingTask { | |||
} | |||
private void lookForPackageInfos(final File srcDir, final File[] newFiles) { | |||
for (int i = 0; i < newFiles.length; i++) { | |||
final File f = newFiles[i]; | |||
if (!f.getName().equals("package-info.java")) { | |||
for (File f : newFiles) { | |||
if (!"package-info.java".equals(f.getName())) { | |||
continue; | |||
} | |||
final String path = FILE_UTILS.removeLeadingPath(srcDir, f). | |||
@@ -1451,7 +1450,7 @@ public class Javac extends MatchingTask { | |||
continue; | |||
} | |||
final String pkg = path.substring(0, path.length() - suffix.length()); | |||
packageInfos.put(pkg, new Long(f.lastModified())); | |||
packageInfos.put(pkg, Long.valueOf(f.lastModified())); | |||
} | |||
} | |||
@@ -1461,7 +1460,7 @@ public class Javac extends MatchingTask { | |||
* @see <a href="https://issues.apache.org/bugzilla/show_bug.cgi?id=43114">Bug #43114</a> | |||
*/ | |||
private void generateMissingPackageInfoClasses(final File dest) throws IOException { | |||
for (final Entry<String, Long> entry : packageInfos.entrySet()) { | |||
for (final Map.Entry<String, Long> entry : packageInfos.entrySet()) { | |||
final String pkg = entry.getKey(); | |||
final Long sourceLastMod = entry.getValue(); | |||
final File pkgBinDir = new File(dest, pkg.replace('/', File.separatorChar)); | |||
@@ -1490,7 +1489,7 @@ public class Javac extends MatchingTask { | |||
* @since 1.9.7 | |||
*/ | |||
private static boolean hasPath(final Path path) { | |||
return path != null && path.size() > 0; | |||
return path != null && !path.isEmpty(); | |||
} | |||
/** | |||
@@ -1524,7 +1523,7 @@ public class Javac extends MatchingTask { | |||
*/ | |||
private static Collection<? extends CharSequence> expandGroups( | |||
final CharSequence element) { | |||
List<StringBuilder> result = new ArrayList<StringBuilder>(); | |||
List<StringBuilder> result = new ArrayList<>(); | |||
result.add(new StringBuilder()); | |||
StringBuilder resolved = new StringBuilder(); | |||
for (int i = 0; i < element.length(); i++) { | |||
@@ -1547,7 +1546,7 @@ public class Javac extends MatchingTask { | |||
break; | |||
default: | |||
final List<StringBuilder> oldRes = result; | |||
result = new ArrayList<StringBuilder>(oldRes.size() * parts.size()); | |||
result = new ArrayList<>(oldRes.size() * parts.size()); | |||
for (CharSequence part : parts) { | |||
for (CharSequence prefix : oldRes) { | |||
result.add(new StringBuilder(prefix).append(resolved).append(part)); | |||
@@ -1574,7 +1573,7 @@ public class Javac extends MatchingTask { | |||
* @since 1.9.7 | |||
*/ | |||
private static Collection<? extends CharSequence> resolveGroup(final CharSequence group) { | |||
final Collection<CharSequence> result = new ArrayList<CharSequence>(); | |||
final Collection<CharSequence> result = new ArrayList<>(); | |||
int start = 0; | |||
int depth = 0; | |||
for (int i = 0; i < group.length(); i++) { | |||
@@ -1643,26 +1642,26 @@ public class Javac extends MatchingTask { | |||
final int startIndex = pattern.indexOf(MODULE_MARKER); | |||
if (startIndex == -1) { | |||
findModules(root, pattern, null, collector); | |||
} else { | |||
if (startIndex == 0) { | |||
throw new BuildException("The modulesourcepath entry must be a folder."); | |||
} | |||
final int endIndex = startIndex + MODULE_MARKER.length(); | |||
if (pattern.charAt(startIndex - 1) != File.separatorChar) { | |||
throw new BuildException("The module mark must be preceded by separator"); | |||
} | |||
if (endIndex < pattern.length() && pattern.charAt(endIndex) != File.separatorChar) { | |||
throw new BuildException("The module mark must be followed by separator"); | |||
} | |||
if (pattern.indexOf(MODULE_MARKER, endIndex) != -1) { | |||
throw new BuildException("The modulesourcepath entry must contain at most one module mark"); | |||
} | |||
final String pathToModule = pattern.substring(0, startIndex); | |||
final String pathInModule = endIndex == pattern.length() ? | |||
null : | |||
pattern.substring(endIndex + 1); //+1 the separator | |||
findModules(root, pathToModule, pathInModule, collector); | |||
return; | |||
} | |||
if (startIndex == 0) { | |||
throw new BuildException("The modulesourcepath entry must be a folder."); | |||
} | |||
final int endIndex = startIndex + MODULE_MARKER.length(); | |||
if (pattern.charAt(startIndex - 1) != File.separatorChar) { | |||
throw new BuildException("The module mark must be preceded by separator"); | |||
} | |||
if (endIndex < pattern.length() && pattern.charAt(endIndex) != File.separatorChar) { | |||
throw new BuildException("The module mark must be followed by separator"); | |||
} | |||
if (pattern.indexOf(MODULE_MARKER, endIndex) != -1) { | |||
throw new BuildException("The modulesourcepath entry must contain at most one module mark"); | |||
} | |||
final String pathToModule = pattern.substring(0, startIndex); | |||
final String pathInModule = endIndex == pattern.length() ? | |||
null : | |||
pattern.substring(endIndex + 1); //+1 the separator | |||
findModules(root, pathToModule, pathInModule, collector); | |||
} | |||
/** | |||
@@ -1683,19 +1682,14 @@ public class Javac extends MatchingTask { | |||
if (!f.isDirectory()) { | |||
return; | |||
} | |||
final File[] modules = f.listFiles(new FileFilter() { | |||
public boolean accept(File pathname) { | |||
return pathname.isDirectory(); | |||
} | |||
}); | |||
for (File module : modules) { | |||
for (File module : f.listFiles(File::isDirectory)) { | |||
final String moduleName = module.getName(); | |||
final File moduleSourceRoot = pathInModule == null ? | |||
module : | |||
new File(module, pathInModule); | |||
Collection<File> moduleRoots = collector.get(moduleName); | |||
if (moduleRoots == null) { | |||
moduleRoots = new ArrayList<File>(); | |||
moduleRoots = new ArrayList<>(); | |||
collector.put(moduleName, moduleRoots); | |||
} | |||
moduleRoots.add(moduleSourceRoot); | |||
@@ -108,7 +108,7 @@ public class Length extends Task implements Condition { | |||
* @param ell the long length to compare with. | |||
*/ | |||
public synchronized void setLength(long ell) { | |||
length = new Long(ell); | |||
length = Long.valueOf(ell); | |||
} | |||
/** | |||
@@ -152,7 +152,7 @@ public class Length extends Task implements Condition { | |||
* @param trim <code>boolean</code>. | |||
*/ | |||
public synchronized void setTrim(boolean trim) { | |||
this.trim = trim ? Boolean.TRUE : Boolean.FALSE; | |||
this.trim = Boolean.valueOf(trim); | |||
} | |||
/** | |||
@@ -160,25 +160,31 @@ public class Length extends Task implements Condition { | |||
* @return boolean trim setting. | |||
*/ | |||
public boolean getTrim() { | |||
return trim != null && trim.booleanValue(); | |||
return Boolean.TRUE.equals(trim); | |||
} | |||
/** | |||
* Execute the length task. | |||
*/ | |||
@Override | |||
public void execute() { | |||
validate(); | |||
PrintStream ps = new PrintStream((property != null) | |||
? (OutputStream) new PropertyOutputStream(getProject(), property) | |||
: (OutputStream) new LogOutputStream(this, Project.MSG_INFO)); | |||
OutputStream out = | |||
property == null ? new LogOutputStream(this, Project.MSG_INFO) | |||
: new PropertyOutputStream(getProject(), property); | |||
PrintStream ps = new PrintStream(out); | |||
if (STRING.equals(mode)) { | |||
switch (mode) { | |||
case STRING: | |||
ps.print(getLength(string, getTrim())); | |||
ps.close(); | |||
} else if (EACH.equals(mode)) { | |||
break; | |||
case EACH: | |||
handleResources(new EachHandler(ps)); | |||
} else if (ALL.equals(mode)) { | |||
break; | |||
case ALL: | |||
handleResources(new AllHandler(ps)); | |||
break; | |||
} | |||
} | |||
@@ -187,6 +193,7 @@ public class Length extends Task implements Condition { | |||
* @return true if the condition is true. | |||
* @throws BuildException if an error occurs. | |||
*/ | |||
@Override | |||
public boolean eval() { | |||
validate(); | |||
if (length == null) { | |||
@@ -194,11 +201,11 @@ public class Length extends Task implements Condition { | |||
} | |||
Long ell; | |||
if (STRING.equals(mode)) { | |||
ell = new Long(getLength(string, getTrim())); | |||
ell = Long.valueOf(getLength(string, getTrim())); | |||
} else { | |||
AccumHandler h = new AccumHandler(); | |||
handleResources(h); | |||
ell = new Long(h.getAccum()); | |||
ell = Long.valueOf(h.getAccum()); | |||
} | |||
return when.evaluate(ell.compareTo(length)); | |||
} | |||
@@ -206,25 +213,26 @@ public class Length extends Task implements Condition { | |||
private void validate() { | |||
if (string != null) { | |||
if (resources != null) { | |||
throw new BuildException("the string length function" | |||
+ " is incompatible with the file/resource length function"); | |||
throw new BuildException( | |||
"the string length function is incompatible with the file/resource length function"); | |||
} | |||
if (!(STRING.equals(mode))) { | |||
throw new BuildException("the mode attribute is for use" | |||
+ " with the file/resource length function"); | |||
throw new BuildException( | |||
"the mode attribute is for use with the file/resource length function"); | |||
} | |||
} else if (resources != null) { | |||
if (!(EACH.equals(mode) || ALL.equals(mode))) { | |||
throw new BuildException("invalid mode setting for" | |||
+ " file/resource length function: \"" + mode + "\""); | |||
} else if (trim != null) { | |||
throw new BuildException("the trim attribute is" | |||
+ " for use with the string length function only"); | |||
throw new BuildException( | |||
"invalid mode setting for file/resource length function: \"" | |||
+ mode + "\""); | |||
} | |||
if (trim != null) { | |||
throw new BuildException( | |||
"the trim attribute is for use with the string length function only"); | |||
} | |||
} else { | |||
throw new BuildException("you must set either the string attribute" | |||
+ " or specify one or more files using the file attribute or" | |||
+ " nested resource collections"); | |||
throw new BuildException( | |||
"you must set either the string attribute or specify one or more files using the file attribute or nested resource collections"); | |||
} | |||
} | |||
@@ -247,12 +255,13 @@ public class Length extends Task implements Condition { | |||
/** EnumeratedAttribute operation mode */ | |||
public static class FileMode extends EnumeratedAttribute { | |||
static final String[] MODES = new String[] {EACH, ALL}; //NOSONAR | |||
static final String[] MODES = new String[] { EACH, ALL }; //NOSONAR | |||
/** | |||
* Return the possible values for FileMode. | |||
* @return <code>String[]</code>. | |||
*/ | |||
@Override | |||
public String[] getValues() { | |||
return MODES; | |||
} | |||
@@ -268,6 +277,7 @@ public class Length extends Task implements Condition { | |||
private abstract class Handler { | |||
private PrintStream ps; | |||
Handler(PrintStream ps) { | |||
this.ps = ps; | |||
} | |||
@@ -287,6 +297,8 @@ public class Length extends Task implements Condition { | |||
EachHandler(PrintStream ps) { | |||
super(ps); | |||
} | |||
@Override | |||
protected void handle(Resource r) { | |||
getPs().print(r.toString()); | |||
getPs().print(" : "); | |||
@@ -306,12 +318,16 @@ public class Length extends Task implements Condition { | |||
AccumHandler() { | |||
super(null); | |||
} | |||
protected AccumHandler(PrintStream ps) { | |||
super(ps); | |||
} | |||
protected long getAccum() { | |||
return accum; | |||
} | |||
@Override | |||
protected synchronized void handle(Resource r) { | |||
long size = r.getSize(); | |||
if (size == Resource.UNKNOWN_SIZE) { | |||
@@ -326,6 +342,8 @@ public class Length extends Task implements Condition { | |||
AllHandler(PrintStream ps) { | |||
super(ps); | |||
} | |||
@Override | |||
void complete() { | |||
getPs().print(getAccum()); | |||
super.complete(); | |||
@@ -17,12 +17,12 @@ | |||
*/ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.BufferedInputStream; | |||
import java.io.ByteArrayInputStream; | |||
import java.io.File; | |||
import java.io.IOException; | |||
import java.io.InputStreamReader; | |||
import java.io.Reader; | |||
import java.nio.charset.Charset; | |||
import java.util.List; | |||
import java.util.Properties; | |||
import java.util.Vector; | |||
@@ -30,6 +30,7 @@ import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.Project; | |||
import org.apache.tools.ant.Task; | |||
import org.apache.tools.ant.filters.util.ChainReaderHelper; | |||
import org.apache.tools.ant.filters.util.ChainReaderHelper.ChainReader; | |||
import org.apache.tools.ant.types.FilterChain; | |||
import org.apache.tools.ant.types.Path; | |||
import org.apache.tools.ant.types.Reference; | |||
@@ -37,7 +38,6 @@ import org.apache.tools.ant.types.Resource; | |||
import org.apache.tools.ant.types.ResourceCollection; | |||
import org.apache.tools.ant.types.resources.FileResource; | |||
import org.apache.tools.ant.types.resources.JavaResource; | |||
import org.apache.tools.ant.util.FileUtils; | |||
import org.apache.tools.ant.util.ResourceUtils; | |||
/** | |||
@@ -56,7 +56,7 @@ public class LoadProperties extends Task { | |||
/** | |||
* Holds filterchains | |||
*/ | |||
private final Vector<FilterChain> filterChains = new Vector<FilterChain>(); | |||
private final List<FilterChain> filterChains = new Vector<>(); | |||
/** | |||
* Encoding to use for input; defaults to the platform's default encoding. | |||
@@ -158,6 +158,7 @@ public class LoadProperties extends Task { | |||
* | |||
* @exception BuildException if something goes wrong with the build | |||
*/ | |||
@Override | |||
public final void execute() throws BuildException { | |||
//validation | |||
if (src == null) { | |||
@@ -171,30 +172,21 @@ public class LoadProperties extends Task { | |||
} | |||
throw new BuildException("Source resource does not exist: " + src); | |||
} | |||
BufferedInputStream bis = null; | |||
Reader instream = null; | |||
ByteArrayInputStream tis = null; | |||
try { | |||
bis = new BufferedInputStream(src.getInputStream()); | |||
if (encoding == null) { | |||
instream = new InputStreamReader(bis); | |||
} else { | |||
instream = new InputStreamReader(bis, encoding); | |||
} | |||
ChainReaderHelper crh = new ChainReaderHelper(); | |||
crh.setPrimaryReader(instream); | |||
crh.setFilterChains(filterChains); | |||
crh.setProject(getProject()); | |||
instream = crh.getAssembledReader(); | |||
String text = crh.readFully(instream); | |||
Charset charset = encoding == null ? Charset.defaultCharset() : Charset.forName(encoding); | |||
try (ChainReader instream = new ChainReaderHelper(getProject(), | |||
new InputStreamReader(src.getInputStream(), charset), filterChains) | |||
.getAssembledReader()) { | |||
String text = instream.readFully(); | |||
if (text != null && text.length() != 0) { | |||
if (!(text == null || text.isEmpty())) { | |||
if (!text.endsWith("\n")) { | |||
text = text + "\n"; | |||
} | |||
tis = new ByteArrayInputStream(text.getBytes(ResourceUtils.ISO_8859_1)); | |||
ByteArrayInputStream tis = new ByteArrayInputStream( | |||
text.getBytes(ResourceUtils.ISO_8859_1)); | |||
final Properties props = new Properties(); | |||
props.load(tis); | |||
@@ -206,9 +198,6 @@ public class LoadProperties extends Task { | |||
} | |||
} catch (final IOException ioe) { | |||
throw new BuildException("Unable to load file: " + ioe, ioe, getLocation()); | |||
} finally { | |||
FileUtils.close(bis); | |||
FileUtils.close(tis); | |||
} | |||
} | |||
@@ -217,7 +206,7 @@ public class LoadProperties extends Task { | |||
* @param filter the filter to add | |||
*/ | |||
public final void addFilterChain(FilterChain filter) { | |||
filterChains.addElement(filter); | |||
filterChains.add(filter); | |||
} | |||
/** | |||
@@ -19,19 +19,18 @@ package org.apache.tools.ant.taskdefs; | |||
import java.io.BufferedInputStream; | |||
import java.io.IOException; | |||
import java.io.InputStream; | |||
import java.io.InputStreamReader; | |||
import java.io.Reader; | |||
import java.nio.charset.Charset; | |||
import java.util.List; | |||
import java.util.Vector; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.Project; | |||
import org.apache.tools.ant.Task; | |||
import org.apache.tools.ant.filters.util.ChainReaderHelper; | |||
import org.apache.tools.ant.filters.util.ChainReaderHelper.ChainReader; | |||
import org.apache.tools.ant.types.FilterChain; | |||
import org.apache.tools.ant.types.Resource; | |||
import org.apache.tools.ant.types.ResourceCollection; | |||
import org.apache.tools.ant.util.FileUtils; | |||
/** | |||
* Load a resource into a property | |||
@@ -70,7 +69,7 @@ public class LoadResource extends Task { | |||
/** | |||
* Holds FilterChains | |||
*/ | |||
private final Vector<FilterChain> filterChains = new Vector<FilterChain>(); | |||
private final List<FilterChain> filterChains = new Vector<>(); | |||
/** | |||
* Encoding to use for input, defaults to the platform's default | |||
@@ -124,6 +123,7 @@ public class LoadResource extends Task { | |||
* | |||
* @exception BuildException if something goes wrong with the build | |||
*/ | |||
@Override | |||
public final void execute() | |||
throws BuildException { | |||
//validation | |||
@@ -134,82 +134,67 @@ public class LoadResource extends Task { | |||
throw new BuildException("output property not defined"); | |||
} | |||
if (quiet && failOnError) { | |||
throw new BuildException("quiet and failonerror cannot both be " | |||
+ "set to true"); | |||
throw new BuildException("quiet and failonerror cannot both be set to true"); | |||
} | |||
if (!src.isExists()) { | |||
String message = src + " doesn't exist"; | |||
if (failOnError) { | |||
throw new BuildException(message); | |||
} else { | |||
log(message, quiet ? Project.MSG_WARN : Project.MSG_ERR); | |||
return; | |||
} | |||
log(message, quiet ? Project.MSG_WARN : Project.MSG_ERR); | |||
return; | |||
} | |||
InputStream is = null; | |||
BufferedInputStream bis = null; | |||
Reader instream = null; | |||
log("loading " + src + " into property " + property, | |||
Project.MSG_VERBOSE); | |||
Charset charset = encoding == null ? Charset.defaultCharset() | |||
: Charset.forName(encoding); | |||
try { | |||
final long len = src.getSize(); | |||
log("resource size = " | |||
+ (len != Resource.UNKNOWN_SIZE ? String.valueOf(len) | |||
: "unknown"), Project.MSG_DEBUG); | |||
log("resource size = " + (len != Resource.UNKNOWN_SIZE | |||
? String.valueOf(len) : "unknown"), Project.MSG_DEBUG); | |||
//discard most of really big resources | |||
final int size = (int) len; | |||
//open up the resource | |||
is = src.getInputStream(); | |||
bis = new BufferedInputStream(is); | |||
if (encoding == null) { | |||
instream = new InputStreamReader(bis); | |||
} else { | |||
instream = new InputStreamReader(bis, encoding); | |||
} | |||
String text = ""; | |||
String text; | |||
if (size != 0) { | |||
ChainReaderHelper crh = new ChainReaderHelper(); | |||
if (len != Resource.UNKNOWN_SIZE) { | |||
crh.setBufferSize(size); | |||
try (ChainReader chainReader = new ChainReaderHelper( | |||
getProject(), | |||
new InputStreamReader( | |||
new BufferedInputStream(src.getInputStream()), charset), | |||
filterChains).with(crh -> { | |||
if (src.getSize() != Resource.UNKNOWN_SIZE) { | |||
crh.setBufferSize(size); | |||
} | |||
}).getAssembledReader()) { | |||
text = chainReader.readFully(); | |||
} | |||
crh.setPrimaryReader(instream); | |||
crh.setFilterChains(filterChains); | |||
crh.setProject(getProject()); | |||
instream = crh.getAssembledReader(); | |||
text = crh.readFully(instream); | |||
} else { | |||
log("Do not set property " + property + " as its length is 0.", | |||
quiet ? Project.MSG_VERBOSE : Project.MSG_INFO); | |||
text = null; | |||
} | |||
if (text != null) { | |||
if (text.length() > 0) { | |||
getProject().setNewProperty(property, text); | |||
log("loaded " + text.length() + " characters", | |||
Project.MSG_VERBOSE); | |||
log(property + " := " + text, Project.MSG_DEBUG); | |||
} | |||
if (!(text == null || text.isEmpty())) { | |||
getProject().setNewProperty(property, text); | |||
log("loaded " + text.length() + " characters", | |||
Project.MSG_VERBOSE); | |||
log(property + " := " + text, Project.MSG_DEBUG); | |||
} | |||
} catch (final IOException ioe) { | |||
final String message = "Unable to load resource: " | |||
+ ioe.toString(); | |||
final String message = "Unable to load resource: " + ioe; | |||
if (failOnError) { | |||
throw new BuildException(message, ioe, getLocation()); | |||
} else { | |||
log(message, quiet ? Project.MSG_VERBOSE : Project.MSG_ERR); | |||
} | |||
log(message, quiet ? Project.MSG_VERBOSE : Project.MSG_ERR); | |||
} catch (final BuildException be) { | |||
if (failOnError) { | |||
throw be; | |||
} else { | |||
log(be.getMessage(), | |||
quiet ? Project.MSG_VERBOSE : Project.MSG_ERR); | |||
} | |||
} finally { | |||
FileUtils.close(is); | |||
log(be.getMessage(), quiet ? Project.MSG_VERBOSE : Project.MSG_ERR); | |||
} | |||
} | |||
@@ -218,7 +203,7 @@ public class LoadResource extends Task { | |||
* @param filter the filter to add | |||
*/ | |||
public final void addFilterChain(FilterChain filter) { | |||
filterChains.addElement(filter); | |||
filterChains.add(filter); | |||
} | |||
/** | |||
@@ -227,8 +212,8 @@ public class LoadResource extends Task { | |||
*/ | |||
public void addConfigured(ResourceCollection a) { | |||
if (a.size() != 1) { | |||
throw new BuildException("only single argument resource collections" | |||
+ " are supported"); | |||
throw new BuildException( | |||
"only single argument resource collections are supported"); | |||
} | |||
src = a.iterator().next(); | |||
} | |||
@@ -18,9 +18,6 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.IOException; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.ProjectComponent; | |||
import org.apache.tools.ant.Task; | |||
import org.apache.tools.ant.util.FileUtils; | |||
@@ -58,6 +55,7 @@ public class LogStreamHandler extends PumpStreamHandler { | |||
/** | |||
* Stop the log stream handler. | |||
*/ | |||
@Override | |||
public void stop() { | |||
super.stop(); | |||
FileUtils.close(getErr()); | |||