public String _range(String args[]) {
verifyCommand(args, _rangeHelp, _rangePattern, 2, 3);
Version version = null;
if (args.length >= 3) version = new Version(args[2]);
else {
String v = domain.getProperty("@");
if (v == null) return null;
version = new Version(v);
}
String spec = args[1];
Matcher m = RANGE_MASK.matcher(spec);
m.matches();
String floor = m.group(1);
String floorMask = m.group(2);
String ceilingMask = m.group(3);
String ceiling = m.group(4);
String left = version(version, floorMask);
String right = version(version, ceilingMask);
StringBuilder sb = new StringBuilder();
sb.append(floor);
sb.append(left);
sb.append(",");
sb.append(right);
sb.append(ceiling);
String s = sb.toString();
VersionRange vr = new VersionRange(s);
if (!(vr.includes(vr.getHigh()) || vr.includes(vr.getLow()))) {
domain.error(
"${range} macro created an invalid range %s from %s and mask %s", s, version, spec);
}
return sb.toString();
}
int process(CharSequence org, int index, char begin, char end, StringBuilder result, Link link) {
StringBuilder line = new StringBuilder(org);
int nesting = 1;
StringBuilder variable = new StringBuilder();
outer:
while (index < line.length()) {
char c1 = line.charAt(index++);
if (c1 == end) {
if (--nesting == 0) {
result.append(replace(variable.toString(), link));
return index;
}
} else if (c1 == begin) nesting++;
else if (c1 == '\\' && index < line.length() - 1 && line.charAt(index) == '$') {
// remove the escape backslash and interpret the dollar
// as a
// literal
index++;
variable.append('$');
continue outer;
} else if (c1 == '$' && index < line.length() - 2) {
char c2 = line.charAt(index);
char terminator = getTerminator(c2);
if (terminator != 0) {
index = process(line, index + 1, c2, terminator, variable, link);
continue outer;
}
} else if (c1 == '.' && index < line.length() && line.charAt(index) == '/') {
// Found the sequence ./
if (index == 1 || Character.isWhitespace(line.charAt(index - 2))) {
// make sure it is preceded by whitespace or starts at begin
index++;
variable.append(domain.getBase().getAbsolutePath());
variable.append('/');
continue outer;
}
}
variable.append(c1);
}
result.append(variable);
return index;
}
String ls(String args[], boolean relative) {
if (args.length < 2)
throw new IllegalArgumentException(
"the ${ls} macro must at least have a directory as parameter");
File dir = domain.getFile(args[1]);
if (!dir.isAbsolute())
throw new IllegalArgumentException(
"the ${ls} macro directory parameter is not absolute: " + dir);
if (!dir.exists())
throw new IllegalArgumentException(
"the ${ls} macro directory parameter does not exist: " + dir);
if (!dir.isDirectory())
throw new IllegalArgumentException(
"the ${ls} macro directory parameter points to a file instead of a directory: " + dir);
Collection<File> files = new ArrayList<File>(new SortedList<File>(dir.listFiles()));
for (int i = 2; i < args.length; i++) {
Instructions filters = new Instructions(args[i]);
files = filters.select(files, true);
}
List<String> result = new ArrayList<String>();
for (File file : files) result.add(relative ? file.getName() : file.getAbsolutePath());
return Processor.join(result, ",");
}
private String doCommand(Object target, String method, String[] args) {
if (target == null) ; // System.err.println("Huh? Target should never be null " +
// domain);
else {
String cname = "_" + method.replaceAll("-", "_");
try {
Method m = target.getClass().getMethod(cname, new Class[] {String[].class});
return (String) m.invoke(target, new Object[] {args});
} catch (NoSuchMethodException e) {
// Ignore
} catch (InvocationTargetException e) {
if (e.getCause() instanceof IllegalArgumentException) {
domain.error(
"%s, for cmd: %s, arguments; %s",
e.getCause().getMessage(), method, Arrays.toString(args));
} else {
domain.warning("Exception in replace: %s", e.getCause());
e.getCause().printStackTrace();
}
} catch (Exception e) {
domain.warning("Exception in replace: " + e + " method=" + method);
e.printStackTrace();
}
}
return null;
}
private String doCommands(String key, Link source) {
String[] args = commands.split(key);
if (args == null || args.length == 0) return null;
for (int i = 0; i < args.length; i++)
if (args[i].indexOf('\\') >= 0) args[i] = args[i].replaceAll("\\\\;", ";");
if (args[0].startsWith("^")) {
String varname = args[0].substring(1).trim();
Processor parent = source.start.getParent();
if (parent != null) return parent.getProperty(varname);
return null;
}
Processor rover = domain;
while (rover != null) {
String result = doCommand(rover, args[0], args);
if (result != null) return result;
rover = rover.getParent();
}
for (int i = 0; targets != null && i < targets.length; i++) {
String result = doCommand(targets[i], args[0], args);
if (result != null) return result;
}
return doCommand(this, args[0], args);
}
public static void testBumpIncludeFile() throws Exception {
File tmp = new File("tmp-ws");
if (tmp.exists()) IO.deleteWithException(tmp);
tmp.mkdir();
assertTrue(tmp.isDirectory());
try {
IO.copy(new File("test/ws"), tmp);
Workspace ws = Workspace.getWorkspace(tmp);
Project project = ws.getProject("bump-included");
project.setTrace(true);
Version old = new Version(project.getProperty("Bundle-Version"));
assertEquals(new Version(1, 0, 0), old);
project.bump("=+0");
Processor processor = new Processor();
processor.setProperties(project.getFile("include.txt"));
Version newv = new Version(processor.getProperty("Bundle-Version"));
System.err.println("New version " + newv);
assertEquals(1, newv.getMajor());
assertEquals(1, newv.getMinor());
assertEquals(0, newv.getMicro());
} finally {
IO.deleteWithException(tmp);
}
}
/**
* System command. Execute a command and insert the result.
*
* @param args
* @param help
* @param patterns
* @param low
* @param high
*/
public String system_internal(boolean allowFail, String args[]) throws Exception {
verifyCommand(
args,
"${"
+ (allowFail ? "system-allow-fail" : "system")
+ ";<command>[;<in>]}, execute a system command",
null,
2,
3);
String command = args[1];
String input = null;
if (args.length > 2) {
input = args[2];
}
Process process = Runtime.getRuntime().exec(command, null, domain.getBase());
if (input != null) {
process.getOutputStream().write(input.getBytes("UTF-8"));
}
process.getOutputStream().close();
String s = IO.collect(process.getInputStream(), "UTF-8");
int exitValue = process.waitFor();
if (exitValue != 0) return exitValue + "";
if (!allowFail && (exitValue != 0)) {
domain.error("System command " + command + " failed with " + exitValue);
}
return s.trim();
}
/** Check if the getSubBuilders properly predicts the output. */
public static void testSubBuilders() throws Exception {
Workspace ws = Workspace.getWorkspace(new File("test/ws"));
Project project = ws.getProject("p4-sub");
Collection<? extends Builder> bs = project.getSubBuilders();
assertNotNull(bs);
assertEquals(3, bs.size());
Set<String> names = new HashSet<String>();
for (Builder b : bs) {
names.add(b.getBsn());
}
assertTrue(names.contains("p4-sub.a"));
assertTrue(names.contains("p4-sub.b"));
assertTrue(names.contains("p4-sub.c"));
File[] files = project.build();
assertTrue(project.check());
System.err.println(Processor.join(project.getErrors(), "\n"));
System.err.println(Processor.join(project.getWarnings(), "\n"));
assertEquals(0, project.getErrors().size());
assertEquals(0, project.getWarnings().size());
assertNotNull(files);
assertEquals(3, files.length);
for (File file : files) {
Jar jar = new Jar(file);
Manifest m = jar.getManifest();
assertTrue(names.contains(m.getMainAttributes().getValue("Bundle-SymbolicName")));
}
}
public String _path(String args[]) {
List<String> list = new ArrayList<String>();
for (int i = 1; i < args.length; i++) {
list.addAll(Processor.split(args[i]));
}
return Processor.join(list, File.pathSeparator);
}
public String _uniq(String args[]) {
verifyCommand(args, _uniqHelp, null, 1, Integer.MAX_VALUE);
Set<String> set = new LinkedHashSet<String>();
for (int i = 1; i < args.length; i++) {
Processor.split(args[i], set);
}
return Processor.join(set, ",");
}
public String _join(String args[]) {
verifyCommand(args, _joinHelp, null, 1, Integer.MAX_VALUE);
List<String> result = new ArrayList<String>();
for (int i = 1; i < args.length; i++) {
Processor.split(args[i], result);
}
return Processor.join(result);
}
String filter(String[] args, boolean include) {
verifyCommand(args, String.format(_filterHelp, args[0]), null, 3, 3);
Collection<String> list = new ArrayList<String>(Processor.split(args[1]));
Pattern pattern = Pattern.compile(args[2]);
for (Iterator<String> i = list.iterator(); i.hasNext(); ) {
if (pattern.matcher(i.next()).matches() == include) i.remove();
}
return Processor.join(list);
}
public String _toclasspath(String args[]) {
verifyCommand(args, _toclasspathHelp, null, 2, 3);
boolean cl = true;
if (args.length > 2) cl = Boolean.valueOf(args[2]);
Collection<String> names = Processor.split(args[1]);
Collection<String> paths = new ArrayList<String>(names.size());
for (String name : names) {
String path = name.replace('.', '/') + (cl ? ".class" : "");
paths.add(path);
}
return Processor.join(paths, ",");
}
private void copy(File workspaceDir, InputStream in, Pattern glob, boolean overwrite)
throws Exception {
Jar jar = new Jar("dot", in);
try {
for (Entry<String, Resource> e : jar.getResources().entrySet()) {
String path = e.getKey();
bnd.trace("path %s", path);
if (glob != null && !glob.matcher(path).matches()) continue;
Resource r = e.getValue();
File dest = Processor.getFile(workspaceDir, path);
if (overwrite
|| !dest.isFile()
|| dest.lastModified() < r.lastModified()
|| r.lastModified() <= 0) {
bnd.trace("copy %s to %s", path, dest);
File dp = dest.getParentFile();
if (!dp.exists() && !dp.mkdirs()) {
throw new IOException("Could not create directory " + dp);
}
IO.copy(r.openInputStream(), dest);
}
}
} finally {
jar.close();
}
}
String version(Version version, String mask) {
if (version == null) {
String v = domain.getProperty("@");
if (v == null) {
domain.error(
"No version specified for ${version} or ${range} and no implicit version ${@} either, mask=%s",
mask);
v = "0";
}
version = new Version(v);
}
StringBuilder sb = new StringBuilder();
String del = "";
for (int i = 0; i < mask.length(); i++) {
char c = mask.charAt(i);
String result = null;
if (c != '~') {
if (i == 3) {
result = version.getQualifier();
} else if (Character.isDigit(c)) {
// Handle masks like +00, =+0
result = String.valueOf(c);
} else {
int x = version.get(i);
switch (c) {
case '+':
x++;
break;
case '-':
x--;
break;
case '=':
break;
}
result = Integer.toString(x);
}
if (result != null) {
sb.append(del);
del = ".";
sb.append(result);
}
}
}
return sb.toString();
}
public String _basename(String args[]) {
if (args.length < 2) {
domain.warning("Need at least one file name for ${basename;...}");
return null;
}
String del = "";
StringBuilder sb = new StringBuilder();
for (int i = 1; i < args.length; i++) {
File f = domain.getFile(args[i]);
if (f.exists() && f.getParentFile().exists()) {
sb.append(del);
sb.append(f.getName());
del = ",";
}
}
return sb.toString();
}
public String _isdir(String args[]) {
if (args.length < 2) {
domain.warning("Need at least one file name for ${isdir;...}");
return null;
}
boolean isdir = true;
for (int i = 1; i < args.length; i++) {
File f = new File(args[i]).getAbsoluteFile();
isdir &= f.isDirectory();
}
return isdir ? "true" : "false";
}
public String _toclassname(String args[]) {
verifyCommand(args, _toclassnameHelp, null, 2, 2);
Collection<String> paths = Processor.split(args[1]);
List<String> names = new ArrayList<String>(paths.size());
for (String path : paths) {
if (path.endsWith(".class")) {
String name = path.substring(0, path.length() - 6).replace('/', '.');
names.add(name);
} else if (path.endsWith(".java")) {
String name = path.substring(0, path.length() - 5).replace('/', '.');
names.add(name);
} else {
domain.warning(
"in toclassname, "
+ args[1]
+ " is not a class path because it does not end in .class");
}
}
return Processor.join(names, ",");
}
public String _fmodified(String args[]) throws Exception {
verifyCommand(args, _fmodifiedHelp, null, 2, Integer.MAX_VALUE);
long time = 0;
Collection<String> names = new ArrayList<String>();
for (int i = 1; i < args.length; i++) {
Processor.split(args[i], names);
}
for (String name : names) {
File f = new File(name);
if (f.exists() && f.lastModified() > time) time = f.lastModified();
}
return "" + time;
}
/** Test default package versions. */
public static void testDefaultPackageVersion() throws Exception {
Builder a = new Builder();
a.addClasspath(new File("bin"));
a.setProperty("Bundle-Version", "1.2.3");
a.setProperty("Export-Package", "test.refer");
Jar jar = a.build();
Manifest m = jar.getManifest();
Parameters exports =
Processor.parseHeader(m.getMainAttributes().getValue(Constants.EXPORT_PACKAGE), null);
Map<String, String> attrs = exports.get("test.refer");
assertNotNull(attrs);
assertEquals("1.2.3", attrs.get("version"));
}
protected String replace(String key, Link link) {
if (link != null && link.contains(key)) return "${infinite:" + link.toString() + "}";
if (key != null) {
key = key.trim();
if (key.length() > 0) {
Processor source = domain;
String value = null;
if (key.indexOf(';') < 0) {
Instruction ins = new Instruction(key);
if (!ins.isLiteral()) {
SortedList<String> sortedList = SortedList.fromIterator(domain.iterator());
StringBuilder sb = new StringBuilder();
String del = "";
for (String k : sortedList) {
if (ins.matches(k)) {
String v = replace(k, new Link(source, link, key));
if (v != null) {
sb.append(del);
del = ",";
sb.append(v);
}
}
}
return sb.toString();
}
}
while (value == null && source != null) {
value = source.getProperties().getProperty(key);
source = source.getParent();
}
if (value != null) return process(value, new Link(source, link, key));
value = doCommands(key, link);
if (value != null) return process(value, new Link(source, link, key));
if (key != null && key.trim().length() > 0) {
value = System.getProperty(key);
if (value != null) return value;
}
if (!flattening && !key.equals("@"))
domain.warning("No translation found for macro: " + key);
} else {
domain.warning("Found empty macro key");
}
} else {
domain.warning("Found null macro key");
}
return "${" + key + "}";
}
/**
* Tests the handling of the -sub facility
*
* @throws Exception
*/
public static void testSub() throws Exception {
Workspace ws = Workspace.getWorkspace(new File("test/ws"));
Project project = ws.getProject("p4-sub");
File[] files = project.build();
Arrays.sort(files);
System.err.println(Processor.join(project.getErrors(), "\n"));
System.err.println(Processor.join(project.getWarnings(), "\n"));
assertEquals(0, project.getErrors().size());
assertEquals(0, project.getWarnings().size());
assertNotNull(files);
assertEquals(3, files.length);
Jar a = new Jar(files[0]);
Jar b = new Jar(files[1]);
Manifest ma = a.getManifest();
Manifest mb = b.getManifest();
assertEquals("base", ma.getMainAttributes().getValue("Base-Header"));
assertEquals("base", mb.getMainAttributes().getValue("Base-Header"));
assertEquals("a", ma.getMainAttributes().getValue("Sub-Header"));
assertEquals("b", mb.getMainAttributes().getValue("Sub-Header"));
}
/**
* Get the contents of a file.
*
* @param in
* @return
* @throws IOException
*/
public String _cat(String args[]) throws IOException {
verifyCommand(args, "${cat;<in>}, get the content of a file", null, 2, 2);
File f = domain.getFile(args[1]);
if (f.isFile()) {
return IO.collect(f);
} else if (f.isDirectory()) {
return Arrays.toString(f.list());
} else {
try {
URL url = new URL(args[1]);
return IO.collect(url, "UTF-8");
} catch (MalformedURLException mfue) {
// Ignore here
}
return null;
}
}
/**
* Take all the properties and translate them to actual values. This method takes the set
* properties and traverse them over all entries, including the default properties for that
* properties. The values no longer contain macros.
*
* @return A new Properties with the flattened values
*/
public Properties getFlattenedProperties() {
// Some macros only work in a lower processor, so we
// do not report unknown macros while flattening
flattening = true;
try {
Properties flattened = new Properties();
Properties source = domain.getProperties();
for (Enumeration<?> e = source.propertyNames(); e.hasMoreElements(); ) {
String key = (String) e.nextElement();
if (!key.startsWith("_"))
if (key.startsWith("-")) flattened.put(key, source.getProperty(key));
else flattened.put(key, process(source.getProperty(key)));
}
return flattened;
} finally {
flattening = false;
}
}
/**
* replace ; <list> ; regex ; replace
*
* @param args
* @return
*/
public String _replace(String args[]) {
if (args.length != 4) {
domain.warning("Invalid nr of arguments to replace " + Arrays.asList(args));
return null;
}
String list[] = args[1].split("\\s*,\\s*");
StringBuilder sb = new StringBuilder();
String del = "";
for (int i = 0; i < list.length; i++) {
String element = list[i].trim();
if (!element.equals("")) {
sb.append(del);
sb.append(element.replaceAll(args[2], args[3]));
del = ", ";
}
}
return sb.toString();
}
public String _tstamp(String args[]) {
String format = "yyyyMMddHHmm";
long now = System.currentTimeMillis();
TimeZone tz = TimeZone.getTimeZone("UTC");
if (args.length > 1) {
format = args[1];
}
if (args.length > 2) {
tz = TimeZone.getTimeZone(args[2]);
}
if (args.length > 3) {
now = Long.parseLong(args[3]);
}
if (args.length > 4) {
domain.warning("Too many arguments for tstamp: " + Arrays.toString(args));
}
SimpleDateFormat sdf = new SimpleDateFormat(format);
sdf.setTimeZone(tz);
return sdf.format(new Date(now));
}
/** Check implementation version policy. Uses the package test.versionpolicy.(uses|implemented) */
static void assertPolicy(String pack, String type) throws Exception {
Builder a = new Builder();
a.addClasspath(new File("bin"));
a.setProperty("Export-Package", "test.versionpolicy.api");
Jar jar = a.build();
Builder b = new Builder();
b.addClasspath(jar);
b.addClasspath(new File("bin"));
b.setProperty("-versionpolicy-impl", "IMPL");
b.setProperty("-versionpolicy-uses", "USES");
b.setProperty("Private-Package", pack);
b.build();
Manifest m = b.getJar().getManifest();
m.write(System.err);
Map<String, String> map = b.getImports().getByFQN("test.versionpolicy.api");
assertNotNull(map);
// String s = map.get(Constants.IMPLEMENTED_DIRECTIVE);
// assertEquals("true", s);
Parameters mp = Processor.parseHeader(m.getMainAttributes().getValue("Import-Package"), null);
assertEquals(type, mp.get("test.versionpolicy.api").get("version"));
}
public String _error(String args[]) {
for (int i = 1; i < args.length; i++) {
domain.error(process(args[i]));
}
return "";
}
public void _workspace(WorkspaceOptions opts) throws Exception {
File base = bnd.getBase();
String name = opts._arguments().get(0);
File workspaceDir = Processor.getFile(base, name);
name = workspaceDir.getName();
base = workspaceDir.getParentFile();
if (base == null) {
bnd.error(
"You cannot create a workspace in the root (%s). The parent of a workspace %n"
+ "must be a valid directory. Recommended is to dedicate a directory to %n"
+ "all (or related) workspaces.",
workspaceDir);
return;
}
if (!opts.anyname() && !Verifier.isBsn(name)) {
bnd.error(
"You specified a workspace name that does not follow the recommended pattern "
+ "(it should be like a Bundle Symbolic name). It is a bit pedantic but it "
+ "really helps hwne you get many workspaces. If you insist on this name, use the -a/--anyname option.");
return;
}
Workspace ws = bnd.getWorkspace((File) null);
if (ws != null && ws.isValid()) {
bnd.error(
"You are currently in a workspace already (%s) in %s. You can only create a new workspace outside an existing workspace",
ws, base);
return;
}
File eclipseDir = workspaceDir;
workspaceDir.mkdirs();
if (!opts.single()) workspaceDir = new File(workspaceDir, "scm");
workspaceDir.mkdirs();
if (!base.isDirectory()) {
bnd.error("Could not create directory for the bnd workspace %s", base);
} else if (!eclipseDir.isDirectory()) {
bnd.error("Could not create directory for the Eclipse workspace %s", eclipseDir);
}
if (!workspaceDir.isDirectory()) {
bnd.error("Could not create the workspace directory %s", workspaceDir);
return;
}
if (!opts.update() && !opts.force() && workspaceDir.list().length > 0) {
bnd.error(
"The workspace directory %s is not empty, specify -u/--update to update or -f/--force to replace",
workspaceDir);
}
InputStream in = getClass().getResourceAsStream("/templates/enroute.zip");
if (in == null) {
bnd.error("Cannot find template in this jar %s", "/templates/enroute.zip");
return;
}
Pattern glob = Pattern.compile("[^/]+|cnf/.*|\\...+/.*");
copy(workspaceDir, in, glob, opts.force());
File readme = new File(workspaceDir, "README.md");
if (readme.isFile()) IO.copy(readme, bnd.out);
bnd.out.printf(
"%nWorkspace %s created.%n%n" //
+ " Start Eclipse:%n" //
+ " 1) Select the Eclipse workspace %s%n" //
+ " 2) Package Explorer context menu: Import/General/Existing Projects from %s%n"
+ "%n"
+ "", //
workspaceDir.getName(), eclipseDir, workspaceDir);
}
public String _osfile(String args[]) {
verifyCommand(args, _fileHelp, null, 3, 3);
File base = new File(args[1]);
File f = Processor.getFile(base, args[2]);
return f.getAbsolutePath();
}