r/org.eclipse.statet.r.core/src/org/eclipse/statet/internal/r/core/builder/RBuilder.java - statet/org.eclipse.statet-r - Git at Google

 /*=============================================================================#
  # Copyright (c) 2009, 2021 Stephan Wahlbrink and others.
  #
  # This program and the accompanying materials are made available under the
  # terms of the Eclipse Public License 2.0 which is available at
  # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
  # which is available at https://www.apache.org/licenses/LICENSE-2.0.
  #
  # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
  #
  # Contributors:
  #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
  #=============================================================================*/

 package org.eclipse.statet.internal.r.core.builder;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.UnsupportedEncodingException;
 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IResourceDelta;
 import org.eclipse.core.resources.IResourceDeltaVisitor;
 import org.eclipse.core.resources.IResourceVisitor;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.MultiStatus;
 import org.eclipse.core.runtime.OperationCanceledException;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.core.runtime.content.IContentDescription;
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.osgi.util.NLS;

 import org.eclipse.statet.jcommons.collections.ImList;

 import org.eclipse.statet.internal.r.core.Messages;
 import org.eclipse.statet.internal.r.core.RCorePlugin;
 import org.eclipse.statet.internal.r.core.RProjectNature;
 import org.eclipse.statet.internal.r.core.sourcemodel.RModelManagerImpl;
 import org.eclipse.statet.ltk.buildpath.core.BuildpathElement;
 import org.eclipse.statet.ltk.buildpath.core.BuildpathUtils;
 import org.eclipse.statet.ltk.core.Ltk;
 import org.eclipse.statet.ltk.core.SourceContent;
 import org.eclipse.statet.ltk.model.core.LtkModels;
 import org.eclipse.statet.ltk.model.core.SourceUnitManager;
 import org.eclipse.statet.r.core.RBuildpaths;
 import org.eclipse.statet.r.core.RCore;
 import org.eclipse.statet.r.core.RProject;
 import org.eclipse.statet.r.core.RProjects;
 import org.eclipse.statet.r.core.model.RModel;
 import org.eclipse.statet.r.core.model.RSourceUnit;
 import org.eclipse.statet.r.core.model.RWorkspaceSourceUnit;


 public class RBuilder implements IResourceDeltaVisitor, IResourceVisitor {


 	public static void clearMarkers(final IResource resource, final int depth) {
 		try {
 			resource.deleteMarkers(RModel.R_MODEL_PROBLEM_MARKER, false, depth);
 			resource.deleteMarkers("org.eclipse.statet.r.resourceMarkers.Tasks", false, depth); //$NON-NLS-1$
 		}
 		catch (final CoreException e) {
 			RCorePlugin.logError("R Builder: Failed to remove old markers.", e);
 		}
 	}


 	private static IContainer getContainer(final IProject project, final IPath path) {
 		return (path.isEmpty()) ? project : project.getFolder(path);
 	}


 	private final SourceUnitManager suManager= LtkModels.getSourceUnitManager();

 	private final List<IFile> toRemoveRSU= new ArrayList<>();
 	private final ArrayList<RWorkspaceSourceUnit> toUpdateRSU= new ArrayList<>();

 	private final RModelManagerImpl modelManager;

 	private MultiStatus statusCollector;

 	private IProject project;
 	private IPath pkgRootPath;
 	private ImList<BuildpathElement> sourceContainters;
 	private BuildpathElement currentSourceContainer;


 	public RBuilder() {
 		this.modelManager= RCorePlugin.getInstance().getRModelManager();
 	}


 	private void initBuildpath(final RProject project) {
 		this.sourceContainters= project.getRawBuildpath();
 		this.pkgRootPath= project.getPkgRootPath();
 		this.currentSourceContainer= null;
 	}

 	private boolean isValidSourceFolder(final IResource resource) {
 		if (this.currentSourceContainer != null) {
 			if (!BuildpathUtils.isExcluded(resource, this.currentSourceContainer)) {
 				return true;
 			}
 		}
 		return false;
 	}


 	public IStatus buildIncremental(final RProject rProject, final IResourceDelta delta, final IProgressMonitor monitor) {
 		this.project= rProject.getProject();
 		this.statusCollector= new MultiStatus(RCore.BUNDLE_ID, 0, "R build status for " + this.project.getName(), null);
 		initBuildpath(rProject);
 		final SubMonitor m= SubMonitor.convert(monitor, 2 + 10 + 1);
 		try {
 			m.subTask(NLS.bind("Collecting resource changes of ''{0}''.", this.project.getName()));
 			IContainer pkgRoot= null;
 			if (this.pkgRootPath != null) {
 				pkgRoot= visitPkgRoot(delta.findMember(this.pkgRootPath.removeFirstSegments(1)));
 			}
 			m.worked(1);

 			for (final BuildpathElement sourceContainer : this.sourceContainters) {
 				final IResourceDelta sourceDelta= delta.findMember(
 						sourceContainer.getPath().removeFirstSegments(1) );
 				if (sourceDelta != null) {
 					this.currentSourceContainer= sourceContainer;
 					sourceDelta.accept(this);
 				}

 				if (m.isCanceled()) {
 					throw new OperationCanceledException();
 				}
 			}
 			m.worked(1);

 			this.modelManager.getIndex().update(rProject, pkgRoot,
 					this.toRemoveRSU, this.toUpdateRSU,
 					this.statusCollector, m.newChild(10) );
 		}
 		catch (final CoreException e) {
 			this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
 					"An error occurred when indexing the project.", e ));
 		}
 		finally {
 			this.currentSourceContainer= null;

 			for (final RSourceUnit su : this.toUpdateRSU) {
 				if (su != null) {
 					su.disconnect(m);
 				}
 			}
 			this.toRemoveRSU.clear();
 			this.toUpdateRSU.clear();
 			this.project= null;
 		}
 		return this.statusCollector;
 	}

 	private IContainer visitPkgRoot(final IResourceDelta delta) throws CoreException {
 		final IResource resource;
 		if (delta != null
 				&& (resource= delta.getResource()) instanceof IContainer ) {
 			final IContainer container= (IContainer) resource;

 			this.project.deleteMarkers(RModel.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);

 			switch (delta.getKind()) {

 			case IResourceDelta.ADDED:
 			case IResourceDelta.CHANGED:
 				clearMarkers(resource, IResource.DEPTH_ZERO);
 				break;

 			case IResourceDelta.REMOVED:
 				if ((delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
 					final IResource movedTo= resource.getWorkspace().getRoot().findMember(delta.getMovedToPath());
 					if (movedTo != null && !isRPkgRootLocation(movedTo)) {
 						clearMarkers(movedTo, IResource.DEPTH_ZERO);
 					}
 				}
 				break;
 			}

 			visitPkgFile(delta.findMember(RBuildpaths.PKG_DESCRIPTION_FILE_PATH));

 			return container;
 		}
 		return null;
 	}

 	private boolean visitPkgFile(final IResourceDelta delta) throws CoreException {
 		final IResource resource;
 		if (delta != null
 				&& (resource= delta.getResource()) instanceof IFile) {

 			switch (delta.getKind()) {

 			case IResourceDelta.ADDED:
 			case IResourceDelta.CHANGED:
 				clearMarkers(resource, IResource.DEPTH_ZERO);
 				break;

 			case IResourceDelta.REMOVED:
 				if ((delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
 					final IResource movedTo= resource.getWorkspace().getRoot().findMember(delta.getMovedToPath());
 					if (movedTo != null && !isRPkgRootLocation(movedTo.getParent())) {
 						clearMarkers(movedTo, IResource.DEPTH_ZERO);
 					}
 				}
 				break;
 			}

 			return true;
 		}
 		return false;
 	}

 	@Override
 	public boolean visit(final IResourceDelta delta) throws CoreException {
 		final IResource resource= delta.getResource();
 		try {
 			if (!isValidSourceFolder(resource)) {
 				return false;
 			}

 			switch (delta.getKind()) {

 			case IResourceDelta.ADDED:
 			case IResourceDelta.CHANGED:
 				if (resource instanceof IFile) {
 					final IFile file= (IFile) resource;
 					final IContentDescription contentDescription= file.getContentDescription();
 					if (contentDescription == null) {
 						return true;
 					}
 					final IContentType contentType= contentDescription.getContentType();
 					if (contentType == null) {
 						return true;
 					}
 					if (RCore.R_CONTENT_ID.equals(contentType.getId())) {
 						clearMarkers(resource, IResource.DEPTH_ZERO);
 						final RWorkspaceSourceUnit su= (RWorkspaceSourceUnit) this.suManager.getSourceUnit(
 								Ltk.PERSISTENCE_CONTEXT, file, contentType, true, null );
 						if (su != null) {
 							this.toUpdateRSU.add(su);
 						}
 						return true;
 					}
 					if (RCore.RD_CONTENT_ID.equals(contentType.getId())) {
 						clearMarkers(resource, IResource.DEPTH_ZERO);
 						doParseRd(file);
 						return true;
 					}
 				}
 				return true;

 			case IResourceDelta.REMOVED:
 				if ((delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
 					final IResource movedTo= resource.getWorkspace().getRoot().findMember(delta.getMovedToPath());
 					if (movedTo != null && !isRSourceLocation(movedTo)) {
 						clearMarkers(movedTo, IResource.DEPTH_INFINITE);
 					}
 				}
 				if (resource instanceof IFile) {
 					this.toRemoveRSU.add((IFile) resource);
 				}
 				return true;
 			}
 			return true;
 		}
 		catch (final CoreException e) {
 			this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
 					NLS.bind("An error occurred when checking ''{0}''", resource.getFullPath().toString()), e));
 			return false;
 		}
 	}


 	public IStatus buildFull(final RProject rProject, final IProgressMonitor monitor) {
 		this.project= rProject.getProject();
 		this.statusCollector= new MultiStatus(RCore.BUNDLE_ID, 0, "R build status for " + this.project.getName(), null);
 		initBuildpath(rProject);
 		final SubMonitor m= SubMonitor.convert(monitor, 2 + 10 + 1);
 		try {
 			m.subTask(NLS.bind("Collecting resource changes of ''{0}''.", this.project.getName()));
 			IContainer pkgRoot= null;
 			if (this.pkgRootPath != null) {
 				pkgRoot= visitPkgRoot(
 						getContainer(this.project, this.pkgRootPath.removeFirstSegments(1)) );

 				this.project.deleteMarkers(RModel.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
 			}
 			m.worked(1);

 			for (final BuildpathElement sourceContainer : this.sourceContainters) {
 				final IResource resource= this.project.findMember(
 						sourceContainer.getPath().removeFirstSegments(1) );
 				if (resource != null) {
 					this.currentSourceContainer= sourceContainer;
 					resource.accept(this);
 				}

 				if (m.isCanceled()) {
 					throw new OperationCanceledException();
 				}
 			}
 			m.worked(1);

 			this.modelManager.getIndex().update(rProject, pkgRoot,
 					null, this.toUpdateRSU,
 					this.statusCollector, m.newChild(10) );
 		}
 		catch (final CoreException e) {
 			this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
 					"An error occurred when indexing the project.", e) );
 		}
 		finally {
 			this.currentSourceContainer= null;

 			for (final RSourceUnit su : this.toUpdateRSU) {
 				if (su != null) {
 					su.disconnect(m);
 				}
 			}
 			this.toRemoveRSU.clear();
 			this.toUpdateRSU.clear();
 			this.project= null;
 		}
 		return this.statusCollector;
 	}

 	private IContainer visitPkgRoot(final IContainer container) throws CoreException {
 		this.project.deleteMarkers(RModel.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);

 		if (container.exists()) {
 			clearMarkers(container, IResource.DEPTH_ZERO);
 			visitPkgFile(container.findMember(RBuildpaths.PKG_DESCRIPTION_FILE_PATH));
 		}

 		return container;
 	}

 	private void visitPkgFile(final IResource resource) {
 		if (resource instanceof IFile) {
 			clearMarkers(resource, IResource.DEPTH_ZERO);
 		}
 	}

 	@Override
 	public boolean visit(final IResource resource) throws CoreException {
 		try {
 			if (!isValidSourceFolder(resource)) {
 				return false;
 			}

 			if (resource instanceof IFile) {
 				final IFile file= (IFile) resource;
 				final IContentDescription contentDescription= file.getContentDescription();
 				if (contentDescription == null) {
 					return true;
 				}
 				final IContentType contentType= contentDescription.getContentType();
 				if (contentType == null) {
 					return true;
 				}
 				if (RCore.R_CONTENT_ID.equals(contentType.getId())) {
 					clearMarkers(resource, IResource.DEPTH_INFINITE);
 					final RWorkspaceSourceUnit su= (RWorkspaceSourceUnit) this.suManager.getSourceUnit(
 							Ltk.PERSISTENCE_CONTEXT, file, contentType, true, null );
 					if (su != null) {
 						this.toUpdateRSU.add(su);
 					}
 					return true;
 				}
 				if (RCore.RD_CONTENT_ID.equals(contentType.getId())) {
 					clearMarkers(resource, IResource.DEPTH_INFINITE);
 					doParseRd(file);
 					return true;
 				}
 			}
 			return true;
 		}
 		catch (final CoreException e) {
 			this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
 					NLS.bind("An error occurred when checking ''{0}''", resource.getFullPath().toString()),
 					e ));
 			return false;
 		}
 	}

 	public void clean(final IProject project, final IProgressMonitor monitor) {
 		this.project= project;
 		try {
 			project.deleteMarkers(RModel.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);

 			clearMarkers(project, IResource.DEPTH_INFINITE);

 			this.modelManager.getIndex().clear(project);
 		}
 		catch (final CoreException e) {
 			this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
 					"An error occurred when indexing the project.", e) );
 		}
 		finally {
 			this.project= null;
 		}
 	}


 	private boolean isRSourceLocation(final IResource resource) throws CoreException {
 		final IProject project= resource.getProject();
 		if (project == this.project) {
 			// TODO check buildpath
 			return true;
 		}
 		if (project.hasNature(RProjects.R_NATURE_ID)) {
 		// TODO check buildpath
 			return true;
 		}
 		return false;
 	}

 	private boolean isRPkgRootLocation(final IResource resource) throws CoreException {
 		final IProject project= resource.getProject();
 		if (project == this.project) {
 			return (resource.getFullPath().equals(this.pkgRootPath));
 		}
 		else if (project.hasNature(RProjects.R_PKG_NATURE_ID)) {
 			final RProjectNature rProject= RProjectNature.getRProject(project);
 			return (rProject != null && resource.getFullPath().equals(rProject.getPkgRootPath()));
 		}
 		return false;
 	}


 /*-- Rd --*/

 	private final RTaskMarkerHandler taskMarkerHandler= new RTaskMarkerHandler();

 	protected void initRd(final RProject project) {
 		this.taskMarkerHandler.init(project);
 	}

 	protected void doParseRd(final IFile file) throws CoreException {
 		try {
 			final SourceContent sourceContent= new SourceContent(0, readFile(file));
 			this.taskMarkerHandler.setup(sourceContent, file);
 			new RdParser(sourceContent, this.taskMarkerHandler).check();
 		}
 		catch (final CoreException e) {
 			this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
 					NLS.bind("An error occurred when parsing Rd file ''{0}''", file.getFullPath().toString()),
 					e ));
 		}
 	}

 	protected String readFile(final IFile file) throws CoreException {
 		String charset= null;
 		InputStream input= null;
 		try {
 			input= file.getContents();
 			charset= file.getCharset();
 			final BufferedReader reader= new BufferedReader(new InputStreamReader(input, charset));

 			final StringBuilder text= new StringBuilder(1000);
 			final char[] readBuffer= new char[2048];
 			int n;
 			while ((n= reader.read(readBuffer)) > 0) {
 				text.append(readBuffer, 0, n);
 			}

 			return text.toString();
 		}
 		catch (final UnsupportedEncodingException e) {
 			throw new CoreException(new Status(
 					IStatus.ERROR, RCore.BUNDLE_ID, 0,
 					NLS.bind(Messages.Builder_error_UnsupportedEncoding_message, new String[] {
 							charset, file.getName() } ),
 					e ));
 		}
 		catch (final IOException e) {
 			throw new CoreException(new Status(
 					IStatus.ERROR, RCore.BUNDLE_ID, 0,
 					NLS.bind(Messages.Builder_error_IOReadingFile_message, file.getName() ),
 					e ));
 		}
 		finally {
 			if (input != null) {
 				try {
 					input.close();
 				} catch (final IOException ignore) {}
 			}
 		}
 	}

 }
	/*=============================================================================#
	# Copyright (c) 2009, 2021 Stephan Wahlbrink and others.
	#
	# This program and the accompanying materials are made available under the
	# terms of the Eclipse Public License 2.0 which is available at
	# https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
	# which is available at https://www.apache.org/licenses/LICENSE-2.0.
	#
	# SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
	#
	# Contributors:
	# Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
	#=============================================================================*/

	package org.eclipse.statet.internal.r.core.builder;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.UnsupportedEncodingException;
	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.core.resources.IContainer;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IResourceDelta;
	import org.eclipse.core.resources.IResourceDeltaVisitor;
	import org.eclipse.core.resources.IResourceVisitor;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.MultiStatus;
	import org.eclipse.core.runtime.OperationCanceledException;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.core.runtime.SubMonitor;
	import org.eclipse.core.runtime.content.IContentDescription;
	import org.eclipse.core.runtime.content.IContentType;
	import org.eclipse.osgi.util.NLS;

	import org.eclipse.statet.jcommons.collections.ImList;

	import org.eclipse.statet.internal.r.core.Messages;
	import org.eclipse.statet.internal.r.core.RCorePlugin;
	import org.eclipse.statet.internal.r.core.RProjectNature;
	import org.eclipse.statet.internal.r.core.sourcemodel.RModelManagerImpl;
	import org.eclipse.statet.ltk.buildpath.core.BuildpathElement;
	import org.eclipse.statet.ltk.buildpath.core.BuildpathUtils;
	import org.eclipse.statet.ltk.core.Ltk;
	import org.eclipse.statet.ltk.core.SourceContent;
	import org.eclipse.statet.ltk.model.core.LtkModels;
	import org.eclipse.statet.ltk.model.core.SourceUnitManager;
	import org.eclipse.statet.r.core.RBuildpaths;
	import org.eclipse.statet.r.core.RCore;
	import org.eclipse.statet.r.core.RProject;
	import org.eclipse.statet.r.core.RProjects;
	import org.eclipse.statet.r.core.model.RModel;
	import org.eclipse.statet.r.core.model.RSourceUnit;
	import org.eclipse.statet.r.core.model.RWorkspaceSourceUnit;


	public class RBuilder implements IResourceDeltaVisitor, IResourceVisitor {


	public static void clearMarkers(final IResource resource, final int depth) {
	try {
	resource.deleteMarkers(RModel.R_MODEL_PROBLEM_MARKER, false, depth);
	resource.deleteMarkers("org.eclipse.statet.r.resourceMarkers.Tasks", false, depth); //$NON-NLS-1$
	}
	catch (final CoreException e) {
	RCorePlugin.logError("R Builder: Failed to remove old markers.", e);
	}
	}


	private static IContainer getContainer(final IProject project, final IPath path) {
	return (path.isEmpty()) ? project : project.getFolder(path);
	}


	private final SourceUnitManager suManager= LtkModels.getSourceUnitManager();

	private final List<IFile> toRemoveRSU= new ArrayList<>();
	private final ArrayList<RWorkspaceSourceUnit> toUpdateRSU= new ArrayList<>();

	private final RModelManagerImpl modelManager;

	private MultiStatus statusCollector;

	private IProject project;
	private IPath pkgRootPath;
	private ImList<BuildpathElement> sourceContainters;
	private BuildpathElement currentSourceContainer;


	public RBuilder() {
	this.modelManager= RCorePlugin.getInstance().getRModelManager();
	}


	private void initBuildpath(final RProject project) {
	this.sourceContainters= project.getRawBuildpath();
	this.pkgRootPath= project.getPkgRootPath();
	this.currentSourceContainer= null;
	}

	private boolean isValidSourceFolder(final IResource resource) {
	if (this.currentSourceContainer != null) {
	if (!BuildpathUtils.isExcluded(resource, this.currentSourceContainer)) {
	return true;
	}
	}
	return false;
	}


	public IStatus buildIncremental(final RProject rProject, final IResourceDelta delta, final IProgressMonitor monitor) {
	this.project= rProject.getProject();
	this.statusCollector= new MultiStatus(RCore.BUNDLE_ID, 0, "R build status for " + this.project.getName(), null);
	initBuildpath(rProject);
	final SubMonitor m= SubMonitor.convert(monitor, 2 + 10 + 1);
	try {
	m.subTask(NLS.bind("Collecting resource changes of ''{0}''.", this.project.getName()));
	IContainer pkgRoot= null;
	if (this.pkgRootPath != null) {
	pkgRoot= visitPkgRoot(delta.findMember(this.pkgRootPath.removeFirstSegments(1)));
	}
	m.worked(1);

	for (final BuildpathElement sourceContainer : this.sourceContainters) {
	final IResourceDelta sourceDelta= delta.findMember(
	sourceContainer.getPath().removeFirstSegments(1) );
	if (sourceDelta != null) {
	this.currentSourceContainer= sourceContainer;
	sourceDelta.accept(this);
	}

	if (m.isCanceled()) {
	throw new OperationCanceledException();
	}
	}
	m.worked(1);

	this.modelManager.getIndex().update(rProject, pkgRoot,
	this.toRemoveRSU, this.toUpdateRSU,
	this.statusCollector, m.newChild(10) );
	}
	catch (final CoreException e) {
	this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
	"An error occurred when indexing the project.", e ));
	}
	finally {
	this.currentSourceContainer= null;

	for (final RSourceUnit su : this.toUpdateRSU) {
	if (su != null) {
	su.disconnect(m);
	}
	}
	this.toRemoveRSU.clear();
	this.toUpdateRSU.clear();
	this.project= null;
	}
	return this.statusCollector;
	}

	private IContainer visitPkgRoot(final IResourceDelta delta) throws CoreException {
	final IResource resource;
	if (delta != null
	&& (resource= delta.getResource()) instanceof IContainer ) {
	final IContainer container= (IContainer) resource;

	this.project.deleteMarkers(RModel.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);

	switch (delta.getKind()) {

	case IResourceDelta.ADDED:
	case IResourceDelta.CHANGED:
	clearMarkers(resource, IResource.DEPTH_ZERO);
	break;

	case IResourceDelta.REMOVED:
	if ((delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
	final IResource movedTo= resource.getWorkspace().getRoot().findMember(delta.getMovedToPath());
	if (movedTo != null && !isRPkgRootLocation(movedTo)) {
	clearMarkers(movedTo, IResource.DEPTH_ZERO);
	}
	}
	break;
	}

	visitPkgFile(delta.findMember(RBuildpaths.PKG_DESCRIPTION_FILE_PATH));

	return container;
	}
	return null;
	}

	private boolean visitPkgFile(final IResourceDelta delta) throws CoreException {
	final IResource resource;
	if (delta != null
	&& (resource= delta.getResource()) instanceof IFile) {

	switch (delta.getKind()) {

	case IResourceDelta.ADDED:
	case IResourceDelta.CHANGED:
	clearMarkers(resource, IResource.DEPTH_ZERO);
	break;

	case IResourceDelta.REMOVED:
	if ((delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
	final IResource movedTo= resource.getWorkspace().getRoot().findMember(delta.getMovedToPath());
	if (movedTo != null && !isRPkgRootLocation(movedTo.getParent())) {
	clearMarkers(movedTo, IResource.DEPTH_ZERO);
	}
	}
	break;
	}

	return true;
	}
	return false;
	}

	@Override
	public boolean visit(final IResourceDelta delta) throws CoreException {
	final IResource resource= delta.getResource();
	try {
	if (!isValidSourceFolder(resource)) {
	return false;
	}

	switch (delta.getKind()) {

	case IResourceDelta.ADDED:
	case IResourceDelta.CHANGED:
	if (resource instanceof IFile) {
	final IFile file= (IFile) resource;
	final IContentDescription contentDescription= file.getContentDescription();
	if (contentDescription == null) {
	return true;
	}
	final IContentType contentType= contentDescription.getContentType();
	if (contentType == null) {
	return true;
	}
	if (RCore.R_CONTENT_ID.equals(contentType.getId())) {
	clearMarkers(resource, IResource.DEPTH_ZERO);
	final RWorkspaceSourceUnit su= (RWorkspaceSourceUnit) this.suManager.getSourceUnit(
	Ltk.PERSISTENCE_CONTEXT, file, contentType, true, null );
	if (su != null) {
	this.toUpdateRSU.add(su);
	}
	return true;
	}
	if (RCore.RD_CONTENT_ID.equals(contentType.getId())) {
	clearMarkers(resource, IResource.DEPTH_ZERO);
	doParseRd(file);
	return true;
	}
	}
	return true;

	case IResourceDelta.REMOVED:
	if ((delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
	final IResource movedTo= resource.getWorkspace().getRoot().findMember(delta.getMovedToPath());
	if (movedTo != null && !isRSourceLocation(movedTo)) {
	clearMarkers(movedTo, IResource.DEPTH_INFINITE);
	}
	}
	if (resource instanceof IFile) {
	this.toRemoveRSU.add((IFile) resource);
	}
	return true;
	}
	return true;
	}
	catch (final CoreException e) {
	this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
	NLS.bind("An error occurred when checking ''{0}''", resource.getFullPath().toString()), e));
	return false;
	}
	}


	public IStatus buildFull(final RProject rProject, final IProgressMonitor monitor) {
	this.project= rProject.getProject();
	this.statusCollector= new MultiStatus(RCore.BUNDLE_ID, 0, "R build status for " + this.project.getName(), null);
	initBuildpath(rProject);
	final SubMonitor m= SubMonitor.convert(monitor, 2 + 10 + 1);
	try {
	m.subTask(NLS.bind("Collecting resource changes of ''{0}''.", this.project.getName()));
	IContainer pkgRoot= null;
	if (this.pkgRootPath != null) {
	pkgRoot= visitPkgRoot(
	getContainer(this.project, this.pkgRootPath.removeFirstSegments(1)) );

	this.project.deleteMarkers(RModel.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
	}
	m.worked(1);

	for (final BuildpathElement sourceContainer : this.sourceContainters) {
	final IResource resource= this.project.findMember(
	sourceContainer.getPath().removeFirstSegments(1) );
	if (resource != null) {
	this.currentSourceContainer= sourceContainer;
	resource.accept(this);
	}

	if (m.isCanceled()) {
	throw new OperationCanceledException();
	}
	}
	m.worked(1);

	this.modelManager.getIndex().update(rProject, pkgRoot,
	null, this.toUpdateRSU,
	this.statusCollector, m.newChild(10) );
	}
	catch (final CoreException e) {
	this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
	"An error occurred when indexing the project.", e) );
	}
	finally {
	this.currentSourceContainer= null;

	for (final RSourceUnit su : this.toUpdateRSU) {
	if (su != null) {
	su.disconnect(m);
	}
	}
	this.toRemoveRSU.clear();
	this.toUpdateRSU.clear();
	this.project= null;
	}
	return this.statusCollector;
	}

	private IContainer visitPkgRoot(final IContainer container) throws CoreException {
	this.project.deleteMarkers(RModel.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);

	if (container.exists()) {
	clearMarkers(container, IResource.DEPTH_ZERO);
	visitPkgFile(container.findMember(RBuildpaths.PKG_DESCRIPTION_FILE_PATH));
	}

	return container;
	}

	private void visitPkgFile(final IResource resource) {
	if (resource instanceof IFile) {
	clearMarkers(resource, IResource.DEPTH_ZERO);
	}
	}

	@Override
	public boolean visit(final IResource resource) throws CoreException {
	try {
	if (!isValidSourceFolder(resource)) {
	return false;
	}

	if (resource instanceof IFile) {
	final IFile file= (IFile) resource;
	final IContentDescription contentDescription= file.getContentDescription();
	if (contentDescription == null) {
	return true;
	}
	final IContentType contentType= contentDescription.getContentType();
	if (contentType == null) {
	return true;
	}
	if (RCore.R_CONTENT_ID.equals(contentType.getId())) {
	clearMarkers(resource, IResource.DEPTH_INFINITE);
	final RWorkspaceSourceUnit su= (RWorkspaceSourceUnit) this.suManager.getSourceUnit(
	Ltk.PERSISTENCE_CONTEXT, file, contentType, true, null );
	if (su != null) {
	this.toUpdateRSU.add(su);
	}
	return true;
	}
	if (RCore.RD_CONTENT_ID.equals(contentType.getId())) {
	clearMarkers(resource, IResource.DEPTH_INFINITE);
	doParseRd(file);
	return true;
	}
	}
	return true;
	}
	catch (final CoreException e) {
	this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
	NLS.bind("An error occurred when checking ''{0}''", resource.getFullPath().toString()),
	e ));
	return false;
	}
	}

	public void clean(final IProject project, final IProgressMonitor monitor) {
	this.project= project;
	try {
	project.deleteMarkers(RModel.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);

	clearMarkers(project, IResource.DEPTH_INFINITE);

	this.modelManager.getIndex().clear(project);
	}
	catch (final CoreException e) {
	this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
	"An error occurred when indexing the project.", e) );
	}
	finally {
	this.project= null;
	}
	}


	private boolean isRSourceLocation(final IResource resource) throws CoreException {
	final IProject project= resource.getProject();
	if (project == this.project) {
	// TODO check buildpath
	return true;
	}
	if (project.hasNature(RProjects.R_NATURE_ID)) {
	// TODO check buildpath
	return true;
	}
	return false;
	}

	private boolean isRPkgRootLocation(final IResource resource) throws CoreException {
	final IProject project= resource.getProject();
	if (project == this.project) {
	return (resource.getFullPath().equals(this.pkgRootPath));
	}
	else if (project.hasNature(RProjects.R_PKG_NATURE_ID)) {
	final RProjectNature rProject= RProjectNature.getRProject(project);
	return (rProject != null && resource.getFullPath().equals(rProject.getPkgRootPath()));
	}
	return false;
	}


	/-- Rd --/

	private final RTaskMarkerHandler taskMarkerHandler= new RTaskMarkerHandler();

	protected void initRd(final RProject project) {
	this.taskMarkerHandler.init(project);
	}

	protected void doParseRd(final IFile file) throws CoreException {
	try {
	final SourceContent sourceContent= new SourceContent(0, readFile(file));
	this.taskMarkerHandler.setup(sourceContent, file);
	new RdParser(sourceContent, this.taskMarkerHandler).check();
	}
	catch (final CoreException e) {
	this.statusCollector.add(new Status(IStatus.ERROR, RCore.BUNDLE_ID, 0,
	NLS.bind("An error occurred when parsing Rd file ''{0}''", file.getFullPath().toString()),
	e ));
	}
	}

	protected String readFile(final IFile file) throws CoreException {
	String charset= null;
	InputStream input= null;
	try {
	input= file.getContents();
	charset= file.getCharset();
	final BufferedReader reader= new BufferedReader(new InputStreamReader(input, charset));

	final StringBuilder text= new StringBuilder(1000);
	final char[] readBuffer= new char[2048];
	int n;
	while ((n= reader.read(readBuffer)) > 0) {
	text.append(readBuffer, 0, n);
	}

	return text.toString();
	}
	catch (final UnsupportedEncodingException e) {
	throw new CoreException(new Status(
	IStatus.ERROR, RCore.BUNDLE_ID, 0,
	NLS.bind(Messages.Builder_error_UnsupportedEncoding_message, new String[] {
	charset, file.getName() } ),
	e ));
	}
	catch (final IOException e) {
	throw new CoreException(new Status(
	IStatus.ERROR, RCore.BUNDLE_ID, 0,
	NLS.bind(Messages.Builder_error_IOReadingFile_message, file.getName() ),
	e ));
	}
	finally {
	if (input != null) {
	try {
	input.close();
	} catch (final IOException ignore) {}
	}
	}
	}

	}