sigil/bld-ivy/src/org/cauldron/bld/ivy/SigilParser.java - onos-felix - Gitiles

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package org.cauldron.bld.ivy;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
 import java.net.URL;
 import java.text.ParseException;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.regex.Pattern;

 import org.apache.ivy.Ivy;
 import org.apache.ivy.core.IvyContext;
 import org.apache.ivy.core.module.descriptor.Artifact;
 import org.apache.ivy.core.module.descriptor.Configuration;
 import org.apache.ivy.core.module.descriptor.DefaultDependencyArtifactDescriptor;
 import org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor;
 import org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor;
 import org.apache.ivy.core.module.descriptor.DependencyDescriptor;
 import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
 import org.apache.ivy.core.module.id.ModuleRevisionId;
 import org.apache.ivy.core.settings.IvySettings;
 import org.apache.ivy.plugins.parser.ModuleDescriptorParser;
 import org.apache.ivy.plugins.parser.ModuleDescriptorParserRegistry;
 import org.apache.ivy.plugins.parser.ParserSettings;
 import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorParser;
 import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorWriter;
 import org.apache.ivy.plugins.repository.Resource;
 import org.apache.ivy.plugins.repository.file.FileResource;
 import org.apache.ivy.plugins.repository.url.URLResource;
 import org.apache.ivy.plugins.resolver.DependencyResolver;
 import org.cauldron.bld.config.BldFactory;
 import org.cauldron.bld.config.IBldProject;
 import org.cauldron.sigil.model.IModelElement;
 import org.cauldron.sigil.model.common.VersionRange;
 import org.cauldron.sigil.model.eclipse.ISigilBundle;
 import org.cauldron.sigil.model.osgi.IBundleModelElement;
 import org.cauldron.sigil.model.osgi.IPackageImport;
 import org.cauldron.sigil.model.osgi.IRequiredBundle;
 import org.cauldron.sigil.repository.IResolution;

 public class SigilParser implements ModuleDescriptorParser {

 	private static DelegateParser instance;

 	// used by ProjectRepository
     static DelegateParser instance() {
 		if (instance == null)
 			throw new IllegalStateException("SigilParser is not instantiated.");
 		return instance;
 	}

 	public SigilParser() {
 		if (instance == null) {
 			instance = new DelegateParser();
 		}
 	}

 	/**
 	 * In IvyDE, IvyContext is not available, so we can't find the SigilResolver.
 	 * This allows us to construct one.
 	 * @deprecated temporary to support IvyDE
 	 */
 	public void setConfig(String config) {
 		instance.config = config;
 	}

 	/**
 	 * sets delegate parser.
 	 * If not set, we delegate to the default Ivy parser.
 	 * @param type name returned by desired parser's getType() method.
 	 */
 	public void setDelegateType(String type) {
 		for (ModuleDescriptorParser parser : ModuleDescriptorParserRegistry.getInstance().getParsers()) {
 			if (parser.getType().equals(type)) {
 				instance.delegate = parser;
 				break;
 			}
 		}

 		if (instance.delegate == null) {
 			throw new IllegalArgumentException("Can't find parser delegateType=" + type);
 		}
 	}

 	/**
 	 * sets default file name the delegate parser accepts.
 	 * If not set, defaults to "ivy.xml".
 	 * @param name
 	 */
 	public void setDelegateFile(String name) {
 		instance.ivyFile = name;
 	}

 	/**
 	 * sets the dependencies to keep from the delegate parser.
 	 * If not set, all existing dependencies are dropped.
 	 * @param regex pattern matching dependency names to keep.
 	 */
 	public void setKeepDependencies(String regex) {
 		instance.keepDependencyPattern = Pattern.compile(regex);
 	}

 	/**
 	 * reduce level of info logging.
 	 * @param quiet
 	 */
 	public void setQuiet(String quiet) {
 		instance.quiet = Boolean.parseBoolean(quiet);
 	}

 	/**
 	 * sets the SigilResolver we use.
 	 * If not set, we use the first SigilResolver we find.
 	 * @param name
 	 */
 	public void setResolver(String name) {
 		instance.resolverName = name;
 	}

 	/**
 	 * adds override element: <override name="X" pattern="Y" replace="Z"/>. Overrides
 	 * Ivy variables using a pattern substitution on the resource directory path.
 	 *
 	 * @deprecated
 	 * This is only needed when a delegate parser expects Ant variables to be set
 	 * during the ivy:buildlist task (or the ProjectRepository initialisation),
 	 * which they are not. The delegate parser should really be fixed, as otherwise
 	 * the ivy:buildlist task won't work without this workaround.
 	 */
 	// e.g. <override name="ant.project.name" pattern=".*/([^/]+)/([^/]+)$" replace="$1-$2"/>
 	public void addConfiguredOverride(Map<String, String> var) {
 		final String name = var.get("name");
 		final String regex = var.get("pattern");
 		final String replace = var.get("replace");

 		if (name == null || regex == null || replace == null)
 			throw new IllegalArgumentException("override must contain name, pattern and replace attributes.");

 		instance.varRegex.put(name, Pattern.compile(regex));
 		instance.varReplace.put(name, replace);
 	}

 	// implement ModuleDescriptorParser interface by delegation to singleton instance.

 	public boolean accept(Resource res) {
 		return instance.accept(res);
 	}

 	public Artifact getMetadataArtifact(ModuleRevisionId mrid, Resource res) {
 		return instance.getMetadataArtifact(mrid, res);
 	}

 	public String getType() {
 		return instance.getType();
 	}

 	public ModuleDescriptor parseDescriptor(ParserSettings settings, URL xmlURL, boolean validate)
 			throws ParseException, IOException {
 		return instance.parseDescriptor(settings, xmlURL, validate);
 	}

 	public ModuleDescriptor parseDescriptor(ParserSettings settings, URL xmlURL, Resource res, boolean validate)
 			throws ParseException, IOException {
 		return instance.parseDescriptor(settings, xmlURL, res, validate);
 	}

 	public void toIvyFile(InputStream source, Resource res, File destFile, ModuleDescriptor md) throws ParseException,
 			IOException {
 		instance.toIvyFile(source, res, destFile, md);
 	}

 	/**
 	 * delegating parser.
 	 * (optionally) removes original dependencies and augments with sigil-determined dependencies.
 	 */
 	static class DelegateParser extends XmlModuleDescriptorParser {

 		private static final String SIGIL_BUILDLIST = IBldProject.PROJECT_FILE;
 		private static final String KEEP_ALL = ".*";

 		private IBldResolver resolver;
 		private ParserSettings defaultSettings;
 		private Map<String, DefaultModuleDescriptor> rawCache = new HashMap<String, DefaultModuleDescriptor>();
 		private Map<String, DefaultModuleDescriptor> augmentedCache = new HashMap<String, DefaultModuleDescriptor>();

 		private HashMap<String, String> varReplace = new HashMap<String, String>();
 		private HashMap<String, Pattern> varRegex = new HashMap<String, Pattern>();

 		private ModuleDescriptorParser delegate;
 		private String ivyFile = "ivy.xml";
 		private String resolverName;
 		private Pattern keepDependencyPattern;
     	private boolean quiet;
     	private String config;

 		@Override
 		public boolean accept(Resource res) {
 			boolean accept = (res instanceof SigilResolver.SigilIvy)
 					|| res.getName().endsWith("/" + SIGIL_BUILDLIST)
 					|| ((instance.getSigilURI(res) != null) &&
 						((instance.delegate != null ? instance.delegate.accept(res) : false) || super.accept(res)));
 			if (accept)
     			Log.verbose("accepted: " + res);
 			return accept;
 		}

 		@Override
 		public void toIvyFile(InputStream source, Resource res, File destFile, ModuleDescriptor md)
 				throws ParseException, IOException {
 			Log.verbose("writing resource: " + res + " toIvyFile: " + destFile);
 			// source allows us to keep layout and comments,
 			// but this doesn't work if source is not ivy.xml.
 			// So just write file directly from descriptor.
 			try {
 				XmlModuleDescriptorWriter.write(md, destFile);
 			} finally {
 				if (source != null)
 					source.close();
 			}
 		}

 		@Override
 		public ModuleDescriptor parseDescriptor(ParserSettings settings, URL xmlURL, boolean validate)
 				throws ParseException, IOException {
 			return parseDescriptor(settings, xmlURL, new URLResource(xmlURL), validate);
 		}

 		@Override
 		public ModuleDescriptor parseDescriptor(ParserSettings settings, URL xmlURL, Resource res, boolean validate)
 				throws ParseException, IOException {
 			String cacheKey = xmlURL.toString() + settings.hashCode();
 			DefaultModuleDescriptor dmd = augmentedCache.get(cacheKey);

 			if (dmd == null) {
 				dmd = rawCache.get(cacheKey);
 				if (dmd == null) {
 					dmd = delegateParse(settings, xmlURL, res, validate);
     			}

 				if (!quiet)
     				Log.info("augmenting module=" + dmd.getModuleRevisionId().getName() +
 						" ant.project.name=" + settings.substitute("${ant.project.name}"));

 				addDependenciesToDescriptor(res, dmd);
 				augmentedCache.put(cacheKey, dmd);

 				Log.verbose("augmented dependencies: " + Arrays.asList(dmd.getDependencies()));
 			}

 			return dmd;
 		}

 		// used by ProjectRepository
 		ModuleDescriptor parseDescriptor(URL projectURL) throws ParseException, IOException {
 			if (defaultSettings == null) {
 				Ivy ivy = IvyContext.getContext().peekIvy();
 				if (ivy == null)
 					throw new IllegalStateException("can't get default settings - no ivy context.");
 				defaultSettings = ivy.getSettings();
 			}

 			URL ivyURL = new URL(projectURL, ivyFile);
 			String cacheKey = ivyURL.toString() + defaultSettings.hashCode();
 			DefaultModuleDescriptor dmd = rawCache.get(cacheKey);

 			if (dmd == null) {
 				URLResource res = new URLResource(ivyURL);
 				// Note: this doesn't contain the augmented dependencies, which is OK,
 				// since the ProjectRepository only needs the id and status.
 				dmd = delegateParse(defaultSettings, ivyURL, res, false);
 				rawCache.put(cacheKey, dmd);
 			}

 			return dmd;
 		}

 		private DefaultModuleDescriptor delegateParse(ParserSettings settings, URL xmlURL, Resource res,
 				boolean validate) throws ParseException, IOException {
 			String resName = res.getName();

 			if (resName.endsWith("/" + SIGIL_BUILDLIST)) {
 				String name = resName.substring(0, resName.length() - SIGIL_BUILDLIST.length());
 				res = res.clone(name + ivyFile);
 				xmlURL = new URL(xmlURL, ivyFile);
 			}

 			if (settings instanceof IvySettings) {
 				IvySettings ivySettings = (IvySettings) settings;
 				String dir = new File(res.getName()).getParent();

 				for (String name : varRegex.keySet()) {
 					Pattern regex = varRegex.get(name);
 					String replace = varReplace.get(name);

 					String value = regex.matcher(dir).replaceAll(replace);

 					Log.debug("overriding variable " + name + "=" + value);
 					ivySettings.setVariable(name, value);
 				}
 			}

 			ModuleDescriptor md = null;
 			if (delegate == null || !delegate.accept(res)) {
 				md = super.parseDescriptor(settings, xmlURL, res, validate);
 			} else {
 				md = delegate.parseDescriptor(settings, xmlURL, res, validate);
 			}

 			return mungeDescriptor(md, res);
 		}

 		/**
 		 * clones descriptor and removes dependencies, as descriptor MUST have
 		 * 'this' as the parser given to its constructor.
 		 * Only dependency names matched by keepDependencyPattern are kept,
 		 * as we're going to add our own dependencies later.
 		 */
 		private DefaultModuleDescriptor mungeDescriptor(ModuleDescriptor md, Resource res) {

 			if ((md instanceof DefaultModuleDescriptor) &&
 					(md.getParser() == this) &&
 					(KEEP_ALL.equals(keepDependencyPattern))) {
 				return (DefaultModuleDescriptor) md;
 			}

 			DefaultModuleDescriptor dmd = new DefaultModuleDescriptor(this, res);

 			dmd.setModuleRevisionId(md.getModuleRevisionId());
 			dmd.setPublicationDate(md.getPublicationDate());

 			for (Configuration c : md.getConfigurations()) {
 				String conf = c.getName();

 				dmd.addConfiguration(c);

 				for (Artifact a : md.getArtifacts(conf)) {
 					dmd.addArtifact(conf, a);
 				}
 			}

 			if (keepDependencyPattern != null) {
     			for (DependencyDescriptor dependency : md.getDependencies()) {
     				String name = dependency.getDependencyId().getName();
     				if (keepDependencyPattern.matcher(name).matches()) {
     					dmd.addDependency(dependency);
     				}
     			}
 			}

 			return dmd;
 		}

 		/*
 		 * find URI to Sigil project file. This assumes that it is in the same
 		 * directory as the ivy file.
 		 */
 		private URI getSigilURI(Resource res) {
 			URI uri = null;

 			if (res instanceof URLResource) {
 				URL url = ((URLResource) res).getURL();
 				uri = URI.create(url.toString()).resolve(IBldProject.PROJECT_FILE);
 				try {
 					InputStream stream = uri.toURL().openStream(); // check file
 																	// exists
 					stream.close();
 				} catch (IOException e) {
 					uri = null;
 				}
 			} else if (res instanceof FileResource) {
 				uri = ((FileResource) res).getFile().toURI().resolve(IBldProject.PROJECT_FILE);
 				if (!(new File(uri).exists()))
 					uri = null;
 			}

 			return uri;
 		}

 		/*
 		 * add sigil dependencies to ModuleDescriptor.
 		 */
 		private void addDependenciesToDescriptor(Resource res, DefaultModuleDescriptor md) throws IOException {
 			// FIXME: transitive should be configurable
 			final boolean transitive = true; // ivy default is true
 			final boolean changing = false;
 			final boolean force = false;

 			URI uri = getSigilURI(res);
 			if (uri == null)
 				return;

 			IBldProject project;

 			project = BldFactory.getProject(uri);

 			IBundleModelElement requirements = project.getDependencies();
 			Log.verbose("requirements: " + Arrays.asList(requirements.children()));

 			// preserve version range for Require-Bundle
 			// XXX: synthesise bundle version range corresponding to package version ranges?
 			HashMap<String, VersionRange> versions = new HashMap<String, VersionRange>();
 			for (IModelElement child : requirements.children()) {
 				if (child instanceof IRequiredBundle) {
 					IRequiredBundle bundle = (IRequiredBundle) child;
 					versions.put(bundle.getSymbolicName(), bundle.getVersions());
 				}
 			}

 			IBldResolver resolver = findResolver();
 			if (resolver == null) {
 				// this can happen in IvyDE, but it retries and is OK next time.
 				Log.warn("failed to find resolver - IvyContext not yet available.");
 				return;
 			}

 			IResolution resolution = resolver.resolve(requirements, false);
 			Log.verbose("resolution: " + resolution.getBundles());

 			ModuleRevisionId masterMrid = md.getModuleRevisionId();
 			DefaultDependencyDescriptor dd;
 			ModuleRevisionId mrid;

 			for (ISigilBundle bundle : resolution.getBundles()) {
 				IBundleModelElement info = bundle.getBundleInfo();
 				String name = info.getSymbolicName();

 				if (name == null) {
 					// e.g. SystemProvider with framework=null
 					continue;
 				}

 				if (bundle instanceof ProjectRepository.ProjectBundle) {
 					ProjectRepository.ProjectBundle pb = (ProjectRepository.ProjectBundle) bundle;
 					String org = pb.getOrg();
 					if (org == null)
 						org = masterMrid.getOrganisation();
 					String id = pb.getId();
 					String module = pb.getModule();
 					String rev = pb.getRevision();

 					mrid = ModuleRevisionId.newInstance(org, module, rev);
 					dd = new SigilDependencyDescriptor(md, mrid, force, changing, transitive);

 					if (!id.equals(module)) { // non-default artifact
 						dd.addDependencyArtifact(module,
 								new DefaultDependencyArtifactDescriptor(dd, id, "jar", "jar", null, null));
 					}
 				} else {
 					VersionRange version = versions.get(name);
 					String rev = version != null ? version.toString() : info.getVersion().toString();
 					mrid = ModuleRevisionId.newInstance(SigilResolver.ORG_SIGIL, name, rev);
 					dd = new SigilDependencyDescriptor(md, mrid, force, changing, transitive);
 				}

 				int nDeps = 0;
 				boolean foundDefault = false;

 				// TODO: make dependency configurations configurable SIGIL-176
 				for (String conf : md.getConfigurationsNames()) {
 					if (conf.equals("default")) {
 						foundDefault = true;
 					} else if (md.getArtifacts(conf).length == 0) {
 						dd.addDependencyConfiguration(conf, conf + "(default)");
 						nDeps++;
 					}
 				}

 				if (nDeps > 0) {
 					if (foundDefault)
 						dd.addDependencyConfiguration("default", "default");
 				} else {
 					dd.addDependencyConfiguration("*", "*");    // all configurations
 				}

 				md.addDependency(dd);
 			}

 			boolean resolved = true;
 			for (IModelElement child : requirements.children()) {
 				ISigilBundle provider = resolution.getProvider(child);
 				if (provider == null) {
 					resolved = false;
 					// this is parse phase, so only log verbose message.
 					// error is produced during resolution phase.
 					Log.verbose("WARN: can't resolve: " + child);

 					String name;
 					String version;
 					if (child instanceof IRequiredBundle) {
 						IRequiredBundle rb = (IRequiredBundle) child;
 						name = rb.getSymbolicName();
 						version = rb.getVersions().toString();
 					} else {
 						IPackageImport pi = (IPackageImport) child;
 						name = "import!" + pi.getPackageName();
 						version = pi.getVersions().toString();
 					}

 					mrid = ModuleRevisionId.newInstance("!" + SigilResolver.ORG_SIGIL, name, version);
 					dd = new SigilDependencyDescriptor(md, mrid, force, changing, transitive);
 					dd.addDependencyConfiguration("*", "*"); // all
 					// configurations
 					md.addDependency(dd);
 				}
 			}

 			if (!resolved) {
 				// Ivy does not show warnings or errors logged from parse phase, until after resolution.
 				// but <buildlist> ant task doesn't do resolution, so errors would be silently ignored.
 				// Hence, we must use Message.info to ensure this failure is seen.
 				if (!quiet)
     				Log.info("WARN: resolution failed in: " + masterMrid.getName() + ". Use -v for details.");
 			}
 		}

 		/*
 		 * find named resolver, or first resolver that implements IBldResolver.
 		 */
 		private IBldResolver findResolver() {
 			if (resolver == null) {
 				Ivy ivy = IvyContext.getContext().peekIvy();
 				if (ivy != null) {
     				if (resolverName != null) {
     					DependencyResolver r = ivy.getSettings().getResolver(resolverName);
     					if (r == null) {
     						throw new Error("SigilParser: resolver \"" + resolverName + "\" not defined.");
     					} else if (r instanceof IBldResolver) {
     						resolver = (IBldResolver) r;
     					} else {
     						throw new Error("SigilParser: resolver \"" + resolverName + "\" is not a SigilResolver.");
     					}
     				} else {
     					for (Object r : ivy.getSettings().getResolvers()) {
     						if (r instanceof IBldResolver) {
     							resolver = (IBldResolver) r;
     							break;
     						}
     					}
     				}

     				if (resolver == null) {
     					throw new Error("SigilParser: can't find SigilResolver. Check ivysettings.xml.");
     				}
 				} else if (config != null) {
 					Log.warn("creating duplicate resolver to support IvyDE.");
 					resolver = new SigilResolver();
 					((SigilResolver)resolver).setConfig(config);
 				}
 			}
 			return resolver;
 		}
 	}

 }

 /*
  * this is only needed so that we can distinguish sigil-added dependencies from
  * existing ones.
  */
 class SigilDependencyDescriptor extends DefaultDependencyDescriptor {
 	public SigilDependencyDescriptor(DefaultModuleDescriptor md, ModuleRevisionId mrid, boolean force,
 			boolean changing, boolean transitive) {
 		super(md, mrid, force, changing, transitive);
 	}
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package org.cauldron.bld.ivy;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.URI;
	import java.net.URL;
	import java.text.ParseException;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.regex.Pattern;

	import org.apache.ivy.Ivy;
	import org.apache.ivy.core.IvyContext;
	import org.apache.ivy.core.module.descriptor.Artifact;
	import org.apache.ivy.core.module.descriptor.Configuration;
	import org.apache.ivy.core.module.descriptor.DefaultDependencyArtifactDescriptor;
	import org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor;
	import org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor;
	import org.apache.ivy.core.module.descriptor.DependencyDescriptor;
	import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
	import org.apache.ivy.core.module.id.ModuleRevisionId;
	import org.apache.ivy.core.settings.IvySettings;
	import org.apache.ivy.plugins.parser.ModuleDescriptorParser;
	import org.apache.ivy.plugins.parser.ModuleDescriptorParserRegistry;
	import org.apache.ivy.plugins.parser.ParserSettings;
	import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorParser;
	import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorWriter;
	import org.apache.ivy.plugins.repository.Resource;
	import org.apache.ivy.plugins.repository.file.FileResource;
	import org.apache.ivy.plugins.repository.url.URLResource;
	import org.apache.ivy.plugins.resolver.DependencyResolver;
	import org.cauldron.bld.config.BldFactory;
	import org.cauldron.bld.config.IBldProject;
	import org.cauldron.sigil.model.IModelElement;
	import org.cauldron.sigil.model.common.VersionRange;
	import org.cauldron.sigil.model.eclipse.ISigilBundle;
	import org.cauldron.sigil.model.osgi.IBundleModelElement;
	import org.cauldron.sigil.model.osgi.IPackageImport;
	import org.cauldron.sigil.model.osgi.IRequiredBundle;
	import org.cauldron.sigil.repository.IResolution;

	public class SigilParser implements ModuleDescriptorParser {

	private static DelegateParser instance;

	// used by ProjectRepository
	static DelegateParser instance() {
	if (instance == null)
	throw new IllegalStateException("SigilParser is not instantiated.");
	return instance;
	}

	public SigilParser() {
	if (instance == null) {
	instance = new DelegateParser();
	}
	}

	/**
	* In IvyDE, IvyContext is not available, so we can't find the SigilResolver.
	* This allows us to construct one.
	* @deprecated temporary to support IvyDE
	*/
	public void setConfig(String config) {
	instance.config = config;
	}

	/**
	* sets delegate parser.
	* If not set, we delegate to the default Ivy parser.
	* @param type name returned by desired parser's getType() method.
	*/
	public void setDelegateType(String type) {
	for (ModuleDescriptorParser parser : ModuleDescriptorParserRegistry.getInstance().getParsers()) {
	if (parser.getType().equals(type)) {
	instance.delegate = parser;
	break;
	}
	}

	if (instance.delegate == null) {
	throw new IllegalArgumentException("Can't find parser delegateType=" + type);
	}
	}

	/**
	* sets default file name the delegate parser accepts.
	* If not set, defaults to "ivy.xml".
	* @param name
	*/
	public void setDelegateFile(String name) {
	instance.ivyFile = name;
	}

	/**
	* sets the dependencies to keep from the delegate parser.
	* If not set, all existing dependencies are dropped.
	* @param regex pattern matching dependency names to keep.
	*/
	public void setKeepDependencies(String regex) {
	instance.keepDependencyPattern = Pattern.compile(regex);
	}

	/**
	* reduce level of info logging.
	* @param quiet
	*/
	public void setQuiet(String quiet) {
	instance.quiet = Boolean.parseBoolean(quiet);
	}

	/**
	* sets the SigilResolver we use.
	* If not set, we use the first SigilResolver we find.
	* @param name
	*/
	public void setResolver(String name) {
	instance.resolverName = name;
	}

	/**
	* adds override element: <override name="X" pattern="Y" replace="Z"/>. Overrides
	* Ivy variables using a pattern substitution on the resource directory path.
	*
	* @deprecated
	* This is only needed when a delegate parser expects Ant variables to be set
	* during the ivy:buildlist task (or the ProjectRepository initialisation),
	* which they are not. The delegate parser should really be fixed, as otherwise
	* the ivy:buildlist task won't work without this workaround.
	*/
	// e.g. <override name="ant.project.name" pattern=".*/([^/]+)/([^/]+)$" replace="$1-$2"/>
	public void addConfiguredOverride(Map<String, String> var) {
	final String name = var.get("name");
	final String regex = var.get("pattern");
	final String replace = var.get("replace");

	if (name == null \|\| regex == null \|\| replace == null)
	throw new IllegalArgumentException("override must contain name, pattern and replace attributes.");

	instance.varRegex.put(name, Pattern.compile(regex));
	instance.varReplace.put(name, replace);
	}

	// implement ModuleDescriptorParser interface by delegation to singleton instance.

	public boolean accept(Resource res) {
	return instance.accept(res);
	}

	public Artifact getMetadataArtifact(ModuleRevisionId mrid, Resource res) {
	return instance.getMetadataArtifact(mrid, res);
	}

	public String getType() {
	return instance.getType();
	}

	public ModuleDescriptor parseDescriptor(ParserSettings settings, URL xmlURL, boolean validate)
	throws ParseException, IOException {
	return instance.parseDescriptor(settings, xmlURL, validate);
	}

	public ModuleDescriptor parseDescriptor(ParserSettings settings, URL xmlURL, Resource res, boolean validate)
	throws ParseException, IOException {
	return instance.parseDescriptor(settings, xmlURL, res, validate);
	}

	public void toIvyFile(InputStream source, Resource res, File destFile, ModuleDescriptor md) throws ParseException,
	IOException {
	instance.toIvyFile(source, res, destFile, md);
	}

	/**
	* delegating parser.
	* (optionally) removes original dependencies and augments with sigil-determined dependencies.
	*/
	static class DelegateParser extends XmlModuleDescriptorParser {

	private static final String SIGIL_BUILDLIST = IBldProject.PROJECT_FILE;
	private static final String KEEP_ALL = ".*";

	private IBldResolver resolver;
	private ParserSettings defaultSettings;
	private Map<String, DefaultModuleDescriptor> rawCache = new HashMap<String, DefaultModuleDescriptor>();
	private Map<String, DefaultModuleDescriptor> augmentedCache = new HashMap<String, DefaultModuleDescriptor>();

	private HashMap<String, String> varReplace = new HashMap<String, String>();
	private HashMap<String, Pattern> varRegex = new HashMap<String, Pattern>();

	private ModuleDescriptorParser delegate;
	private String ivyFile = "ivy.xml";
	private String resolverName;
	private Pattern keepDependencyPattern;
	private boolean quiet;
	private String config;

	@Override
	public boolean accept(Resource res) {
	boolean accept = (res instanceof SigilResolver.SigilIvy)
	\|\| res.getName().endsWith("/" + SIGIL_BUILDLIST)
	\|\| ((instance.getSigilURI(res) != null) &&
	((instance.delegate != null ? instance.delegate.accept(res) : false) \|\| super.accept(res)));
	if (accept)
	Log.verbose("accepted: " + res);
	return accept;
	}

	@Override
	public void toIvyFile(InputStream source, Resource res, File destFile, ModuleDescriptor md)
	throws ParseException, IOException {
	Log.verbose("writing resource: " + res + " toIvyFile: " + destFile);
	// source allows us to keep layout and comments,
	// but this doesn't work if source is not ivy.xml.
	// So just write file directly from descriptor.
	try {
	XmlModuleDescriptorWriter.write(md, destFile);
	} finally {
	if (source != null)
	source.close();
	}
	}

	@Override
	public ModuleDescriptor parseDescriptor(ParserSettings settings, URL xmlURL, boolean validate)
	throws ParseException, IOException {
	return parseDescriptor(settings, xmlURL, new URLResource(xmlURL), validate);
	}

	@Override
	public ModuleDescriptor parseDescriptor(ParserSettings settings, URL xmlURL, Resource res, boolean validate)
	throws ParseException, IOException {
	String cacheKey = xmlURL.toString() + settings.hashCode();
	DefaultModuleDescriptor dmd = augmentedCache.get(cacheKey);

	if (dmd == null) {
	dmd = rawCache.get(cacheKey);
	if (dmd == null) {
	dmd = delegateParse(settings, xmlURL, res, validate);
	}

	if (!quiet)
	Log.info("augmenting module=" + dmd.getModuleRevisionId().getName() +
	" ant.project.name=" + settings.substitute("${ant.project.name}"));

	addDependenciesToDescriptor(res, dmd);
	augmentedCache.put(cacheKey, dmd);

	Log.verbose("augmented dependencies: " + Arrays.asList(dmd.getDependencies()));
	}

	return dmd;
	}

	// used by ProjectRepository
	ModuleDescriptor parseDescriptor(URL projectURL) throws ParseException, IOException {
	if (defaultSettings == null) {
	Ivy ivy = IvyContext.getContext().peekIvy();
	if (ivy == null)
	throw new IllegalStateException("can't get default settings - no ivy context.");
	defaultSettings = ivy.getSettings();
	}

	URL ivyURL = new URL(projectURL, ivyFile);
	String cacheKey = ivyURL.toString() + defaultSettings.hashCode();
	DefaultModuleDescriptor dmd = rawCache.get(cacheKey);

	if (dmd == null) {
	URLResource res = new URLResource(ivyURL);
	// Note: this doesn't contain the augmented dependencies, which is OK,
	// since the ProjectRepository only needs the id and status.
	dmd = delegateParse(defaultSettings, ivyURL, res, false);
	rawCache.put(cacheKey, dmd);
	}

	return dmd;
	}

	private DefaultModuleDescriptor delegateParse(ParserSettings settings, URL xmlURL, Resource res,
	boolean validate) throws ParseException, IOException {
	String resName = res.getName();

	if (resName.endsWith("/" + SIGIL_BUILDLIST)) {
	String name = resName.substring(0, resName.length() - SIGIL_BUILDLIST.length());
	res = res.clone(name + ivyFile);
	xmlURL = new URL(xmlURL, ivyFile);
	}

	if (settings instanceof IvySettings) {
	IvySettings ivySettings = (IvySettings) settings;
	String dir = new File(res.getName()).getParent();

	for (String name : varRegex.keySet()) {
	Pattern regex = varRegex.get(name);
	String replace = varReplace.get(name);

	String value = regex.matcher(dir).replaceAll(replace);

	Log.debug("overriding variable " + name + "=" + value);
	ivySettings.setVariable(name, value);
	}
	}

	ModuleDescriptor md = null;
	if (delegate == null \|\| !delegate.accept(res)) {
	md = super.parseDescriptor(settings, xmlURL, res, validate);
	} else {
	md = delegate.parseDescriptor(settings, xmlURL, res, validate);
	}

	return mungeDescriptor(md, res);
	}

	/**
	* clones descriptor and removes dependencies, as descriptor MUST have
	* 'this' as the parser given to its constructor.
	* Only dependency names matched by keepDependencyPattern are kept,
	* as we're going to add our own dependencies later.
	*/
	private DefaultModuleDescriptor mungeDescriptor(ModuleDescriptor md, Resource res) {

	if ((md instanceof DefaultModuleDescriptor) &&
	(md.getParser() == this) &&
	(KEEP_ALL.equals(keepDependencyPattern))) {
	return (DefaultModuleDescriptor) md;
	}

	DefaultModuleDescriptor dmd = new DefaultModuleDescriptor(this, res);

	dmd.setModuleRevisionId(md.getModuleRevisionId());
	dmd.setPublicationDate(md.getPublicationDate());

	for (Configuration c : md.getConfigurations()) {
	String conf = c.getName();

	dmd.addConfiguration(c);

	for (Artifact a : md.getArtifacts(conf)) {
	dmd.addArtifact(conf, a);
	}
	}

	if (keepDependencyPattern != null) {
	for (DependencyDescriptor dependency : md.getDependencies()) {
	String name = dependency.getDependencyId().getName();
	if (keepDependencyPattern.matcher(name).matches()) {
	dmd.addDependency(dependency);
	}
	}
	}

	return dmd;
	}

	/*
	* find URI to Sigil project file. This assumes that it is in the same
	* directory as the ivy file.
	*/
	private URI getSigilURI(Resource res) {
	URI uri = null;

	if (res instanceof URLResource) {
	URL url = ((URLResource) res).getURL();
	uri = URI.create(url.toString()).resolve(IBldProject.PROJECT_FILE);
	try {
	InputStream stream = uri.toURL().openStream(); // check file
	// exists
	stream.close();
	} catch (IOException e) {
	uri = null;
	}
	} else if (res instanceof FileResource) {
	uri = ((FileResource) res).getFile().toURI().resolve(IBldProject.PROJECT_FILE);
	if (!(new File(uri).exists()))
	uri = null;
	}

	return uri;
	}

	/*
	* add sigil dependencies to ModuleDescriptor.
	*/
	private void addDependenciesToDescriptor(Resource res, DefaultModuleDescriptor md) throws IOException {
	// FIXME: transitive should be configurable
	final boolean transitive = true; // ivy default is true
	final boolean changing = false;
	final boolean force = false;

	URI uri = getSigilURI(res);
	if (uri == null)
	return;

	IBldProject project;

	project = BldFactory.getProject(uri);

	IBundleModelElement requirements = project.getDependencies();
	Log.verbose("requirements: " + Arrays.asList(requirements.children()));

	// preserve version range for Require-Bundle
	// XXX: synthesise bundle version range corresponding to package version ranges?
	HashMap<String, VersionRange> versions = new HashMap<String, VersionRange>();
	for (IModelElement child : requirements.children()) {
	if (child instanceof IRequiredBundle) {
	IRequiredBundle bundle = (IRequiredBundle) child;
	versions.put(bundle.getSymbolicName(), bundle.getVersions());
	}
	}

	IBldResolver resolver = findResolver();
	if (resolver == null) {
	// this can happen in IvyDE, but it retries and is OK next time.
	Log.warn("failed to find resolver - IvyContext not yet available.");
	return;
	}

	IResolution resolution = resolver.resolve(requirements, false);
	Log.verbose("resolution: " + resolution.getBundles());

	ModuleRevisionId masterMrid = md.getModuleRevisionId();
	DefaultDependencyDescriptor dd;
	ModuleRevisionId mrid;

	for (ISigilBundle bundle : resolution.getBundles()) {
	IBundleModelElement info = bundle.getBundleInfo();
	String name = info.getSymbolicName();

	if (name == null) {
	// e.g. SystemProvider with framework=null
	continue;
	}

	if (bundle instanceof ProjectRepository.ProjectBundle) {
	ProjectRepository.ProjectBundle pb = (ProjectRepository.ProjectBundle) bundle;
	String org = pb.getOrg();
	if (org == null)
	org = masterMrid.getOrganisation();
	String id = pb.getId();
	String module = pb.getModule();
	String rev = pb.getRevision();

	mrid = ModuleRevisionId.newInstance(org, module, rev);
	dd = new SigilDependencyDescriptor(md, mrid, force, changing, transitive);

	if (!id.equals(module)) { // non-default artifact
	dd.addDependencyArtifact(module,
	new DefaultDependencyArtifactDescriptor(dd, id, "jar", "jar", null, null));
	}
	} else {
	VersionRange version = versions.get(name);
	String rev = version != null ? version.toString() : info.getVersion().toString();
	mrid = ModuleRevisionId.newInstance(SigilResolver.ORG_SIGIL, name, rev);
	dd = new SigilDependencyDescriptor(md, mrid, force, changing, transitive);
	}

	int nDeps = 0;
	boolean foundDefault = false;

	// TODO: make dependency configurations configurable SIGIL-176
	for (String conf : md.getConfigurationsNames()) {
	if (conf.equals("default")) {
	foundDefault = true;
	} else if (md.getArtifacts(conf).length == 0) {
	dd.addDependencyConfiguration(conf, conf + "(default)");
	nDeps++;
	}
	}

	if (nDeps > 0) {
	if (foundDefault)
	dd.addDependencyConfiguration("default", "default");
	} else {
	dd.addDependencyConfiguration("", ""); // all configurations
	}

	md.addDependency(dd);
	}

	boolean resolved = true;
	for (IModelElement child : requirements.children()) {
	ISigilBundle provider = resolution.getProvider(child);
	if (provider == null) {
	resolved = false;
	// this is parse phase, so only log verbose message.
	// error is produced during resolution phase.
	Log.verbose("WARN: can't resolve: " + child);

	String name;
	String version;
	if (child instanceof IRequiredBundle) {
	IRequiredBundle rb = (IRequiredBundle) child;
	name = rb.getSymbolicName();
	version = rb.getVersions().toString();
	} else {
	IPackageImport pi = (IPackageImport) child;
	name = "import!" + pi.getPackageName();
	version = pi.getVersions().toString();
	}

	mrid = ModuleRevisionId.newInstance("!" + SigilResolver.ORG_SIGIL, name, version);
	dd = new SigilDependencyDescriptor(md, mrid, force, changing, transitive);
	dd.addDependencyConfiguration("", ""); // all
	// configurations
	md.addDependency(dd);
	}
	}

	if (!resolved) {
	// Ivy does not show warnings or errors logged from parse phase, until after resolution.
	// but <buildlist> ant task doesn't do resolution, so errors would be silently ignored.
	// Hence, we must use Message.info to ensure this failure is seen.
	if (!quiet)
	Log.info("WARN: resolution failed in: " + masterMrid.getName() + ". Use -v for details.");
	}
	}

	/*
	* find named resolver, or first resolver that implements IBldResolver.
	*/
	private IBldResolver findResolver() {
	if (resolver == null) {
	Ivy ivy = IvyContext.getContext().peekIvy();
	if (ivy != null) {
	if (resolverName != null) {
	DependencyResolver r = ivy.getSettings().getResolver(resolverName);
	if (r == null) {
	throw new Error("SigilParser: resolver \"" + resolverName + "\" not defined.");
	} else if (r instanceof IBldResolver) {
	resolver = (IBldResolver) r;
	} else {
	throw new Error("SigilParser: resolver \"" + resolverName + "\" is not a SigilResolver.");
	}
	} else {
	for (Object r : ivy.getSettings().getResolvers()) {
	if (r instanceof IBldResolver) {
	resolver = (IBldResolver) r;
	break;
	}
	}
	}

	if (resolver == null) {
	throw new Error("SigilParser: can't find SigilResolver. Check ivysettings.xml.");
	}
	} else if (config != null) {
	Log.warn("creating duplicate resolver to support IvyDE.");
	resolver = new SigilResolver();
	((SigilResolver)resolver).setConfig(config);
	}
	}
	return resolver;
	}
	}

	}

	/*
	* this is only needed so that we can distinguish sigil-added dependencies from
	* existing ones.
	*/
	class SigilDependencyDescriptor extends DefaultDependencyDescriptor {
	public SigilDependencyDescriptor(DefaultModuleDescriptor md, ModuleRevisionId mrid, boolean force,
	boolean changing, boolean transitive) {
	super(md, mrid, force, changing, transitive);
	}
	}