plugins/org.eclipse.gmf.xpand.migration/src/org/eclipse/gmf/internal/xpand/build/WorkspaceResourceManager.java

/*
 * Copyright (c) 2006, 2008 Borland Software Corporation
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     Artem Tikhomirov (Borland)
 *     Boris Blajer (Borland) - support for composite resources
 */
package org.eclipse.gmf.internal.xpand.build;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.ArrayList;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.gmf.internal.xpand.expression.SyntaxConstants;
import org.eclipse.gmf.internal.xpand.migration.Activator;
import org.eclipse.gmf.internal.xpand.model.XpandResource;
import org.eclipse.gmf.internal.xpand.util.ParserException;
import org.eclipse.gmf.internal.xpand.util.ResourceManagerImpl;
import org.eclipse.gmf.internal.xpand.util.StreamConverter;
import org.eclipse.gmf.internal.xpand.xtend.ast.XtendResource;
import org.osgi.framework.Bundle;

// FIXME package-local?, refactor Activator.getResourceManager uses
public class WorkspaceResourceManager extends ResourceManagerImpl {
	private final IProject contextProject;
	private final IPath[] myConfiguredRoots;

	public WorkspaceResourceManager(IProject context, IPath[] configuredRoots) {
		this.contextProject = context;
		myConfiguredRoots = configuredRoots;
	}

	public XtendResource loadXtendResource(IFile file) throws CoreException, IOException, ParserException {
		String fullyQualifiedName;
		if (file == null || (fullyQualifiedName = toFullyQualifiedName(file)) == null) {
			return null;
		}
		// try file directly, to get IO/Parse exceptions, if any.
		Reader r = new StreamConverter().toContentsReader(file);
		loadXtendResources(new Reader[] { r }, fullyQualifiedName);
		//
		try {
			return loadXtendThroughCache(fullyQualifiedName);
		} catch (FileNotFoundException ex) {
			return null;	//Missing resource is an anticipated situation, not a error that should be handled
		}
	}

	public XpandResource loadXpandResource(IFile file) throws CoreException, IOException, ParserException {
		String fullyQualifiedName;
		if (file == null || (fullyQualifiedName = toFullyQualifiedName(file)) == null) {
			return null;
		}
		// try file directly, to get IO/Parse exceptions, if any.
		Reader r = new StreamConverter().toContentsReader(file);
		loadXpandResources(new Reader[] { r }, fullyQualifiedName);
		//
		fullyQualifiedName = getNonAspectsTemplateName(fullyQualifiedName);
		try {
			return loadXpandThroughCache(fullyQualifiedName);
		} catch (FileNotFoundException ex) {
			return null;	//Missing resource is an anticipated situation, not a error that should be handled
		}
	}

	@Override
	protected void handleParserException(ParserException ex) {
		// may get here only when some referenced template/xtend file is
		// broken. Since it's expected to get compiled anyway (either prior
		// to compilation of its use or afterwards), error messages should get
		// into problems view sooner or later.
		Activator.logWarn(ex.getClass().getSimpleName() + ":" + ex.getResourceName());
	}

	@Override
	protected boolean shouldCache() {
		// we don't cache workspace resources for now (for the sake of reducing 
		// underemined problems that may arise), although may do this later
		return false;
	}

	public void forget(IFile resource) {
		// implement when caching
	}

	public Reader[] resolveMultiple(String fqn, String ext) throws IOException {
		IPath fp = new Path(fqn.replaceAll(SyntaxConstants.NS_DELIM, "/")).addFileExtension(ext);
		IPath[] resolutions = getResolutions(fp);
		ArrayList<Reader> result = new ArrayList<Reader>(resolutions.length);
		for (IPath p : getResolutions(fp)) {
			Reader nextReader = getReader(p);
			if (nextReader != null) {
				result.add(nextReader);
			}
		}
		if (result.isEmpty()) {
			throw new FileNotFoundException(fp.toString());
		}
		return result.toArray(new Reader[result.size()]);
	}

	private Reader getReader(IPath p) throws IOException {
		if (p.isAbsolute()) {
			assert p.segmentCount() > 1;
			//Try workspace-relative first.
			IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(p.segment(0));
			if (project.isAccessible()) {
				return getWorkspaceFileReader(project, p.removeFirstSegments(1));
			}
			//Fallback to platform location
			Bundle platformBundle = Platform.getBundle(p.segment(0));
			if (platformBundle != null) {
				URL url = platformBundle.getEntry(p.removeFirstSegments(1).toString());
				if (url != null) {
					InputStream is = url.openStream();
					return new InputStreamReader(is, Charset.forName("ISO-8859-1"));	//$NON-NLS-1$
				}
			}
		} else {
			return getWorkspaceFileReader(contextProject, p);
		}
		return null;
	}

	private Reader getWorkspaceFileReader(IProject project, IPath path) throws IOException {
		IResource r = project.findMember(path);
		if (r instanceof IFile) {
			try {
				return new StreamConverter().toContentsReader((IFile) r);
			} catch (CoreException ex) {
				IOException wrap = new IOException(ex.getStatus().getMessage());
				wrap.initCause(ex);
				throw wrap;
			}
		}
		return null;
	}

	private IPath[] getResolutions(IPath p) {
		IPath[] rv = new IPath[myConfiguredRoots.length];
		for (int i = 0; i < myConfiguredRoots.length; i++) {
			rv[i] = myConfiguredRoots[i].append(p);
		}
		return rv;
	}
	private String toFullyQualifiedName(IFile file) {
		for (IPath nextRoot : myConfiguredRoots) {
			if (!nextRoot.isAbsolute()) {
				if (file.getProject().equals(contextProject) && nextRoot.isPrefixOf(file.getProjectRelativePath())) {
					return toFullyQualifiedName(file.getProjectRelativePath().removeFirstSegments(nextRoot.segmentCount()));
				}
			} else {
				if (nextRoot.isPrefixOf(file.getFullPath())) {
					return toFullyQualifiedName(file.getFullPath().removeFirstSegments(nextRoot.segmentCount()));
				}
			}
		}
		return null;
	}

	private static String toFullyQualifiedName(IPath filePath) {
		return filePath.removeFileExtension().toString().replace("/", SyntaxConstants.NS_DELIM);
	}
}